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 "libavcodec/mpeg4audio.h"
28 #include "avio_internal.h"
29 #include "avio.h"
30 #include "avc.h"
31 #include "avformat.h"
32 #include "flv.h"
33 #include "internal.h"
34 #include "metadata.h"
35 #include "libavutil/opt.h"
36 #include "libavcodec/put_bits.h"
37 
38 
39 static const AVCodecTag flv_video_codec_ids[] = {
49  { AV_CODEC_ID_NONE, 0 }
50 };
51 
52 static const AVCodecTag flv_audio_codec_ids[] = {
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) {
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) {
152  break;
153  } else {
154  goto error;
155  }
156  case 44100:
158  break;
159  case 22050:
161  break;
162  case 11025:
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) {
170  break;
171  }
172  default:
173 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  put_timestamp(pb, ts); // timestamp
288  avio_wb24(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
311  put_amf_double(pb, s->duration / AV_TIME_BASE);
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 {
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  == ff_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;
580  int64_t metadata_size = 0;
581  FLVContext *flv = s->priv_data;
582 
583  metadata_size = flv->filepositions_count * 9 * 2 + 10; /* filepositions and times value */
584  metadata_size += 2 + 13; /* filepositions String */
585  metadata_size += 2 + 5; /* times String */
586  metadata_size += 3; /* Object end */
587 
588  flv->keyframe_index_size = metadata_size;
589 
590  if (metadata_size < 0)
591  return metadata_size;
592 
593  ret = ff_format_shift_data(s, flv->keyframes_info_offset, metadata_size);
594  if (ret < 0)
595  return ret;
596 
597  avio_seek(s->pb, flv->metadata_size_pos, SEEK_SET);
598  avio_wb24(s->pb, flv->metadata_totalsize + metadata_size);
599 
600  avio_seek(s->pb, flv->metadata_totalsize_pos + metadata_size, SEEK_SET);
601  avio_wb32(s->pb, flv->metadata_totalsize + 11 + metadata_size);
602 
603  return 0;
604 }
605 
606 static int flv_init(struct AVFormatContext *s)
607 {
608  int i;
609  FLVContext *flv = s->priv_data;
610 
611  for (i = 0; i < s->nb_streams; i++) {
612  AVCodecParameters *par = s->streams[i]->codecpar;
613  FLVStreamContext *sc;
614  switch (par->codec_type) {
615  case AVMEDIA_TYPE_VIDEO:
616  if (s->streams[i]->avg_frame_rate.den &&
617  s->streams[i]->avg_frame_rate.num) {
618  flv->framerate = av_q2d(s->streams[i]->avg_frame_rate);
619  }
620  if (flv->video_par) {
622  "at most one video stream is supported in flv\n");
623  return AVERROR(EINVAL);
624  }
625  flv->video_par = par;
627  return unsupported_codec(s, "Video", par->codec_id);
628 
629  if (par->codec_id == AV_CODEC_ID_MPEG4 ||
630  par->codec_id == AV_CODEC_ID_H263) {
631  int error = s->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL;
633  "Codec %s is not supported in the official FLV specification,\n", avcodec_get_name(par->codec_id));
634 
635  if (error) {
637  "use vstrict=-1 / -strict -1 to use it anyway.\n");
638  return AVERROR(EINVAL);
639  }
640  } else if (par->codec_id == AV_CODEC_ID_VP6) {
642  "Muxing VP6 in flv will produce flipped video on playback.\n");
643  }
644  break;
645  case AVMEDIA_TYPE_AUDIO:
646  if (flv->audio_par) {
648  "at most one audio stream is supported in flv\n");
649  return AVERROR(EINVAL);
650  }
651  flv->audio_par = par;
652  if (get_audio_flags(s, par) < 0)
653  return unsupported_codec(s, "Audio", par->codec_id);
654  if (par->codec_id == AV_CODEC_ID_PCM_S16BE)
656  "16-bit big-endian audio in flv is valid but most likely unplayable (hardware dependent); use s16le\n");
657  break;
658  case AVMEDIA_TYPE_DATA:
659  if (par->codec_id != AV_CODEC_ID_TEXT && par->codec_id != AV_CODEC_ID_NONE)
660  return unsupported_codec(s, "Data", par->codec_id);
661  flv->data_par = par;
662  break;
664  if (par->codec_id != AV_CODEC_ID_TEXT) {
665  av_log(s, AV_LOG_ERROR, "Subtitle codec '%s' for stream %d is not compatible with FLV\n",
666  avcodec_get_name(par->codec_id), i);
667  return AVERROR_INVALIDDATA;
668  }
669  flv->data_par = par;
670  break;
671  default:
672  av_log(s, AV_LOG_ERROR, "Codec type '%s' for stream %d is not compatible with FLV\n",
674  return AVERROR(EINVAL);
675  }
676  avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
677 
678  sc = av_mallocz(sizeof(FLVStreamContext));
679  if (!sc)
680  return AVERROR(ENOMEM);
681  s->streams[i]->priv_data = sc;
682  sc->last_ts = -1;
683  }
684 
685  flv->delay = AV_NOPTS_VALUE;
686 
687  return 0;
688 }
689 
691 {
692  int i;
693  AVIOContext *pb = s->pb;
694  FLVContext *flv = s->priv_data;
695 
696  avio_write(pb, "FLV", 3);
697  avio_w8(pb, 1);
700  avio_wb32(pb, 9);
701  avio_wb32(pb, 0);
702 
703  for (i = 0; i < s->nb_streams; i++)
704  if (s->streams[i]->codecpar->codec_tag == 5) {
705  avio_w8(pb, 8); // message type
706  avio_wb24(pb, 0); // include flags
707  avio_wb24(pb, 0); // time stamp
708  avio_wb32(pb, 0); // reserved
709  avio_wb32(pb, 11); // size
710  flv->reserved = 5;
711  }
712 
713  if (flv->flags & FLV_NO_METADATA) {
714  pb->seekable = 0;
715  } else {
716  write_metadata(s, 0);
717  }
718 
719  for (i = 0; i < s->nb_streams; i++) {
720  flv_write_codec_header(s, s->streams[i]->codecpar, 0);
721  }
722 
723  flv->datastart_offset = avio_tell(pb);
724  return 0;
725 }
726 
728 {
729  int64_t file_size;
730  AVIOContext *pb = s->pb;
731  FLVContext *flv = s->priv_data;
732  int build_keyframes_idx = flv->flags & FLV_ADD_KEYFRAME_INDEX;
733  int i, res;
734  int64_t cur_pos = avio_tell(s->pb);
735 
736  if (build_keyframes_idx) {
737  FLVFileposition *newflv_posinfo, *p;
738 
739  avio_seek(pb, flv->videosize_offset, SEEK_SET);
740  put_amf_double(pb, flv->videosize);
741 
742  avio_seek(pb, flv->audiosize_offset, SEEK_SET);
743  put_amf_double(pb, flv->audiosize);
744 
745  avio_seek(pb, flv->lasttimestamp_offset, SEEK_SET);
746  put_amf_double(pb, flv->lasttimestamp);
747 
748  avio_seek(pb, flv->lastkeyframetimestamp_offset, SEEK_SET);
750 
751  avio_seek(pb, flv->lastkeyframelocation_offset, SEEK_SET);
753  avio_seek(pb, cur_pos, SEEK_SET);
754 
755  res = shift_data(s);
756  if (res < 0) {
757  goto end;
758  }
759  avio_seek(pb, flv->keyframes_info_offset, SEEK_SET);
760  put_amf_string(pb, "filepositions");
762  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
763  put_amf_double(pb, newflv_posinfo->keyframe_position + flv->keyframe_index_size);
764  }
765 
766  put_amf_string(pb, "times");
768  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
769  put_amf_double(pb, newflv_posinfo->keyframe_timestamp);
770  }
771 
772  newflv_posinfo = flv->head_filepositions;
773  while (newflv_posinfo) {
774  p = newflv_posinfo->next;
775  if (p) {
776  newflv_posinfo->next = p->next;
777  av_free(p);
778  p = NULL;
779  } else {
780  av_free(newflv_posinfo);
781  newflv_posinfo = NULL;
782  }
783  }
784 
785  put_amf_string(pb, "");
787 
788  avio_seek(pb, cur_pos + flv->keyframe_index_size, SEEK_SET);
789  }
790 
791 end:
792  if (flv->flags & FLV_NO_SEQUENCE_END) {
793  av_log(s, AV_LOG_DEBUG, "FLV no sequence end mode open\n");
794  } else {
795  /* Add EOS tag */
796  for (i = 0; i < s->nb_streams; i++) {
797  AVCodecParameters *par = s->streams[i]->codecpar;
798  FLVStreamContext *sc = s->streams[i]->priv_data;
799  if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
801  put_avc_eos_tag(pb, sc->last_ts);
802  }
803  }
804 
805  file_size = avio_tell(pb);
806 
807  if (build_keyframes_idx) {
808  flv->datasize = file_size - flv->datastart_offset;
809  avio_seek(pb, flv->datasize_offset, SEEK_SET);
810  put_amf_double(pb, flv->datasize);
811  }
812  if (!(flv->flags & FLV_NO_METADATA)) {
813  if (!(flv->flags & FLV_NO_DURATION_FILESIZE)) {
814  /* update information */
815  if (avio_seek(pb, flv->duration_offset, SEEK_SET) < 0) {
816  av_log(s, AV_LOG_WARNING, "Failed to update header with correct duration.\n");
817  } else {
818  put_amf_double(pb, flv->duration / (double)1000);
819  }
820  if (avio_seek(pb, flv->filesize_offset, SEEK_SET) < 0) {
821  av_log(s, AV_LOG_WARNING, "Failed to update header with correct filesize.\n");
822  } else {
823  put_amf_double(pb, file_size);
824  }
825  }
826  }
827 
828  return 0;
829 }
830 
832 {
833  AVIOContext *pb = s->pb;
834  AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
835  FLVContext *flv = s->priv_data;
836  FLVStreamContext *sc = s->streams[pkt->stream_index]->priv_data;
837  unsigned ts;
838  int size = pkt->size;
839  uint8_t *data = NULL;
840  int flags = -1, flags_size, ret = 0;
841  int64_t cur_offset = avio_tell(pb);
842 
843  if (par->codec_type == AVMEDIA_TYPE_AUDIO && !pkt->size) {
844  av_log(s, AV_LOG_WARNING, "Empty audio Packet\n");
845  return AVERROR(EINVAL);
846  }
847 
848  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A ||
850  flags_size = 2;
851  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4)
852  flags_size = 5;
853  else
854  flags_size = 1;
855 
856  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
857  || par->codec_id == AV_CODEC_ID_MPEG4) {
858  size_t side_size;
859  uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
860  if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
861  ret = ff_alloc_extradata(par, side_size);
862  if (ret < 0)
863  return ret;
864  memcpy(par->extradata, side, side_size);
866  }
867  }
868 
869  if (flv->delay == AV_NOPTS_VALUE)
870  flv->delay = -pkt->dts;
871 
872  if (pkt->dts < -flv->delay) {
874  "Packets are not in the proper order with respect to DTS\n");
875  return AVERROR(EINVAL);
876  }
877  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
878  if (pkt->pts == AV_NOPTS_VALUE) {
879  av_log(s, AV_LOG_ERROR, "Packet is missing PTS\n");
880  return AVERROR(EINVAL);
881  }
882  }
883 
884  ts = pkt->dts;
885 
886  if (s->event_flags & AVSTREAM_EVENT_FLAG_METADATA_UPDATED) {
887  write_metadata(s, ts);
888  s->event_flags &= ~AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
889  }
890 
893 
894  switch (par->codec_type) {
895  case AVMEDIA_TYPE_VIDEO:
897 
899 
901  break;
902  case AVMEDIA_TYPE_AUDIO:
903  flags = get_audio_flags(s, par);
904 
905  av_assert0(size);
906 
908  break;
910  case AVMEDIA_TYPE_DATA:
912  break;
913  default:
914  return AVERROR(EINVAL);
915  }
916 
917  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
918  /* check if extradata looks like mp4 formatted */
919  if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
920  if ((ret = ff_avc_parse_nal_units_buf(pkt->data, &data, &size)) < 0)
921  return ret;
922  } else if (par->codec_id == AV_CODEC_ID_AAC && pkt->size > 2 &&
923  (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
924  if (!s->streams[pkt->stream_index]->nb_frames) {
925  av_log(s, AV_LOG_ERROR, "Malformed AAC bitstream detected: "
926  "use the audio bitstream filter 'aac_adtstoasc' to fix it "
927  "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
928  return AVERROR_INVALIDDATA;
929  }
930  av_log(s, AV_LOG_WARNING, "aac bitstream error\n");
931  }
932 
933  /* check Speex packet duration */
934  if (par->codec_id == AV_CODEC_ID_SPEEX && ts - sc->last_ts > 160)
935  av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
936  "8 frames per packet. Adobe Flash "
937  "Player cannot handle this!\n");
938 
939  if (sc->last_ts < ts)
940  sc->last_ts = ts;
941 
942  if (size + flags_size >= 1<<24) {
943  av_log(s, AV_LOG_ERROR, "Too large packet with size %u >= %u\n",
944  size + flags_size, 1<<24);
945  ret = AVERROR(EINVAL);
946  goto fail;
947  }
948 
949  avio_wb24(pb, size + flags_size);
950  put_timestamp(pb, ts);
951  avio_wb24(pb, flv->reserved);
952 
953  if (par->codec_type == AVMEDIA_TYPE_DATA ||
955  int data_size;
956  int64_t metadata_size_pos = avio_tell(pb);
957  if (par->codec_id == AV_CODEC_ID_TEXT) {
958  // legacy FFmpeg magic?
960  put_amf_string(pb, "onTextData");
962  avio_wb32(pb, 2);
963  put_amf_string(pb, "type");
965  put_amf_string(pb, "Text");
966  put_amf_string(pb, "text");
968  put_amf_string(pb, pkt->data);
969  put_amf_string(pb, "");
971  } else {
972  // just pass the metadata through
973  avio_write(pb, data ? data : pkt->data, size);
974  }
975  /* write total size of tag */
976  data_size = avio_tell(pb) - metadata_size_pos;
977  avio_seek(pb, metadata_size_pos - 10, SEEK_SET);
978  avio_wb24(pb, data_size);
979  avio_seek(pb, data_size + 10 - 3, SEEK_CUR);
980  avio_wb32(pb, data_size + 11);
981  } else {
982  av_assert1(flags>=0);
983  avio_w8(pb,flags);
984  if (par->codec_id == AV_CODEC_ID_VP6)
985  avio_w8(pb,0);
986  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A) {
987  if (par->extradata_size)
988  avio_w8(pb, par->extradata[0]);
989  else
990  avio_w8(pb, ((FFALIGN(par->width, 16) - par->width) << 4) |
991  (FFALIGN(par->height, 16) - par->height));
992  } else if (par->codec_id == AV_CODEC_ID_AAC)
993  avio_w8(pb, 1); // AAC raw
994  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
995  avio_w8(pb, 1); // AVC NALU
996  avio_wb24(pb, pkt->pts - pkt->dts);
997  }
998 
999  avio_write(pb, data ? data : pkt->data, size);
1000 
1001  avio_wb32(pb, size + flags_size + 11); // previous tag size
1002  flv->duration = FFMAX(flv->duration,
1003  pkt->pts + flv->delay + pkt->duration);
1004  }
1005 
1006  if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
1007  switch (par->codec_type) {
1008  case AVMEDIA_TYPE_VIDEO:
1009  flv->videosize += (avio_tell(pb) - cur_offset);
1010  flv->lasttimestamp = flv->acurframeindex / flv->framerate;
1011  flv->acurframeindex++;
1012  if (pkt->flags & AV_PKT_FLAG_KEY) {
1013  double ts = flv->lasttimestamp;
1014  int64_t pos = cur_offset;
1015 
1016  flv->lastkeyframetimestamp = ts;
1017  flv->lastkeyframelocation = pos;
1018  ret = flv_append_keyframe_info(s, flv, ts, pos);
1019  if (ret < 0)
1020  goto fail;
1021  }
1022  break;
1023 
1024  case AVMEDIA_TYPE_AUDIO:
1025  flv->audiosize += (avio_tell(pb) - cur_offset);
1026  break;
1027 
1028  default:
1029  av_log(s, AV_LOG_WARNING, "par->codec_type is type = [%d]\n", par->codec_type);
1030  break;
1031  }
1032  }
1033 fail:
1034  av_free(data);
1035 
1036  return ret;
1037 }
1038 
1040  const AVPacket *pkt)
1041 {
1042  int ret = 1;
1043 
1044  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
1045  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
1046  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
1047  }
1048  return ret;
1049 }
1050 
1051 static const AVOption options[] = {
1052  { "flvflags", "FLV muxer flags", offsetof(FLVContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1053  { "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" },
1054  { "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" },
1055  { "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" },
1056  { "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" },
1057  { "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" },
1058  { NULL },
1059 };
1060 
1061 static const AVClass flv_muxer_class = {
1062  .class_name = "flv muxer",
1063  .item_name = av_default_item_name,
1064  .option = options,
1065  .version = LIBAVUTIL_VERSION_INT,
1066 };
1067 
1069  .name = "flv",
1070  .long_name = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1071  .mime_type = "video/x-flv",
1072  .extensions = "flv",
1073  .priv_data_size = sizeof(FLVContext),
1074  .audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_ADPCM_SWF,
1075  .video_codec = AV_CODEC_ID_FLV1,
1076  .init = flv_init,
1081  .codec_tag = (const AVCodecTag* const []) {
1083  },
1086  .priv_class = &flv_muxer_class,
1087 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
FLV_CODECID_H264
@ FLV_CODECID_H264
Definition: flv.h:110
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:314
FLVContext::metadata_totalsize
int64_t metadata_totalsize
Definition: flvenc.c:98
FLVContext::audio_par
AVCodecParameters * audio_par
Definition: flvenc.c:115
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_CODEC_ID_VP6F
@ AV_CODEC_ID_VP6F
Definition: codec_id.h:142
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ff_flv_muxer
const AVOutputFormat ff_flv_muxer
Definition: flvenc.c:1068
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
FLV_NO_DURATION_FILESIZE
@ FLV_NO_DURATION_FILESIZE
Definition: flvenc.c:71
AVIO_DATA_MARKER_BOUNDARY_POINT
@ AVIO_DATA_MARKER_BOUNDARY_POINT
A point in the output bytestream where a demuxer can start parsing (for non self synchronizing bytest...
Definition: avio.h:128
FLVContext::duration_offset
int64_t duration_offset
Definition: flvenc.c:83
AVOutputFormat::name
const char * name
Definition: avformat.h:504
AVERROR
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
put_avc_eos_tag
static void put_avc_eos_tag(AVIOContext *pb, unsigned ts)
Definition: flvenc.c:239
opt.h
FLV_HEADER_FLAG_HASVIDEO
@ FLV_HEADER_FLAG_HASVIDEO
Definition: flv.h:55
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
FLVContext::flags
int flags
Definition: flvenc.c:120
FLV_CODECID_VP6A
@ FLV_CODECID_VP6A
Definition: flv.h:108
FLV_CODECID_AAC
@ FLV_CODECID_AAC
Definition: flv.h:100
FLVContext::filepositions
FLVFileposition * filepositions
Definition: flvenc.c:112
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
FLV_NO_SEQUENCE_END
@ FLV_NO_SEQUENCE_END
Definition: flvenc.c:68
FLV_CODECID_SCREEN
@ FLV_CODECID_SCREEN
Definition: flv.h:106
AMF_END_OF_OBJECT
#define AMF_END_OF_OBJECT
Definition: flv.h:47
AVFMT_VARIABLE_FPS
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:478
FLVContext::delay
int64_t delay
first dts delay (needed for AVC & Speex)
Definition: flvenc.c:86
FLV_CODECID_PCM_ALAW
@ FLV_CODECID_PCM_ALAW
Definition: flv.h:98
FLV_SAMPLERATE_11025HZ
@ FLV_SAMPLERATE_11025HZ
Definition: flv.h:85
FLV_FRAME_INTER
@ FLV_FRAME_INTER
inter frame (for AVC, a non-seekable frame)
Definition: flv.h:117
FLVContext::acurframeindex
int acurframeindex
Definition: flvenc.c:108
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:61
check_bitstream
static int check_bitstream(AVFormatContext *s, FFStream *sti, AVPacket *pkt)
Definition: mux.c:1062
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:62
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
AVPacket::data
uint8_t * data
Definition: packet.h:373
FLVContext::metadata_totalsize_pos
int64_t metadata_totalsize_pos
Definition: flvenc.c:97
AV_CODEC_ID_VP6
@ AV_CODEC_ID_VP6
Definition: codec_id.h:141
AVOption
AVOption.
Definition: opt.h:247
b
#define b
Definition: input.c:40
data
const char data[16]
Definition: mxf.c:143
FLV_CODECID_VP6
@ FLV_CODECID_VP6
Definition: flv.h:107
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:68
FLV_STEREO
@ FLV_STEREO
Definition: flv.h:75
FLVContext::audiosize_offset
int64_t audiosize_offset
Definition: flvenc.c:93
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
mathematics.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
FLV_CODECID_SCREEN2
@ FLV_CODECID_SCREEN2
Definition: flv.h:109
FLV_SAMPLERATE_44100HZ
@ FLV_SAMPLERATE_44100HZ
Definition: flv.h:87
intfloat.h
put_amf_bool
static void put_amf_bool(AVIOContext *pb, int b)
Definition: flvenc.c:268
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:428
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1284
FLVContext::lasttimestamp_offset
int64_t lasttimestamp_offset
Definition: flvenc.c:101
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
init
static int init
Definition: av_tx.c:47
FLVContext::videosize_offset
int64_t videosize_offset
Definition: flvenc.c:91
FLV_CODECID_MPEG4
@ FLV_CODECID_MPEG4
Definition: flv.h:112
avio_write_marker
void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type)
Mark the written bytestream as a specific type.
Definition: aviobuf.c:490
FLV_CODECID_PCM_LE
@ FLV_CODECID_PCM_LE
Definition: flv.h:94
flv_append_keyframe_info
static int flv_append_keyframe_info(AVFormatContext *s, FLVContext *flv, double ts, int64_t pos)
Definition: flvenc.c:550
FLVContext::lastkeyframelocation_offset
int64_t lastkeyframelocation_offset
Definition: flvenc.c:105
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
mpeg4audio.h
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:458
flv_write_packet
static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: flvenc.c:831
AMF_DATA_TYPE_STRING
@ AMF_DATA_TYPE_STRING
Definition: flv.h:126
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:315
fail
#define fail()
Definition: checkasm.h:128
FLVContext::lastkeyframetimestamp
double lastkeyframetimestamp
Definition: flvenc.c:104
put_amf_double
static void put_amf_double(AVIOContext *pb, double d)
Definition: flvenc.c:251
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:504
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:424
FLV_SAMPLESSIZE_16BIT
@ FLV_SAMPLESSIZE_16BIT
Definition: flv.h:80
FLVContext::duration
int64_t duration
Definition: flvenc.c:85
FLVFlags
FLVFlags
Definition: flvenc.c:66
FLV_TAG_TYPE_META
@ FLV_TAG_TYPE_META
Definition: flv.h:62
avassert.h
AMF_DATA_TYPE_BOOL
@ AMF_DATA_TYPE_BOOL
Definition: flv.h:125
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FLVFileposition::keyframe_position
int64_t keyframe_position
Definition: flvenc.c:75
AVCodecTag
Definition: internal.h:51
FLVContext::lastkeyframelocation
int64_t lastkeyframelocation
Definition: flvenc.c:106
av_dict_get
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
FLVContext::video_par
AVCodecParameters * video_par
Definition: flvenc.c:116
FLVContext::filepositions_count
int64_t filepositions_count
Definition: flvenc.c:111
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:277
flv_write_header
static int flv_write_header(AVFormatContext *s)
Definition: flvenc.c:690
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
FLV_FRAME_KEY
@ FLV_FRAME_KEY
key frame (for AVC, a seekable frame)
Definition: flv.h:116
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
channels
channels
Definition: aptx.h:33
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:320
FLVContext::audiosize
int64_t audiosize
Definition: flvenc.c:94
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
FLVContext::head_filepositions
FLVFileposition * head_filepositions
Definition: flvenc.c:113
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
PutBitContext
Definition: put_bits.h:49
FLVContext::framerate
double framerate
Definition: flvenc.c:117
AVFormatContext
Format I/O context.
Definition: avformat.h:1200
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:321
AV_CODEC_ID_FLASHSV2
@ AV_CODEC_ID_FLASHSV2
Definition: codec_id.h:181
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1095
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
FLVContext::datasize_offset
int64_t datasize_offset
Definition: flvenc.c:89
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
FLV_ADD_KEYFRAME_INDEX
@ FLV_ADD_KEYFRAME_INDEX
Definition: flvenc.c:69
FLV_HEADER_FLAG_HASAUDIO
@ FLV_HEADER_FLAG_HASAUDIO
Definition: flv.h:56
FLVContext::av_class
AVClass * av_class
Definition: flvenc.c:81
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
ff_stream_add_bitstream_filter
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:1789
avc.h
ff_avc_parse_nal_units_buf
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
Definition: avc.c:95
FLVFileposition
Definition: flvenc.c:74
FLV_CODECID_SPEEX
@ FLV_CODECID_SPEEX
Definition: flv.h:101
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:210
AV_CODEC_ID_FLASHSV
@ AV_CODEC_ID_FLASHSV
Definition: codec_id.h:136
AV_CODEC_ID_VP6A
@ AV_CODEC_ID_VP6A
Definition: codec_id.h:156
AVSTREAM_EVENT_FLAG_METADATA_UPDATED
#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:1068
FLVContext::videosize
int64_t videosize
Definition: flvenc.c:92
FLVContext::datasize
int64_t datasize
Definition: flvenc.c:90
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
FLVFileposition::keyframe_timestamp
double keyframe_timestamp
Definition: flvenc.c:76
FLVContext::keyframes_info_offset
int64_t keyframes_info_offset
Definition: flvenc.c:109
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:425
FLV_TAG_TYPE_VIDEO
@ FLV_TAG_TYPE_VIDEO
Definition: flv.h:61
AMF_DATA_TYPE_MIXEDARRAY
@ AMF_DATA_TYPE_MIXEDARRAY
Definition: flv.h:131
flv.h
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
flv_muxer_class
static const AVClass flv_muxer_class
Definition: flvenc.c:1061
AVPacket::size
int size
Definition: packet.h:374
flv_init
static int flv_init(struct AVFormatContext *s)
Definition: flvenc.c:606
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:262
ff_isom_write_avcc
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
Definition: avc.c:108
AMF_DATA_TYPE_OBJECT
@ AMF_DATA_TYPE_OBJECT
Definition: flv.h:127
shift_data
static int shift_data(AVFormatContext *s)
Definition: flvenc.c:577
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:54
AV_CODEC_ID_ADPCM_SWF
@ AV_CODEC_ID_ADPCM_SWF
Definition: codec_id.h:366
size
int size
Definition: twinvq_data.h:10344
flv_audio_codec_ids
static const AVCodecTag flv_audio_codec_ids[]
Definition: flvenc.c:52
avio.h
FLVContext
Definition: flvdec.c:47
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
get_audio_flags
static int get_audio_flags(AVFormatContext *s, AVCodecParameters *par)
Definition: flvenc.c:127
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:120
AVIO_DATA_MARKER_SYNC_POINT
@ AVIO_DATA_MARKER_SYNC_POINT
A point in the output bytestream where a decoder can start decoding (i.e.
Definition: avio.h:122
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:232
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:394
FLVContext::data_par
AVCodecParameters * data_par
Definition: flvenc.c:118
FLVContext::filesize_offset
int64_t filesize_offset
Definition: flvenc.c:84
FLV_AUDIO_CODECID_OFFSET
#define FLV_AUDIO_CODECID_OFFSET
Definition: flv.h:34
FLV_SAMPLERATE_SPECIAL
@ FLV_SAMPLERATE_SPECIAL
signifies 5512Hz and 8000Hz in the case of NELLYMOSER
Definition: flv.h:84
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
FLVContext::reserved
int reserved
Definition: flvenc.c:82
FLV_SAMPLESSIZE_8BIT
@ FLV_SAMPLESSIZE_8BIT
Definition: flv.h:79
put_amf_byte
static void put_amf_byte(AVIOContext *pb, unsigned char abyte)
Definition: flvenc.c:257
flv_video_codec_ids
static const AVCodecTag flv_video_codec_ids[]
Definition: flvenc.c:39
FLV_CODECID_H263
@ FLV_CODECID_H263
Definition: flv.h:105
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:727
ff_standardize_creation_time
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: utils.c:1882
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:443
av_double2int
static av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
Definition: intfloat.h:70
flv_check_bitstream
static int flv_check_bitstream(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Definition: flvenc.c:1039
AMF_DATA_TYPE_ARRAY
@ AMF_DATA_TYPE_ARRAY
Definition: flv.h:133
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:474
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
AVOutputFormat
Definition: avformat.h:503
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
avio_internal.h
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: avpacket.c:253
FLVContext::keyframe_index_size
int64_t keyframe_index_size
Definition: flvenc.c:99
unsupported_codec
static int unsupported_codec(AVFormatContext *s, const char *type, int codec_id)
Definition: flvenc.c:477
AVCodecParameters::height
int height
Definition: codec_par.h:127
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
FLVContext::framerate
AVRational framerate
Definition: flvdec.c:77
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
FLV_CODECID_NELLYMOSER_8KHZ_MONO
@ FLV_CODECID_NELLYMOSER_8KHZ_MONO
Definition: flv.h:96
len
int len
Definition: vorbis_enc_data.h:426
FLVContext::metadata_size_pos
int64_t metadata_size_pos
Definition: flvenc.c:96
FLV_NO_METADATA
@ FLV_NO_METADATA
Definition: flvenc.c:70
av_rescale
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:128
FLV_CODECID_MP3
@ FLV_CODECID_MP3
Definition: flv.h:93
put_timestamp
static void put_timestamp(AVIOContext *pb, int64_t ts)
Definition: flvenc.c:234
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:485
FLVStreamContext
Definition: flvenc.c:123
tag
uint32_t tag
Definition: movenc.c:1596
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:935
put_amf_dword_array
static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
Definition: flvenc.c:262
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
AVClass::class_name
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:71
metadata.h
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
dict.h
AV_CODEC_ID_TEXT
@ AV_CODEC_ID_TEXT
raw UTF-8 text
Definition: codec_id.h:524
av_get_media_type_string
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:71
FLV_AAC_SEQ_HEADER_DETECT
@ FLV_AAC_SEQ_HEADER_DETECT
Definition: flvenc.c:67
FLV_TAG_TYPE_AUDIO
@ FLV_TAG_TYPE_AUDIO
Definition: flv.h:60
FLVContext::lastkeyframetimestamp_offset
int64_t lastkeyframetimestamp_offset
Definition: flvenc.c:103
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
ff_codec_get_tag
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:347
FLV_CODECID_PCM_MULAW
@ FLV_CODECID_PCM_MULAW
Definition: flv.h:99
AMF_DATA_TYPE_NUMBER
@ AMF_DATA_TYPE_NUMBER
Definition: flv.h:124
FLV_CODECID_REALH263
@ FLV_CODECID_REALH263
Definition: flv.h:111
put_amf_string
static void put_amf_string(AVIOContext *pb, const char *str)
Definition: flvenc.c:226
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, 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:1195
FLV_SAMPLERATE_22050HZ
@ FLV_SAMPLERATE_22050HZ
Definition: flv.h:86
AVPacket::stream_index
int stream_index
Definition: packet.h:375
FLVStreamContext::last_ts
int64_t last_ts
last timestamp for each stream
Definition: flvenc.c:124
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:347
avio_wb64
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:460
ff_mpeg4audio_sample_rates
const int ff_mpeg4audio_sample_rates[16]
Definition: mpeg4audio_sample_rates.h:26
FLV_CODECID_NELLYMOSER_16KHZ_MONO
@ FLV_CODECID_NELLYMOSER_16KHZ_MONO
Definition: flv.h:95
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
FLVContext::lasttimestamp
double lasttimestamp
Definition: flvenc.c:102
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:319
FLV_CODECID_ADPCM
@ FLV_CODECID_ADPCM
Definition: flv.h:92
flv_write_trailer
static int flv_write_trailer(AVFormatContext *s)
Definition: flvenc.c:727
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
avio_wb24
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:484
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:79
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
FLV_CODECID_NELLYMOSER
@ FLV_CODECID_NELLYMOSER
Definition: flv.h:97
write_metadata
static void write_metadata(AVFormatContext *s, unsigned int ts)
Definition: flvenc.c:274
FLV_CODECID_PCM
@ FLV_CODECID_PCM
Definition: flv.h:91
d
d
Definition: ffmpeg_filter.c:153
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:223
convert_header.str
string str
Definition: convert_header.py:20
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:472
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
options
static const AVOption options[]
Definition: flvenc.c:1051
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3521
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:347
FLVFileposition::next
struct FLVFileposition * next
Definition: flvenc.c:77
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:71
ff_format_shift_data
int ff_format_shift_data(AVFormatContext *s, int64_t read_start, int shift_size)
Make shift_size amount of space at read_start by shifting data in the output at read_start until the ...
Definition: utils.c:2038
FLVContext::datastart_offset
int64_t datastart_offset
Definition: flvenc.c:88
put_bits.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
flv_write_codec_header
static void flv_write_codec_header(AVFormatContext *s, AVCodecParameters *par, int64_t ts)
Definition: flvenc.c:488
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:456
AV_RB16
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:98
ff_alloc_extradata
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:451