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); /* Save the pre-shift size. */
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 
612  /* Shift the data: the AVIO context of the output can only be used for
613  * writing, so we re-open the same output, but for reading. It also avoids
614  * a read/seek/write/seek back and forth. */
615  avio_flush(s->pb);
616  ret = s->io_open(s, &read_pb, s->url, AVIO_FLAG_READ, NULL);
617  if (ret < 0) {
618  av_log(s, AV_LOG_ERROR, "Unable to re-open %s output file for "
619  "the second pass (add_keyframe_index)\n", s->url);
620  goto end;
621  }
622 
623  /* Get ready for writing. */
624  avio_seek(s->pb, flv->keyframes_info_offset + metadata_size, SEEK_SET);
625 
626  /* start reading at where the keyframe index information will be placed */
627  avio_seek(read_pb, flv->keyframes_info_offset, SEEK_SET);
628  pos = avio_tell(read_pb);
629 
630 #define READ_BLOCK do { \
631  read_size[read_buf_id] = avio_read(read_pb, read_buf[read_buf_id], metadata_size); \
632  read_buf_id ^= 1; \
633 } while (0)
634 
635  /* shift data by chunk of at most keyframe *filepositions* and *times* size */
636  READ_BLOCK;
637  do {
638  READ_BLOCK;
639  n = read_size[read_buf_id];
640  if (n < 0)
641  break;
642  avio_write(s->pb, read_buf[read_buf_id], n);
643  pos += n;
644  } while (pos <= pos_end);
645 
646  ff_format_io_close(s, &read_pb);
647 
648 end:
649  av_free(buf);
650  return ret;
651 }
652 
653 static int flv_init(struct AVFormatContext *s)
654 {
655  int i;
656  FLVContext *flv = s->priv_data;
657 
658  for (i = 0; i < s->nb_streams; i++) {
659  AVCodecParameters *par = s->streams[i]->codecpar;
660  FLVStreamContext *sc;
661  switch (par->codec_type) {
662  case AVMEDIA_TYPE_VIDEO:
663  if (s->streams[i]->avg_frame_rate.den &&
664  s->streams[i]->avg_frame_rate.num) {
665  flv->framerate = av_q2d(s->streams[i]->avg_frame_rate);
666  }
667  if (flv->video_par) {
668  av_log(s, AV_LOG_ERROR,
669  "at most one video stream is supported in flv\n");
670  return AVERROR(EINVAL);
671  }
672  flv->video_par = par;
673  if (!ff_codec_get_tag(flv_video_codec_ids, par->codec_id))
674  return unsupported_codec(s, "Video", par->codec_id);
675 
676  if (par->codec_id == AV_CODEC_ID_MPEG4 ||
677  par->codec_id == AV_CODEC_ID_H263) {
679  av_log(s, error ? AV_LOG_ERROR : AV_LOG_WARNING,
680  "Codec %s is not supported in the official FLV specification,\n", avcodec_get_name(par->codec_id));
681 
682  if (error) {
683  av_log(s, AV_LOG_ERROR,
684  "use vstrict=-1 / -strict -1 to use it anyway.\n");
685  return AVERROR(EINVAL);
686  }
687  } else if (par->codec_id == AV_CODEC_ID_VP6) {
689  "Muxing VP6 in flv will produce flipped video on playback.\n");
690  }
691  break;
692  case AVMEDIA_TYPE_AUDIO:
693  if (flv->audio_par) {
694  av_log(s, AV_LOG_ERROR,
695  "at most one audio stream is supported in flv\n");
696  return AVERROR(EINVAL);
697  }
698  flv->audio_par = par;
699  if (get_audio_flags(s, par) < 0)
700  return unsupported_codec(s, "Audio", par->codec_id);
701  if (par->codec_id == AV_CODEC_ID_PCM_S16BE)
703  "16-bit big-endian audio in flv is valid but most likely unplayable (hardware dependent); use s16le\n");
704  break;
705  case AVMEDIA_TYPE_DATA:
706  if (par->codec_id != AV_CODEC_ID_TEXT && par->codec_id != AV_CODEC_ID_NONE)
707  return unsupported_codec(s, "Data", par->codec_id);
708  flv->data_par = par;
709  break;
711  if (par->codec_id != AV_CODEC_ID_TEXT) {
712  av_log(s, AV_LOG_ERROR, "Subtitle codec '%s' for stream %d is not compatible with FLV\n",
713  avcodec_get_name(par->codec_id), i);
714  return AVERROR_INVALIDDATA;
715  }
716  flv->data_par = par;
717  break;
718  default:
719  av_log(s, AV_LOG_ERROR, "Codec type '%s' for stream %d is not compatible with FLV\n",
721  return AVERROR(EINVAL);
722  }
723  avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
724 
725  sc = av_mallocz(sizeof(FLVStreamContext));
726  if (!sc)
727  return AVERROR(ENOMEM);
728  s->streams[i]->priv_data = sc;
729  sc->last_ts = -1;
730  }
731 
732  flv->delay = AV_NOPTS_VALUE;
733 
734  return 0;
735 }
736 
738 {
739  int i;
740  AVIOContext *pb = s->pb;
741  FLVContext *flv = s->priv_data;
742 
743  avio_write(pb, "FLV", 3);
744  avio_w8(pb, 1);
747  avio_wb32(pb, 9);
748  avio_wb32(pb, 0);
749 
750  for (i = 0; i < s->nb_streams; i++)
751  if (s->streams[i]->codecpar->codec_tag == 5) {
752  avio_w8(pb, 8); // message type
753  avio_wb24(pb, 0); // include flags
754  avio_wb24(pb, 0); // time stamp
755  avio_wb32(pb, 0); // reserved
756  avio_wb32(pb, 11); // size
757  flv->reserved = 5;
758  }
759 
760  if (flv->flags & FLV_NO_METADATA) {
761  pb->seekable = 0;
762  } else {
763  write_metadata(s, 0);
764  }
765 
766  for (i = 0; i < s->nb_streams; i++) {
768  }
769 
770  flv->datastart_offset = avio_tell(pb);
771  return 0;
772 }
773 
775 {
776  int64_t file_size;
777  AVIOContext *pb = s->pb;
778  FLVContext *flv = s->priv_data;
779  int build_keyframes_idx = flv->flags & FLV_ADD_KEYFRAME_INDEX;
780  int i, res;
781  int64_t cur_pos = avio_tell(s->pb);
782 
783  if (build_keyframes_idx) {
784  FLVFileposition *newflv_posinfo, *p;
785 
786  avio_seek(pb, flv->videosize_offset, SEEK_SET);
787  put_amf_double(pb, flv->videosize);
788 
789  avio_seek(pb, flv->audiosize_offset, SEEK_SET);
790  put_amf_double(pb, flv->audiosize);
791 
792  avio_seek(pb, flv->lasttimestamp_offset, SEEK_SET);
793  put_amf_double(pb, flv->lasttimestamp);
794 
795  avio_seek(pb, flv->lastkeyframetimestamp_offset, SEEK_SET);
797 
798  avio_seek(pb, flv->lastkeyframelocation_offset, SEEK_SET);
800  avio_seek(pb, cur_pos, SEEK_SET);
801 
802  res = shift_data(s);
803  if (res < 0) {
804  goto end;
805  }
806  avio_seek(pb, flv->keyframes_info_offset, SEEK_SET);
807  put_amf_string(pb, "filepositions");
809  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
810  put_amf_double(pb, newflv_posinfo->keyframe_position + flv->keyframe_index_size);
811  }
812 
813  put_amf_string(pb, "times");
815  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
816  put_amf_double(pb, newflv_posinfo->keyframe_timestamp);
817  }
818 
819  newflv_posinfo = flv->head_filepositions;
820  while (newflv_posinfo) {
821  p = newflv_posinfo->next;
822  if (p) {
823  newflv_posinfo->next = p->next;
824  av_free(p);
825  p = NULL;
826  } else {
827  av_free(newflv_posinfo);
828  newflv_posinfo = NULL;
829  }
830  }
831 
832  put_amf_string(pb, "");
834 
835  avio_seek(pb, cur_pos + flv->keyframe_index_size, SEEK_SET);
836  }
837 
838 end:
839  if (flv->flags & FLV_NO_SEQUENCE_END) {
840  av_log(s, AV_LOG_DEBUG, "FLV no sequence end mode open\n");
841  } else {
842  /* Add EOS tag */
843  for (i = 0; i < s->nb_streams; i++) {
844  AVCodecParameters *par = s->streams[i]->codecpar;
845  FLVStreamContext *sc = s->streams[i]->priv_data;
846  if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
848  put_avc_eos_tag(pb, sc->last_ts);
849  }
850  }
851 
852  file_size = avio_tell(pb);
853 
854  if (build_keyframes_idx) {
855  flv->datasize = file_size - flv->datastart_offset;
856  avio_seek(pb, flv->datasize_offset, SEEK_SET);
857  put_amf_double(pb, flv->datasize);
858  }
859  if (!(flv->flags & FLV_NO_METADATA)) {
860  if (!(flv->flags & FLV_NO_DURATION_FILESIZE)) {
861  /* update information */
862  if (avio_seek(pb, flv->duration_offset, SEEK_SET) < 0) {
863  av_log(s, AV_LOG_WARNING, "Failed to update header with correct duration.\n");
864  } else {
865  put_amf_double(pb, flv->duration / (double)1000);
866  }
867  if (avio_seek(pb, flv->filesize_offset, SEEK_SET) < 0) {
868  av_log(s, AV_LOG_WARNING, "Failed to update header with correct filesize.\n");
869  } else {
870  put_amf_double(pb, file_size);
871  }
872  }
873  }
874 
875  return 0;
876 }
877 
879 {
880  AVIOContext *pb = s->pb;
882  FLVContext *flv = s->priv_data;
884  unsigned ts;
885  int size = pkt->size;
886  uint8_t *data = NULL;
887  int flags = -1, flags_size, ret = 0;
888  int64_t cur_offset = avio_tell(pb);
889 
890  if (par->codec_type == AVMEDIA_TYPE_AUDIO && !pkt->size) {
891  av_log(s, AV_LOG_WARNING, "Empty audio Packet\n");
892  return AVERROR(EINVAL);
893  }
894 
895  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A ||
897  flags_size = 2;
898  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4)
899  flags_size = 5;
900  else
901  flags_size = 1;
902 
903  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
904  || par->codec_id == AV_CODEC_ID_MPEG4) {
905  int side_size;
907  if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
908  ret = ff_alloc_extradata(par, side_size);
909  if (ret < 0)
910  return ret;
911  memcpy(par->extradata, side, 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  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
925  if (pkt->pts == AV_NOPTS_VALUE) {
926  av_log(s, AV_LOG_ERROR, "Packet is missing PTS\n");
927  return AVERROR(EINVAL);
928  }
929  }
930 
931  ts = pkt->dts;
932 
934  write_metadata(s, ts);
936  }
937 
940 
941  switch (par->codec_type) {
942  case AVMEDIA_TYPE_VIDEO:
944 
945  flags = ff_codec_get_tag(flv_video_codec_ids, par->codec_id);
946 
948  break;
949  case AVMEDIA_TYPE_AUDIO:
950  flags = get_audio_flags(s, par);
951 
952  av_assert0(size);
953 
955  break;
957  case AVMEDIA_TYPE_DATA:
959  break;
960  default:
961  return AVERROR(EINVAL);
962  }
963 
964  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
965  /* check if extradata looks like mp4 formatted */
966  if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
967  if ((ret = ff_avc_parse_nal_units_buf(pkt->data, &data, &size)) < 0)
968  return ret;
969  } else if (par->codec_id == AV_CODEC_ID_AAC && pkt->size > 2 &&
970  (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
971  if (!s->streams[pkt->stream_index]->nb_frames) {
972  av_log(s, AV_LOG_ERROR, "Malformed AAC bitstream detected: "
973  "use the audio bitstream filter 'aac_adtstoasc' to fix it "
974  "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
975  return AVERROR_INVALIDDATA;
976  }
977  av_log(s, AV_LOG_WARNING, "aac bitstream error\n");
978  }
979 
980  /* check Speex packet duration */
981  if (par->codec_id == AV_CODEC_ID_SPEEX && ts - sc->last_ts > 160)
982  av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
983  "8 frames per packet. Adobe Flash "
984  "Player cannot handle this!\n");
985 
986  if (sc->last_ts < ts)
987  sc->last_ts = ts;
988 
989  if (size + flags_size >= 1<<24) {
990  av_log(s, AV_LOG_ERROR, "Too large packet with size %u >= %u\n",
991  size + flags_size, 1<<24);
992  ret = AVERROR(EINVAL);
993  goto fail;
994  }
995 
996  avio_wb24(pb, size + flags_size);
997  put_timestamp(pb, ts);
998  avio_wb24(pb, flv->reserved);
999 
1000  if (par->codec_type == AVMEDIA_TYPE_DATA ||
1001  par->codec_type == AVMEDIA_TYPE_SUBTITLE ) {
1002  int data_size;
1003  int64_t metadata_size_pos = avio_tell(pb);
1004  if (par->codec_id == AV_CODEC_ID_TEXT) {
1005  // legacy FFmpeg magic?
1007  put_amf_string(pb, "onTextData");
1009  avio_wb32(pb, 2);
1010  put_amf_string(pb, "type");
1012  put_amf_string(pb, "Text");
1013  put_amf_string(pb, "text");
1015  put_amf_string(pb, pkt->data);
1016  put_amf_string(pb, "");
1018  } else {
1019  // just pass the metadata through
1020  avio_write(pb, data ? data : pkt->data, size);
1021  }
1022  /* write total size of tag */
1023  data_size = avio_tell(pb) - metadata_size_pos;
1024  avio_seek(pb, metadata_size_pos - 10, SEEK_SET);
1025  avio_wb24(pb, data_size);
1026  avio_seek(pb, data_size + 10 - 3, SEEK_CUR);
1027  avio_wb32(pb, data_size + 11);
1028  } else {
1029  av_assert1(flags>=0);
1030  avio_w8(pb,flags);
1031  if (par->codec_id == AV_CODEC_ID_VP6)
1032  avio_w8(pb,0);
1033  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A) {
1034  if (par->extradata_size)
1035  avio_w8(pb, par->extradata[0]);
1036  else
1037  avio_w8(pb, ((FFALIGN(par->width, 16) - par->width) << 4) |
1038  (FFALIGN(par->height, 16) - par->height));
1039  } else if (par->codec_id == AV_CODEC_ID_AAC)
1040  avio_w8(pb, 1); // AAC raw
1041  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
1042  avio_w8(pb, 1); // AVC NALU
1043  avio_wb24(pb, pkt->pts - pkt->dts);
1044  }
1045 
1046  avio_write(pb, data ? data : pkt->data, size);
1047 
1048  avio_wb32(pb, size + flags_size + 11); // previous tag size
1049  flv->duration = FFMAX(flv->duration,
1050  pkt->pts + flv->delay + pkt->duration);
1051  }
1052 
1053  if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
1054  switch (par->codec_type) {
1055  case AVMEDIA_TYPE_VIDEO:
1056  flv->videosize += (avio_tell(pb) - cur_offset);
1057  flv->lasttimestamp = flv->acurframeindex / flv->framerate;
1058  flv->acurframeindex++;
1059  if (pkt->flags & AV_PKT_FLAG_KEY) {
1060  double ts = flv->lasttimestamp;
1061  int64_t pos = cur_offset;
1062 
1063  flv->lastkeyframetimestamp = ts;
1064  flv->lastkeyframelocation = pos;
1065  ret = flv_append_keyframe_info(s, flv, ts, pos);
1066  if (ret < 0)
1067  goto fail;
1068  }
1069  break;
1070 
1071  case AVMEDIA_TYPE_AUDIO:
1072  flv->audiosize += (avio_tell(pb) - cur_offset);
1073  break;
1074 
1075  default:
1076  av_log(s, AV_LOG_WARNING, "par->codec_type is type = [%d]\n", par->codec_type);
1077  break;
1078  }
1079  }
1080 fail:
1081  av_free(data);
1082 
1083  return ret;
1084 }
1085 
1086 static int flv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
1087 {
1088  int ret = 1;
1089  AVStream *st = s->streams[pkt->stream_index];
1090 
1091  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
1092  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
1093  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
1094  }
1095  return ret;
1096 }
1097 
1098 static const AVOption options[] = {
1099  { "flvflags", "FLV muxer flags", offsetof(FLVContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1100  { "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" },
1101  { "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" },
1102  { "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" },
1103  { "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" },
1104  { "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" },
1105  { NULL },
1106 };
1107 
1108 static const AVClass flv_muxer_class = {
1109  .class_name = "flv muxer",
1110  .item_name = av_default_item_name,
1111  .option = options,
1112  .version = LIBAVUTIL_VERSION_INT,
1113 };
1114 
1116  .name = "flv",
1117  .long_name = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1118  .mime_type = "video/x-flv",
1119  .extensions = "flv",
1120  .priv_data_size = sizeof(FLVContext),
1121  .audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_ADPCM_SWF,
1122  .video_codec = AV_CODEC_ID_FLV1,
1123  .init = flv_init,
1128  .codec_tag = (const AVCodecTag* const []) {
1130  },
1133  .priv_class = &flv_muxer_class,
1134 };
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:702
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:1937
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:453
#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:994
AVOutputFormat ff_flv_muxer
Definition: flvenc.c:1115
AVOption.
Definition: opt.h:248
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
const char * desc
Definition: libsvtav1.c:79
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
signifies 5512Hz and 8000Hz in the case of NELLYMOSER
Definition: flv.h:84
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:4868
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int64_t duration
Definition: flvenc.c:85
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int num
Numerator.
Definition: rational.h:59
int size
Definition: packet.h:364
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
#define AVIO_FLAG_READ
read-only
Definition: avio.h:674
static int unsupported_codec(AVFormatContext *s, const char *type, int codec_id)
Definition: flvenc.c:477
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:1108
#define READ_BLOCK
int event_flags
Flags for the user to detect events happening on the file.
Definition: avformat.h:1670
int64_t metadata_totalsize
Definition: flvenc.c:98
GLint GLenum type
Definition: opengl_enc.c:104
void * priv_data
Definition: avformat.h:895
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:341
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:3085
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
double lastkeyframetimestamp
Definition: flvenc.c:104
static AVPacket pkt
static void error(const char *err)
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:91
inter frame (for AVC, a non-seekable frame)
Definition: flv.h:117
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:1663
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:472
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
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:1098
Format I/O context.
Definition: avformat.h:1355
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: codec_par.h:126
AVCodecParameters * video_par
Definition: flvenc.c:116
AVOptions.
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:381
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5615
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:483
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1423
A point in the output bytestream where a demuxer can start parsing (for non self synchronizing bytest...
Definition: avio.h:128
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: packet.h:363
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
uint32_t tag
Definition: movenc.c:1597
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:225
int64_t lastkeyframelocation_offset
Definition: flvenc.c:105
int64_t datasize_offset
Definition: flvenc.c:89
channels
Definition: aptx.h:33
#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:278
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1593
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
static int flv_write_trailer(AVFormatContext *s)
Definition: flvenc.c:774
int64_t filepositions_count
Definition: flvenc.c:111
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1595
Definition: flv.h:75
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:353
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
char * url
input or output URL.
Definition: avformat.h:1451
int64_t videosize
Definition: flvenc.c:92
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:419
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
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:5644
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:953
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:95
#define fail()
Definition: checkasm.h:123
static int flv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
Definition: flvenc.c:1086
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1411
#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 ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0...
Definition: utils.c:3258
#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:878
int64_t lasttimestamp_offset
Definition: flvenc.c:101
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:461
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:477
const char * name
Definition: avformat.h:500
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
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
key frame (for AVC, a seekable frame)
Definition: flv.h:116
struct FLVFileposition * next
Definition: flvenc.c:77
int reserved
Definition: flvenc.c:82
static void put_timestamp(AVIOContext *pb, int64_t ts)
Definition: flvenc.c:234
Stream structure.
Definition: avformat.h:880
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
FLV common header.
AVIOContext * pb
I/O context.
Definition: avformat.h:1397
static int flv_write_header(AVFormatContext *s)
Definition: flvenc.c:737
AVRational framerate
Definition: flvdec.c:74
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:203
int64_t keyframe_position
Definition: flvenc.c:75
static void put_amf_string(AVIOContext *pb, const char *str)
Definition: flvenc.c:226
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
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:245
AVCodecParameters * data_par
Definition: flvenc.c:118
static int flv_init(struct AVFormatContext *s)
Definition: flvenc.c:653
int64_t lastkeyframetimestamp_offset
Definition: flvenc.c:103
const char * name
Name of the codec described by this descriptor.
Definition: codec_desc.h:46
int64_t datasize
Definition: flvenc.c:90
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: codec_desc.h:38
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:465
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:560
int sample_rate
Audio only.
Definition: codec_par.h:170
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:115
int64_t duration_offset
Definition: flvenc.c:83
raw UTF-8 text
Definition: codec_id.h:519
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: codec_par.h:120
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1200
int flags
Definition: flvenc.c:120
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:931
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:62
int den
Denominator.
Definition: rational.h:60
double lasttimestamp
Definition: flvenc.c:102
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:465
#define av_free(p)
char * value
Definition: dict.h:87
int len
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5499
void * priv_data
Format private data.
Definition: avformat.h:1383
static int check_bitstream(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: mux.c:1075
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3457
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
int channels
Audio only.
Definition: codec_par.h:166
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:362
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:387
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1470
#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:1027
#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: codec_par.h:64
int64_t metadata_size_pos
Definition: flvenc.c:96
int stream_index
Definition: packet.h:365
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: packet.h:340
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: packet.h:356
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
int i
Definition: input.c:407
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
bitstream writer API