FFmpeg
flvenc.c
Go to the documentation of this file.
1 /*
2  * FLV muxer
3  * Copyright (c) 2003 The FFmpeg Project
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/intreadwrite.h"
23 #include "libavutil/dict.h"
24 #include "libavutil/intfloat.h"
25 #include "libavutil/avassert.h"
26 #include "libavutil/mathematics.h"
27 #include "avio_internal.h"
28 #include "avio.h"
29 #include "avc.h"
30 #include "avformat.h"
31 #include "flv.h"
32 #include "internal.h"
33 #include "metadata.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/put_bits.h"
36 #include "libavcodec/aacenctab.h"
37 
38 
39 static const AVCodecTag flv_video_codec_ids[] = {
46  { AV_CODEC_ID_VP6, FLV_CODECID_VP6 },
49  { AV_CODEC_ID_NONE, 0 }
50 };
51 
52 static const AVCodecTag flv_audio_codec_ids[] = {
54  { AV_CODEC_ID_PCM_U8, FLV_CODECID_PCM >> FLV_AUDIO_CODECID_OFFSET },
55  { AV_CODEC_ID_PCM_S16BE, FLV_CODECID_PCM >> FLV_AUDIO_CODECID_OFFSET },
56  { AV_CODEC_ID_PCM_S16LE, FLV_CODECID_PCM_LE >> FLV_AUDIO_CODECID_OFFSET },
57  { AV_CODEC_ID_ADPCM_SWF, FLV_CODECID_ADPCM >> FLV_AUDIO_CODECID_OFFSET },
58  { AV_CODEC_ID_AAC, FLV_CODECID_AAC >> FLV_AUDIO_CODECID_OFFSET },
59  { AV_CODEC_ID_NELLYMOSER, FLV_CODECID_NELLYMOSER >> FLV_AUDIO_CODECID_OFFSET },
60  { AV_CODEC_ID_PCM_MULAW, FLV_CODECID_PCM_MULAW >> FLV_AUDIO_CODECID_OFFSET },
61  { AV_CODEC_ID_PCM_ALAW, FLV_CODECID_PCM_ALAW >> FLV_AUDIO_CODECID_OFFSET },
62  { AV_CODEC_ID_SPEEX, FLV_CODECID_SPEEX >> FLV_AUDIO_CODECID_OFFSET },
63  { AV_CODEC_ID_NONE, 0 }
64 };
65 
66 typedef enum {
68  FLV_NO_SEQUENCE_END = (1 << 1),
70  FLV_NO_METADATA = (1 << 3),
72 } FLVFlags;
73 
74 typedef struct FLVFileposition {
79 
80 typedef struct FLVContext {
82  int reserved;
83  int64_t duration_offset;
84  int64_t filesize_offset;
85  int64_t duration;
86  int64_t delay; ///< first dts delay (needed for AVC & Speex)
87 
89  int64_t datasize_offset;
90  int64_t datasize;
92  int64_t videosize;
94  int64_t audiosize;
95 
100 
107 
110 
114 
117  double framerate;
119 
120  int flags;
121 } FLVContext;
122 
123 typedef struct FLVStreamContext {
124  int64_t last_ts; ///< last timestamp for each stream
126 
128 {
131 
132  if (par->codec_id == AV_CODEC_ID_AAC) // specs force these parameters
135  else if (par->codec_id == AV_CODEC_ID_SPEEX) {
136  if (par->sample_rate != 16000) {
137  av_log(s, AV_LOG_ERROR,
138  "FLV only supports wideband (16kHz) Speex audio\n");
139  return AVERROR(EINVAL);
140  }
141  if (par->channels != 1) {
142  av_log(s, AV_LOG_ERROR, "FLV only supports mono Speex audio\n");
143  return AVERROR(EINVAL);
144  }
146  } else {
147  switch (par->sample_rate) {
148  case 48000:
149  // 48khz mp3 is stored with 44k1 samplerate identifer
150  if (par->codec_id == AV_CODEC_ID_MP3) {
151  flags |= FLV_SAMPLERATE_44100HZ;
152  break;
153  } else {
154  goto error;
155  }
156  case 44100:
157  flags |= FLV_SAMPLERATE_44100HZ;
158  break;
159  case 22050:
160  flags |= FLV_SAMPLERATE_22050HZ;
161  break;
162  case 11025:
163  flags |= FLV_SAMPLERATE_11025HZ;
164  break;
165  case 16000: // nellymoser only
166  case 8000: // nellymoser only
167  case 5512: // not MP3
168  if (par->codec_id != AV_CODEC_ID_MP3) {
169  flags |= FLV_SAMPLERATE_SPECIAL;
170  break;
171  }
172  default:
173 error:
174  av_log(s, AV_LOG_ERROR,
175  "FLV does not support sample rate %d, "
176  "choose from (44100, 22050, 11025)\n", par->sample_rate);
177  return AVERROR(EINVAL);
178  }
179  }
180 
181  if (par->channels > 1)
182  flags |= FLV_STEREO;
183 
184  switch (par->codec_id) {
185  case AV_CODEC_ID_MP3:
187  break;
188  case AV_CODEC_ID_PCM_U8:
190  break;
193  break;
196  break;
199  break;
201  if (par->sample_rate == 8000)
203  else if (par->sample_rate == 16000)
205  else
207  break;
210  break;
213  break;
214  case 0:
215  flags |= par->codec_tag << 4;
216  break;
217  default:
218  av_log(s, AV_LOG_ERROR, "Audio codec '%s' not compatible with FLV\n",
219  avcodec_get_name(par->codec_id));
220  return AVERROR(EINVAL);
221  }
222 
223  return flags;
224 }
225 
226 static void put_amf_string(AVIOContext *pb, const char *str)
227 {
228  size_t len = strlen(str);
229  avio_wb16(pb, len);
230  avio_write(pb, str, len);
231 }
232 
233 // FLV timestamps are 32 bits signed, RTMP timestamps should be 32-bit unsigned
234 static void put_timestamp(AVIOContext *pb, int64_t ts) {
235  avio_wb24(pb, ts & 0xFFFFFF);
236  avio_w8(pb, (ts >> 24) & 0x7F);
237 }
238 
239 static void put_avc_eos_tag(AVIOContext *pb, unsigned ts)
240 {
242  avio_wb24(pb, 5); /* Tag Data Size */
243  put_timestamp(pb, ts);
244  avio_wb24(pb, 0); /* StreamId = 0 */
245  avio_w8(pb, 23); /* ub[4] FrameType = 1, ub[4] CodecId = 7 */
246  avio_w8(pb, 2); /* AVC end of sequence */
247  avio_wb24(pb, 0); /* Always 0 for AVC EOS. */
248  avio_wb32(pb, 16); /* Size of FLV tag */
249 }
250 
251 static void put_amf_double(AVIOContext *pb, double d)
252 {
254  avio_wb64(pb, av_double2int(d));
255 }
256 
257 static void put_amf_byte(AVIOContext *pb, unsigned char abyte)
258 {
259  avio_w8(pb, abyte);
260 }
261 
262 static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
263 {
265  avio_wb32(pb, dw);
266 }
267 
268 static void put_amf_bool(AVIOContext *pb, int b)
269 {
271  avio_w8(pb, !!b);
272 }
273 
274 static void write_metadata(AVFormatContext *s, unsigned int ts)
275 {
276  AVIOContext *pb = s->pb;
277  FLVContext *flv = s->priv_data;
278  int write_duration_filesize = !(flv->flags & FLV_NO_DURATION_FILESIZE);
279  int metadata_count = 0;
280  int64_t metadata_count_pos;
282 
283  /* write meta_tag */
284  avio_w8(pb, FLV_TAG_TYPE_META); // tag type META
285  flv->metadata_size_pos = avio_tell(pb);
286  avio_wb24(pb, 0); // size of data part (sum of all parts below)
287  avio_wb24(pb, ts); // timestamp
288  avio_wb32(pb, 0); // reserved
289 
290  /* now data of data_size size */
291 
292  /* first event name as a string */
294  put_amf_string(pb, "onMetaData"); // 12 bytes
295 
296  /* mixed array (hash) with size and string/type/data tuples */
298  metadata_count_pos = avio_tell(pb);
299  metadata_count = 4 * !!flv->video_par +
300  5 * !!flv->audio_par +
301  1 * !!flv->data_par;
302  if (write_duration_filesize) {
303  metadata_count += 2; // +2 for duration and file size
304  }
305  avio_wb32(pb, metadata_count);
306 
307  if (write_duration_filesize) {
308  put_amf_string(pb, "duration");
309  flv->duration_offset = avio_tell(pb);
310  // fill in the guessed duration, it'll be corrected later if incorrect
312  }
313 
314  if (flv->video_par) {
315  put_amf_string(pb, "width");
316  put_amf_double(pb, flv->video_par->width);
317 
318  put_amf_string(pb, "height");
319  put_amf_double(pb, flv->video_par->height);
320 
321  put_amf_string(pb, "videodatarate");
322  put_amf_double(pb, flv->video_par->bit_rate / 1024.0);
323 
324  if (flv->framerate != 0.0) {
325  put_amf_string(pb, "framerate");
326  put_amf_double(pb, flv->framerate);
327  metadata_count++;
328  }
329 
330  put_amf_string(pb, "videocodecid");
332  }
333 
334  if (flv->audio_par) {
335  put_amf_string(pb, "audiodatarate");
336  put_amf_double(pb, flv->audio_par->bit_rate / 1024.0);
337 
338  put_amf_string(pb, "audiosamplerate");
340 
341  put_amf_string(pb, "audiosamplesize");
342  put_amf_double(pb, flv->audio_par->codec_id == AV_CODEC_ID_PCM_U8 ? 8 : 16);
343 
344  put_amf_string(pb, "stereo");
345  put_amf_bool(pb, flv->audio_par->channels == 2);
346 
347  put_amf_string(pb, "audiocodecid");
349  }
350 
351  if (flv->data_par) {
352  put_amf_string(pb, "datastream");
353  put_amf_double(pb, 0.0);
354  }
355 
357  while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
358  if( !strcmp(tag->key, "width")
359  ||!strcmp(tag->key, "height")
360  ||!strcmp(tag->key, "videodatarate")
361  ||!strcmp(tag->key, "framerate")
362  ||!strcmp(tag->key, "videocodecid")
363  ||!strcmp(tag->key, "audiodatarate")
364  ||!strcmp(tag->key, "audiosamplerate")
365  ||!strcmp(tag->key, "audiosamplesize")
366  ||!strcmp(tag->key, "stereo")
367  ||!strcmp(tag->key, "audiocodecid")
368  ||!strcmp(tag->key, "duration")
369  ||!strcmp(tag->key, "onMetaData")
370  ||!strcmp(tag->key, "datasize")
371  ||!strcmp(tag->key, "lasttimestamp")
372  ||!strcmp(tag->key, "totalframes")
373  ||!strcmp(tag->key, "hasAudio")
374  ||!strcmp(tag->key, "hasVideo")
375  ||!strcmp(tag->key, "hasCuePoints")
376  ||!strcmp(tag->key, "hasMetadata")
377  ||!strcmp(tag->key, "hasKeyframes")
378  ){
379  av_log(s, AV_LOG_DEBUG, "Ignoring metadata for %s\n", tag->key);
380  continue;
381  }
382  put_amf_string(pb, tag->key);
384  put_amf_string(pb, tag->value);
385  metadata_count++;
386  }
387 
388  if (write_duration_filesize) {
389  put_amf_string(pb, "filesize");
390  flv->filesize_offset = avio_tell(pb);
391  put_amf_double(pb, 0); // delayed write
392  }
393 
394  if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
395  flv->acurframeindex = 0;
396  flv->keyframe_index_size = 0;
397 
398  put_amf_string(pb, "hasVideo");
399  put_amf_bool(pb, !!flv->video_par);
400  metadata_count++;
401 
402  put_amf_string(pb, "hasKeyframes");
403  put_amf_bool(pb, 1);
404  metadata_count++;
405 
406  put_amf_string(pb, "hasAudio");
407  put_amf_bool(pb, !!flv->audio_par);
408  metadata_count++;
409 
410  put_amf_string(pb, "hasMetadata");
411  put_amf_bool(pb, 1);
412  metadata_count++;
413 
414  put_amf_string(pb, "canSeekToEnd");
415  put_amf_bool(pb, 1);
416  metadata_count++;
417 
418  put_amf_string(pb, "datasize");
419  flv->datasize_offset = avio_tell(pb);
420  flv->datasize = 0;
421  put_amf_double(pb, flv->datasize);
422  metadata_count++;
423 
424  put_amf_string(pb, "videosize");
425  flv->videosize_offset = avio_tell(pb);
426  flv->videosize = 0;
427  put_amf_double(pb, flv->videosize);
428  metadata_count++;
429 
430  put_amf_string(pb, "audiosize");
431  flv->audiosize_offset = avio_tell(pb);
432  flv->audiosize = 0;
433  put_amf_double(pb, flv->audiosize);
434  metadata_count++;
435 
436  put_amf_string(pb, "lasttimestamp");
437  flv->lasttimestamp_offset = avio_tell(pb);
438  flv->lasttimestamp = 0;
439  put_amf_double(pb, 0);
440  metadata_count++;
441 
442  put_amf_string(pb, "lastkeyframetimestamp");
444  flv->lastkeyframetimestamp = 0;
445  put_amf_double(pb, 0);
446  metadata_count++;
447 
448  put_amf_string(pb, "lastkeyframelocation");
450  flv->lastkeyframelocation = 0;
451  put_amf_double(pb, 0);
452  metadata_count++;
453 
454  put_amf_string(pb, "keyframes");
456  metadata_count++;
457 
458  flv->keyframes_info_offset = avio_tell(pb);
459  }
460 
461  put_amf_string(pb, "");
463 
464  /* write total size of tag */
465  flv->metadata_totalsize = avio_tell(pb) - flv->metadata_size_pos - 10;
466 
467  avio_seek(pb, metadata_count_pos, SEEK_SET);
468  avio_wb32(pb, metadata_count);
469 
470  avio_seek(pb, flv->metadata_size_pos, SEEK_SET);
471  avio_wb24(pb, flv->metadata_totalsize);
472  avio_skip(pb, flv->metadata_totalsize + 10 - 3);
474  avio_wb32(pb, flv->metadata_totalsize + 11);
475 }
476 
478  const char* type, int codec_id)
479 {
480  const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
481  av_log(s, AV_LOG_ERROR,
482  "%s codec %s not compatible with flv\n",
483  type,
484  desc ? desc->name : "unknown");
485  return AVERROR(ENOSYS);
486 }
487 
489  int64_t data_size;
490  AVIOContext *pb = s->pb;
491  FLVContext *flv = s->priv_data;
492 
493  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
494  || par->codec_id == AV_CODEC_ID_MPEG4) {
495  int64_t pos;
496  avio_w8(pb,
499  avio_wb24(pb, 0); // size patched later
500  put_timestamp(pb, ts);
501  avio_wb24(pb, 0); // streamid
502  pos = avio_tell(pb);
503  if (par->codec_id == AV_CODEC_ID_AAC) {
504  avio_w8(pb, get_audio_flags(s, par));
505  avio_w8(pb, 0); // AAC sequence header
506 
507  if (!par->extradata_size && (flv->flags & FLV_AAC_SEQ_HEADER_DETECT)) {
508  PutBitContext pbc;
509  int samplerate_index;
510  int channels = flv->audio_par->channels
511  - (flv->audio_par->channels == 8 ? 1 : 0);
512  uint8_t data[2];
513 
514  for (samplerate_index = 0; samplerate_index < 16;
515  samplerate_index++)
516  if (flv->audio_par->sample_rate
517  == mpeg4audio_sample_rates[samplerate_index])
518  break;
519 
520  init_put_bits(&pbc, data, sizeof(data));
521  put_bits(&pbc, 5, flv->audio_par->profile + 1); //profile
522  put_bits(&pbc, 4, samplerate_index); //sample rate index
523  put_bits(&pbc, 4, channels);
524  put_bits(&pbc, 1, 0); //frame length - 1024 samples
525  put_bits(&pbc, 1, 0); //does not depend on core coder
526  put_bits(&pbc, 1, 0); //is not extension
527  flush_put_bits(&pbc);
528 
529  avio_w8(pb, data[0]);
530  avio_w8(pb, data[1]);
531 
532  av_log(s, AV_LOG_WARNING, "AAC sequence header: %02x %02x.\n",
533  data[0], data[1]);
534  }
535  avio_write(pb, par->extradata, par->extradata_size);
536  } else {
537  avio_w8(pb, par->codec_tag | FLV_FRAME_KEY); // flags
538  avio_w8(pb, 0); // AVC sequence header
539  avio_wb24(pb, 0); // composition time
541  }
542  data_size = avio_tell(pb) - pos;
543  avio_seek(pb, -data_size - 10, SEEK_CUR);
544  avio_wb24(pb, data_size);
545  avio_skip(pb, data_size + 10 - 3);
546  avio_wb32(pb, data_size + 11); // previous tag size
547  }
548 }
549 
550 static int flv_append_keyframe_info(AVFormatContext *s, FLVContext *flv, double ts, int64_t pos)
551 {
552  FLVFileposition *position = av_malloc(sizeof(FLVFileposition));
553 
554  if (!position) {
555  av_log(s, AV_LOG_WARNING, "no mem for add keyframe index!\n");
556  return AVERROR(ENOMEM);
557  }
558 
559  position->keyframe_timestamp = ts;
560  position->keyframe_position = pos;
561 
562  if (!flv->filepositions_count) {
563  flv->filepositions = position;
564  flv->head_filepositions = flv->filepositions;
565  position->next = NULL;
566  } else {
567  flv->filepositions->next = position;
568  position->next = NULL;
569  flv->filepositions = flv->filepositions->next;
570  }
571 
572  flv->filepositions_count++;
573 
574  return 0;
575 }
576 
578 {
579  int ret = 0;
580  int n = 0;
581  int64_t metadata_size = 0;
582  FLVContext *flv = s->priv_data;
583  int64_t pos, pos_end = avio_tell(s->pb);
584  uint8_t *buf, *read_buf[2];
585  int read_buf_id = 0;
586  int read_size[2];
587  AVIOContext *read_pb;
588 
589  metadata_size = flv->filepositions_count * 9 * 2 + 10; /* filepositions and times value */
590  metadata_size += 2 + 13; /* filepositions String */
591  metadata_size += 2 + 5; /* times String */
592  metadata_size += 3; /* Object end */
593 
594  flv->keyframe_index_size = metadata_size;
595 
596  if (metadata_size < 0)
597  return metadata_size;
598 
599  buf = av_malloc_array(metadata_size, 2);
600  if (!buf) {
601  return AVERROR(ENOMEM);
602  }
603  read_buf[0] = buf;
604  read_buf[1] = buf + metadata_size;
605 
606  avio_seek(s->pb, flv->metadata_size_pos, SEEK_SET);
607  avio_wb24(s->pb, flv->metadata_totalsize + metadata_size);
608 
609  avio_seek(s->pb, flv->metadata_totalsize_pos, SEEK_SET);
610  avio_wb32(s->pb, flv->metadata_totalsize + 11 + metadata_size);
611  avio_seek(s->pb, pos_end, SEEK_SET);
612 
613  /* Shift the data: the AVIO context of the output can only be used for
614  * writing, so we re-open the same output, but for reading. It also avoids
615  * a read/seek/write/seek back and forth. */
616  avio_flush(s->pb);
617  ret = s->io_open(s, &read_pb, s->url, AVIO_FLAG_READ, NULL);
618  if (ret < 0) {
619  av_log(s, AV_LOG_ERROR, "Unable to re-open %s output file for "
620  "the second pass (add_keyframe_index)\n", s->url);
621  goto end;
622  }
623 
624  /* mark the end of the shift to up to the last data we wrote, and get ready
625  * for writing */
626  pos_end = avio_tell(s->pb);
627  avio_seek(s->pb, flv->keyframes_info_offset + metadata_size, SEEK_SET);
628 
629  /* start reading at where the keyframe index information will be placed */
630  avio_seek(read_pb, flv->keyframes_info_offset, SEEK_SET);
631  pos = avio_tell(read_pb);
632 
633 #define READ_BLOCK do { \
634  read_size[read_buf_id] = avio_read(read_pb, read_buf[read_buf_id], metadata_size); \
635  read_buf_id ^= 1; \
636 } while (0)
637 
638  /* shift data by chunk of at most keyframe *filepositions* and *times* size */
639  READ_BLOCK;
640  do {
641  READ_BLOCK;
642  n = read_size[read_buf_id];
643  if (n < 0)
644  break;
645  avio_write(s->pb, read_buf[read_buf_id], n);
646  pos += n;
647  } while (pos <= pos_end);
648 
649  ff_format_io_close(s, &read_pb);
650 
651 end:
652  av_free(buf);
653  return ret;
654 }
655 
656 
658 {
659  int i;
660  AVIOContext *pb = s->pb;
661  FLVContext *flv = s->priv_data;
662 
663  for (i = 0; i < s->nb_streams; i++) {
664  AVCodecParameters *par = s->streams[i]->codecpar;
665  FLVStreamContext *sc;
666  switch (par->codec_type) {
667  case AVMEDIA_TYPE_VIDEO:
668  if (s->streams[i]->avg_frame_rate.den &&
669  s->streams[i]->avg_frame_rate.num) {
670  flv->framerate = av_q2d(s->streams[i]->avg_frame_rate);
671  }
672  if (flv->video_par) {
673  av_log(s, AV_LOG_ERROR,
674  "at most one video stream is supported in flv\n");
675  return AVERROR(EINVAL);
676  }
677  flv->video_par = par;
678  if (!ff_codec_get_tag(flv_video_codec_ids, par->codec_id))
679  return unsupported_codec(s, "Video", par->codec_id);
680 
681  if (par->codec_id == AV_CODEC_ID_MPEG4 ||
682  par->codec_id == AV_CODEC_ID_H263) {
684  av_log(s, error ? AV_LOG_ERROR : AV_LOG_WARNING,
685  "Codec %s is not supported in the official FLV specification,\n", avcodec_get_name(par->codec_id));
686 
687  if (error) {
688  av_log(s, AV_LOG_ERROR,
689  "use vstrict=-1 / -strict -1 to use it anyway.\n");
690  return AVERROR(EINVAL);
691  }
692  } else if (par->codec_id == AV_CODEC_ID_VP6) {
694  "Muxing VP6 in flv will produce flipped video on playback.\n");
695  }
696  break;
697  case AVMEDIA_TYPE_AUDIO:
698  if (flv->audio_par) {
699  av_log(s, AV_LOG_ERROR,
700  "at most one audio stream is supported in flv\n");
701  return AVERROR(EINVAL);
702  }
703  flv->audio_par = par;
704  if (get_audio_flags(s, par) < 0)
705  return unsupported_codec(s, "Audio", par->codec_id);
706  if (par->codec_id == AV_CODEC_ID_PCM_S16BE)
708  "16-bit big-endian audio in flv is valid but most likely unplayable (hardware dependent); use s16le\n");
709  break;
710  case AVMEDIA_TYPE_DATA:
711  if (par->codec_id != AV_CODEC_ID_TEXT && par->codec_id != AV_CODEC_ID_NONE)
712  return unsupported_codec(s, "Data", par->codec_id);
713  flv->data_par = par;
714  break;
716  if (par->codec_id != AV_CODEC_ID_TEXT) {
717  av_log(s, AV_LOG_ERROR, "Subtitle codec '%s' for stream %d is not compatible with FLV\n",
718  avcodec_get_name(par->codec_id), i);
719  return AVERROR_INVALIDDATA;
720  }
721  flv->data_par = par;
722  break;
723  default:
724  av_log(s, AV_LOG_ERROR, "Codec type '%s' for stream %d is not compatible with FLV\n",
726  return AVERROR(EINVAL);
727  }
728  avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
729 
730  sc = av_mallocz(sizeof(FLVStreamContext));
731  if (!sc)
732  return AVERROR(ENOMEM);
733  s->streams[i]->priv_data = sc;
734  sc->last_ts = -1;
735  }
736 
737  flv->delay = AV_NOPTS_VALUE;
738 
739  avio_write(pb, "FLV", 3);
740  avio_w8(pb, 1);
743  avio_wb32(pb, 9);
744  avio_wb32(pb, 0);
745 
746  for (i = 0; i < s->nb_streams; i++)
747  if (s->streams[i]->codecpar->codec_tag == 5) {
748  avio_w8(pb, 8); // message type
749  avio_wb24(pb, 0); // include flags
750  avio_wb24(pb, 0); // time stamp
751  avio_wb32(pb, 0); // reserved
752  avio_wb32(pb, 11); // size
753  flv->reserved = 5;
754  }
755 
756  if (flv->flags & FLV_NO_METADATA) {
757  pb->seekable = 0;
758  } else {
759  write_metadata(s, 0);
760  }
761 
762  for (i = 0; i < s->nb_streams; i++) {
764  }
765 
766  flv->datastart_offset = avio_tell(pb);
767  return 0;
768 }
769 
771 {
772  int64_t file_size;
773  AVIOContext *pb = s->pb;
774  FLVContext *flv = s->priv_data;
775  int build_keyframes_idx = flv->flags & FLV_ADD_KEYFRAME_INDEX;
776  int i, res;
777  int64_t cur_pos = avio_tell(s->pb);
778 
779  if (build_keyframes_idx) {
780  FLVFileposition *newflv_posinfo, *p;
781 
782  avio_seek(pb, flv->videosize_offset, SEEK_SET);
783  put_amf_double(pb, flv->videosize);
784 
785  avio_seek(pb, flv->audiosize_offset, SEEK_SET);
786  put_amf_double(pb, flv->audiosize);
787 
788  avio_seek(pb, flv->lasttimestamp_offset, SEEK_SET);
789  put_amf_double(pb, flv->lasttimestamp);
790 
791  avio_seek(pb, flv->lastkeyframetimestamp_offset, SEEK_SET);
793 
794  avio_seek(pb, flv->lastkeyframelocation_offset, SEEK_SET);
796  avio_seek(pb, cur_pos, SEEK_SET);
797 
798  res = shift_data(s);
799  if (res < 0) {
800  goto end;
801  }
802  avio_seek(pb, flv->keyframes_info_offset, SEEK_SET);
803  put_amf_string(pb, "filepositions");
805  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
806  put_amf_double(pb, newflv_posinfo->keyframe_position + flv->keyframe_index_size);
807  }
808 
809  put_amf_string(pb, "times");
811  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
812  put_amf_double(pb, newflv_posinfo->keyframe_timestamp);
813  }
814 
815  newflv_posinfo = flv->head_filepositions;
816  while (newflv_posinfo) {
817  p = newflv_posinfo->next;
818  if (p) {
819  newflv_posinfo->next = p->next;
820  av_free(p);
821  p = NULL;
822  } else {
823  av_free(newflv_posinfo);
824  newflv_posinfo = NULL;
825  }
826  }
827 
828  put_amf_string(pb, "");
830 
831  avio_seek(pb, cur_pos + flv->keyframe_index_size, SEEK_SET);
832  }
833 
834 end:
835  if (flv->flags & FLV_NO_SEQUENCE_END) {
836  av_log(s, AV_LOG_DEBUG, "FLV no sequence end mode open\n");
837  } else {
838  /* Add EOS tag */
839  for (i = 0; i < s->nb_streams; i++) {
840  AVCodecParameters *par = s->streams[i]->codecpar;
841  FLVStreamContext *sc = s->streams[i]->priv_data;
842  if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
844  put_avc_eos_tag(pb, sc->last_ts);
845  }
846  }
847 
848  file_size = avio_tell(pb);
849 
850  if (build_keyframes_idx) {
851  flv->datasize = file_size - flv->datastart_offset;
852  avio_seek(pb, flv->datasize_offset, SEEK_SET);
853  put_amf_double(pb, flv->datasize);
854  }
855  if (!(flv->flags & FLV_NO_METADATA)) {
856  if (!(flv->flags & FLV_NO_DURATION_FILESIZE)) {
857  /* update information */
858  if (avio_seek(pb, flv->duration_offset, SEEK_SET) < 0) {
859  av_log(s, AV_LOG_WARNING, "Failed to update header with correct duration.\n");
860  } else {
861  put_amf_double(pb, flv->duration / (double)1000);
862  }
863  if (avio_seek(pb, flv->filesize_offset, SEEK_SET) < 0) {
864  av_log(s, AV_LOG_WARNING, "Failed to update header with correct filesize.\n");
865  } else {
866  put_amf_double(pb, file_size);
867  }
868  }
869  }
870 
871  return 0;
872 }
873 
875 {
876  AVIOContext *pb = s->pb;
878  FLVContext *flv = s->priv_data;
880  unsigned ts;
881  int size = pkt->size;
882  uint8_t *data = NULL;
883  int flags = -1, flags_size, ret;
884  int64_t cur_offset = avio_tell(pb);
885 
886  if (par->codec_type == AVMEDIA_TYPE_AUDIO && !pkt->size) {
887  av_log(s, AV_LOG_WARNING, "Empty audio Packet\n");
888  return AVERROR(EINVAL);
889  }
890 
891  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A ||
893  flags_size = 2;
894  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4)
895  flags_size = 5;
896  else
897  flags_size = 1;
898 
899  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
900  || par->codec_id == AV_CODEC_ID_MPEG4) {
901  int side_size = 0;
903  if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
904  av_free(par->extradata);
906  if (!par->extradata) {
907  par->extradata_size = 0;
908  return AVERROR(ENOMEM);
909  }
910  memcpy(par->extradata, side, side_size);
911  par->extradata_size = side_size;
912  flv_write_codec_header(s, par, pkt->dts);
913  }
914  }
915 
916  if (flv->delay == AV_NOPTS_VALUE)
917  flv->delay = -pkt->dts;
918 
919  if (pkt->dts < -flv->delay) {
921  "Packets are not in the proper order with respect to DTS\n");
922  return AVERROR(EINVAL);
923  }
924 
925  ts = pkt->dts;
926 
928  write_metadata(s, ts);
930  }
931 
934 
935  switch (par->codec_type) {
936  case AVMEDIA_TYPE_VIDEO:
938 
939  flags = ff_codec_get_tag(flv_video_codec_ids, par->codec_id);
940 
942  break;
943  case AVMEDIA_TYPE_AUDIO:
944  flags = get_audio_flags(s, par);
945 
946  av_assert0(size);
947 
949  break;
951  case AVMEDIA_TYPE_DATA:
953  break;
954  default:
955  return AVERROR(EINVAL);
956  }
957 
958  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
959  /* check if extradata looks like mp4 formatted */
960  if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
961  if ((ret = ff_avc_parse_nal_units_buf(pkt->data, &data, &size)) < 0)
962  return ret;
963  } else if (par->codec_id == AV_CODEC_ID_AAC && pkt->size > 2 &&
964  (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
965  if (!s->streams[pkt->stream_index]->nb_frames) {
966  av_log(s, AV_LOG_ERROR, "Malformed AAC bitstream detected: "
967  "use the audio bitstream filter 'aac_adtstoasc' to fix it "
968  "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
969  return AVERROR_INVALIDDATA;
970  }
971  av_log(s, AV_LOG_WARNING, "aac bitstream error\n");
972  }
973 
974  /* check Speex packet duration */
975  if (par->codec_id == AV_CODEC_ID_SPEEX && ts - sc->last_ts > 160)
976  av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
977  "8 frames per packet. Adobe Flash "
978  "Player cannot handle this!\n");
979 
980  if (sc->last_ts < ts)
981  sc->last_ts = ts;
982 
983  if (size + flags_size >= 1<<24) {
984  av_log(s, AV_LOG_ERROR, "Too large packet with size %u >= %u\n",
985  size + flags_size, 1<<24);
986  return AVERROR(EINVAL);
987  }
988 
989  avio_wb24(pb, size + flags_size);
990  put_timestamp(pb, ts);
991  avio_wb24(pb, flv->reserved);
992 
993  if (par->codec_type == AVMEDIA_TYPE_DATA ||
995  int data_size;
996  int64_t metadata_size_pos = avio_tell(pb);
997  if (par->codec_id == AV_CODEC_ID_TEXT) {
998  // legacy FFmpeg magic?
1000  put_amf_string(pb, "onTextData");
1002  avio_wb32(pb, 2);
1003  put_amf_string(pb, "type");
1005  put_amf_string(pb, "Text");
1006  put_amf_string(pb, "text");
1008  put_amf_string(pb, pkt->data);
1009  put_amf_string(pb, "");
1011  } else {
1012  // just pass the metadata through
1013  avio_write(pb, data ? data : pkt->data, size);
1014  }
1015  /* write total size of tag */
1016  data_size = avio_tell(pb) - metadata_size_pos;
1017  avio_seek(pb, metadata_size_pos - 10, SEEK_SET);
1018  avio_wb24(pb, data_size);
1019  avio_seek(pb, data_size + 10 - 3, SEEK_CUR);
1020  avio_wb32(pb, data_size + 11);
1021  } else {
1022  av_assert1(flags>=0);
1023  avio_w8(pb,flags);
1024  if (par->codec_id == AV_CODEC_ID_VP6)
1025  avio_w8(pb,0);
1026  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A) {
1027  if (par->extradata_size)
1028  avio_w8(pb, par->extradata[0]);
1029  else
1030  avio_w8(pb, ((FFALIGN(par->width, 16) - par->width) << 4) |
1031  (FFALIGN(par->height, 16) - par->height));
1032  } else if (par->codec_id == AV_CODEC_ID_AAC)
1033  avio_w8(pb, 1); // AAC raw
1034  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
1035  avio_w8(pb, 1); // AVC NALU
1036  avio_wb24(pb, pkt->pts - pkt->dts);
1037  }
1038 
1039  avio_write(pb, data ? data : pkt->data, size);
1040 
1041  avio_wb32(pb, size + flags_size + 11); // previous tag size
1042  flv->duration = FFMAX(flv->duration,
1043  pkt->pts + flv->delay + pkt->duration);
1044  }
1045 
1046  if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
1047  switch (par->codec_type) {
1048  case AVMEDIA_TYPE_VIDEO:
1049  flv->videosize += (avio_tell(pb) - cur_offset);
1050  flv->lasttimestamp = flv->acurframeindex / flv->framerate;
1051  if (pkt->flags & AV_PKT_FLAG_KEY) {
1052  double ts = flv->acurframeindex / flv->framerate;
1053  int64_t pos = cur_offset;
1054 
1055  flv->lastkeyframetimestamp = flv->acurframeindex / flv->framerate;
1056  flv->lastkeyframelocation = pos;
1057  flv_append_keyframe_info(s, flv, ts, pos);
1058  }
1059  flv->acurframeindex++;
1060  break;
1061 
1062  case AVMEDIA_TYPE_AUDIO:
1063  flv->audiosize += (avio_tell(pb) - cur_offset);
1064  break;
1065 
1066  default:
1067  av_log(s, AV_LOG_WARNING, "par->codec_type is type = [%d]\n", par->codec_type);
1068  break;
1069  }
1070  }
1071 
1072  av_free(data);
1073 
1074  return pb->error;
1075 }
1076 
1077 static const AVOption options[] = {
1078  { "flvflags", "FLV muxer flags", offsetof(FLVContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1079  { "aac_seq_header_detect", "Put AAC sequence header based on stream data", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_AAC_SEQ_HEADER_DETECT}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1080  { "no_sequence_end", "disable sequence end for FLV", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_NO_SEQUENCE_END}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1081  { "no_metadata", "disable metadata for FLV", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_NO_METADATA}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1082  { "no_duration_filesize", "disable duration and filesize zero value metadata for FLV", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_NO_DURATION_FILESIZE}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1083  { "add_keyframe_index", "Add keyframe index metadata", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_ADD_KEYFRAME_INDEX}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1084  { NULL },
1085 };
1086 
1087 static const AVClass flv_muxer_class = {
1088  .class_name = "flv muxer",
1089  .item_name = av_default_item_name,
1090  .option = options,
1091  .version = LIBAVUTIL_VERSION_INT,
1092 };
1093 
1095  .name = "flv",
1096  .long_name = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1097  .mime_type = "video/x-flv",
1098  .extensions = "flv",
1099  .priv_data_size = sizeof(FLVContext),
1100  .audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_ADPCM_SWF,
1101  .video_codec = AV_CODEC_ID_FLV1,
1105  .codec_tag = (const AVCodecTag* const []) {
1107  },
1110  .priv_class = &flv_muxer_class,
1111 };
static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
Definition: flvenc.c:262
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:689
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
Definition: avformat.h:1940
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:463
#define NULL
Definition: coverity.c:32
static const AVCodecTag flv_audio_codec_ids[]
Definition: flvenc.c:52
int acurframeindex
Definition: flvenc.c:108
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
Buffered I/O operations.
#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED
The call resulted in updated metadata.
Definition: avformat.h:995
AVOutputFormat ff_flv_muxer
Definition: flvenc.c:1094
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
double framerate
Definition: flvenc.c:117
int64_t datastart_offset
Definition: flvenc.c:88
int64_t audiosize_offset
Definition: flvenc.c:93
int64_t delay
first dts delay (needed for AVC & Speex)
Definition: flvenc.c:86
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4882
const char * desc
Definition: nvenc.c:68
int64_t duration
Definition: flvenc.c:85
channels
Definition: aptx.c:30
enum AVCodecID codec_id
Definition: qsv.c:72
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3953
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1478
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
#define AVIO_FLAG_READ
read-only
Definition: avio.h:654
static int unsupported_codec(AVFormatContext *s, const char *type, int codec_id)
Definition: flvenc.c:477
signifies 5512Hz and 8000Hz in the case of NELLYMOSER
Definition: flv.h:84
static av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
Definition: intfloat.h:70
static const AVClass flv_muxer_class
Definition: flvenc.c:1087
#define READ_BLOCK
int event_flags
Flags for the user to detect events happening on the file.
Definition: avformat.h:1673
int64_t metadata_totalsize
Definition: flvenc.c:98
GLint GLenum type
Definition: opengl_enc.c:104
void * priv_data
Definition: avformat.h:896
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:331
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:3114
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
double lastkeyframetimestamp
Definition: flvenc.c:104
static AVPacket pkt
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:87
static int get_audio_flags(AVFormatContext *s, AVCodecParameters *par)
Definition: flvenc.c:127
int strict_std_compliance
Allow non-standard and experimental extension.
Definition: avformat.h:1666
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:477
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3945
int64_t keyframe_index_size
Definition: flvenc.c:99
static const AVCodecTag flv_video_codec_ids[]
Definition: flvenc.c:39
static const AVOption options[]
Definition: flvenc.c:1077
Format I/O context.
Definition: avformat.h:1358
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
internal metadata API header see avformat.h or the public API!
Public dictionary API.
FLVFileposition * head_filepositions
Definition: flvenc.c:113
uint8_t
static void flv_write_codec_header(AVFormatContext *s, AVCodecParameters *par, int64_t ts)
Definition: flvenc.c:488
#define av_malloc(s)
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: avcodec.h:4019
AVCodecParameters * video_par
Definition: flvenc.c:116
AVOptions.
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1495
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5637
double keyframe_timestamp
Definition: flvenc.c:76
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:493
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
A point in the output bytestream where a demuxer can start parsing (for non self synchronizing bytest...
Definition: avio.h:128
key frame (for AVC, a seekable frame)
Definition: flv.h:116
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
uint8_t * data
Definition: avcodec.h:1477
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
uint32_t tag
Definition: movenc.c:1496
AVCodecParameters * audio_par
Definition: flvenc.c:115
int64_t keyframes_info_offset
Definition: flvenc.c:109
int64_t metadata_totalsize_pos
Definition: flvenc.c:97
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
int64_t lastkeyframelocation_offset
Definition: flvenc.c:105
int64_t datasize_offset
Definition: flvenc.c:89
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:276
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3982
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:2628
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
static int flv_write_trailer(AVFormatContext *s)
Definition: flvenc.c:770
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
int64_t filepositions_count
Definition: flvenc.c:111
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
char * url
input or output URL.
Definition: avformat.h:1454
int64_t videosize
Definition: flvenc.c:92
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:565
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3949
int64_t videosize_offset
Definition: flvenc.c:91
static const int mpeg4audio_sample_rates[16]
Definition: aacenctab.h:85
simple assert() macros that are a bit more flexible than ISO C assert().
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: utils.c:5666
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:954
FLVFileposition * filepositions
Definition: flvenc.c:112
#define FFMAX(a, b)
Definition: common.h:94
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
Definition: avc.c:94
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3257
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3971
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
#define FLV_AUDIO_CODECID_OFFSET
Definition: flv.h:34
#define b
Definition: input.c:41
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: flvenc.c:874
int64_t lasttimestamp_offset
Definition: flvenc.c:101
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:466
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:487
const char * name
Definition: avformat.h:505
int64_t lastkeyframelocation
Definition: flvenc.c:106
static int flv_append_keyframe_info(AVFormatContext *s, FLVContext *flv, double ts, int64_t pos)
Definition: flvenc.c:550
#define s(width, name)
Definition: cbs_vp9.c:257
int n
Definition: avisynth_c.h:760
static void error(const char *err)
struct FLVFileposition * next
Definition: flvenc.c:77
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1139
int reserved
Definition: flvenc.c:82
static void put_timestamp(AVIOContext *pb, int64_t ts)
Definition: flvenc.c:234
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: avcodec.h:1199
FLV common header.
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
static int flv_write_header(AVFormatContext *s)
Definition: flvenc.c:657
AVRational framerate
Definition: flvdec.c:75
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:196
int64_t keyframe_position
Definition: flvenc.c:75
static void put_amf_string(AVIOContext *pb, const char *str)
Definition: flvenc.c:226
void * buf
Definition: avisynth_c.h:766
static void put_amf_double(AVIOContext *pb, double d)
Definition: flvenc.c:251
AVClass * av_class
Definition: flvenc.c:81
Describe the class of an AVClass context structure.
Definition: log.h:67
AVCodecParameters * data_par
Definition: flvenc.c:118
int64_t lastkeyframetimestamp_offset
Definition: flvenc.c:103
const char * name
Name of the codec described by this descriptor.
Definition: avcodec.h:724
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
Definition: flv.h:75
inter frame (for AVC, a non-seekable frame)
Definition: flv.h:117
int64_t datasize
Definition: flvenc.c:90
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:716
AAC encoder data.
#define AMF_END_OF_OBJECT
Definition: flv.h:47
static void put_amf_bool(AVIOContext *pb, int b)
Definition: flvenc.c:268
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:475
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:76
#define flags(name, subs,...)
Definition: cbs_av1.c:561
int sample_rate
Audio only.
Definition: avcodec.h:4063
Main libavformat public API header.
int64_t audiosize
Definition: flvenc.c:94
static void put_amf_byte(AVIOContext *pb, unsigned char abyte)
Definition: flvenc.c:257
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
int64_t duration_offset
Definition: flvenc.c:83
raw UTF-8 text
Definition: avcodec.h:660
static void write_metadata(AVFormatContext *s, unsigned int ts)
Definition: flvenc.c:274
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: avcodec.h:4013
int flags
Definition: flvenc.c:120
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:932
char * key
Definition: dict.h:86
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
int den
Denominator.
Definition: rational.h:60
double lasttimestamp
Definition: flvenc.c:102
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:790
static void put_avc_eos_tag(AVIOContext *pb, unsigned ts)
Definition: flvenc.c:239
A point in the output bytestream where a decoder can start decoding (i.e.
Definition: avio.h:122
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:470
#define av_free(p)
char * value
Definition: dict.h:87
int len
void * priv_data
Format private data.
Definition: avformat.h:1386
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:337
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3995
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3967
int channels
Audio only.
Definition: avcodec.h:4059
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1476
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:377
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1473
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
#define av_malloc_array(a, b)
int64_t filesize_offset
Definition: flvenc.c:84
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3957
int64_t metadata_size_pos
Definition: flvenc.c:96
int stream_index
Definition: avcodec.h:1479
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
This structure stores compressed data.
Definition: avcodec.h:1454
static int shift_data(AVFormatContext *s)
Definition: flvenc.c:577
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
int64_t last_ts
last timestamp for each stream
Definition: flvenc.c:124
FLVFlags
Definition: flvenc.c:66
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
Definition: avc.c:108
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
bitstream writer API