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"
27 #include "libavutil/mathematics.h"
28 #include "libavcodec/codec_desc.h"
29 #include "libavcodec/mpeg4audio.h"
30 #include "avio.h"
31 #include "avc.h"
32 #include "av1.h"
33 #include "vpcc.h"
34 #include "hevc.h"
35 #include "avformat.h"
36 #include "flv.h"
37 #include "internal.h"
38 #include "mux.h"
39 #include "libavutil/opt.h"
40 #include "libavcodec/put_bits.h"
41 
42 
43 static const AVCodecTag flv_video_codec_ids[] = {
53  { AV_CODEC_ID_HEVC, MKBETAG('h', 'v', 'c', '1') },
54  { AV_CODEC_ID_AV1, MKBETAG('a', 'v', '0', '1') },
55  { AV_CODEC_ID_VP9, MKBETAG('v', 'p', '0', '9') },
56  { AV_CODEC_ID_NONE, 0 }
57 };
58 
59 static const AVCodecTag flv_audio_codec_ids[] = {
70  { AV_CODEC_ID_NONE, 0 }
71 };
72 
73 typedef enum {
75  FLV_NO_SEQUENCE_END = (1 << 1),
77  FLV_NO_METADATA = (1 << 3),
79 } FLVFlags;
80 
81 typedef struct FLVFileposition {
86 
87 typedef struct FLVContext {
89  int reserved;
90  int64_t duration_offset;
91  int64_t filesize_offset;
92  int64_t duration;
93  int64_t delay; ///< first dts delay (needed for AVC & Speex)
94 
96  int64_t datasize_offset;
97  int64_t datasize;
99  int64_t videosize;
101  int64_t audiosize;
102 
107 
114 
116 
120 
123  double framerate;
125 
126  int flags;
127  int64_t last_ts[FLV_STREAM_TYPE_NB];
129 } FLVContext;
130 
132 {
135 
136  if (par->codec_id == AV_CODEC_ID_AAC) // specs force these parameters
139  else if (par->codec_id == AV_CODEC_ID_SPEEX) {
140  if (par->sample_rate != 16000) {
142  "FLV only supports wideband (16kHz) Speex audio\n");
143  return AVERROR(EINVAL);
144  }
145  if (par->ch_layout.nb_channels != 1) {
146  av_log(s, AV_LOG_ERROR, "FLV only supports mono Speex audio\n");
147  return AVERROR(EINVAL);
148  }
150  } else {
151  switch (par->sample_rate) {
152  case 48000:
153  // 48khz mp3 is stored with 44k1 samplerate identifer
154  if (par->codec_id == AV_CODEC_ID_MP3) {
156  break;
157  } else {
158  goto error;
159  }
160  case 44100:
162  break;
163  case 22050:
165  break;
166  case 11025:
168  break;
169  case 16000: // nellymoser only
170  case 8000: // nellymoser only
171  case 5512: // not MP3
172  if (par->codec_id != AV_CODEC_ID_MP3) {
174  break;
175  }
176  default:
177 error:
179  "FLV does not support sample rate %d, "
180  "choose from (44100, 22050, 11025)\n", par->sample_rate);
181  return AVERROR(EINVAL);
182  }
183  }
184 
185  if (par->ch_layout.nb_channels > 1)
186  flags |= FLV_STEREO;
187 
188  switch (par->codec_id) {
189  case AV_CODEC_ID_MP3:
191  break;
192  case AV_CODEC_ID_PCM_U8:
194  break;
197  break;
200  break;
203  break;
205  if (par->sample_rate == 8000)
207  else if (par->sample_rate == 16000)
209  else
211  break;
214  break;
217  break;
218  case 0:
219  flags |= par->codec_tag << 4;
220  break;
221  default:
222  av_log(s, AV_LOG_ERROR, "Audio codec '%s' not compatible with FLV\n",
223  avcodec_get_name(par->codec_id));
224  return AVERROR(EINVAL);
225  }
226 
227  return flags;
228 }
229 
230 static void put_amf_string(AVIOContext *pb, const char *str)
231 {
232  size_t len = strlen(str);
233  avio_wb16(pb, len);
234  avio_write(pb, str, len);
235 }
236 
237 // FLV timestamps are 32 bits signed, RTMP timestamps should be 32-bit unsigned
238 static void put_timestamp(AVIOContext *pb, int64_t ts) {
239  avio_wb24(pb, ts & 0xFFFFFF);
240  avio_w8(pb, (ts >> 24) & 0x7F);
241 }
242 
243 static void put_eos_tag(AVIOContext *pb, unsigned ts, enum AVCodecID codec_id)
244 {
246  /* ub[4] FrameType = 1, ub[4] CodecId */
247  tag |= 1 << 4;
249  avio_wb24(pb, 5); /* Tag Data Size */
250  put_timestamp(pb, ts);
251  avio_wb24(pb, 0); /* StreamId = 0 */
252  avio_w8(pb, tag);
253  avio_w8(pb, 2); /* AVC end of sequence */
254  avio_wb24(pb, 0); /* Always 0 for AVC EOS. */
255  avio_wb32(pb, 16); /* Size of FLV tag */
256 }
257 
258 static void put_amf_double(AVIOContext *pb, double d)
259 {
261  avio_wb64(pb, av_double2int(d));
262 }
263 
264 static void put_amf_byte(AVIOContext *pb, unsigned char abyte)
265 {
266  avio_w8(pb, abyte);
267 }
268 
269 static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
270 {
272  avio_wb32(pb, dw);
273 }
274 
275 static void put_amf_bool(AVIOContext *pb, int b)
276 {
278  avio_w8(pb, !!b);
279 }
280 
281 static void write_metadata(AVFormatContext *s, unsigned int ts)
282 {
283  AVIOContext *pb = s->pb;
284  FLVContext *flv = s->priv_data;
285  int write_duration_filesize = !(flv->flags & FLV_NO_DURATION_FILESIZE);
286  int metadata_count = 0;
287  int64_t metadata_count_pos;
288  const AVDictionaryEntry *tag = NULL;
289 
290  /* write meta_tag */
291  avio_w8(pb, FLV_TAG_TYPE_META); // tag type META
292  flv->metadata_size_pos = avio_tell(pb);
293  avio_wb24(pb, 0); // size of data part (sum of all parts below)
294  put_timestamp(pb, ts); // timestamp
295  avio_wb24(pb, 0); // reserved
296 
297  /* now data of data_size size */
298 
299  /* first event name as a string */
301  put_amf_string(pb, "onMetaData"); // 12 bytes
302 
303  /* mixed array (hash) with size and string/type/data tuples */
305  metadata_count_pos = avio_tell(pb);
306  metadata_count = 4 * !!flv->video_par +
307  5 * !!flv->audio_par +
308  1 * !!flv->data_par;
309  if (write_duration_filesize) {
310  metadata_count += 2; // +2 for duration and file size
311  }
312  avio_wb32(pb, metadata_count);
313 
314  if (write_duration_filesize) {
315  put_amf_string(pb, "duration");
316  flv->duration_offset = avio_tell(pb);
317  // fill in the guessed duration, it'll be corrected later if incorrect
318  put_amf_double(pb, s->duration / AV_TIME_BASE);
319  }
320 
321  if (flv->video_par) {
322  put_amf_string(pb, "width");
323  put_amf_double(pb, flv->video_par->width);
324 
325  put_amf_string(pb, "height");
326  put_amf_double(pb, flv->video_par->height);
327 
328  put_amf_string(pb, "videodatarate");
329  put_amf_double(pb, flv->video_par->bit_rate / 1024.0);
330 
331  if (flv->framerate != 0.0) {
332  put_amf_string(pb, "framerate");
333  put_amf_double(pb, flv->framerate);
334  metadata_count++;
335  }
336 
337  put_amf_string(pb, "videocodecid");
339  }
340 
341  if (flv->audio_par) {
342  put_amf_string(pb, "audiodatarate");
343  put_amf_double(pb, flv->audio_par->bit_rate / 1024.0);
344 
345  put_amf_string(pb, "audiosamplerate");
347 
348  put_amf_string(pb, "audiosamplesize");
349  put_amf_double(pb, flv->audio_par->codec_id == AV_CODEC_ID_PCM_U8 ? 8 : 16);
350 
351  put_amf_string(pb, "stereo");
353 
354  put_amf_string(pb, "audiocodecid");
356  }
357 
358  if (flv->data_par) {
359  put_amf_string(pb, "datastream");
360  put_amf_double(pb, 0.0);
361  }
362 
364  while ((tag = av_dict_iterate(s->metadata, tag))) {
365  if( !strcmp(tag->key, "width")
366  ||!strcmp(tag->key, "height")
367  ||!strcmp(tag->key, "videodatarate")
368  ||!strcmp(tag->key, "framerate")
369  ||!strcmp(tag->key, "videocodecid")
370  ||!strcmp(tag->key, "audiodatarate")
371  ||!strcmp(tag->key, "audiosamplerate")
372  ||!strcmp(tag->key, "audiosamplesize")
373  ||!strcmp(tag->key, "stereo")
374  ||!strcmp(tag->key, "audiocodecid")
375  ||!strcmp(tag->key, "duration")
376  ||!strcmp(tag->key, "onMetaData")
377  ||!strcmp(tag->key, "datasize")
378  ||!strcmp(tag->key, "lasttimestamp")
379  ||!strcmp(tag->key, "totalframes")
380  ||!strcmp(tag->key, "hasAudio")
381  ||!strcmp(tag->key, "hasVideo")
382  ||!strcmp(tag->key, "hasCuePoints")
383  ||!strcmp(tag->key, "hasMetadata")
384  ||!strcmp(tag->key, "hasKeyframes")
385  ){
386  av_log(s, AV_LOG_DEBUG, "Ignoring metadata for %s\n", tag->key);
387  continue;
388  }
389  put_amf_string(pb, tag->key);
391  put_amf_string(pb, tag->value);
392  metadata_count++;
393  }
394 
395  if (write_duration_filesize) {
396  put_amf_string(pb, "filesize");
397  flv->filesize_offset = avio_tell(pb);
398  put_amf_double(pb, 0); // delayed write
399  }
400 
401  if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
402  flv->keyframe_index_size = 0;
403 
404  put_amf_string(pb, "hasVideo");
405  put_amf_bool(pb, !!flv->video_par);
406  metadata_count++;
407 
408  put_amf_string(pb, "hasKeyframes");
409  put_amf_bool(pb, 1);
410  metadata_count++;
411 
412  put_amf_string(pb, "hasAudio");
413  put_amf_bool(pb, !!flv->audio_par);
414  metadata_count++;
415 
416  put_amf_string(pb, "hasMetadata");
417  put_amf_bool(pb, 1);
418  metadata_count++;
419 
420  put_amf_string(pb, "canSeekToEnd");
421  put_amf_bool(pb, 1);
422  metadata_count++;
423 
424  put_amf_string(pb, "datasize");
425  flv->datasize_offset = avio_tell(pb);
426  flv->datasize = 0;
427  put_amf_double(pb, flv->datasize);
428  metadata_count++;
429 
430  put_amf_string(pb, "videosize");
431  flv->videosize_offset = avio_tell(pb);
432  flv->videosize = 0;
433  put_amf_double(pb, flv->videosize);
434  metadata_count++;
435 
436  put_amf_string(pb, "audiosize");
437  flv->audiosize_offset = avio_tell(pb);
438  flv->audiosize = 0;
439  put_amf_double(pb, flv->audiosize);
440  metadata_count++;
441 
442  put_amf_string(pb, "lasttimestamp");
443  flv->lasttimestamp_offset = avio_tell(pb);
444  flv->lasttimestamp = 0;
445  put_amf_double(pb, 0);
446  metadata_count++;
447 
448  put_amf_string(pb, "lastkeyframetimestamp");
450  flv->lastkeyframetimestamp = 0;
451  put_amf_double(pb, 0);
452  metadata_count++;
453 
454  put_amf_string(pb, "lastkeyframelocation");
456  flv->lastkeyframelocation = 0;
457  put_amf_double(pb, 0);
458  metadata_count++;
459 
460  put_amf_string(pb, "keyframes");
462  metadata_count++;
463 
464  flv->keyframes_info_offset = avio_tell(pb);
465  }
466 
467  put_amf_string(pb, "");
469 
470  /* write total size of tag */
471  flv->metadata_totalsize = avio_tell(pb) - flv->metadata_size_pos - 10;
472 
473  avio_seek(pb, metadata_count_pos, SEEK_SET);
474  avio_wb32(pb, metadata_count);
475 
476  avio_seek(pb, flv->metadata_size_pos, SEEK_SET);
477  avio_wb24(pb, flv->metadata_totalsize);
478  avio_skip(pb, flv->metadata_totalsize + 10 - 3);
480  avio_wb32(pb, flv->metadata_totalsize + 11);
481 }
482 
483 static void flv_write_metadata_packet(AVFormatContext *s, AVCodecParameters *par, unsigned int ts)
484 {
485  AVIOContext *pb = s->pb;
486  FLVContext *flv = s->priv_data;
487  AVContentLightMetadata *lightMetadata = NULL;
488  AVMasteringDisplayMetadata *displayMetadata = NULL;
489  int64_t metadata_size_pos = 0;
490  int64_t total_size = 0;
491  const AVPacketSideData *side_data = NULL;
492 
493  if (flv->metadata_pkt_written) return;
494  if (par->codec_id == AV_CODEC_ID_HEVC || par->codec_id == AV_CODEC_ID_AV1 ||
495  par->codec_id == AV_CODEC_ID_VP9) {
496  int flags_size = 5;
499  if (side_data)
500  lightMetadata = (AVContentLightMetadata *)side_data->data;
501 
504  if (side_data)
505  displayMetadata = (AVMasteringDisplayMetadata *)side_data->data;
506 
507  /*
508  * Reference Enhancing FLV
509  * https://github.com/veovera/enhanced-rtmp/blob/main/enhanced-rtmp.pdf
510  * */
511  avio_w8(pb, FLV_TAG_TYPE_VIDEO); //write video tag type
512  metadata_size_pos = avio_tell(pb);
513  avio_wb24(pb, 0 + flags_size);
514  put_timestamp(pb, ts); //ts = pkt->dts, gen
515  avio_wb24(pb, flv->reserved);
516 
517  if (par->codec_id == AV_CODEC_ID_HEVC) {
518  avio_w8(pb, FLV_IS_EX_HEADER | PacketTypeMetadata| FLV_FRAME_VIDEO_INFO_CMD); // ExVideoTagHeader mode with PacketTypeMetadata
519  avio_write(pb, "hvc1", 4);
520  } else if (par->codec_id == AV_CODEC_ID_AV1 || par->codec_id == AV_CODEC_ID_VP9) {
522  avio_write(pb, par->codec_id == AV_CODEC_ID_AV1 ? "av01" : "vp09", 4);
523  }
524 
526  put_amf_string(pb, "colorInfo");
527 
529 
530  put_amf_string(pb, "colorConfig"); // colorConfig
531 
533 
534  if (par->color_trc != AVCOL_TRC_UNSPECIFIED &&
535  par->color_trc < AVCOL_TRC_NB) {
536  put_amf_string(pb, "transferCharacteristics"); // color_trc
537  put_amf_double(pb, par->color_trc);
538  }
539 
540  if (par->color_space != AVCOL_SPC_UNSPECIFIED &&
541  par->color_space < AVCOL_SPC_NB) {
542  put_amf_string(pb, "matrixCoefficients"); // colorspace
543  put_amf_double(pb, par->color_space);
544  }
545 
547  par->color_primaries < AVCOL_PRI_NB) {
548  put_amf_string(pb, "colorPrimaries"); // color_primaries
550  }
551 
552  put_amf_string(pb, "");
554 
555  if (lightMetadata) {
556  put_amf_string(pb, "hdrCll");
558 
559  put_amf_string(pb, "maxFall");
560  put_amf_double(pb, lightMetadata->MaxFALL);
561 
562  put_amf_string(pb, "maxCLL");
563  put_amf_double(pb, lightMetadata->MaxCLL);
564 
565  put_amf_string(pb, "");
567  }
568 
569  if (displayMetadata && (displayMetadata->has_primaries || displayMetadata->has_luminance)) {
570  put_amf_string(pb, "hdrMdcv");
572  if (displayMetadata->has_primaries) {
573  put_amf_string(pb, "redX");
574  put_amf_double(pb, av_q2d(displayMetadata->display_primaries[0][0]));
575 
576  put_amf_string(pb, "redY");
577  put_amf_double(pb, av_q2d(displayMetadata->display_primaries[0][1]));
578 
579  put_amf_string(pb, "greenX");
580  put_amf_double(pb, av_q2d(displayMetadata->display_primaries[1][0]));
581 
582  put_amf_string(pb, "greenY");
583  put_amf_double(pb, av_q2d(displayMetadata->display_primaries[1][1]));
584 
585  put_amf_string(pb, "blueX");
586  put_amf_double(pb, av_q2d(displayMetadata->display_primaries[2][0]));
587 
588  put_amf_string(pb, "blueY");
589  put_amf_double(pb, av_q2d(displayMetadata->display_primaries[2][1]));
590 
591  put_amf_string(pb, "whitePointX");
592  put_amf_double(pb, av_q2d(displayMetadata->white_point[0]));
593 
594  put_amf_string(pb, "whitePointY");
595  put_amf_double(pb, av_q2d(displayMetadata->white_point[1]));
596  }
597  if (displayMetadata->has_luminance) {
598  put_amf_string(pb, "maxLuminance");
599  put_amf_double(pb, av_q2d(displayMetadata->max_luminance));
600 
601  put_amf_string(pb, "minLuminance");
602  put_amf_double(pb, av_q2d(displayMetadata->min_luminance));
603  }
604  put_amf_string(pb, "");
606  }
607  put_amf_string(pb, "");
609 
610  total_size = avio_tell(pb) - metadata_size_pos - 10;
611  avio_seek(pb, metadata_size_pos, SEEK_SET);
612  avio_wb24(pb, total_size);
613  avio_skip(pb, total_size + 10 - 3);
614  avio_wb32(pb, total_size + 11); // previous tag size
615  flv->metadata_pkt_written = 1;
616  }
617 }
618 
620  const char* type, int codec_id)
621 {
624  "%s codec %s not compatible with flv\n",
625  type,
626  desc ? desc->name : "unknown");
627  return AVERROR(ENOSYS);
628 }
629 
631  int64_t data_size;
632  AVIOContext *pb = s->pb;
633  FLVContext *flv = s->priv_data;
634 
635  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
637  || par->codec_id == AV_CODEC_ID_AV1 || par->codec_id == AV_CODEC_ID_VP9) {
638  int64_t pos;
639  avio_w8(pb,
642  avio_wb24(pb, 0); // size patched later
643  put_timestamp(pb, ts);
644  avio_wb24(pb, 0); // streamid
645  pos = avio_tell(pb);
646  if (par->codec_id == AV_CODEC_ID_AAC) {
647  avio_w8(pb, get_audio_flags(s, par));
648  avio_w8(pb, 0); // AAC sequence header
649 
650  if (!par->extradata_size && (flv->flags & FLV_AAC_SEQ_HEADER_DETECT)) {
651  PutBitContext pbc;
652  int samplerate_index;
653  int channels = par->ch_layout.nb_channels
654  - (par->ch_layout.nb_channels == 8 ? 1 : 0);
655  uint8_t data[2];
656 
657  for (samplerate_index = 0; samplerate_index < 16;
658  samplerate_index++)
659  if (par->sample_rate
660  == ff_mpeg4audio_sample_rates[samplerate_index])
661  break;
662 
663  init_put_bits(&pbc, data, sizeof(data));
664  put_bits(&pbc, 5, par->profile + 1); //profile
665  put_bits(&pbc, 4, samplerate_index); //sample rate index
666  put_bits(&pbc, 4, channels);
667  put_bits(&pbc, 1, 0); //frame length - 1024 samples
668  put_bits(&pbc, 1, 0); //does not depend on core coder
669  put_bits(&pbc, 1, 0); //is not extension
670  flush_put_bits(&pbc);
671 
672  avio_w8(pb, data[0]);
673  avio_w8(pb, data[1]);
674 
675  av_log(s, AV_LOG_WARNING, "AAC sequence header: %02x %02x.\n",
676  data[0], data[1]);
677  }
678  avio_write(pb, par->extradata, par->extradata_size);
679  } else {
680  if (par->codec_id == AV_CODEC_ID_HEVC) {
681  avio_w8(pb, FLV_IS_EX_HEADER | PacketTypeSequenceStart | FLV_FRAME_KEY); // ExVideoTagHeader mode with PacketTypeSequenceStart
682  avio_write(pb, "hvc1", 4);
683  } else if (par->codec_id == AV_CODEC_ID_AV1 || par->codec_id == AV_CODEC_ID_VP9) {
685  avio_write(pb, par->codec_id == AV_CODEC_ID_AV1 ? "av01" : "vp09", 4);
686  } else {
687  avio_w8(pb, par->codec_tag | FLV_FRAME_KEY); // flags
688  avio_w8(pb, 0); // AVC sequence header
689  avio_wb24(pb, 0); // composition time
690  }
691 
692  if (par->codec_id == AV_CODEC_ID_HEVC)
693  ff_isom_write_hvcc(pb, par->extradata, par->extradata_size, 0);
694  else if (par->codec_id == AV_CODEC_ID_AV1)
695  ff_isom_write_av1c(pb, par->extradata, par->extradata_size, 1);
696  else if (par->codec_id == AV_CODEC_ID_VP9)
697  ff_isom_write_vpcc(s, pb, par->extradata, par->extradata_size, par);
698  else
700  }
701  data_size = avio_tell(pb) - pos;
702  avio_seek(pb, -data_size - 10, SEEK_CUR);
703  avio_wb24(pb, data_size);
704  avio_skip(pb, data_size + 10 - 3);
705  avio_wb32(pb, data_size + 11); // previous tag size
706  }
707 }
708 
709 static int flv_append_keyframe_info(AVFormatContext *s, FLVContext *flv, double ts, int64_t pos)
710 {
711  FLVFileposition *position = av_malloc(sizeof(FLVFileposition));
712 
713  if (!position) {
714  av_log(s, AV_LOG_WARNING, "no mem for add keyframe index!\n");
715  return AVERROR(ENOMEM);
716  }
717 
718  position->keyframe_timestamp = ts;
719  position->keyframe_position = pos;
720 
721  if (!flv->filepositions_count) {
722  flv->filepositions = position;
723  flv->head_filepositions = flv->filepositions;
724  position->next = NULL;
725  } else {
726  flv->filepositions->next = position;
727  position->next = NULL;
728  flv->filepositions = flv->filepositions->next;
729  }
730 
731  flv->filepositions_count++;
732 
733  return 0;
734 }
735 
737 {
738  int ret;
739  int64_t metadata_size = 0;
740  FLVContext *flv = s->priv_data;
741 
742  metadata_size = flv->filepositions_count * 9 * 2 + 10; /* filepositions and times value */
743  metadata_size += 2 + 13; /* filepositions String */
744  metadata_size += 2 + 5; /* times String */
745  metadata_size += 3; /* Object end */
746 
747  flv->keyframe_index_size = metadata_size;
748 
749  if (metadata_size < 0)
750  return metadata_size;
751 
752  ret = ff_format_shift_data(s, flv->keyframes_info_offset, metadata_size);
753  if (ret < 0)
754  return ret;
755 
756  avio_seek(s->pb, flv->metadata_size_pos, SEEK_SET);
757  avio_wb24(s->pb, flv->metadata_totalsize + metadata_size);
758 
759  avio_seek(s->pb, flv->metadata_totalsize_pos + metadata_size, SEEK_SET);
760  avio_wb32(s->pb, flv->metadata_totalsize + 11 + metadata_size);
761 
762  return 0;
763 }
764 
765 static int flv_init(struct AVFormatContext *s)
766 {
767  int i;
768  FLVContext *flv = s->priv_data;
769 
770  if (s->nb_streams > FLV_STREAM_TYPE_NB) {
771  av_log(s, AV_LOG_ERROR, "invalid number of streams %d\n",
772  s->nb_streams);
773  return AVERROR(EINVAL);
774  }
775 
776  for (i = 0; i < s->nb_streams; i++) {
777  AVCodecParameters *par = s->streams[i]->codecpar;
778 
779  switch (par->codec_type) {
780  case AVMEDIA_TYPE_VIDEO:
781  if (s->streams[i]->avg_frame_rate.den &&
782  s->streams[i]->avg_frame_rate.num) {
783  flv->framerate = av_q2d(s->streams[i]->avg_frame_rate);
784  }
785  if (flv->video_par) {
787  "at most one video stream is supported in flv\n");
788  return AVERROR(EINVAL);
789  }
790  flv->video_par = par;
792  return unsupported_codec(s, "Video", par->codec_id);
793 
794  if (par->codec_id == AV_CODEC_ID_MPEG4 ||
795  par->codec_id == AV_CODEC_ID_H263) {
796  int error = s->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL;
798  "Codec %s is not supported in the official FLV specification,\n", avcodec_get_name(par->codec_id));
799 
800  if (error) {
802  "use vstrict=-1 / -strict -1 to use it anyway.\n");
803  return AVERROR(EINVAL);
804  }
805  } else if (par->codec_id == AV_CODEC_ID_VP6) {
807  "Muxing VP6 in flv will produce flipped video on playback.\n");
808  }
809  break;
810  case AVMEDIA_TYPE_AUDIO:
811  if (flv->audio_par) {
813  "at most one audio stream is supported in flv\n");
814  return AVERROR(EINVAL);
815  }
816  flv->audio_par = par;
817  if (get_audio_flags(s, par) < 0)
818  return unsupported_codec(s, "Audio", par->codec_id);
819  if (par->codec_id == AV_CODEC_ID_PCM_S16BE)
821  "16-bit big-endian audio in flv is valid but most likely unplayable (hardware dependent); use s16le\n");
822  break;
823  case AVMEDIA_TYPE_DATA:
824  if (par->codec_id != AV_CODEC_ID_TEXT && par->codec_id != AV_CODEC_ID_NONE)
825  return unsupported_codec(s, "Data", par->codec_id);
826  flv->data_par = par;
827  break;
829  if (par->codec_id != AV_CODEC_ID_TEXT) {
830  av_log(s, AV_LOG_ERROR, "Subtitle codec '%s' for stream %d is not compatible with FLV\n",
831  avcodec_get_name(par->codec_id), i);
832  return AVERROR_INVALIDDATA;
833  }
834  flv->data_par = par;
835  break;
836  default:
837  av_log(s, AV_LOG_ERROR, "Codec type '%s' for stream %d is not compatible with FLV\n",
839  return AVERROR(EINVAL);
840  }
841  avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
842  flv->last_ts[i] = -1;
843  }
844 
845  flv->delay = AV_NOPTS_VALUE;
846 
847  return 0;
848 }
849 
851 {
852  int i;
853  AVIOContext *pb = s->pb;
854  FLVContext *flv = s->priv_data;
855 
856  avio_write(pb, "FLV", 3);
857  avio_w8(pb, 1);
860  avio_wb32(pb, 9);
861  avio_wb32(pb, 0);
862 
863  for (i = 0; i < s->nb_streams; i++)
864  if (s->streams[i]->codecpar->codec_tag == 5) {
865  avio_w8(pb, 8); // message type
866  avio_wb24(pb, 0); // include flags
867  avio_wb24(pb, 0); // time stamp
868  avio_wb32(pb, 0); // reserved
869  avio_wb32(pb, 11); // size
870  flv->reserved = 5;
871  }
872 
873  if (flv->flags & FLV_NO_METADATA) {
874  pb->seekable = 0;
875  } else {
876  write_metadata(s, 0);
877  }
878 
879  for (i = 0; i < s->nb_streams; i++) {
880  flv_write_codec_header(s, s->streams[i]->codecpar, 0);
881  }
882 
883  flv->datastart_offset = avio_tell(pb);
884  return 0;
885 }
886 
888 {
889  int64_t file_size;
890  AVIOContext *pb = s->pb;
891  FLVContext *flv = s->priv_data;
892  int build_keyframes_idx = flv->flags & FLV_ADD_KEYFRAME_INDEX;
893  int i, res;
894  int64_t cur_pos = avio_tell(s->pb);
895 
896  if (build_keyframes_idx) {
897  const FLVFileposition *newflv_posinfo;
898 
899  avio_seek(pb, flv->videosize_offset, SEEK_SET);
900  put_amf_double(pb, flv->videosize);
901 
902  avio_seek(pb, flv->audiosize_offset, SEEK_SET);
903  put_amf_double(pb, flv->audiosize);
904 
905  avio_seek(pb, flv->lasttimestamp_offset, SEEK_SET);
906  put_amf_double(pb, flv->lasttimestamp);
907 
908  avio_seek(pb, flv->lastkeyframetimestamp_offset, SEEK_SET);
910 
911  avio_seek(pb, flv->lastkeyframelocation_offset, SEEK_SET);
913  avio_seek(pb, cur_pos, SEEK_SET);
914 
915  res = shift_data(s);
916  if (res < 0) {
917  goto end;
918  }
919  avio_seek(pb, flv->keyframes_info_offset, SEEK_SET);
920  put_amf_string(pb, "filepositions");
922  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
923  put_amf_double(pb, newflv_posinfo->keyframe_position + flv->keyframe_index_size);
924  }
925 
926  put_amf_string(pb, "times");
928  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
929  put_amf_double(pb, newflv_posinfo->keyframe_timestamp);
930  }
931 
932  put_amf_string(pb, "");
934 
935  avio_seek(pb, cur_pos + flv->keyframe_index_size, SEEK_SET);
936  }
937 
938 end:
939  if (flv->flags & FLV_NO_SEQUENCE_END) {
940  av_log(s, AV_LOG_DEBUG, "FLV no sequence end mode open\n");
941  } else {
942  /* Add EOS tag */
943  for (i = 0; i < s->nb_streams; i++) {
944  AVCodecParameters *par = s->streams[i]->codecpar;
945  if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
947  put_eos_tag(pb, flv->last_ts[i], par->codec_id);
948  }
949  }
950 
951  file_size = avio_tell(pb);
952 
953  if (build_keyframes_idx) {
954  flv->datasize = file_size - flv->datastart_offset;
955  avio_seek(pb, flv->datasize_offset, SEEK_SET);
956  put_amf_double(pb, flv->datasize);
957  }
958  if (!(flv->flags & FLV_NO_METADATA)) {
959  if (!(flv->flags & FLV_NO_DURATION_FILESIZE)) {
960  /* update information */
961  if (avio_seek(pb, flv->duration_offset, SEEK_SET) < 0) {
962  av_log(s, AV_LOG_WARNING, "Failed to update header with correct duration.\n");
963  } else {
964  put_amf_double(pb, flv->duration / (double)1000);
965  }
966  if (avio_seek(pb, flv->filesize_offset, SEEK_SET) < 0) {
967  av_log(s, AV_LOG_WARNING, "Failed to update header with correct filesize.\n");
968  } else {
969  put_amf_double(pb, file_size);
970  }
971  }
972  }
973 
974  return 0;
975 }
976 
978 {
979  AVIOContext *pb = s->pb;
980  AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
981  FLVContext *flv = s->priv_data;
982  unsigned ts;
983  int size = pkt->size;
984  uint8_t *data = NULL;
985  uint8_t frametype = pkt->flags & AV_PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER;
986  int flags = -1, flags_size, ret = 0;
987  int64_t cur_offset = avio_tell(pb);
988 
989  if (par->codec_type == AVMEDIA_TYPE_AUDIO && !pkt->size) {
990  av_log(s, AV_LOG_WARNING, "Empty audio Packet\n");
991  return AVERROR(EINVAL);
992  }
993 
994  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A ||
996  flags_size = 2;
997  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4 ||
998  par->codec_id == AV_CODEC_ID_HEVC || par->codec_id == AV_CODEC_ID_AV1 ||
999  par->codec_id == AV_CODEC_ID_VP9)
1000  flags_size = 5;
1001  else
1002  flags_size = 1;
1003 
1004  if (par->codec_id == AV_CODEC_ID_HEVC && pkt->pts != pkt->dts)
1005  flags_size += 3;
1006 
1007  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
1008  || par->codec_id == AV_CODEC_ID_MPEG4 || par->codec_id == AV_CODEC_ID_HEVC
1009  || par->codec_id == AV_CODEC_ID_AV1 || par->codec_id == AV_CODEC_ID_VP9) {
1010  size_t side_size;
1011  uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
1012  if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
1013  ret = ff_alloc_extradata(par, side_size);
1014  if (ret < 0)
1015  return ret;
1016  memcpy(par->extradata, side, side_size);
1017  flv_write_codec_header(s, par, pkt->dts);
1018  }
1020  }
1021 
1022  if (flv->delay == AV_NOPTS_VALUE)
1023  flv->delay = -pkt->dts;
1024 
1025  if (pkt->dts < -flv->delay) {
1027  "Packets are not in the proper order with respect to DTS\n");
1028  return AVERROR(EINVAL);
1029  }
1030  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4 ||
1031  par->codec_id == AV_CODEC_ID_HEVC || par->codec_id == AV_CODEC_ID_AV1 ||
1032  par->codec_id == AV_CODEC_ID_VP9) {
1033  if (pkt->pts == AV_NOPTS_VALUE) {
1034  av_log(s, AV_LOG_ERROR, "Packet is missing PTS\n");
1035  return AVERROR(EINVAL);
1036  }
1037  }
1038 
1039  ts = pkt->dts;
1040 
1041  if (s->event_flags & AVSTREAM_EVENT_FLAG_METADATA_UPDATED) {
1042  write_metadata(s, ts);
1043  s->event_flags &= ~AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
1044  }
1045 
1046  avio_write_marker(pb, av_rescale(ts, AV_TIME_BASE, 1000),
1048 
1049  switch (par->codec_type) {
1050  case AVMEDIA_TYPE_VIDEO:
1052 
1054 
1055  flags |= frametype;
1056  break;
1057  case AVMEDIA_TYPE_AUDIO:
1058  flags = get_audio_flags(s, par);
1059 
1060  av_assert0(size);
1061 
1063  break;
1064  case AVMEDIA_TYPE_SUBTITLE:
1065  case AVMEDIA_TYPE_DATA:
1067  break;
1068  default:
1069  return AVERROR(EINVAL);
1070  }
1071 
1072  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
1073  /* check if extradata looks like mp4 formatted */
1074  if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
1075  if ((ret = ff_avc_parse_nal_units_buf(pkt->data, &data, &size)) < 0)
1076  return ret;
1077  } else if (par->codec_id == AV_CODEC_ID_HEVC) {
1078  if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
1079  if ((ret = ff_hevc_annexb2mp4_buf(pkt->data, &data, &size, 0, NULL)) < 0)
1080  return ret;
1081  } else if (par->codec_id == AV_CODEC_ID_AAC && pkt->size > 2 &&
1082  (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
1083  if (!s->streams[pkt->stream_index]->nb_frames) {
1084  av_log(s, AV_LOG_ERROR, "Malformed AAC bitstream detected: "
1085  "use the audio bitstream filter 'aac_adtstoasc' to fix it "
1086  "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
1087  return AVERROR_INVALIDDATA;
1088  }
1089  av_log(s, AV_LOG_WARNING, "aac bitstream error\n");
1090  }
1091 
1092  /* check Speex packet duration */
1093  if (par->codec_id == AV_CODEC_ID_SPEEX && ts - flv->last_ts[pkt->stream_index] > 160)
1094  av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
1095  "8 frames per packet. Adobe Flash "
1096  "Player cannot handle this!\n");
1097 
1098  if (flv->last_ts[pkt->stream_index] < ts)
1099  flv->last_ts[pkt->stream_index] = ts;
1100 
1101  if (size + flags_size >= 1<<24) {
1102  av_log(s, AV_LOG_ERROR, "Too large packet with size %u >= %u\n",
1103  size + flags_size, 1<<24);
1104  ret = AVERROR(EINVAL);
1105  goto fail;
1106  }
1107 
1108  avio_wb24(pb, size + flags_size);
1109  put_timestamp(pb, ts);
1110  avio_wb24(pb, flv->reserved);
1111 
1112  if (par->codec_type == AVMEDIA_TYPE_DATA ||
1113  par->codec_type == AVMEDIA_TYPE_SUBTITLE ) {
1114  int data_size;
1115  int64_t metadata_size_pos = avio_tell(pb);
1116  if (par->codec_id == AV_CODEC_ID_TEXT) {
1117  // legacy FFmpeg magic?
1119  put_amf_string(pb, "onTextData");
1121  avio_wb32(pb, 2);
1122  put_amf_string(pb, "type");
1124  put_amf_string(pb, "Text");
1125  put_amf_string(pb, "text");
1127  put_amf_string(pb, pkt->data);
1128  put_amf_string(pb, "");
1130  } else {
1131  // just pass the metadata through
1132  avio_write(pb, data ? data : pkt->data, size);
1133  }
1134  /* write total size of tag */
1135  data_size = avio_tell(pb) - metadata_size_pos;
1136  avio_seek(pb, metadata_size_pos - 10, SEEK_SET);
1137  avio_wb24(pb, data_size);
1138  avio_seek(pb, data_size + 10 - 3, SEEK_CUR);
1139  avio_wb32(pb, data_size + 11);
1140  } else {
1141  av_assert1(flags>=0);
1142  if (par->codec_id == AV_CODEC_ID_HEVC) {
1143  int pkttype = (pkt->pts != pkt->dts) ? PacketTypeCodedFrames : PacketTypeCodedFramesX;
1144  avio_w8(pb, FLV_IS_EX_HEADER | pkttype | frametype); // ExVideoTagHeader mode with PacketTypeCodedFrames(X)
1145  avio_write(pb, "hvc1", 4);
1146  if (pkttype == PacketTypeCodedFrames)
1147  avio_wb24(pb, pkt->pts - pkt->dts);
1148  } else if (par->codec_id == AV_CODEC_ID_AV1 || par->codec_id == AV_CODEC_ID_VP9) {
1149  avio_w8(pb, FLV_IS_EX_HEADER | PacketTypeCodedFrames | frametype);
1150  avio_write(pb, par->codec_id == AV_CODEC_ID_AV1 ? "av01" : "vp09", 4);
1151  } else {
1152  avio_w8(pb, flags);
1153  }
1154  if (par->codec_id == AV_CODEC_ID_VP6)
1155  avio_w8(pb,0);
1156  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A) {
1157  if (par->extradata_size)
1158  avio_w8(pb, par->extradata[0]);
1159  else
1160  avio_w8(pb, ((FFALIGN(par->width, 16) - par->width) << 4) |
1161  (FFALIGN(par->height, 16) - par->height));
1162  } else if (par->codec_id == AV_CODEC_ID_AAC)
1163  avio_w8(pb, 1); // AAC raw
1164  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
1165  avio_w8(pb, 1); // AVC NALU
1166  avio_wb24(pb, pkt->pts - pkt->dts);
1167  }
1168 
1169  avio_write(pb, data ? data : pkt->data, size);
1170 
1171  avio_wb32(pb, size + flags_size + 11); // previous tag size
1172  flv->duration = FFMAX(flv->duration,
1173  pkt->pts + flv->delay + pkt->duration);
1174  }
1175 
1176  if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
1177  switch (par->codec_type) {
1178  case AVMEDIA_TYPE_VIDEO:
1179  flv->videosize += (avio_tell(pb) - cur_offset);
1180  flv->lasttimestamp = pkt->dts / 1000.0;
1181  if (pkt->flags & AV_PKT_FLAG_KEY) {
1183  flv->lastkeyframelocation = cur_offset;
1184  ret = flv_append_keyframe_info(s, flv, flv->lasttimestamp, cur_offset);
1185  if (ret < 0)
1186  goto fail;
1187  }
1188  break;
1189 
1190  case AVMEDIA_TYPE_AUDIO:
1191  flv->audiosize += (avio_tell(pb) - cur_offset);
1192  break;
1193 
1194  default:
1195  av_log(s, AV_LOG_WARNING, "par->codec_type is type = [%d]\n", par->codec_type);
1196  break;
1197  }
1198  }
1199 fail:
1200  av_free(data);
1201 
1202  return ret;
1203 }
1204 
1206  const AVPacket *pkt)
1207 {
1208  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
1209  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
1210  return ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
1211  }
1212  if (!st->codecpar->extradata_size &&
1213  (st->codecpar->codec_id == AV_CODEC_ID_H264 ||
1215  st->codecpar->codec_id == AV_CODEC_ID_AV1 ||
1217  return ff_stream_add_bitstream_filter(st, "extract_extradata", NULL);
1218  return 1;
1219 }
1220 
1222 {
1223  FLVContext *flv = s->priv_data;
1224  FLVFileposition *filepos = flv->head_filepositions;
1225 
1226  while (filepos) {
1227  FLVFileposition *next = filepos->next;
1228  av_free(filepos);
1229  filepos = next;
1230  }
1231  flv->filepositions = flv->head_filepositions = NULL;
1232  flv->filepositions_count = 0;
1233 }
1234 
1235 static const AVOption options[] = {
1236  { "flvflags", "FLV muxer flags", offsetof(FLVContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, .unit = "flvflags" },
1237  { "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, .unit = "flvflags" },
1238  { "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, .unit = "flvflags" },
1239  { "no_metadata", "disable metadata for FLV", 0, AV_OPT_TYPE_CONST, {.i64 = FLV_NO_METADATA}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, .unit = "flvflags" },
1240  { "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, .unit = "flvflags" },
1241  { "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, .unit = "flvflags" },
1242  { NULL },
1243 };
1244 
1245 static const AVClass flv_muxer_class = {
1246  .class_name = "flv muxer",
1247  .item_name = av_default_item_name,
1248  .option = options,
1249  .version = LIBAVUTIL_VERSION_INT,
1250 };
1251 
1253  .p.name = "flv",
1254  .p.long_name = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1255  .p.mime_type = "video/x-flv",
1256  .p.extensions = "flv",
1257  .priv_data_size = sizeof(FLVContext),
1258  .p.audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_ADPCM_SWF,
1259  .p.video_codec = AV_CODEC_ID_FLV1,
1260  .init = flv_init,
1261  .write_header = flv_write_header,
1262  .write_packet = flv_write_packet,
1263  .write_trailer = flv_write_trailer,
1264  .deinit = flv_deinit,
1265  .check_bitstream= flv_check_bitstream,
1266  .p.codec_tag = (const AVCodecTag* const []) {
1268  },
1269  .p.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS |
1271  .p.priv_class = &flv_muxer_class,
1272 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:328
FLVContext::metadata_totalsize
int64_t metadata_totalsize
Definition: flvenc.c:105
FLVContext::audio_par
AVCodecParameters * audio_par
Definition: flvenc.c:121
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
FLV_CODECID_ADPCM
@ FLV_CODECID_ADPCM
Definition: flv.h:98
AMF_END_OF_OBJECT
#define AMF_END_OF_OBJECT
Definition: flv.h:53
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_CODEC_ID_VP6F
@ AV_CODEC_ID_VP6F
Definition: codec_id.h:144
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
FLV_CODECID_SPEEX
@ FLV_CODECID_SPEEX
Definition: flv.h:107
FLV_NO_DURATION_FILESIZE
@ FLV_NO_DURATION_FILESIZE
Definition: flvenc.c:78
FLV_TAG_TYPE_VIDEO
@ FLV_TAG_TYPE_VIDEO
Definition: flv.h:67
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:127
FLVContext::duration_offset
int64_t duration_offset
Definition: flvenc.c:90
AVOutputFormat::name
const char * name
Definition: avformat.h:510
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
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
hevc.h
FLVContext::flags
int flags
Definition: flvenc.c:126
FLVContext::filepositions
FLVFileposition * filepositions
Definition: flvenc.c:118
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
FLV_NO_SEQUENCE_END
@ FLV_NO_SEQUENCE_END
Definition: flvenc.c:75
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:169
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:56
AVFMT_VARIABLE_FPS
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:482
FLVContext::delay
int64_t delay
first dts delay (needed for AVC & Speex)
Definition: flvenc.c:93
FLV_SAMPLESSIZE_16BIT
@ FLV_SAMPLESSIZE_16BIT
Definition: flv.h:86
FLV_CODECID_H264
@ FLV_CODECID_H264
Definition: flv.h:116
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:223
PacketTypeCodedFramesX
@ PacketTypeCodedFramesX
Definition: flv.h:125
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
FLV_IS_EX_HEADER
#define FLV_IS_EX_HEADER
Definition: flv.h:42
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
FLV_CODECID_AAC
@ FLV_CODECID_AAC
Definition: flv.h:106
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:102
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:222
AVCOL_TRC_NB
@ AVCOL_TRC_NB
Not part of ABI.
Definition: pixfmt.h:602
FLV_CODECID_PCM_ALAW
@ FLV_CODECID_PCM_ALAW
Definition: flv.h:104
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:373
AVPacket::data
uint8_t * data
Definition: packet.h:522
FLVContext::metadata_totalsize_pos
int64_t metadata_totalsize_pos
Definition: flvenc.c:104
AV_CODEC_ID_VP6
@ AV_CODEC_ID_VP6
Definition: codec_id.h:143
AVOption
AVOption.
Definition: opt.h:346
AVCOL_SPC_NB
@ AVCOL_SPC_NB
Not part of ABI.
Definition: pixfmt.h:626
b
#define b
Definition: input.c:41
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
data
const char data[16]
Definition: mxf.c:148
FLVContext::audiosize_offset
int64_t audiosize_offset
Definition: flvenc.c:100
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:540
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
mathematics.h
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
FLV_CODECID_SCREEN
@ FLV_CODECID_SCREEN
Definition: flv.h:112
PacketTypeSequenceStart
@ PacketTypeSequenceStart
Definition: flv.h:122
FLV_CODECID_VP6A
@ FLV_CODECID_VP6A
Definition: flv.h:114
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
intfloat.h
put_amf_bool
static void put_amf_bool(AVIOContext *pb, int b)
Definition: flvenc.c:275
AMF_DATA_TYPE_OBJECT
@ AMF_DATA_TYPE_OBJECT
Definition: flv.h:142
FLV_SAMPLESSIZE_8BIT
@ FLV_SAMPLESSIZE_8BIT
Definition: flv.h:85
PacketTypeMetadata
@ PacketTypeMetadata
Definition: flv.h:126
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:577
FLVContext::lasttimestamp_offset
int64_t lasttimestamp_offset
Definition: flvenc.c:108
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:36
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:98
FLVContext::videosize_offset
int64_t videosize_offset
Definition: flvenc.c:98
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:167
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:460
flv_append_keyframe_info
static int flv_append_keyframe_info(AVFormatContext *s, FLVContext *flv, double ts, int64_t pos)
Definition: flvenc.c:709
FLVContext::lastkeyframelocation_offset
int64_t lastkeyframelocation_offset
Definition: flvenc.c:112
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: avformat.c:853
mpeg4audio.h
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:475
flv_write_packet
static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: flvenc.c:977
FLVContext::last_ts
int64_t last_ts
Definition: flvdec.c:102
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:329
ff_flv_muxer
const FFOutputFormat ff_flv_muxer
Definition: flvenc.c:1252
FLV_HEADER_FLAG_HASAUDIO
@ FLV_HEADER_FLAG_HASAUDIO
Definition: flv.h:62
fail
#define fail()
Definition: checkasm.h:179
FLV_CODECID_PCM
@ FLV_CODECID_PCM
Definition: flv.h:97
FLVContext::lastkeyframetimestamp
double lastkeyframetimestamp
Definition: flvenc.c:111
put_amf_double
static void put_amf_double(AVIOContext *pb, double d)
Definition: flvenc.c:258
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
FLV_CODECID_VP6
@ FLV_CODECID_VP6
Definition: flv.h:113
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:441
FLV_SAMPLERATE_44100HZ
@ FLV_SAMPLERATE_44100HZ
Definition: flv.h:93
vpcc.h
FLV_AUDIO_CODECID_OFFSET
#define FLV_AUDIO_CODECID_OFFSET
Definition: flv.h:34
FLVContext::duration
int64_t duration
Definition: flvenc.c:92
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:168
FLVFlags
FLVFlags
Definition: flvenc.c:73
avassert.h
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:82
AVCodecTag
Definition: internal.h:48
FLVContext::lastkeyframelocation
int64_t lastkeyframelocation
Definition: flvenc.c:113
FLVContext::video_par
AVCodecParameters * video_par
Definition: flvenc.c:122
FLVContext::filepositions_count
int64_t filepositions_count
Definition: flvenc.c:117
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCOL_PRI_NB
@ AVCOL_PRI_NB
Not part of ABI.
Definition: pixfmt.h:573
FLV_CODECID_PCM_MULAW
@ FLV_CODECID_PCM_MULAW
Definition: flv.h:105
flv_write_header
static int flv_write_header(AVFormatContext *s)
Definition: flvenc.c:850
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
FLV_CODECID_REALH263
@ FLV_CODECID_REALH263
Definition: flv.h:117
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:40
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVPacketSideData::data
uint8_t * data
Definition: packet.h:374
channels
channels
Definition: aptx.h:31
FLV_STEREO
@ FLV_STEREO
Definition: flv.h:81
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:334
FLVContext::audiosize
int64_t audiosize
Definition: flvenc.c:101
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:386
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
FLVContext::head_filepositions
FLVFileposition * head_filepositions
Definition: flvenc.c:119
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
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: mux_utils.c:50
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
PutBitContext
Definition: put_bits.h:50
FLVContext::framerate
double framerate
Definition: flvenc.c:123
ff_isom_write_vpcc
int ff_isom_write_vpcc(AVFormatContext *s, AVIOContext *pb, const uint8_t *data, int len, AVCodecParameters *par)
Writes VP codec configuration to the provided AVIOContext.
Definition: vpcc.c:200
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:335
AV_CODEC_ID_FLASHSV2
@ AV_CODEC_ID_FLASHSV2
Definition: codec_id.h:183
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
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
FLV_SAMPLERATE_11025HZ
@ FLV_SAMPLERATE_11025HZ
Definition: flv.h:91
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:280
FLVContext::datasize_offset
int64_t datasize_offset
Definition: flvenc.c:96
FLV_ADD_KEYFRAME_INDEX
@ FLV_ADD_KEYFRAME_INDEX
Definition: flvenc.c:76
AMF_DATA_TYPE_BOOL
@ AMF_DATA_TYPE_BOOL
Definition: flv.h:140
ff_hevc_annexb2mp4_buf
int ff_hevc_annexb2mp4_buf(const uint8_t *buf_in, uint8_t **buf_out, int *size, int filter_ps, int *ps_count)
Writes Annex B formatted HEVC NAL units to a data buffer.
Definition: hevc.c:1021
FLVContext::av_class
AVClass * av_class
Definition: flvenc.c:88
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
avc.h
FLV_FRAME_VIDEO_INFO_CMD
@ FLV_FRAME_VIDEO_INFO_CMD
video info/command frame
Definition: flv.h:135
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:129
FLVFileposition
Definition: flvenc.c:81
FFOutputFormat
Definition: mux.h:32
flv.h
FLV_FRAME_KEY
@ FLV_FRAME_KEY
key frame (for AVC, a seekable frame)
Definition: flv.h:131
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:178
AMF_DATA_TYPE_ARRAY
@ AMF_DATA_TYPE_ARRAY
Definition: flv.h:148
AV_CODEC_ID_FLASHSV
@ AV_CODEC_ID_FLASHSV
Definition: codec_id.h:138
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
AV_CODEC_ID_VP6A
@ AV_CODEC_ID_VP6A
Definition: codec_id.h:158
FLV_CODECID_NELLYMOSER
@ FLV_CODECID_NELLYMOSER
Definition: flv.h:103
AVSTREAM_EVENT_FLAG_METADATA_UPDATED
#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:893
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:236
FLVContext::videosize
int64_t videosize
Definition: flvenc.c:99
FLVContext::datasize
int64_t datasize
Definition: flvenc.c:97
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:269
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
FLVFileposition::keyframe_timestamp
double keyframe_timestamp
Definition: flvenc.c:83
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
FLV_SAMPLERATE_SPECIAL
@ FLV_SAMPLERATE_SPECIAL
signifies 5512Hz and 8000Hz in the case of NELLYMOSER
Definition: flv.h:90
av_packet_side_data_get
const AVPacketSideData * av_packet_side_data_get(const AVPacketSideData *sd, int nb_sd, enum AVPacketSideDataType type)
Get side information from a side data array.
Definition: avpacket.c:654
FLVContext::keyframes_info_offset
int64_t keyframes_info_offset
Definition: flvenc.c:115
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
flv_muxer_class
static const AVClass flv_muxer_class
Definition: flvenc.c:1245
AVPacket::size
int size
Definition: packet.h:523
flv_init
static int flv_init(struct AVFormatContext *s)
Definition: flvenc.c:765
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:106
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
ff_isom_write_avcc
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
Definition: avc.c:142
ff_standardize_creation_time
int ff_standardize_creation_time(AVFormatContext *s)
Standardize creation_time metadata in AVFormatContext to an ISO-8601 timestamp string.
Definition: mux_utils.c:133
put_eos_tag
static void put_eos_tag(AVIOContext *pb, unsigned ts, enum AVCodecID codec_id)
Definition: flvenc.c:243
shift_data
static int shift_data(AVFormatContext *s)
Definition: flvenc.c:736
FLV_FRAME_INTER
@ FLV_FRAME_INTER
inter frame (for AVC, a non-seekable frame)
Definition: flv.h:132
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:56
AV_CODEC_ID_ADPCM_SWF
@ AV_CODEC_ID_ADPCM_SWF
Definition: codec_id.h:380
size
int size
Definition: twinvq_data.h:10344
flv_audio_codec_ids
static const AVCodecTag flv_audio_codec_ids[]
Definition: flvenc.c:59
avio.h
FLVContext
Definition: flvdec.c:71
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
get_audio_flags
static int get_audio_flags(AVFormatContext *s, AVCodecParameters *par)
Definition: flvenc.c:131
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:128
FLV_TAG_TYPE_AUDIO
@ FLV_TAG_TYPE_AUDIO
Definition: flv.h:66
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:121
ff_isom_write_av1c
int ff_isom_write_av1c(AVIOContext *pb, const uint8_t *buf, int size, int write_seq_header)
Writes AV1 extradata (Sequence Header and Metadata OBUs) to the provided AVIOContext.
Definition: av1.c:398
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:521
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:200
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:364
FLVContext::data_par
AVCodecParameters * data_par
Definition: flvenc.c:124
FLVContext::filesize_offset
int64_t filesize_offset
Definition: flvenc.c:91
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: defs.h:61
FLVContext::reserved
int reserved
Definition: flvenc.c:89
put_amf_byte
static void put_amf_byte(AVIOContext *pb, unsigned char abyte)
Definition: flvenc.c:264
FLV_CODECID_PCM_LE
@ FLV_CODECID_PCM_LE
Definition: flv.h:100
FLV_HEADER_FLAG_HASVIDEO
@ FLV_HEADER_FLAG_HASVIDEO
Definition: flv.h:61
flv_video_codec_ids
static const AVCodecTag flv_video_codec_ids[]
Definition: flvenc.c:43
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:406
ff_isom_write_hvcc
int ff_isom_write_hvcc(AVIOContext *pb, const uint8_t *data, int size, int ps_array_completeness)
Writes HEVC extradata (parameter sets, declarative SEI NAL units) to the provided AVIOContext.
Definition: hevc.c:1042
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:1205
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:478
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
FLV_CODECID_MPEG4
@ FLV_CODECID_MPEG4
Definition: flv.h:118
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
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:252
FLVContext::keyframe_index_size
int64_t keyframe_index_size
Definition: flvenc.c:106
FLV_CODECID_SCREEN2
@ FLV_CODECID_SCREEN2
Definition: flv.h:115
unsupported_codec
static int unsupported_codec(AVFormatContext *s, const char *type, int codec_id)
Definition: flvenc.c:619
AVCodecParameters::height
int height
Definition: codec_par.h:135
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
FLVContext::framerate
AVRational framerate
Definition: flvdec.c:101
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
len
int len
Definition: vorbis_enc_data.h:426
FLVContext::metadata_size_pos
int64_t metadata_size_pos
Definition: flvenc.c:103
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
FLV_NO_METADATA
@ FLV_NO_METADATA
Definition: flvenc.c:77
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:129
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
AMF_DATA_TYPE_MIXEDARRAY
@ AMF_DATA_TYPE_MIXEDARRAY
Definition: flv.h:146
AMF_DATA_TYPE_STRING
@ AMF_DATA_TYPE_STRING
Definition: flv.h:141
put_timestamp
static void put_timestamp(AVIOContext *pb, int64_t ts)
Definition: flvenc.c:238
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:491
FLV_CODECID_H263
@ FLV_CODECID_H263
Definition: flv.h:111
tag
uint32_t tag
Definition: movenc.c:1786
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
put_amf_dword_array
static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
Definition: flvenc.c:269
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:230
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
flv_write_metadata_packet
static void flv_write_metadata_packet(AVFormatContext *s, AVCodecParameters *par, unsigned int ts)
Definition: flvenc.c:483
pos
unsigned int pos
Definition: spdifenc.c:413
avformat.h
dict.h
AV_CODEC_ID_TEXT
@ AV_CODEC_ID_TEXT
raw UTF-8 text
Definition: codec_id.h:551
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:28
FLV_AAC_SEQ_HEADER_DETECT
@ FLV_AAC_SEQ_HEADER_DETECT
Definition: flvenc.c:74
flv_deinit
static void flv_deinit(AVFormatContext *s)
Definition: flvenc.c:1221
FLVContext::lastkeyframetimestamp_offset
int64_t lastkeyframetimestamp_offset
Definition: flvenc.c:110
ff_codec_get_tag
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:135
FLV_TAG_TYPE_META
@ FLV_TAG_TYPE_META
Definition: flv.h:68
put_amf_string
static void put_amf_string(AVIOContext *pb, const char *str)
Definition: flvenc.c:230
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
AVPacket::stream_index
int stream_index
Definition: packet.h:524
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:317
avio_wb64
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:430
ff_mpeg4audio_sample_rates
const int ff_mpeg4audio_sample_rates[16]
Definition: mpeg4audio_sample_rates.h:26
PacketTypeCodedFrames
@ PacketTypeCodedFrames
Definition: flv.h:123
desc
const char * desc
Definition: libsvtav1.c:73
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:110
FLVContext::lasttimestamp
double lasttimestamp
Definition: flvenc.c:109
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:333
mastering_display_metadata.h
flv_write_trailer
static int flv_write_trailer(AVFormatContext *s)
Definition: flvenc.c:887
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
FLVContext::metadata_pkt_written
int metadata_pkt_written
Definition: flvenc.c:128
FLV_CODECID_NELLYMOSER_8KHZ_MONO
@ FLV_CODECID_NELLYMOSER_8KHZ_MONO
Definition: flv.h:102
avio_wb24
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:454
AMF_DATA_TYPE_NUMBER
@ AMF_DATA_TYPE_NUMBER
Definition: flv.h:139
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
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:55
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:107
write_metadata
static void write_metadata(AVFormatContext *s, unsigned int ts)
Definition: flvenc.c:281
d
d
Definition: ffmpeg_filter.c:425
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:234
FLV_CODECID_NELLYMOSER_16KHZ_MONO
@ FLV_CODECID_NELLYMOSER_16KHZ_MONO
Definition: flv.h:101
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:442
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
av1.h
options
static const AVOption options[]
Definition: flvenc.c:1235
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3727
FLV_SAMPLERATE_22050HZ
@ FLV_SAMPLERATE_22050HZ
Definition: flv.h:92
FLVFileposition::next
struct FLVFileposition * next
Definition: flvenc.c:84
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:73
FLVContext::datastart_offset
int64_t datastart_offset
Definition: flvenc.c:95
codec_desc.h
put_bits.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
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: mux.c:1326
FLV_STREAM_TYPE_NB
@ FLV_STREAM_TYPE_NB
Definition: flv.h:76
flv_write_codec_header
static void flv_write_codec_header(AVFormatContext *s, AVCodecParameters *par, int64_t ts)
Definition: flvenc.c:630
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:473
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
FLV_CODECID_MP3
@ FLV_CODECID_MP3
Definition: flv.h:99
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:239
mux.h