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 static int flv_init(struct AVFormatContext *s)
657 {
658  int i;
659  FLVContext *flv = s->priv_data;
660 
661  for (i = 0; i < s->nb_streams; i++) {
662  AVCodecParameters *par = s->streams[i]->codecpar;
663  FLVStreamContext *sc;
664  switch (par->codec_type) {
665  case AVMEDIA_TYPE_VIDEO:
666  if (s->streams[i]->avg_frame_rate.den &&
667  s->streams[i]->avg_frame_rate.num) {
668  flv->framerate = av_q2d(s->streams[i]->avg_frame_rate);
669  }
670  if (flv->video_par) {
671  av_log(s, AV_LOG_ERROR,
672  "at most one video stream is supported in flv\n");
673  return AVERROR(EINVAL);
674  }
675  flv->video_par = par;
676  if (!ff_codec_get_tag(flv_video_codec_ids, par->codec_id))
677  return unsupported_codec(s, "Video", par->codec_id);
678 
679  if (par->codec_id == AV_CODEC_ID_MPEG4 ||
680  par->codec_id == AV_CODEC_ID_H263) {
682  av_log(s, error ? AV_LOG_ERROR : AV_LOG_WARNING,
683  "Codec %s is not supported in the official FLV specification,\n", avcodec_get_name(par->codec_id));
684 
685  if (error) {
686  av_log(s, AV_LOG_ERROR,
687  "use vstrict=-1 / -strict -1 to use it anyway.\n");
688  return AVERROR(EINVAL);
689  }
690  } else if (par->codec_id == AV_CODEC_ID_VP6) {
692  "Muxing VP6 in flv will produce flipped video on playback.\n");
693  }
694  break;
695  case AVMEDIA_TYPE_AUDIO:
696  if (flv->audio_par) {
697  av_log(s, AV_LOG_ERROR,
698  "at most one audio stream is supported in flv\n");
699  return AVERROR(EINVAL);
700  }
701  flv->audio_par = par;
702  if (get_audio_flags(s, par) < 0)
703  return unsupported_codec(s, "Audio", par->codec_id);
704  if (par->codec_id == AV_CODEC_ID_PCM_S16BE)
706  "16-bit big-endian audio in flv is valid but most likely unplayable (hardware dependent); use s16le\n");
707  break;
708  case AVMEDIA_TYPE_DATA:
709  if (par->codec_id != AV_CODEC_ID_TEXT && par->codec_id != AV_CODEC_ID_NONE)
710  return unsupported_codec(s, "Data", par->codec_id);
711  flv->data_par = par;
712  break;
714  if (par->codec_id != AV_CODEC_ID_TEXT) {
715  av_log(s, AV_LOG_ERROR, "Subtitle codec '%s' for stream %d is not compatible with FLV\n",
716  avcodec_get_name(par->codec_id), i);
717  return AVERROR_INVALIDDATA;
718  }
719  flv->data_par = par;
720  break;
721  default:
722  av_log(s, AV_LOG_ERROR, "Codec type '%s' for stream %d is not compatible with FLV\n",
724  return AVERROR(EINVAL);
725  }
726  avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
727 
728  sc = av_mallocz(sizeof(FLVStreamContext));
729  if (!sc)
730  return AVERROR(ENOMEM);
731  s->streams[i]->priv_data = sc;
732  sc->last_ts = -1;
733  }
734 
735  flv->delay = AV_NOPTS_VALUE;
736 
737  return 0;
738 }
739 
741 {
742  int i;
743  AVIOContext *pb = s->pb;
744  FLVContext *flv = s->priv_data;
745 
746  avio_write(pb, "FLV", 3);
747  avio_w8(pb, 1);
750  avio_wb32(pb, 9);
751  avio_wb32(pb, 0);
752 
753  for (i = 0; i < s->nb_streams; i++)
754  if (s->streams[i]->codecpar->codec_tag == 5) {
755  avio_w8(pb, 8); // message type
756  avio_wb24(pb, 0); // include flags
757  avio_wb24(pb, 0); // time stamp
758  avio_wb32(pb, 0); // reserved
759  avio_wb32(pb, 11); // size
760  flv->reserved = 5;
761  }
762 
763  if (flv->flags & FLV_NO_METADATA) {
764  pb->seekable = 0;
765  } else {
766  write_metadata(s, 0);
767  }
768 
769  for (i = 0; i < s->nb_streams; i++) {
771  }
772 
773  flv->datastart_offset = avio_tell(pb);
774  return 0;
775 }
776 
778 {
779  int64_t file_size;
780  AVIOContext *pb = s->pb;
781  FLVContext *flv = s->priv_data;
782  int build_keyframes_idx = flv->flags & FLV_ADD_KEYFRAME_INDEX;
783  int i, res;
784  int64_t cur_pos = avio_tell(s->pb);
785 
786  if (build_keyframes_idx) {
787  FLVFileposition *newflv_posinfo, *p;
788 
789  avio_seek(pb, flv->videosize_offset, SEEK_SET);
790  put_amf_double(pb, flv->videosize);
791 
792  avio_seek(pb, flv->audiosize_offset, SEEK_SET);
793  put_amf_double(pb, flv->audiosize);
794 
795  avio_seek(pb, flv->lasttimestamp_offset, SEEK_SET);
796  put_amf_double(pb, flv->lasttimestamp);
797 
798  avio_seek(pb, flv->lastkeyframetimestamp_offset, SEEK_SET);
800 
801  avio_seek(pb, flv->lastkeyframelocation_offset, SEEK_SET);
803  avio_seek(pb, cur_pos, SEEK_SET);
804 
805  res = shift_data(s);
806  if (res < 0) {
807  goto end;
808  }
809  avio_seek(pb, flv->keyframes_info_offset, SEEK_SET);
810  put_amf_string(pb, "filepositions");
812  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
813  put_amf_double(pb, newflv_posinfo->keyframe_position + flv->keyframe_index_size);
814  }
815 
816  put_amf_string(pb, "times");
818  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
819  put_amf_double(pb, newflv_posinfo->keyframe_timestamp);
820  }
821 
822  newflv_posinfo = flv->head_filepositions;
823  while (newflv_posinfo) {
824  p = newflv_posinfo->next;
825  if (p) {
826  newflv_posinfo->next = p->next;
827  av_free(p);
828  p = NULL;
829  } else {
830  av_free(newflv_posinfo);
831  newflv_posinfo = NULL;
832  }
833  }
834 
835  put_amf_string(pb, "");
837 
838  avio_seek(pb, cur_pos + flv->keyframe_index_size, SEEK_SET);
839  }
840 
841 end:
842  if (flv->flags & FLV_NO_SEQUENCE_END) {
843  av_log(s, AV_LOG_DEBUG, "FLV no sequence end mode open\n");
844  } else {
845  /* Add EOS tag */
846  for (i = 0; i < s->nb_streams; i++) {
847  AVCodecParameters *par = s->streams[i]->codecpar;
848  FLVStreamContext *sc = s->streams[i]->priv_data;
849  if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
851  put_avc_eos_tag(pb, sc->last_ts);
852  }
853  }
854 
855  file_size = avio_tell(pb);
856 
857  if (build_keyframes_idx) {
858  flv->datasize = file_size - flv->datastart_offset;
859  avio_seek(pb, flv->datasize_offset, SEEK_SET);
860  put_amf_double(pb, flv->datasize);
861  }
862  if (!(flv->flags & FLV_NO_METADATA)) {
863  if (!(flv->flags & FLV_NO_DURATION_FILESIZE)) {
864  /* update information */
865  if (avio_seek(pb, flv->duration_offset, SEEK_SET) < 0) {
866  av_log(s, AV_LOG_WARNING, "Failed to update header with correct duration.\n");
867  } else {
868  put_amf_double(pb, flv->duration / (double)1000);
869  }
870  if (avio_seek(pb, flv->filesize_offset, SEEK_SET) < 0) {
871  av_log(s, AV_LOG_WARNING, "Failed to update header with correct filesize.\n");
872  } else {
873  put_amf_double(pb, file_size);
874  }
875  }
876  }
877 
878  return 0;
879 }
880 
882 {
883  AVIOContext *pb = s->pb;
885  FLVContext *flv = s->priv_data;
887  unsigned ts;
888  int size = pkt->size;
889  uint8_t *data = NULL;
890  int flags = -1, flags_size, ret;
891  int64_t cur_offset = avio_tell(pb);
892 
893  if (par->codec_type == AVMEDIA_TYPE_AUDIO && !pkt->size) {
894  av_log(s, AV_LOG_WARNING, "Empty audio Packet\n");
895  return AVERROR(EINVAL);
896  }
897 
898  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A ||
900  flags_size = 2;
901  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4)
902  flags_size = 5;
903  else
904  flags_size = 1;
905 
906  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
907  || par->codec_id == AV_CODEC_ID_MPEG4) {
908  int side_size = 0;
910  if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
911  av_free(par->extradata);
913  if (!par->extradata) {
914  par->extradata_size = 0;
915  return AVERROR(ENOMEM);
916  }
917  memcpy(par->extradata, side, side_size);
918  par->extradata_size = side_size;
919  flv_write_codec_header(s, par, pkt->dts);
920  }
921  }
922 
923  if (flv->delay == AV_NOPTS_VALUE)
924  flv->delay = -pkt->dts;
925 
926  if (pkt->dts < -flv->delay) {
928  "Packets are not in the proper order with respect to DTS\n");
929  return AVERROR(EINVAL);
930  }
931 
932  ts = pkt->dts;
933 
935  write_metadata(s, ts);
937  }
938 
941 
942  switch (par->codec_type) {
943  case AVMEDIA_TYPE_VIDEO:
945 
946  flags = ff_codec_get_tag(flv_video_codec_ids, par->codec_id);
947 
949  break;
950  case AVMEDIA_TYPE_AUDIO:
951  flags = get_audio_flags(s, par);
952 
953  av_assert0(size);
954 
956  break;
958  case AVMEDIA_TYPE_DATA:
960  break;
961  default:
962  return AVERROR(EINVAL);
963  }
964 
965  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
966  /* check if extradata looks like mp4 formatted */
967  if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
968  if ((ret = ff_avc_parse_nal_units_buf(pkt->data, &data, &size)) < 0)
969  return ret;
970  } else if (par->codec_id == AV_CODEC_ID_AAC && pkt->size > 2 &&
971  (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
972  if (!s->streams[pkt->stream_index]->nb_frames) {
973  av_log(s, AV_LOG_ERROR, "Malformed AAC bitstream detected: "
974  "use the audio bitstream filter 'aac_adtstoasc' to fix it "
975  "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
976  return AVERROR_INVALIDDATA;
977  }
978  av_log(s, AV_LOG_WARNING, "aac bitstream error\n");
979  }
980 
981  /* check Speex packet duration */
982  if (par->codec_id == AV_CODEC_ID_SPEEX && ts - sc->last_ts > 160)
983  av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
984  "8 frames per packet. Adobe Flash "
985  "Player cannot handle this!\n");
986 
987  if (sc->last_ts < ts)
988  sc->last_ts = ts;
989 
990  if (size + flags_size >= 1<<24) {
991  av_log(s, AV_LOG_ERROR, "Too large packet with size %u >= %u\n",
992  size + flags_size, 1<<24);
993  return AVERROR(EINVAL);
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  if (pkt->flags & AV_PKT_FLAG_KEY) {
1059  double ts = flv->acurframeindex / flv->framerate;
1060  int64_t pos = cur_offset;
1061 
1062  flv->lastkeyframetimestamp = flv->acurframeindex / flv->framerate;
1063  flv->lastkeyframelocation = pos;
1064  flv_append_keyframe_info(s, flv, ts, pos);
1065  }
1066  flv->acurframeindex++;
1067  break;
1068 
1069  case AVMEDIA_TYPE_AUDIO:
1070  flv->audiosize += (avio_tell(pb) - cur_offset);
1071  break;
1072 
1073  default:
1074  av_log(s, AV_LOG_WARNING, "par->codec_type is type = [%d]\n", par->codec_type);
1075  break;
1076  }
1077  }
1078 
1079  av_free(data);
1080 
1081  return pb->error;
1082 }
1083 
1084 static int flv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
1085 {
1086  int ret = 1;
1087  AVStream *st = s->streams[pkt->stream_index];
1088 
1089  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
1090  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
1091  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
1092  }
1093  return ret;
1094 }
1095 
1096 static const AVOption options[] = {
1097  { "flvflags", "FLV muxer flags", offsetof(FLVContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1098  { "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" },
1099  { "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" },
1100  { "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" },
1101  { "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" },
1102  { "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" },
1103  { NULL },
1104 };
1105 
1106 static const AVClass flv_muxer_class = {
1107  .class_name = "flv muxer",
1108  .item_name = av_default_item_name,
1109  .option = options,
1110  .version = LIBAVUTIL_VERSION_INT,
1111 };
1112 
1114  .name = "flv",
1115  .long_name = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1116  .mime_type = "video/x-flv",
1117  .extensions = "flv",
1118  .priv_data_size = sizeof(FLVContext),
1119  .audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_ADPCM_SWF,
1120  .video_codec = AV_CODEC_ID_FLV1,
1121  .init = flv_init,
1125  .check_bitstream= flv_check_bitstream,
1126  .codec_tag = (const AVCodecTag* const []) {
1128  },
1131  .priv_class = &flv_muxer_class,
1132 };
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:466
#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:1113
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:4926
const char * desc
Definition: nvenc.c:68
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int64_t duration
Definition: flvenc.c:85
channels
Definition: aptx.c:30
enum AVCodecID codec_id
Definition: qsv.c:77
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3968
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1481
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: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:1106
#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:334
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:3148
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:3960
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:1096
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:4034
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:1498
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5681
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:496
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
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:1480
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
uint32_t tag
Definition: movenc.c:1531
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
Definition: flv.h:75
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:3997
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:2635
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1512
static int flv_write_trailer(AVFormatContext *s)
Definition: flvenc.c:777
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
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:566
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3964
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:5710
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
static int flv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
Definition: flvenc.c:1084
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1486
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3276
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3986
key frame (for AVC, a seekable frame)
Definition: flv.h:116
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
#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:881
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:490
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:1161
int reserved
Definition: flvenc.c:82
static void put_timestamp(AVIOContext *pb, int64_t ts)
Definition: flvenc.c:234
Stream structure.
Definition: avformat.h:881
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: avcodec.h:1202
FLV common header.
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
static int flv_write_header(AVFormatContext *s)
Definition: flvenc.c:740
AVRational framerate
Definition: flvdec.c:74
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
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
AVCodecParameters * data_par
Definition: flvenc.c:118
static int flv_init(struct AVFormatContext *s)
Definition: flvenc.c:656
int64_t lastkeyframetimestamp_offset
Definition: flvenc.c:103
const char * name
Name of the codec described by this descriptor.
Definition: avcodec.h:727
inter frame (for AVC, a non-seekable frame)
Definition: flv.h:117
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
int64_t datasize
Definition: flvenc.c:90
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:719
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:478
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:4078
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:662
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:4028
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:793
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
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5556
void * priv_data
Format private data.
Definition: avformat.h:1386
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:349
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:4010
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3982
int channels
Audio only.
Definition: avcodec.h:4074
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1479
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:380
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:3972
int64_t metadata_size_pos
Definition: flvenc.c:96
signifies 5512Hz and 8000Hz in the case of NELLYMOSER
Definition: flv.h:84
int stream_index
Definition: avcodec.h:1482
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:1457
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:1473
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