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