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/attributes.h"
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/dict.h"
25 #include "libavutil/intfloat.h"
26 #include "libavutil/avassert.h"
27 #include "libavutil/mastering_display_metadata.h"
28 #include "libavutil/mathematics.h"
29 #include "libavutil/mem.h"
30 #include "libavcodec/codec_desc.h"
31 #include "libavcodec/mpeg4audio.h"
32 #include "avio.h"
33 #include "avc.h"
34 #include "av1.h"
35 #include "vpcc.h"
36 #include "hevc.h"
37 #include "vvc.h"
38 #include "avformat.h"
39 #include "flv.h"
40 #include "internal.h"
41 #include "nal.h"
42 #include "mux.h"
43 #include "libavutil/opt.h"
44 #include "libavcodec/put_bits.h"
45 
46 
47 static const AVCodecTag flv_video_codec_ids[] = {
48  { AV_CODEC_ID_FLV1, FLV_CODECID_H263 },
49  { AV_CODEC_ID_H263, FLV_CODECID_REALH263 },
50  { AV_CODEC_ID_MPEG4, FLV_CODECID_MPEG4 },
51  { AV_CODEC_ID_FLASHSV, FLV_CODECID_SCREEN },
52  { AV_CODEC_ID_FLASHSV2, FLV_CODECID_SCREEN2 },
53  { AV_CODEC_ID_VP6F, FLV_CODECID_VP6 },
54  { AV_CODEC_ID_VP6, FLV_CODECID_VP6 },
55  { AV_CODEC_ID_VP6A, FLV_CODECID_VP6A },
56  { AV_CODEC_ID_H264, FLV_CODECID_H264 },
57  { AV_CODEC_ID_HEVC, MKBETAG('h', 'v', 'c', '1') },
58  { AV_CODEC_ID_VVC, MKBETAG('v', 'v', 'c', '1') },
59  { AV_CODEC_ID_AV1, MKBETAG('a', 'v', '0', '1') },
60  { AV_CODEC_ID_VP9, MKBETAG('v', 'p', '0', '9') },
61  { AV_CODEC_ID_NONE, 0 }
62 };
63 
64 static const AVCodecTag flv_audio_codec_ids[] = {
65  { AV_CODEC_ID_MP3, FLV_CODECID_MP3 >> FLV_AUDIO_CODECID_OFFSET },
66  { AV_CODEC_ID_PCM_U8, FLV_CODECID_PCM >> FLV_AUDIO_CODECID_OFFSET },
67  { AV_CODEC_ID_PCM_S16BE, FLV_CODECID_PCM >> FLV_AUDIO_CODECID_OFFSET },
68  { AV_CODEC_ID_PCM_S16LE, FLV_CODECID_PCM_LE >> FLV_AUDIO_CODECID_OFFSET },
69  { AV_CODEC_ID_ADPCM_SWF, FLV_CODECID_ADPCM >> FLV_AUDIO_CODECID_OFFSET },
70  { AV_CODEC_ID_AAC, FLV_CODECID_AAC >> FLV_AUDIO_CODECID_OFFSET },
71  { AV_CODEC_ID_NELLYMOSER, FLV_CODECID_NELLYMOSER >> FLV_AUDIO_CODECID_OFFSET },
72  { AV_CODEC_ID_PCM_MULAW, FLV_CODECID_PCM_MULAW >> FLV_AUDIO_CODECID_OFFSET },
73  { AV_CODEC_ID_PCM_ALAW, FLV_CODECID_PCM_ALAW >> FLV_AUDIO_CODECID_OFFSET },
74  { AV_CODEC_ID_SPEEX, FLV_CODECID_SPEEX >> FLV_AUDIO_CODECID_OFFSET },
75  { AV_CODEC_ID_OPUS, MKBETAG('O', 'p', 'u', 's') },
76  { AV_CODEC_ID_FLAC, MKBETAG('f', 'L', 'a', 'C') },
77  { AV_CODEC_ID_AC3, MKBETAG('a', 'c', '-', '3') },
78  { AV_CODEC_ID_EAC3, MKBETAG('e', 'c', '-', '3') },
79  { AV_CODEC_ID_NONE, 0 }
80 };
81 
82 typedef enum {
83  FLV_AAC_SEQ_HEADER_DETECT = (1 << 0),
84  FLV_NO_SEQUENCE_END = (1 << 1),
85  FLV_ADD_KEYFRAME_INDEX = (1 << 2),
86  FLV_NO_METADATA = (1 << 3),
87  FLV_NO_DURATION_FILESIZE = (1 << 4),
88 } FLVFlags;
89 
90 typedef struct FLVFileposition {
91  int64_t keyframe_position;
92  double keyframe_timestamp;
93  struct FLVFileposition *next;
94 } FLVFileposition;
95 
96 typedef struct FLVContext {
97  AVClass *av_class;
98  int reserved;
99  int64_t duration_offset;
100  int64_t filesize_offset;
101  int64_t duration;
102  int64_t delay; ///< first dts delay (needed for AVC & Speex)
103 
104  int64_t datastart_offset;
105  int64_t datasize_offset;
106  int64_t datasize;
107  int64_t videosize_offset;
108  int64_t videosize;
109  int64_t audiosize_offset;
110  int64_t audiosize;
111 
112  int64_t metadata_size_pos;
113  int64_t metadata_totalsize_pos;
114  int64_t metadata_totalsize;
115  int64_t keyframe_index_size;
116 
117  int64_t lasttimestamp_offset;
118  double lasttimestamp;
119  int64_t lastkeyframetimestamp_offset;
120  double lastkeyframetimestamp;
121  int64_t lastkeyframelocation_offset;
122  int64_t lastkeyframelocation;
123 
124  int64_t keyframes_info_offset;
125 
126  int64_t filepositions_count;
127  FLVFileposition *filepositions;
128  FLVFileposition *head_filepositions;
129 
130  AVCodecParameters *audio_par;
131  AVCodecParameters *video_par;
132  double framerate;
133  AVCodecParameters *data_par;
134 
135  int flags;
136  int64_t *last_ts;
137  int *metadata_pkt_written;
138  int *track_idx_map;
139 } FLVContext;
140 
141 static int get_audio_flags(AVFormatContext *s, AVCodecParameters *par)
142 {
143  int flags = (par->bits_per_coded_sample == 16) ? FLV_SAMPLESSIZE_16BIT
144  : FLV_SAMPLESSIZE_8BIT;
145 
146  if (par->codec_id == AV_CODEC_ID_AAC) // specs force these parameters
147  return FLV_CODECID_AAC | FLV_SAMPLERATE_44100HZ |
148  FLV_SAMPLESSIZE_16BIT | FLV_STEREO;
149  if (par->codec_id == AV_CODEC_ID_OPUS || par->codec_id == AV_CODEC_ID_FLAC
150  || par->codec_id == AV_CODEC_ID_AC3 || par->codec_id == AV_CODEC_ID_EAC3)
151  return FLV_CODECID_EX_HEADER; // only needed for codec support check
152  else if (par->codec_id == AV_CODEC_ID_SPEEX) {
153  if (par->sample_rate != 16000) {
154  av_log(s, AV_LOG_ERROR,
155  "FLV only supports wideband (16kHz) Speex audio\n");
156  return AVERROR(EINVAL);
157  }
158  if (par->ch_layout.nb_channels != 1) {
159  av_log(s, AV_LOG_ERROR, "FLV only supports mono Speex audio\n");
160  return AVERROR(EINVAL);
161  }
162  return FLV_CODECID_SPEEX | FLV_SAMPLERATE_11025HZ | FLV_SAMPLESSIZE_16BIT;
163  } else {
164  switch (par->sample_rate) {
165  case 48000:
166  // 48khz mp3 is stored with 44k1 samplerate identifier
167  if (par->codec_id == AV_CODEC_ID_MP3) {
168  flags |= FLV_SAMPLERATE_44100HZ;
169  break;
170  } else {
171  goto error;
172  }
173  case 44100:
174  flags |= FLV_SAMPLERATE_44100HZ;
175  break;
176  case 22050:
177  flags |= FLV_SAMPLERATE_22050HZ;
178  break;
179  case 11025:
180  flags |= FLV_SAMPLERATE_11025HZ;
181  break;
182  case 16000: // nellymoser only
183  case 8000: // nellymoser only
184  case 5512: // not MP3
185  if (par->codec_id != AV_CODEC_ID_MP3) {
186  flags |= FLV_SAMPLERATE_SPECIAL;
187  break;
188  }
189  av_fallthrough;
190  default:
191 error:
192  av_log(s, AV_LOG_ERROR,
193  "FLV does not support sample rate %d, "
194  "choose from (44100, 22050, 11025)\n", par->sample_rate);
195  return AVERROR(EINVAL);
196  }
197  }
198 
199  if (par->ch_layout.nb_channels > 1)
200  flags |= FLV_STEREO;
201 
202  switch (par->codec_id) {
203  case AV_CODEC_ID_MP3:
204  flags |= FLV_CODECID_MP3 | FLV_SAMPLESSIZE_16BIT;
205  break;
206  case AV_CODEC_ID_PCM_U8:
207  flags |= FLV_CODECID_PCM | FLV_SAMPLESSIZE_8BIT;
208  break;
209  case AV_CODEC_ID_PCM_S16BE:
210  flags |= FLV_CODECID_PCM | FLV_SAMPLESSIZE_16BIT;
211  break;
212  case AV_CODEC_ID_PCM_S16LE:
213  flags |= FLV_CODECID_PCM_LE | FLV_SAMPLESSIZE_16BIT;
214  break;
215  case AV_CODEC_ID_ADPCM_SWF:
216  flags |= FLV_CODECID_ADPCM | FLV_SAMPLESSIZE_16BIT;
217  break;
218  case AV_CODEC_ID_NELLYMOSER:
219  if (par->sample_rate == 8000)
220  flags |= FLV_CODECID_NELLYMOSER_8KHZ_MONO | FLV_SAMPLESSIZE_16BIT;
221  else if (par->sample_rate == 16000)
222  flags |= FLV_CODECID_NELLYMOSER_16KHZ_MONO | FLV_SAMPLESSIZE_16BIT;
223  else
224  flags |= FLV_CODECID_NELLYMOSER | FLV_SAMPLESSIZE_16BIT;
225  break;
226  case AV_CODEC_ID_PCM_MULAW:
227  flags |= FLV_CODECID_PCM_MULAW | FLV_SAMPLESSIZE_16BIT;
228  break;
229  case AV_CODEC_ID_PCM_ALAW:
230  flags |= FLV_CODECID_PCM_ALAW | FLV_SAMPLESSIZE_16BIT;
231  break;
232  case 0:
233  flags |= par->codec_tag << 4;
234  break;
235  default:
236  av_log(s, AV_LOG_ERROR, "Audio codec '%s' not compatible with FLV\n",
237  avcodec_get_name(par->codec_id));
238  return AVERROR(EINVAL);
239  }
240 
241  return flags;
242 }
243 
244 static void put_amf_string(AVIOContext *pb, const char *str)
245 {
246  size_t len = strlen(str);
247  avio_wb16(pb, len);
248  // Avoid avio_write() if put_amf_string(pb, "") is inlined.
249  if (av_builtin_constant_p(len == 0) && len == 0)
250  return;
251  avio_write(pb, str, len);
252 }
253 
254 // FLV timestamps are 32 bits signed, RTMP timestamps should be 32-bit unsigned
255 static void put_timestamp(AVIOContext *pb, int64_t ts) {
256  avio_wb24(pb, ts & 0xFFFFFF);
257  avio_w8(pb, (ts >> 24) & 0x7F);
258 }
259 
260 static void put_eos_tag(AVIOContext *pb, unsigned ts, enum AVCodecID codec_id)
261 {
262  uint32_t tag = ff_codec_get_tag(flv_video_codec_ids, codec_id);
263  /* ub[4] FrameType = 1, ub[4] CodecId */
264  tag |= 1 << 4;
265  avio_w8(pb, FLV_TAG_TYPE_VIDEO);
266  avio_wb24(pb, 5); /* Tag Data Size */
267  put_timestamp(pb, ts);
268  avio_wb24(pb, 0); /* StreamId = 0 */
269  avio_w8(pb, tag);
270  avio_w8(pb, 2); /* AVC end of sequence */
271  avio_wb24(pb, 0); /* Always 0 for AVC EOS. */
272  avio_wb32(pb, 16); /* Size of FLV tag */
273 }
274 
275 static void put_amf_double(AVIOContext *pb, double d)
276 {
277  avio_w8(pb, AMF_DATA_TYPE_NUMBER);
278  avio_wb64(pb, av_double2int(d));
279 }
280 
281 static void put_amf_byte(AVIOContext *pb, unsigned char abyte)
282 {
283  avio_w8(pb, abyte);
284 }
285 
286 static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
287 {
288  avio_w8(pb, AMF_DATA_TYPE_ARRAY);
289  avio_wb32(pb, dw);
290 }
291 
292 static void put_amf_bool(AVIOContext *pb, int b)
293 {
294  avio_w8(pb, AMF_DATA_TYPE_BOOL);
295  avio_w8(pb, !!b);
296 }
297 
298 static void write_metadata(AVFormatContext *s, unsigned int ts)
299 {
300  AVIOContext *pb = s->pb;
301  FLVContext *flv = s->priv_data;
302  int write_duration_filesize = !(flv->flags & FLV_NO_DURATION_FILESIZE);
303  int metadata_count = 0;
304  int64_t metadata_count_pos;
305  const AVDictionaryEntry *tag = NULL;
306 
307  /* write meta_tag */
308  avio_w8(pb, FLV_TAG_TYPE_META); // tag type META
309  flv->metadata_size_pos = avio_tell(pb);
310  avio_wb24(pb, 0); // size of data part (sum of all parts below)
311  put_timestamp(pb, ts); // timestamp
312  avio_wb24(pb, 0); // reserved
313 
314  /* now data of data_size size */
315 
316  /* first event name as a string */
317  avio_w8(pb, AMF_DATA_TYPE_STRING);
318  put_amf_string(pb, "onMetaData"); // 12 bytes
319 
320  /* mixed array (hash) with size and string/type/data tuples */
321  avio_w8(pb, AMF_DATA_TYPE_MIXEDARRAY);
322  metadata_count_pos = avio_tell(pb);
323  metadata_count = 4 * !!flv->video_par +
324  5 * !!flv->audio_par +
325  1 * !!flv->data_par;
326  if (write_duration_filesize) {
327  metadata_count += 2; // +2 for duration and file size
328  }
329  avio_wb32(pb, metadata_count);
330 
331  if (write_duration_filesize) {
332  put_amf_string(pb, "duration");
333  flv->duration_offset = avio_tell(pb);
334  // fill in the guessed duration, it'll be corrected later if incorrect
335  put_amf_double(pb, s->duration / AV_TIME_BASE);
336  }
337 
338  if (flv->video_par) {
339  put_amf_string(pb, "width");
340  put_amf_double(pb, flv->video_par->width);
341 
342  put_amf_string(pb, "height");
343  put_amf_double(pb, flv->video_par->height);
344 
345  put_amf_string(pb, "videodatarate");
346  put_amf_double(pb, flv->video_par->bit_rate / 1024.0);
347 
348  if (flv->framerate != 0.0) {
349  put_amf_string(pb, "framerate");
350  put_amf_double(pb, flv->framerate);
351  metadata_count++;
352  }
353 
354  put_amf_string(pb, "videocodecid");
355  put_amf_double(pb, flv->video_par->codec_tag);
356  }
357 
358  if (flv->audio_par) {
359  put_amf_string(pb, "audiodatarate");
360  put_amf_double(pb, flv->audio_par->bit_rate / 1024.0);
361 
362  put_amf_string(pb, "audiosamplerate");
363  put_amf_double(pb, flv->audio_par->sample_rate);
364 
365  put_amf_string(pb, "audiosamplesize");
366  put_amf_double(pb, flv->audio_par->codec_id == AV_CODEC_ID_PCM_U8 ? 8 : 16);
367 
368  put_amf_string(pb, "stereo");
369  put_amf_bool(pb, flv->audio_par->ch_layout.nb_channels == 2);
370 
371  put_amf_string(pb, "audiocodecid");
372  put_amf_double(pb, flv->audio_par->codec_tag);
373  }
374 
375  if (flv->data_par) {
376  put_amf_string(pb, "datastream");
377  put_amf_double(pb, 0.0);
378  }
379 
380  ff_standardize_creation_time(s);
381  while ((tag = av_dict_iterate(s->metadata, tag))) {
382  if( !strcmp(tag->key, "width")
383  ||!strcmp(tag->key, "height")
384  ||!strcmp(tag->key, "videodatarate")
385  ||!strcmp(tag->key, "framerate")
386  ||!strcmp(tag->key, "videocodecid")
387  ||!strcmp(tag->key, "audiodatarate")
388  ||!strcmp(tag->key, "audiosamplerate")
389  ||!strcmp(tag->key, "audiosamplesize")
390  ||!strcmp(tag->key, "stereo")
391  ||!strcmp(tag->key, "audiocodecid")
392  ||!strcmp(tag->key, "duration")
393  ||!strcmp(tag->key, "onMetaData")
394  ||!strcmp(tag->key, "datasize")
395  ||!strcmp(tag->key, "lasttimestamp")
396  ||!strcmp(tag->key, "totalframes")
397  ||!strcmp(tag->key, "hasAudio")
398  ||!strcmp(tag->key, "hasVideo")
399  ||!strcmp(tag->key, "hasCuePoints")
400  ||!strcmp(tag->key, "hasMetadata")
401  ||!strcmp(tag->key, "hasKeyframes")
402  ){
403  av_log(s, AV_LOG_DEBUG, "Ignoring metadata for %s\n", tag->key);
404  continue;
405  }
406  put_amf_string(pb, tag->key);
407  avio_w8(pb, AMF_DATA_TYPE_STRING);
408  put_amf_string(pb, tag->value);
409  metadata_count++;
410  }
411 
412  if (write_duration_filesize) {
413  put_amf_string(pb, "filesize");
414  flv->filesize_offset = avio_tell(pb);
415  put_amf_double(pb, 0); // delayed write
416  }
417 
418  if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
419  flv->keyframe_index_size = 0;
420 
421  put_amf_string(pb, "hasVideo");
422  put_amf_bool(pb, !!flv->video_par);
423  metadata_count++;
424 
425  put_amf_string(pb, "hasKeyframes");
426  put_amf_bool(pb, 1);
427  metadata_count++;
428 
429  put_amf_string(pb, "hasAudio");
430  put_amf_bool(pb, !!flv->audio_par);
431  metadata_count++;
432 
433  put_amf_string(pb, "hasMetadata");
434  put_amf_bool(pb, 1);
435  metadata_count++;
436 
437  put_amf_string(pb, "canSeekToEnd");
438  put_amf_bool(pb, 1);
439  metadata_count++;
440 
441  put_amf_string(pb, "datasize");
442  flv->datasize_offset = avio_tell(pb);
443  flv->datasize = 0;
444  put_amf_double(pb, flv->datasize);
445  metadata_count++;
446 
447  put_amf_string(pb, "videosize");
448  flv->videosize_offset = avio_tell(pb);
449  flv->videosize = 0;
450  put_amf_double(pb, flv->videosize);
451  metadata_count++;
452 
453  put_amf_string(pb, "audiosize");
454  flv->audiosize_offset = avio_tell(pb);
455  flv->audiosize = 0;
456  put_amf_double(pb, flv->audiosize);
457  metadata_count++;
458 
459  put_amf_string(pb, "lasttimestamp");
460  flv->lasttimestamp_offset = avio_tell(pb);
461  flv->lasttimestamp = 0;
462  put_amf_double(pb, 0);
463  metadata_count++;
464 
465  put_amf_string(pb, "lastkeyframetimestamp");
466  flv->lastkeyframetimestamp_offset = avio_tell(pb);
467  flv->lastkeyframetimestamp = 0;
468  put_amf_double(pb, 0);
469  metadata_count++;
470 
471  put_amf_string(pb, "lastkeyframelocation");
472  flv->lastkeyframelocation_offset = avio_tell(pb);
473  flv->lastkeyframelocation = 0;
474  put_amf_double(pb, 0);
475  metadata_count++;
476 
477  put_amf_string(pb, "keyframes");
478  put_amf_byte(pb, AMF_DATA_TYPE_OBJECT);
479  metadata_count++;
480 
481  flv->keyframes_info_offset = avio_tell(pb);
482  }
483 
484  put_amf_string(pb, "");
485  avio_w8(pb, AMF_END_OF_OBJECT);
486 
487  /* write total size of tag */
488  flv->metadata_totalsize = avio_tell(pb) - flv->metadata_size_pos - 10;
489 
490  avio_seek(pb, metadata_count_pos, SEEK_SET);
491  avio_wb32(pb, metadata_count);
492 
493  avio_seek(pb, flv->metadata_size_pos, SEEK_SET);
494  avio_wb24(pb, flv->metadata_totalsize);
495  avio_skip(pb, flv->metadata_totalsize + 10 - 3);
496  flv->metadata_totalsize_pos = avio_tell(pb);
497  avio_wb32(pb, flv->metadata_totalsize + 11);
498 }
499 
500 static void write_codec_fourcc(AVIOContext *pb, enum AVCodecID codec_id)
501 {
502  switch (codec_id) {
503  case AV_CODEC_ID_AAC:
504  avio_write(pb, "mp4a", 4);
505  return;
506  case AV_CODEC_ID_OPUS:
507  avio_write(pb, "Opus", 4);
508  return;
509  case AV_CODEC_ID_FLAC:
510  avio_write(pb, "fLaC", 4);
511  return;
512  case AV_CODEC_ID_MP3:
513  avio_write(pb, ".mp3", 4);
514  return;
515  case AV_CODEC_ID_AC3:
516  avio_write(pb, "ac-3", 4);
517  return;
518  case AV_CODEC_ID_EAC3:
519  avio_write(pb, "ec-3", 4);
520  return;
521  case AV_CODEC_ID_H264:
522  avio_write(pb, "avc1", 4);
523  return;
524  case AV_CODEC_ID_HEVC:
525  avio_write(pb, "hvc1", 4);
526  return;
527  case AV_CODEC_ID_VVC:
528  avio_write(pb, "vvc1", 4);
529  return;
530  case AV_CODEC_ID_AV1:
531  avio_write(pb, "av01", 4);
532  return;
533  case AV_CODEC_ID_VP9:
534  avio_write(pb, "vp09", 4);
535  return;
536  default:
537  av_log(NULL, AV_LOG_ERROR, "Invalid codec FourCC write requested.\n");
538  av_assert0(0);
539  }
540 }
541 
542 static void flv_write_metadata_packet(AVFormatContext *s, AVCodecParameters *par, unsigned int ts, int stream_idx)
543 {
544  AVIOContext *pb = s->pb;
545  FLVContext *flv = s->priv_data;
546  AVContentLightMetadata *lightMetadata = NULL;
547  AVMasteringDisplayMetadata *displayMetadata = NULL;
548  int64_t metadata_size_pos = 0;
549  int64_t total_size = 0;
550  const AVPacketSideData *side_data = NULL;
551 
552  if (flv->metadata_pkt_written[stream_idx])
553  return;
554 
555  if (par->codec_id == AV_CODEC_ID_HEVC || par->codec_id == AV_CODEC_ID_AV1 ||
556  par->codec_id == AV_CODEC_ID_VP9 || par->codec_id == AV_CODEC_ID_VVC) {
557  int flags_size = 5;
558  side_data = av_packet_side_data_get(par->coded_side_data, par->nb_coded_side_data,
559  AV_PKT_DATA_CONTENT_LIGHT_LEVEL);
560  if (side_data)
561  lightMetadata = (AVContentLightMetadata *)side_data->data;
562 
563  side_data = av_packet_side_data_get(par->coded_side_data, par->nb_coded_side_data,
564  AV_PKT_DATA_MASTERING_DISPLAY_METADATA);
565  if (side_data)
566  displayMetadata = (AVMasteringDisplayMetadata *)side_data->data;
567 
568  /*
569  * Reference Enhancing FLV
570  * https://github.com/veovera/enhanced-rtmp/blob/main/enhanced-rtmp.pdf
571  * */
572  avio_w8(pb, FLV_TAG_TYPE_VIDEO); //write video tag type
573  metadata_size_pos = avio_tell(pb);
574  avio_wb24(pb, 0 + flags_size);
575  put_timestamp(pb, ts); //ts = pkt->dts, gen
576  avio_wb24(pb, flv->reserved);
577 
578  avio_w8(pb, FLV_IS_EX_HEADER | PacketTypeMetadata | FLV_FRAME_VIDEO_INFO_CMD); // ExVideoTagHeader mode with PacketTypeMetadata
579  write_codec_fourcc(pb, par->codec_id);
580 
581  avio_w8(pb, AMF_DATA_TYPE_STRING);
582  put_amf_string(pb, "colorInfo");
583 
584  avio_w8(pb, AMF_DATA_TYPE_OBJECT);
585 
586  put_amf_string(pb, "colorConfig"); // colorConfig
587 
588  avio_w8(pb, AMF_DATA_TYPE_OBJECT);
589 
590  if (par->color_trc != AVCOL_TRC_UNSPECIFIED &&
591  par->color_trc < AVCOL_TRC_NB) {
592  put_amf_string(pb, "transferCharacteristics"); // color_trc
593  put_amf_double(pb, par->color_trc);
594  }
595 
596  if (par->color_space != AVCOL_SPC_UNSPECIFIED &&
597  par->color_space < AVCOL_SPC_NB) {
598  put_amf_string(pb, "matrixCoefficients"); // colorspace
599  put_amf_double(pb, par->color_space);
600  }
601 
602  if (par->color_primaries != AVCOL_PRI_UNSPECIFIED &&
603  par->color_primaries < AVCOL_PRI_NB) {
604  put_amf_string(pb, "colorPrimaries"); // color_primaries
605  put_amf_double(pb, par->color_primaries);
606  }
607 
608  put_amf_string(pb, "");
609  avio_w8(pb, AMF_END_OF_OBJECT);
610 
611  if (lightMetadata) {
612  put_amf_string(pb, "hdrCll");
613  avio_w8(pb, AMF_DATA_TYPE_OBJECT);
614 
615  put_amf_string(pb, "maxFall");
616  put_amf_double(pb, lightMetadata->MaxFALL);
617 
618  put_amf_string(pb, "maxCLL");
619  put_amf_double(pb, lightMetadata->MaxCLL);
620 
621  put_amf_string(pb, "");
622  avio_w8(pb, AMF_END_OF_OBJECT);
623  }
624 
625  if (displayMetadata && (displayMetadata->has_primaries || displayMetadata->has_luminance)) {
626  put_amf_string(pb, "hdrMdcv");
627  avio_w8(pb, AMF_DATA_TYPE_OBJECT);
628  if (displayMetadata->has_primaries) {
629  put_amf_string(pb, "redX");
630  put_amf_double(pb, av_q2d(displayMetadata->display_primaries[0][0]));
631 
632  put_amf_string(pb, "redY");
633  put_amf_double(pb, av_q2d(displayMetadata->display_primaries[0][1]));
634 
635  put_amf_string(pb, "greenX");
636  put_amf_double(pb, av_q2d(displayMetadata->display_primaries[1][0]));
637 
638  put_amf_string(pb, "greenY");
639  put_amf_double(pb, av_q2d(displayMetadata->display_primaries[1][1]));
640 
641  put_amf_string(pb, "blueX");
642  put_amf_double(pb, av_q2d(displayMetadata->display_primaries[2][0]));
643 
644  put_amf_string(pb, "blueY");
645  put_amf_double(pb, av_q2d(displayMetadata->display_primaries[2][1]));
646 
647  put_amf_string(pb, "whitePointX");
648  put_amf_double(pb, av_q2d(displayMetadata->white_point[0]));
649 
650  put_amf_string(pb, "whitePointY");
651  put_amf_double(pb, av_q2d(displayMetadata->white_point[1]));
652  }
653  if (displayMetadata->has_luminance) {
654  put_amf_string(pb, "maxLuminance");
655  put_amf_double(pb, av_q2d(displayMetadata->max_luminance));
656 
657  put_amf_string(pb, "minLuminance");
658  put_amf_double(pb, av_q2d(displayMetadata->min_luminance));
659  }
660  put_amf_string(pb, "");
661  avio_w8(pb, AMF_END_OF_OBJECT);
662  }
663  put_amf_string(pb, "");
664  avio_w8(pb, AMF_END_OF_OBJECT);
665 
666  total_size = avio_tell(pb) - metadata_size_pos - 10;
667  avio_seek(pb, metadata_size_pos, SEEK_SET);
668  avio_wb24(pb, total_size);
669  avio_skip(pb, total_size + 10 - 3);
670  avio_wb32(pb, total_size + 11); // previous tag size
671  flv->metadata_pkt_written[stream_idx] = 1;
672  }
673 }
674 
675 static int unsupported_codec(AVFormatContext *s,
676  const char* type, int codec_id)
677 {
678  const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
679  av_log(s, AV_LOG_ERROR,
680  "%s codec %s not compatible with flv\n",
681  type,
682  desc ? desc->name : "unknown");
683  return AVERROR(ENOSYS);
684 }
685 
686 static void flv_write_aac_header(AVFormatContext* s, AVCodecParameters* par)
687 {
688  AVIOContext *pb = s->pb;
689  FLVContext *flv = s->priv_data;
690 
691  if (!par->extradata_size && (flv->flags & FLV_AAC_SEQ_HEADER_DETECT)) {
692  PutBitContext pbc;
693  int samplerate_index;
694  int channels = par->ch_layout.nb_channels
695  - (par->ch_layout.nb_channels == 8 ? 1 : 0);
696  uint8_t data[2];
697 
698  for (samplerate_index = 0; samplerate_index < 16;
699  samplerate_index++)
700  if (par->sample_rate
701  == ff_mpeg4audio_sample_rates[samplerate_index])
702  break;
703 
704  init_put_bits(&pbc, data, sizeof(data));
705  put_bits(&pbc, 5, par->profile + 1); //profile
706  put_bits(&pbc, 4, samplerate_index); //sample rate index
707  put_bits(&pbc, 4, channels);
708  put_bits(&pbc, 1, 0); //frame length - 1024 samples
709  put_bits(&pbc, 1, 0); //does not depend on core coder
710  put_bits(&pbc, 1, 0); //is not extension
711  flush_put_bits(&pbc);
712 
713  avio_w8(pb, data[0]);
714  avio_w8(pb, data[1]);
715 
716  av_log(s, AV_LOG_WARNING, "AAC sequence header: %02x %02x.\n",
717  data[0], data[1]);
718  }
719  avio_write(pb, par->extradata, par->extradata_size);
720 }
721 
722 static void flv_write_multichannel_body(AVFormatContext* s, AVCodecParameters* par)
723 {
724  AVIOContext *pb = s->pb;
725 
726  switch (par->ch_layout.order) {
727  case AV_CHANNEL_ORDER_NATIVE:
728  avio_w8(pb, AudioChannelOrderNative);
729  break;
730  case AV_CHANNEL_ORDER_CUSTOM:
731  avio_w8(pb, AudioChannelOrderCustom);
732  break;
733  default:
734  avio_w8(pb, AudioChannelOrderUnspecified);
735  break;
736  }
737 
738  avio_w8(pb, par->ch_layout.nb_channels);
739 
740  if (par->ch_layout.order == AV_CHANNEL_ORDER_NATIVE) {
741  // The first 18 entries are identical between FFmpeg and flv
742  uint32_t mask = par->ch_layout.u.mask & 0x03FFFF;
743  // The remaining 6 flv entries are in the right order, but start at AV_CHAN_LOW_FREQUENCY_2
744  mask |= (par->ch_layout.u.mask >> (AV_CHAN_LOW_FREQUENCY_2 - 18)) & 0xFC0000;
745 
746  avio_wb32(pb, mask);
747  } else if (par->ch_layout.order == AV_CHANNEL_ORDER_CUSTOM) {
748  for (int i = 0; i < par->ch_layout.nb_channels; i++) {
749  enum AVChannel id = par->ch_layout.u.map[i].id;
750  if (id >= AV_CHAN_FRONT_LEFT && id <= AV_CHAN_TOP_BACK_RIGHT) {
751  avio_w8(pb, id - AV_CHAN_FRONT_LEFT + 0);
752  } else if (id >= AV_CHAN_LOW_FREQUENCY_2 && id <= AV_CHAN_BOTTOM_FRONT_RIGHT) {
753  avio_w8(pb, id - AV_CHAN_LOW_FREQUENCY_2 + 18);
754  } else if (id == AV_CHAN_UNUSED) {
755  avio_w8(pb, 0xFE);
756  } else {
757  avio_w8(pb, 0xFF); // unknown
758  }
759  }
760  }
761 }
762 
763 static int flv_get_multichannel_body_size(AVCodecParameters* par)
764 {
765  int res = 2;
766 
767  if (par->ch_layout.order == AV_CHANNEL_ORDER_NATIVE)
768  res += 4;
769  else if (par->ch_layout.order == AV_CHANNEL_ORDER_CUSTOM)
770  res += par->ch_layout.nb_channels;
771 
772  return res;
773 }
774 
775 static void flv_write_multichannel_header(AVFormatContext* s, AVCodecParameters* par, int64_t ts, int stream_index)
776 {
777  AVIOContext *pb = s->pb;
778  FLVContext *flv = s->priv_data;
779 
780  int track_idx = flv->track_idx_map[stream_index];
781  int data_size = flv_get_multichannel_body_size(par);
782  if (track_idx)
783  data_size += 2;
784 
785  avio_w8(pb, FLV_TAG_TYPE_AUDIO);
786  avio_wb24(pb, data_size + 5); // size
787  put_timestamp(pb, ts);
788  avio_wb24(pb, 0); // streamid
789 
790  if (track_idx) {
791  avio_w8(pb, FLV_CODECID_EX_HEADER | AudioPacketTypeMultitrack);
792  avio_w8(pb, MultitrackTypeOneTrack | AudioPacketTypeMultichannelConfig);
793  } else {
794  avio_w8(pb, FLV_CODECID_EX_HEADER | AudioPacketTypeMultichannelConfig);
795  }
796 
797  write_codec_fourcc(pb, par->codec_id);
798 
799  if (track_idx)
800  avio_w8(pb, track_idx);
801 
802  flv_write_multichannel_body(s, par);
803 
804  avio_wb32(pb, data_size + 5 + 11); // previous tag size
805 }
806 
807 static void flv_write_codec_header(AVFormatContext* s, AVCodecParameters* par, int64_t ts, int stream_index) {
808  int64_t data_size;
809  AVIOContext *pb = s->pb;
810  FLVContext *flv = s->priv_data;
811  int track_idx = flv->track_idx_map[stream_index];
812  int extended_flv = 0;
813 
814  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
815  || par->codec_id == AV_CODEC_ID_MPEG4 || par->codec_id == AV_CODEC_ID_HEVC
816  || par->codec_id == AV_CODEC_ID_AV1 || par->codec_id == AV_CODEC_ID_VP9
817  || par->codec_id == AV_CODEC_ID_VVC
818  || (par->codec_id == AV_CODEC_ID_MP3 && track_idx)
819  || par->codec_id == AV_CODEC_ID_OPUS || par->codec_id == AV_CODEC_ID_FLAC
820  || par->codec_id == AV_CODEC_ID_AC3 || par->codec_id == AV_CODEC_ID_EAC3) {
821  int64_t pos;
822  avio_w8(pb,
823  par->codec_type == AVMEDIA_TYPE_VIDEO ?
824  FLV_TAG_TYPE_VIDEO : FLV_TAG_TYPE_AUDIO);
825  avio_wb24(pb, 0); // size patched later
826  put_timestamp(pb, ts);
827  avio_wb24(pb, 0); // streamid
828  pos = avio_tell(pb);
829  if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
830  extended_flv = (par->codec_id == AV_CODEC_ID_AAC && track_idx)
831  || (par->codec_id == AV_CODEC_ID_MP3 && track_idx)
832  || par->codec_id == AV_CODEC_ID_OPUS
833  || par->codec_id == AV_CODEC_ID_FLAC
834  || par->codec_id == AV_CODEC_ID_AC3
835  || par->codec_id == AV_CODEC_ID_EAC3;
836 
837  if (extended_flv) {
838  if (track_idx) {
839  avio_w8(pb, FLV_CODECID_EX_HEADER | AudioPacketTypeMultitrack);
840  avio_w8(pb, MultitrackTypeOneTrack | AudioPacketTypeSequenceStart);
841  } else {
842  avio_w8(pb, FLV_CODECID_EX_HEADER | AudioPacketTypeSequenceStart);
843  }
844 
845  write_codec_fourcc(pb, par->codec_id);
846 
847  if (track_idx)
848  avio_w8(pb, track_idx);
849 
850  if (par->codec_id == AV_CODEC_ID_AAC) {
851  flv_write_aac_header(s, par);
852  } else if (par->codec_id == AV_CODEC_ID_OPUS || par->codec_id == AV_CODEC_ID_FLAC) {
853  av_assert0(par->extradata_size);
854  avio_write(pb, par->extradata, par->extradata_size);
855  }
856  } else if (par->codec_id == AV_CODEC_ID_AAC) {
857  avio_w8(pb, get_audio_flags(s, par));
858  avio_w8(pb, 0); // AAC sequence header
859 
860  flv_write_aac_header(s, par);
861  }
862  } else {
863  // If video stream has track_idx > 0 we need to send H.264 as extended video packet
864  extended_flv = (par->codec_id == AV_CODEC_ID_H264 && track_idx) ||
865  par->codec_id == AV_CODEC_ID_HEVC ||
866  par->codec_id == AV_CODEC_ID_VVC ||
867  par->codec_id == AV_CODEC_ID_AV1 ||
868  par->codec_id == AV_CODEC_ID_VP9;
869 
870  if (extended_flv) {
871  if (track_idx) {
872  avio_w8(pb, FLV_IS_EX_HEADER | PacketTypeMultitrack | FLV_FRAME_KEY);
873  avio_w8(pb, MultitrackTypeOneTrack | PacketTypeSequenceStart);
874  } else {
875  avio_w8(pb, FLV_IS_EX_HEADER | PacketTypeSequenceStart | FLV_FRAME_KEY);
876  }
877 
878  write_codec_fourcc(pb, par->codec_id);
879 
880  if (track_idx)
881  avio_w8(pb, track_idx);
882  } else {
883  avio_w8(pb, par->codec_tag | FLV_FRAME_KEY); // flags
884  avio_w8(pb, 0); // AVC sequence header
885  avio_wb24(pb, 0); // composition time
886  }
887 
888  if (par->codec_id == AV_CODEC_ID_HEVC)
889  ff_isom_write_hvcc(pb, par->extradata, par->extradata_size, 0, s);
890  else if (par->codec_id == AV_CODEC_ID_VVC)
891  ff_isom_write_vvcc(pb, par->extradata, par->extradata_size, 1);
892  else if (par->codec_id == AV_CODEC_ID_AV1)
893  ff_isom_write_av1c(pb, par->extradata, par->extradata_size, 1);
894  else if (par->codec_id == AV_CODEC_ID_VP9)
895  ff_isom_write_vpcc(s, pb, par->extradata, par->extradata_size, par);
896  else if (par->codec_id == AV_CODEC_ID_H264)
897  ff_isom_write_avcc(pb, par->extradata, par->extradata_size);
898  else if (par->codec_id == AV_CODEC_ID_MPEG4)
899  avio_write(pb, par->extradata, par->extradata_size);
900  else
901  av_assert0(0);
902  }
903  data_size = avio_tell(pb) - pos;
904  avio_seek(pb, -data_size - 10, SEEK_CUR);
905  avio_wb24(pb, data_size);
906  avio_skip(pb, data_size + 10 - 3);
907  avio_wb32(pb, data_size + 11); // previous tag size
908  }
909 
910  if (par->codec_type == AVMEDIA_TYPE_AUDIO && (extended_flv ||
911  (av_channel_layout_compare(&par->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO) == 1 &&
912  av_channel_layout_compare(&par->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_MONO) == 1)))
913  flv_write_multichannel_header(s, par, ts, stream_index);
914 }
915 
916 static int flv_append_keyframe_info(AVFormatContext *s, FLVContext *flv, double ts, int64_t pos)
917 {
918  FLVFileposition *position = av_malloc(sizeof(FLVFileposition));
919 
920  if (!position) {
921  av_log(s, AV_LOG_WARNING, "no mem for add keyframe index!\n");
922  return AVERROR(ENOMEM);
923  }
924 
925  position->keyframe_timestamp = ts;
926  position->keyframe_position = pos;
927 
928  if (!flv->filepositions_count) {
929  flv->filepositions = position;
930  flv->head_filepositions = flv->filepositions;
931  position->next = NULL;
932  } else {
933  flv->filepositions->next = position;
934  position->next = NULL;
935  flv->filepositions = flv->filepositions->next;
936  }
937 
938  flv->filepositions_count++;
939 
940  return 0;
941 }
942 
943 static int shift_data(AVFormatContext *s)
944 {
945  int ret;
946  int64_t metadata_size = 0;
947  FLVContext *flv = s->priv_data;
948 
949  metadata_size = flv->filepositions_count * 9 * 2 + 10; /* filepositions and times value */
950  metadata_size += 2 + 13; /* filepositions String */
951  metadata_size += 2 + 5; /* times String */
952  metadata_size += 3; /* Object end */
953 
954  flv->keyframe_index_size = metadata_size;
955 
956  if (metadata_size < 0)
957  return metadata_size;
958 
959  ret = ff_format_shift_data(s, flv->keyframes_info_offset, metadata_size);
960  if (ret < 0)
961  return ret;
962 
963  avio_seek(s->pb, flv->metadata_size_pos, SEEK_SET);
964  avio_wb24(s->pb, flv->metadata_totalsize + metadata_size);
965 
966  avio_seek(s->pb, flv->metadata_totalsize_pos + metadata_size, SEEK_SET);
967  avio_wb32(s->pb, flv->metadata_totalsize + 11 + metadata_size);
968 
969  return 0;
970 }
971 
972 static int flv_init(struct AVFormatContext *s)
973 {
974  int i;
975  int video_ctr = 0, audio_ctr = 0;
976  FLVContext *flv = s->priv_data;
977 
978  flv->last_ts = av_calloc(s->nb_streams, sizeof(*flv->last_ts));
979  flv->metadata_pkt_written = av_calloc(s->nb_streams, sizeof(*flv->metadata_pkt_written));
980  flv->track_idx_map = av_calloc(s->nb_streams, sizeof(*flv->track_idx_map));
981  if (!flv->last_ts || !flv->metadata_pkt_written || !flv->track_idx_map)
982  return AVERROR(ENOMEM);
983 
984  for (i = 0; i < s->nb_streams; i++) {
985  AVCodecParameters *par = s->streams[i]->codecpar;
986 
987  switch (par->codec_type) {
988  case AVMEDIA_TYPE_VIDEO:
989  if (video_ctr &&
990  par->codec_id != AV_CODEC_ID_VP8 &&
991  par->codec_id != AV_CODEC_ID_VP9 &&
992  par->codec_id != AV_CODEC_ID_AV1 &&
993  par->codec_id != AV_CODEC_ID_H264 &&
994  par->codec_id != AV_CODEC_ID_HEVC &&
995  par->codec_id != AV_CODEC_ID_VVC) {
996  av_log(s, AV_LOG_ERROR, "Unsupported multi-track video codec.\n");
997  return AVERROR(EINVAL);
998  }
999  if (s->streams[i]->avg_frame_rate.den &&
1000  s->streams[i]->avg_frame_rate.num) {
1001  flv->framerate = av_q2d(s->streams[i]->avg_frame_rate);
1002  }
1003  flv->track_idx_map[i] = video_ctr++;
1004  if (flv->video_par && flv->flags & FLV_ADD_KEYFRAME_INDEX) {
1005  av_log(s, AV_LOG_ERROR,
1006  "at most one video stream is supported in flv with keyframe index\n");
1007  return AVERROR(EINVAL);
1008  } else if (flv->video_par) {
1009  av_log(s, AV_LOG_WARNING,
1010  "more than one video stream is not supported by most flv demuxers.\n");
1011  }
1012  if (!flv->video_par)
1013  flv->video_par = par;
1014  if (!ff_codec_get_tag(flv_video_codec_ids, par->codec_id))
1015  return unsupported_codec(s, "Video", par->codec_id);
1016 
1017  if (par->codec_id == AV_CODEC_ID_MPEG4 ||
1018  par->codec_id == AV_CODEC_ID_H263) {
1019  int error = s->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL;
1020  av_log(s, error ? AV_LOG_ERROR : AV_LOG_WARNING,
1021  "Codec %s is not supported in the official FLV specification,\n", avcodec_get_name(par->codec_id));
1022 
1023  if (error) {
1024  av_log(s, AV_LOG_ERROR,
1025  "use vstrict=-1 / -strict -1 to use it anyway.\n");
1026  return AVERROR(EINVAL);
1027  }
1028  } else if (par->codec_id == AV_CODEC_ID_VP6) {
1029  av_log(s, AV_LOG_WARNING,
1030  "Muxing VP6 in flv will produce flipped video on playback.\n");
1031  }
1032  break;
1033  case AVMEDIA_TYPE_AUDIO:
1034  if (audio_ctr &&
1035  par->codec_id != AV_CODEC_ID_AAC &&
1036  par->codec_id != AV_CODEC_ID_MP3 &&
1037  par->codec_id != AV_CODEC_ID_OPUS &&
1038  par->codec_id != AV_CODEC_ID_FLAC &&
1039  par->codec_id != AV_CODEC_ID_AC3 &&
1040  par->codec_id != AV_CODEC_ID_EAC3) {
1041  av_log(s, AV_LOG_ERROR, "Unsupported multi-track audio codec.\n");
1042  return AVERROR(EINVAL);
1043  }
1044  flv->track_idx_map[i] = audio_ctr++;
1045  if (flv->audio_par)
1046  av_log(s, AV_LOG_WARNING,
1047  "more than one audio stream is not supported by most flv demuxers.\n");
1048  else
1049  flv->audio_par = par;
1050  if (get_audio_flags(s, par) < 0)
1051  return unsupported_codec(s, "Audio", par->codec_id);
1052  if (par->codec_id == AV_CODEC_ID_PCM_S16BE)
1053  av_log(s, AV_LOG_WARNING,
1054  "16-bit big-endian audio in flv is valid but most likely unplayable (hardware dependent); use s16le\n");
1055  break;
1056  case AVMEDIA_TYPE_DATA:
1057  if (par->codec_id != AV_CODEC_ID_TEXT && par->codec_id != AV_CODEC_ID_NONE)
1058  return unsupported_codec(s, "Data", par->codec_id);
1059  flv->data_par = par;
1060  break;
1061  case AVMEDIA_TYPE_SUBTITLE:
1062  if (par->codec_id != AV_CODEC_ID_TEXT) {
1063  av_log(s, AV_LOG_ERROR, "Subtitle codec '%s' for stream %d is not compatible with FLV\n",
1064  avcodec_get_name(par->codec_id), i);
1065  return AVERROR_INVALIDDATA;
1066  }
1067  flv->data_par = par;
1068  break;
1069  default:
1070  av_log(s, AV_LOG_ERROR, "Codec type '%s' for stream %d is not compatible with FLV\n",
1071  av_get_media_type_string(par->codec_type), i);
1072  return AVERROR(EINVAL);
1073  }
1074  avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
1075  flv->last_ts[i] = -1;
1076  }
1077 
1078  flv->delay = AV_NOPTS_VALUE;
1079 
1080  return 0;
1081 }
1082 
1083 static int flv_write_header(AVFormatContext *s)
1084 {
1085  int i;
1086  AVIOContext *pb = s->pb;
1087  FLVContext *flv = s->priv_data;
1088 
1089  avio_write(pb, "FLV", 3);
1090  avio_w8(pb, 1);
1091  avio_w8(pb, FLV_HEADER_FLAG_HASAUDIO * !!flv->audio_par +
1092  FLV_HEADER_FLAG_HASVIDEO * !!flv->video_par);
1093  avio_wb32(pb, 9);
1094  avio_wb32(pb, 0);
1095 
1096  for (i = 0; i < s->nb_streams; i++)
1097  if (s->streams[i]->codecpar->codec_tag == 5) {
1098  avio_w8(pb, 8); // message type
1099  avio_wb24(pb, 0); // include flags
1100  avio_wb24(pb, 0); // time stamp
1101  avio_wb32(pb, 0); // reserved
1102  avio_wb32(pb, 11); // size
1103  flv->reserved = 5;
1104  }
1105 
1106  if (flv->flags & FLV_NO_METADATA) {
1107  pb->seekable = 0;
1108  } else {
1109  write_metadata(s, 0);
1110  }
1111 
1112  for (i = 0; i < s->nb_streams; i++) {
1113  flv_write_codec_header(s, s->streams[i]->codecpar, 0, i);
1114  }
1115 
1116  flv->datastart_offset = avio_tell(pb);
1117  return 0;
1118 }
1119 
1120 static int flv_write_trailer(AVFormatContext *s)
1121 {
1122  int64_t file_size;
1123  AVIOContext *pb = s->pb;
1124  FLVContext *flv = s->priv_data;
1125  int build_keyframes_idx = flv->flags & FLV_ADD_KEYFRAME_INDEX;
1126  int i, res;
1127  int64_t cur_pos = avio_tell(s->pb);
1128 
1129  if (build_keyframes_idx) {
1130  const FLVFileposition *newflv_posinfo;
1131 
1132  avio_seek(pb, flv->videosize_offset, SEEK_SET);
1133  put_amf_double(pb, flv->videosize);
1134 
1135  avio_seek(pb, flv->audiosize_offset, SEEK_SET);
1136  put_amf_double(pb, flv->audiosize);
1137 
1138  avio_seek(pb, flv->lasttimestamp_offset, SEEK_SET);
1139  put_amf_double(pb, flv->lasttimestamp);
1140 
1141  avio_seek(pb, flv->lastkeyframetimestamp_offset, SEEK_SET);
1142  put_amf_double(pb, flv->lastkeyframetimestamp);
1143 
1144  avio_seek(pb, flv->lastkeyframelocation_offset, SEEK_SET);
1145  put_amf_double(pb, flv->lastkeyframelocation + flv->keyframe_index_size);
1146  avio_seek(pb, cur_pos, SEEK_SET);
1147 
1148  res = shift_data(s);
1149  if (res < 0) {
1150  goto end;
1151  }
1152  avio_seek(pb, flv->keyframes_info_offset, SEEK_SET);
1153  put_amf_string(pb, "filepositions");
1154  put_amf_dword_array(pb, flv->filepositions_count);
1155  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
1156  put_amf_double(pb, newflv_posinfo->keyframe_position + flv->keyframe_index_size);
1157  }
1158 
1159  put_amf_string(pb, "times");
1160  put_amf_dword_array(pb, flv->filepositions_count);
1161  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
1162  put_amf_double(pb, newflv_posinfo->keyframe_timestamp);
1163  }
1164 
1165  put_amf_string(pb, "");
1166  avio_w8(pb, AMF_END_OF_OBJECT);
1167 
1168  avio_seek(pb, cur_pos + flv->keyframe_index_size, SEEK_SET);
1169  }
1170 
1171 end:
1172  if (flv->flags & FLV_NO_SEQUENCE_END) {
1173  av_log(s, AV_LOG_DEBUG, "FLV no sequence end mode open\n");
1174  } else {
1175  /* Add EOS tag */
1176  for (i = 0; i < s->nb_streams; i++) {
1177  AVCodecParameters *par = s->streams[i]->codecpar;
1178  if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
1179  (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4))
1180  put_eos_tag(pb, flv->last_ts[i], par->codec_id);
1181  }
1182  }
1183 
1184  file_size = avio_tell(pb);
1185 
1186  if (build_keyframes_idx) {
1187  flv->datasize = file_size - flv->datastart_offset;
1188  avio_seek(pb, flv->datasize_offset, SEEK_SET);
1189  put_amf_double(pb, flv->datasize);
1190  }
1191  if (!(flv->flags & FLV_NO_METADATA)) {
1192  if (!(flv->flags & FLV_NO_DURATION_FILESIZE)) {
1193  /* update information */
1194  if (avio_seek(pb, flv->duration_offset, SEEK_SET) < 0) {
1195  av_log(s, AV_LOG_WARNING, "Failed to update header with correct duration.\n");
1196  } else {
1197  put_amf_double(pb, flv->duration / (double)1000);
1198  }
1199  if (avio_seek(pb, flv->filesize_offset, SEEK_SET) < 0) {
1200  av_log(s, AV_LOG_WARNING, "Failed to update header with correct filesize.\n");
1201  } else {
1202  put_amf_double(pb, file_size);
1203  }
1204  }
1205  }
1206 
1207  return 0;
1208 }
1209 
1210 static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
1211 {
1212  AVIOContext *pb = s->pb;
1213  AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
1214  FLVContext *flv = s->priv_data;
1215  unsigned ts;
1216  int size = pkt->size;
1217  uint8_t *data = NULL;
1218  uint8_t frametype = pkt->flags & AV_PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER;
1219  int flags = -1, flags_size, ret = 0;
1220  int64_t cur_offset = avio_tell(pb);
1221  int track_idx = flv->track_idx_map[pkt->stream_index];
1222 
1223  int extended_audio = (par->codec_id == AV_CODEC_ID_AAC && track_idx)
1224  || (par->codec_id == AV_CODEC_ID_MP3 && track_idx)
1225  || par->codec_id == AV_CODEC_ID_OPUS
1226  || par->codec_id == AV_CODEC_ID_FLAC
1227  || par->codec_id == AV_CODEC_ID_AC3
1228  || par->codec_id == AV_CODEC_ID_EAC3;
1229 
1230  if (extended_audio)
1231  flags_size = 5;
1232  else if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A ||
1233  par->codec_id == AV_CODEC_ID_VP6 || par->codec_id == AV_CODEC_ID_AAC)
1234  flags_size = 2;
1235  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4 ||
1236  par->codec_id == AV_CODEC_ID_HEVC || par->codec_id == AV_CODEC_ID_AV1 ||
1237  par->codec_id == AV_CODEC_ID_VP9 || par->codec_id == AV_CODEC_ID_VVC)
1238  flags_size = 5;
1239  else
1240  flags_size = 1;
1241 
1242  if ((par->codec_type == AVMEDIA_TYPE_VIDEO || par->codec_type == AVMEDIA_TYPE_AUDIO) && track_idx)
1243  flags_size += 2; // additional header bytes for multi-track flv
1244 
1245  if ((par->codec_id == AV_CODEC_ID_HEVC || par->codec_id == AV_CODEC_ID_VVC ||
1246  (par->codec_id == AV_CODEC_ID_H264 && track_idx))
1247  && pkt->pts != pkt->dts)
1248  flags_size += 3;
1249 
1250  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
1251  || par->codec_id == AV_CODEC_ID_MPEG4 || par->codec_id == AV_CODEC_ID_HEVC
1252  || par->codec_id == AV_CODEC_ID_VVC
1253  || par->codec_id == AV_CODEC_ID_AV1 || par->codec_id == AV_CODEC_ID_VP9
1254  || par->codec_id == AV_CODEC_ID_OPUS || par->codec_id == AV_CODEC_ID_FLAC) {
1255  size_t side_size;
1256  uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
1257  if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
1258  ret = ff_alloc_extradata(par, side_size);
1259  if (ret < 0)
1260  return ret;
1261  memcpy(par->extradata, side, side_size);
1262  flv_write_codec_header(s, par, pkt->dts, pkt->stream_index);
1263  }
1264  flv_write_metadata_packet(s, par, pkt->dts, pkt->stream_index);
1265  }
1266 
1267  if (flv->delay == AV_NOPTS_VALUE)
1268  flv->delay = -pkt->dts;
1269 
1270  if (pkt->dts < -flv->delay) {
1271  av_log(s, AV_LOG_WARNING,
1272  "Packets are not in the proper order with respect to DTS\n");
1273  return AVERROR(EINVAL);
1274  }
1275  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4 ||
1276  par->codec_id == AV_CODEC_ID_HEVC || par->codec_id == AV_CODEC_ID_AV1 ||
1277  par->codec_id == AV_CODEC_ID_VP9 || par->codec_id == AV_CODEC_ID_VVC) {
1278  if (pkt->pts == AV_NOPTS_VALUE) {
1279  av_log(s, AV_LOG_ERROR, "Packet is missing PTS\n");
1280  return AVERROR(EINVAL);
1281  }
1282  }
1283 
1284  ts = pkt->dts;
1285 
1286  if (s->event_flags & AVFMT_EVENT_FLAG_METADATA_UPDATED) {
1287  write_metadata(s, ts);
1288  s->event_flags &= ~AVFMT_EVENT_FLAG_METADATA_UPDATED;
1289  }
1290 
1291  avio_write_marker(pb, av_rescale(ts, AV_TIME_BASE, 1000),
1292  pkt->flags & AV_PKT_FLAG_KEY && (flv->video_par ? par->codec_type == AVMEDIA_TYPE_VIDEO : 1) ? AVIO_DATA_MARKER_SYNC_POINT : AVIO_DATA_MARKER_BOUNDARY_POINT);
1293 
1294  switch (par->codec_type) {
1295  case AVMEDIA_TYPE_VIDEO:
1296  avio_w8(pb, FLV_TAG_TYPE_VIDEO);
1297 
1298  flags = ff_codec_get_tag(flv_video_codec_ids, par->codec_id);
1299 
1300  flags |= frametype;
1301  break;
1302  case AVMEDIA_TYPE_AUDIO:
1303  flags = get_audio_flags(s, par);
1304 
1305  avio_w8(pb, FLV_TAG_TYPE_AUDIO);
1306  break;
1307  case AVMEDIA_TYPE_SUBTITLE:
1308  case AVMEDIA_TYPE_DATA:
1309  avio_w8(pb, FLV_TAG_TYPE_META);
1310  break;
1311  default:
1312  return AVERROR(EINVAL);
1313  }
1314 
1315  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
1316  /* check if extradata looks like mp4 formatted */
1317  if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
1318  if ((ret = ff_nal_parse_units_buf(pkt->data, &data, &size)) < 0)
1319  return ret;
1320  } else if (par->codec_id == AV_CODEC_ID_HEVC) {
1321  if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
1322  if ((ret = ff_hevc_annexb2mp4_buf(pkt->data, &data, &size, 0, NULL)) < 0)
1323  return ret;
1324  } else if (par->codec_id == AV_CODEC_ID_VVC) {
1325  if (par->extradata_size > 0 && (*(uint8_t*)par->extradata & 0xF8) != 0xF8)
1326  if ((ret = ff_vvc_annexb2mp4_buf(pkt->data, &data, &size, 0, NULL)) < 0)
1327  return ret;
1328  } else if (par->codec_id == AV_CODEC_ID_AAC && pkt->size > 2 &&
1329  (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
1330  if (!s->streams[pkt->stream_index]->nb_frames) {
1331  av_log(s, AV_LOG_ERROR, "Malformed AAC bitstream detected: "
1332  "use the audio bitstream filter 'aac_adtstoasc' to fix it "
1333  "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
1334  return AVERROR_INVALIDDATA;
1335  }
1336  av_log(s, AV_LOG_WARNING, "aac bitstream error\n");
1337  }
1338 
1339  /* check Speex packet duration */
1340  if (par->codec_id == AV_CODEC_ID_SPEEX && ts - flv->last_ts[pkt->stream_index] > 160)
1341  av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
1342  "8 frames per packet. Adobe Flash "
1343  "Player cannot handle this!\n");
1344 
1345  if (flv->last_ts[pkt->stream_index] < ts)
1346  flv->last_ts[pkt->stream_index] = ts;
1347 
1348  if (size + flags_size >= 1<<24) {
1349  av_log(s, AV_LOG_ERROR, "Too large packet with size %u >= %u\n",
1350  size + flags_size, 1<<24);
1351  ret = AVERROR(EINVAL);
1352  goto fail;
1353  }
1354 
1355  avio_wb24(pb, size + flags_size);
1356  put_timestamp(pb, ts);
1357  avio_wb24(pb, flv->reserved);
1358 
1359  if (par->codec_type == AVMEDIA_TYPE_DATA ||
1360  par->codec_type == AVMEDIA_TYPE_SUBTITLE ) {
1361  int data_size;
1362  int64_t metadata_size_pos = avio_tell(pb);
1363  if (par->codec_id == AV_CODEC_ID_TEXT) {
1364  // legacy FFmpeg magic?
1365  avio_w8(pb, AMF_DATA_TYPE_STRING);
1366  put_amf_string(pb, "onTextData");
1367  avio_w8(pb, AMF_DATA_TYPE_MIXEDARRAY);
1368  avio_wb32(pb, 2);
1369  put_amf_string(pb, "type");
1370  avio_w8(pb, AMF_DATA_TYPE_STRING);
1371  put_amf_string(pb, "Text");
1372  put_amf_string(pb, "text");
1373  avio_w8(pb, AMF_DATA_TYPE_STRING);
1374  put_amf_string(pb, pkt->data);
1375  put_amf_string(pb, "");
1376  avio_w8(pb, AMF_END_OF_OBJECT);
1377  } else {
1378  // just pass the metadata through
1379  avio_write(pb, data ? data : pkt->data, size);
1380  }
1381  /* write total size of tag */
1382  data_size = avio_tell(pb) - metadata_size_pos;
1383  avio_seek(pb, metadata_size_pos - 10, SEEK_SET);
1384  avio_wb24(pb, data_size);
1385  avio_seek(pb, data_size + 10 - 3, SEEK_CUR);
1386  avio_wb32(pb, data_size + 11);
1387  } else {
1388  int extended_video = (par->codec_id == AV_CODEC_ID_H264 && track_idx) ||
1389  par->codec_id == AV_CODEC_ID_HEVC ||
1390  par->codec_id == AV_CODEC_ID_VVC ||
1391  par->codec_id == AV_CODEC_ID_AV1 ||
1392  par->codec_id == AV_CODEC_ID_VP9;
1393 
1394  if (extended_video) {
1395  int h26456 = par->codec_id == AV_CODEC_ID_H264 ||
1396  par->codec_id == AV_CODEC_ID_VVC ||
1397  par->codec_id == AV_CODEC_ID_HEVC;
1398  int pkttype = PacketTypeCodedFrames;
1399  // Optimisation for VVC/HEVC/H264: Do not send composition time if DTS == PTS
1400  if (h26456 && pkt->pts == pkt->dts)
1401  pkttype = PacketTypeCodedFramesX;
1402 
1403  if (track_idx) {
1404  avio_w8(pb, FLV_IS_EX_HEADER | PacketTypeMultitrack | frametype);
1405  avio_w8(pb, MultitrackTypeOneTrack | pkttype);
1406  } else {
1407  avio_w8(pb, FLV_IS_EX_HEADER | pkttype | frametype);
1408  }
1409 
1410  write_codec_fourcc(pb, par->codec_id);
1411 
1412  if (track_idx)
1413  avio_w8(pb, track_idx);
1414  if (h26456 && pkttype == PacketTypeCodedFrames)
1415  avio_wb24(pb, pkt->pts - pkt->dts);
1416  } else if (extended_audio) {
1417  if (track_idx) {
1418  avio_w8(pb, FLV_CODECID_EX_HEADER | AudioPacketTypeMultitrack);
1419  avio_w8(pb, MultitrackTypeOneTrack | AudioPacketTypeCodedFrames);
1420  } else {
1421  avio_w8(pb, FLV_CODECID_EX_HEADER | AudioPacketTypeCodedFrames);
1422  }
1423  write_codec_fourcc(pb, par->codec_id);
1424  if (track_idx)
1425  avio_w8(pb, track_idx);
1426  } else if (track_idx) {
1427  av_log(s, AV_LOG_ERROR, "Attempted to write legacy codec into extended flv track.\n");
1428  ret = AVERROR(EINVAL);
1429  goto fail;
1430  } else {
1431  av_assert1(flags >= 0);
1432  avio_w8(pb, flags);
1433 
1434  if (par->codec_id == AV_CODEC_ID_VP6) {
1435  avio_w8(pb,0);
1436  } else if (par->codec_id == AV_CODEC_ID_VP6F ||
1437  par->codec_id == AV_CODEC_ID_VP6A) {
1438  if (par->extradata_size)
1439  avio_w8(pb, par->extradata[0]);
1440  else
1441  avio_w8(pb, ((FFALIGN(par->width, 16) - par->width) << 4) |
1442  (FFALIGN(par->height, 16) - par->height));
1443  } else if (par->codec_id == AV_CODEC_ID_AAC) {
1444  avio_w8(pb, 1); // AAC raw
1445  } else if (par->codec_id == AV_CODEC_ID_H264 ||
1446  par->codec_id == AV_CODEC_ID_MPEG4) {
1447  avio_w8(pb, 1); // AVC NALU
1448  avio_wb24(pb, pkt->pts - pkt->dts);
1449  }
1450  }
1451 
1452  avio_write(pb, data ? data : pkt->data, size);
1453 
1454  avio_wb32(pb, size + flags_size + 11); // previous tag size
1455  flv->duration = FFMAX(flv->duration,
1456  pkt->pts + flv->delay + pkt->duration);
1457  }
1458 
1459  if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
1460  switch (par->codec_type) {
1461  case AVMEDIA_TYPE_VIDEO:
1462  flv->videosize += (avio_tell(pb) - cur_offset);
1463  flv->lasttimestamp = pkt->dts / 1000.0;
1464  if (pkt->flags & AV_PKT_FLAG_KEY) {
1465  flv->lastkeyframetimestamp = flv->lasttimestamp;
1466  flv->lastkeyframelocation = cur_offset;
1467  ret = flv_append_keyframe_info(s, flv, flv->lasttimestamp, cur_offset);
1468  if (ret < 0)
1469  goto fail;
1470  }
1471  break;
1472 
1473  case AVMEDIA_TYPE_AUDIO:
1474  flv->audiosize += (avio_tell(pb) - cur_offset);
1475  break;
1476 
1477  default:
1478  av_log(s, AV_LOG_WARNING, "par->codec_type is type = [%d]\n", par->codec_type);
1479  break;
1480  }
1481  }
1482 fail:
1483  av_free(data);
1484 
1485  return ret;
1486 }
1487 
1488 static int flv_check_bitstream(AVFormatContext *s, AVStream *st,
1489  const AVPacket *pkt)
1490 {
1491  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
1492  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
1493  return ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
1494  }
1495  if (!st->codecpar->extradata_size &&
1496  (st->codecpar->codec_id == AV_CODEC_ID_H264 ||
1497  st->codecpar->codec_id == AV_CODEC_ID_HEVC ||
1498  st->codecpar->codec_id == AV_CODEC_ID_VVC ||
1499  st->codecpar->codec_id == AV_CODEC_ID_AV1 ||
1500  st->codecpar->codec_id == AV_CODEC_ID_MPEG4))
1501  return ff_stream_add_bitstream_filter(st, "extract_extradata", NULL);
1502  return 1;
1503 }
1504 
1505 static void flv_deinit(AVFormatContext *s)
1506 {
1507  FLVContext *flv = s->priv_data;
1508  FLVFileposition *filepos = flv->head_filepositions;
1509 
1510  while (filepos) {
1511  FLVFileposition *next = filepos->next;
1512  av_free(filepos);
1513  filepos = next;
1514  }
1515  flv->filepositions = flv->head_filepositions = NULL;
1516  flv->filepositions_count = 0;
1517 
1518  av_freep(&flv->last_ts);
1519  av_freep(&flv->metadata_pkt_written);
1520  av_freep(&flv->track_idx_map);
1521 }
1522 
1523 static const AVOption options[] = {
1524  { "flvflags", "FLV muxer flags", offsetof(FLVContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, .unit = "flvflags" },
1525  { "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" },
1526  { "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" },
1527  { "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" },
1528  { "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" },
1529  { "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" },
1530  { NULL },
1531 };
1532 
1533 static const AVClass flv_muxer_class = {
1534  .class_name = "flv muxer",
1535  .item_name = av_default_item_name,
1536  .option = options,
1537  .version = LIBAVUTIL_VERSION_INT,
1538 };
1539 
1540 const FFOutputFormat ff_flv_muxer = {
1541  .p.name = "flv",
1542  .p.long_name = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1543  .p.mime_type = "video/x-flv",
1544  .p.extensions = "flv",
1545  .priv_data_size = sizeof(FLVContext),
1546  .p.audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_ADPCM_SWF,
1547  .p.video_codec = AV_CODEC_ID_FLV1,
1548  .init = flv_init,
1549  .write_header = flv_write_header,
1550  .write_packet = flv_write_packet,
1551  .write_trailer = flv_write_trailer,
1552  .deinit = flv_deinit,
1553  .check_bitstream= flv_check_bitstream,
1554  .p.codec_tag = (const AVCodecTag* const []) {
1555  flv_video_codec_ids, flv_audio_codec_ids, 0
1556  },
1557  .p.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS |
1558  AVFMT_TS_NONSTRICT,
1559  .p.priv_class = &flv_muxer_class,
1560 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
AudioPacketTypeMultichannelConfig
@ AudioPacketTypeMultichannelConfig
Definition: flv.h:139
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:338
flags
const SwsFlags flags[]
Definition: swscale.c:72
FLVContext::metadata_totalsize
int64_t metadata_totalsize
Definition: flvenc.c:114
ff_isom_write_vpcc
int ff_isom_write_vpcc(void *logctx, AVIOContext *pb, const uint8_t *data, int len, const AVCodecParameters *par)
Writes VP codec configuration to the provided AVIOContext.
Definition: vpcc.c:204
FLVContext::audio_par
AVCodecParameters * audio_par
Definition: flvenc.c:130
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_PCM_LE
@ FLV_CODECID_PCM_LE
Definition: flv.h:100
AMF_END_OF_OBJECT
#define AMF_END_OF_OBJECT
Definition: flv.h:53
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:203
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:216
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:71
FLV_NO_DURATION_FILESIZE
@ FLV_NO_DURATION_FILESIZE
Definition: flvenc.c:87
FLV_TAG_TYPE_VIDEO
@ FLV_TAG_TYPE_VIDEO
Definition: flv.h:67
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:463
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
FLV_FRAME_VIDEO_INFO_CMD
@ FLV_FRAME_VIDEO_INFO_CMD
video info/command frame
Definition: flv.h:164
FLVContext::duration_offset
int64_t duration_offset
Definition: flvenc.c:99
AVOutputFormat::name
const char * name
Definition: avformat.h:506
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:53
hevc.h
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:395
FLV_CODECID_MPEG4
@ FLV_CODECID_MPEG4
Definition: flv.h:119
FLVContext::flags
int flags
Definition: flvenc.c:135
FLVContext::filepositions
FLVFileposition * filepositions
Definition: flvenc.c:127
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:49
FLV_NO_SEQUENCE_END
@ FLV_NO_SEQUENCE_END
Definition: flvenc.c:84
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:192
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:481
FLVContext::delay
int64_t delay
first dts delay (needed for AVC & Speex)
Definition: flvenc.c:102
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
FLVContext::metadata_pkt_written
int * metadata_pkt_written
Definition: flvenc.c:137
int64_t
long long int64_t
Definition: coverity.c:34
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
AVChannelLayout::map
AVChannelCustom * map
This member must be used when the channel order is AV_CHANNEL_ORDER_CUSTOM.
Definition: channel_layout.h:370
vvc.h
mask
int mask
Definition: mediacodecdec_common.c:154
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
flv_write_metadata_packet
static void flv_write_metadata_packet(AVFormatContext *s, AVCodecParameters *par, unsigned int ts, int stream_idx)
Definition: flvenc.c:542
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:111
ff_isom_write_vvcc
int ff_isom_write_vvcc(AVIOContext *pb, const uint8_t *data, int size, int ps_array_completeness)
Writes H.266/VVC extradata (parameter sets, declarative SEI NAL units) to the provided AVIOContext.
Definition: vvc.c:879
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:154
AVCOL_TRC_NB
@ AVCOL_TRC_NB
Not part of ABI.
Definition: pixfmt.h:688
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:416
AVPacket::data
uint8_t * data
Definition: packet.h:595
FLVContext::metadata_totalsize_pos
int64_t metadata_totalsize_pos
Definition: flvenc.c:113
AV_CODEC_ID_VP6
@ AV_CODEC_ID_VP6
Definition: codec_id.h:143
AudioPacketTypeCodedFrames
@ AudioPacketTypeCodedFrames
Definition: flv.h:138
AVOption
AVOption.
Definition: opt.h:429
PacketTypeMetadata
@ PacketTypeMetadata
Definition: flv.h:130
AVCOL_SPC_NB
@ AVCOL_SPC_NB
Not part of ABI.
Definition: pixfmt.h:720
b
#define b
Definition: input.c:43
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:669
data
const char data[16]
Definition: mxf.c:149
FLVContext::audiosize_offset
int64_t audiosize_offset
Definition: flvenc.c:109
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:613
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:61
mathematics.h
AV_CODEC_ID_FLAC
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:472
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:324
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVChannelLayout::mask
uint64_t mask
This member must be used for AV_CHANNEL_ORDER_NATIVE, and may be used for AV_CHANNEL_ORDER_AMBISONIC ...
Definition: channel_layout.h:351
FLV_CODECID_PCM
@ FLV_CODECID_PCM
Definition: flv.h:97
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
intfloat.h
put_amf_bool
static void put_amf_bool(AVIOContext *pb, int b)
Definition: flvenc.c:292
AMF_DATA_TYPE_OBJECT
@ AMF_DATA_TYPE_OBJECT
Definition: flv.h:171
FLV_STEREO
@ FLV_STEREO
Definition: flv.h:81
FLV_CODECID_AAC
@ FLV_CODECID_AAC
Definition: flv.h:107
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:650
FLV_CODECID_NELLYMOSER
@ FLV_CODECID_NELLYMOSER
Definition: flv.h:103
FLVContext::last_ts
int64_t * last_ts
Definition: flvenc.c:136
FLVContext::lasttimestamp_offset
int64_t lasttimestamp_offset
Definition: flvenc.c:117
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:65
PacketTypeCodedFrames
@ PacketTypeCodedFrames
Definition: flv.h:127
FLV_CODECID_VP6A
@ FLV_CODECID_VP6A
Definition: flv.h:115
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:107
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:190
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:464
PacketTypeSequenceStart
@ PacketTypeSequenceStart
Definition: flv.h:126
flv_append_keyframe_info
static int flv_append_keyframe_info(AVFormatContext *s, FLVContext *flv, double ts, int64_t pos)
Definition: flvenc.c:916
FLVContext::lastkeyframelocation_offset
int64_t lastkeyframelocation_offset
Definition: flvenc.c:121
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:781
mpeg4audio.h
FLV_FRAME_INTER
@ FLV_FRAME_INTER
inter frame (for AVC, a non-seekable frame)
Definition: flv.h:161
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:495
flv_write_packet
static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: flvenc.c:1210
FLVContext::last_ts
int64_t last_ts
Definition: flvdec.c:107
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:339
AV_CHAN_TOP_BACK_RIGHT
@ AV_CHAN_TOP_BACK_RIGHT
Definition: channel_layout.h:67
ff_flv_muxer
const FFOutputFormat ff_flv_muxer
Definition: flvenc.c:1540
fail
#define fail()
Definition: checkasm.h:224
FLVContext::lastkeyframetimestamp
double lastkeyframetimestamp
Definition: flvenc.c:120
put_amf_double
static void put_amf_double(AVIOContext *pb, double d)
Definition: flvenc.c:275
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
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:461
vpcc.h
FLV_AUDIO_CODECID_OFFSET
#define FLV_AUDIO_CODECID_OFFSET
Definition: flv.h:34
FLVContext::duration
int64_t duration
Definition: flvenc.c:101
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:191
FLVFlags
FLVFlags
Definition: flvenc.c:82
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FLVFileposition::keyframe_position
int64_t keyframe_position
Definition: flvenc.c:91
AVCodecTag
Definition: internal.h:42
FLVContext::lastkeyframelocation
int64_t lastkeyframelocation
Definition: flvenc.c:122
flv_get_multichannel_body_size
static int flv_get_multichannel_body_size(AVCodecParameters *par)
Definition: flvenc.c:763
FLV_CODECID_ADPCM
@ FLV_CODECID_ADPCM
Definition: flv.h:98
FLVContext::video_par
AVCodecParameters * video_par
Definition: flvenc.c:131
FLVContext::filepositions_count
int64_t filepositions_count
Definition: flvenc.c:126
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
AudioPacketTypeSequenceStart
@ AudioPacketTypeSequenceStart
Definition: flv.h:137
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:654
FLVContext::track_idx_map
int * track_idx_map
Definition: flvenc.c:138
flv_write_header
static int flv_write_header(AVFormatContext *s)
Definition: flvenc.c:1083
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:222
AVCodecParameters::width
int width
The width of the video frame in pixels.
Definition: codec_par.h:143
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:42
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
AVPacketSideData::data
uint8_t * data
Definition: packet.h:417
channels
channels
Definition: aptx.h:31
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:344
FLVContext::audiosize
int64_t audiosize
Definition: flvenc.c:110
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:410
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:88
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:202
FLVContext::head_filepositions
FLVFileposition * head_filepositions
Definition: flvenc.c:128
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:639
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:71
av_fallthrough
#define av_fallthrough
Definition: attributes.h:67
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:132
if
if(ret)
Definition: filter_design.txt:179
AVFormatContext
Format I/O context.
Definition: avformat.h:1263
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:345
AV_CODEC_ID_FLASHSV2
@ AV_CODEC_ID_FLASHSV2
Definition: codec_id.h:183
internal.h
FLV_CODECID_REALH263
@ FLV_CODECID_REALH263
Definition: flv.h:118
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:767
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
PacketTypeMultitrack
@ PacketTypeMultitrack
Definition: flv.h:132
NULL
#define NULL
Definition: coverity.c:32
FLV_CODECID_NELLYMOSER_16KHZ_MONO
@ FLV_CODECID_NELLYMOSER_16KHZ_MONO
Definition: flv.h:101
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:284
FLVContext::datasize_offset
int64_t datasize_offset
Definition: flvenc.c:105
FLV_ADD_KEYFRAME_INDEX
@ FLV_ADD_KEYFRAME_INDEX
Definition: flvenc.c:85
AMF_DATA_TYPE_BOOL
@ AMF_DATA_TYPE_BOOL
Definition: flv.h:169
flv_write_aac_header
static void flv_write_aac_header(AVFormatContext *s, AVCodecParameters *par)
Definition: flvenc.c:686
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:1249
ff_isom_write_hvcc
int ff_isom_write_hvcc(AVIOContext *pb, const uint8_t *data, int size, int ps_array_completeness, void *logctx)
Writes HEVC extradata (parameter sets and declarative SEI NAL units with nuh_layer_id == 0,...
Definition: hevc.c:1398
FLV_CODECID_PCM_MULAW
@ FLV_CODECID_PCM_MULAW
Definition: flv.h:105
FLVContext::av_class
AVClass * av_class
Definition: flvenc.c:97
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:242
avc.h
options
Definition: swscale.c:45
FLVFileposition
Definition: flvenc.c:90
FFOutputFormat
Definition: mux.h:61
AV_CHAN_BOTTOM_FRONT_RIGHT
@ AV_CHAN_BOTTOM_FRONT_RIGHT
Definition: channel_layout.h:81
flv.h
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:184
AMF_DATA_TYPE_ARRAY
@ AMF_DATA_TYPE_ARRAY
Definition: flv.h:177
AV_CODEC_ID_FLASHSV
@ AV_CODEC_ID_FLASHSV
Definition: codec_id.h:138
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
The channel layout and number of channels.
Definition: codec_par.h:207
AV_CODEC_ID_VP6A
@ AV_CODEC_ID_VP6A
Definition: codec_id.h:158
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:232
FLV_SAMPLERATE_44100HZ
@ FLV_SAMPLERATE_44100HZ
Definition: flv.h:93
FLVContext::videosize
int64_t videosize
Definition: flvenc.c:108
FLVContext::datasize
int64_t datasize
Definition: flvenc.c:106
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:352
AVCodecParameters::sample_rate
int sample_rate
The number of audio samples per second.
Definition: codec_par.h:213
FLVFileposition::keyframe_timestamp
double keyframe_timestamp
Definition: flvenc.c:92
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:645
AV_CODEC_ID_EAC3
@ AV_CODEC_ID_EAC3
Definition: codec_id.h:500
FLVContext::keyframes_info_offset
int64_t keyframes_info_offset
Definition: flvenc.c:124
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:75
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:462
FLV_SAMPLESSIZE_16BIT
@ FLV_SAMPLESSIZE_16BIT
Definition: flv.h:86
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
flv_muxer_class
static const AVClass flv_muxer_class
Definition: flvenc.c:1533
AVPacket::size
int size
Definition: packet.h:596
flv_init
static int flv_init(struct AVFormatContext *s)
Definition: flvenc.c:972
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:31
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:319
FLV_FRAME_KEY
@ FLV_FRAME_KEY
key frame (for AVC, a seekable frame)
Definition: flv.h:160
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:154
put_eos_tag
static void put_eos_tag(AVIOContext *pb, unsigned ts, enum AVCodecID codec_id)
Definition: flvenc.c:260
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
flv_write_multichannel_header
static void flv_write_multichannel_header(AVFormatContext *s, AVCodecParameters *par, int64_t ts, int stream_index)
Definition: flvenc.c:775
shift_data
static int shift_data(AVFormatContext *s)
Definition: flvenc.c:943
ff_vvc_annexb2mp4_buf
int ff_vvc_annexb2mp4_buf(const uint8_t *buf_in, uint8_t **buf_out, int *size, int filter_ps, int *ps_count)
Writes Annex B formatted H.266/VVC NAL units to a data buffer.
Definition: vvc.c:858
FLV_CODECID_EX_HEADER
@ FLV_CODECID_EX_HEADER
Definition: flv.h:106
ff_nal_parse_units_buf
int ff_nal_parse_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
Definition: nal.c:133
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:390
size
int size
Definition: twinvq_data.h:10344
flv_audio_codec_ids
static const AVCodecTag flv_audio_codec_ids[]
Definition: flvenc.c:64
avio.h
FLVContext
Definition: flvdec.c:77
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
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:141
AVCodecParameters::profile
int profile
Codec-specific bitstream restrictions that the stream conforms to.
Definition: codec_par.h:135
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:520
FLV_TAG_TYPE_AUDIO
@ FLV_TAG_TYPE_AUDIO
Definition: flv.h:66
FLV_CODECID_H264
@ FLV_CODECID_H264
Definition: flv.h:117
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:594
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:206
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:368
FLVContext::data_par
AVCodecParameters * data_par
Definition: flvenc.c:133
FLVContext::filesize_offset
int64_t filesize_offset
Definition: flvenc.c:100
AV_CODEC_ID_VVC
@ AV_CODEC_ID_VVC
Definition: codec_id.h:252
FLV_CODECID_SCREEN2
@ FLV_CODECID_SCREEN2
Definition: flv.h:116
attributes.h
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:125
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:601
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: defs.h:61
FLVContext::reserved
int reserved
Definition: flvenc.c:98
AV_CHAN_UNUSED
@ AV_CHAN_UNUSED
Channel is empty can be safely skipped.
Definition: channel_layout.h:91
put_amf_byte
static void put_amf_byte(AVIOContext *pb, unsigned char abyte)
Definition: flvenc.c:281
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:811
flv_video_codec_ids
static const AVCodecTag flv_video_codec_ids[]
Definition: flvenc.c:47
flv_write_multichannel_body
static void flv_write_multichannel_body(AVFormatContext *s, AVCodecParameters *par)
Definition: flvenc.c:722
FLV_SAMPLERATE_SPECIAL
@ FLV_SAMPLERATE_SPECIAL
signifies 5512Hz and 8000Hz in the case of NELLYMOSER
Definition: flv.h:90
AVChannel
AVChannel
Definition: channel_layout.h:47
AVChannelLayout::u
union AVChannelLayout::@515 u
Details about which channels are present in this layout.
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:406
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_CODECID_SPEEX
@ FLV_CODECID_SPEEX
Definition: flv.h:108
flv_check_bitstream
static int flv_check_bitstream(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
Definition: flvenc.c:1488
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:477
av_malloc
#define av_malloc(s)
Definition: ops_asmgen.c:44
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:588
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:115
av_builtin_constant_p
#define av_builtin_constant_p
Definition: attributes.h:193
unsupported_codec
static int unsupported_codec(AVFormatContext *s, const char *type, int codec_id)
Definition: flvenc.c:675
AVCodecParameters::height
int height
The height of the video frame in pixels.
Definition: codec_par.h:150
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:253
FLVContext::framerate
AVRational framerate
Definition: flvdec.c:106
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:58
AudioPacketTypeMultitrack
@ AudioPacketTypeMultitrack
Definition: flv.h:140
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:228
FLV_CODECID_MP3
@ FLV_CODECID_MP3
Definition: flv.h:99
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:112
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:703
FLV_NO_METADATA
@ FLV_NO_METADATA
Definition: flvenc.c:86
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:83
nal.h
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AMF_DATA_TYPE_MIXEDARRAY
@ AMF_DATA_TYPE_MIXEDARRAY
Definition: flv.h:175
AMF_DATA_TYPE_STRING
@ AMF_DATA_TYPE_STRING
Definition: flv.h:170
put_timestamp
static void put_timestamp(AVIOContext *pb, int64_t ts)
Definition: flvenc.c:255
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:487
tag
uint32_t tag
Definition: movenc.c:2046
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:744
put_amf_dword_array
static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
Definition: flvenc.c:286
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:236
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:81
FLV_SAMPLESSIZE_8BIT
@ FLV_SAMPLESSIZE_8BIT
Definition: flv.h:85
pos
unsigned int pos
Definition: spdifenc.c:414
avformat.h
FLV_HEADER_FLAG_HASVIDEO
@ FLV_HEADER_FLAG_HASVIDEO
Definition: flv.h:61
AudioChannelOrderCustom
@ AudioChannelOrderCustom
Definition: flv.h:150
dict.h
AV_CODEC_ID_TEXT
@ AV_CODEC_ID_TEXT
raw UTF-8 text
Definition: codec_id.h:574
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:83
AV_CHANNEL_ORDER_CUSTOM
@ AV_CHANNEL_ORDER_CUSTOM
The channel order does not correspond to any other predefined order and is stored as an explicit map.
Definition: channel_layout.h:132
AV_CHAN_LOW_FREQUENCY_2
@ AV_CHAN_LOW_FREQUENCY_2
Definition: channel_layout.h:76
flv_deinit
static void flv_deinit(AVFormatContext *s)
Definition: flvenc.c:1505
FLVContext::lastkeyframetimestamp_offset
int64_t lastkeyframetimestamp_offset
Definition: flvenc.c:119
FLV_SAMPLERATE_22050HZ
@ FLV_SAMPLERATE_22050HZ
Definition: flv.h:92
AudioChannelOrderUnspecified
@ AudioChannelOrderUnspecified
Definition: flv.h:148
ff_codec_get_tag
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:133
FLV_TAG_TYPE_META
@ FLV_TAG_TYPE_META
Definition: flv.h:68
FLV_CODECID_VP6
@ FLV_CODECID_VP6
Definition: flv.h:114
FLV_HEADER_FLAG_HASAUDIO
@ FLV_HEADER_FLAG_HASAUDIO
Definition: flv.h:62
AudioChannelOrderNative
@ AudioChannelOrderNative
Definition: flv.h:149
put_amf_string
static void put_amf_string(AVIOContext *pb, const char *str)
Definition: flvenc.c:244
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
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:597
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:321
avio_wb64
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:434
ff_mpeg4audio_sample_rates
const int ff_mpeg4audio_sample_rates[16]
Definition: mpeg4audio_sample_rates.h:30
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:113
mem.h
FLVContext::lasttimestamp
double lasttimestamp
Definition: flvenc.c:118
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:343
mastering_display_metadata.h
flv_write_trailer
static int flv_write_trailer(AVFormatContext *s)
Definition: flvenc.c:1120
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:153
avio_wb24
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:458
AMF_DATA_TYPE_NUMBER
@ AMF_DATA_TYPE_NUMBER
Definition: flv.h:168
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:394
FLV_CODECID_PCM_ALAW
@ FLV_CODECID_PCM_ALAW
Definition: flv.h:104
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:90
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:57
AVPacket
This structure stores compressed data.
Definition: packet.h:572
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
write_metadata
static void write_metadata(AVFormatContext *s, unsigned int ts)
Definition: flvenc.c:298
FLV_CODECID_SCREEN
@ FLV_CODECID_SCREEN
Definition: flv.h:113
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Underlying C type is unsigned int.
Definition: opt.h:255
avio_wb16
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:446
AV_CODEC_ID_VP8
@ AV_CODEC_ID_VP8
Definition: codec_id.h:192
FLV_SAMPLERATE_11025HZ
@ FLV_SAMPLERATE_11025HZ
Definition: flv.h:91
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:99
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:1523
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3888
write_codec_fourcc
static void write_codec_fourcc(AVIOContext *pb, enum AVCodecID codec_id)
Definition: flvenc.c:500
AV_CHAN_FRONT_LEFT
@ AV_CHAN_FRONT_LEFT
Definition: channel_layout.h:50
pkt
static AVPacket * pkt
Definition: demux_decode.c:55
FLVFileposition::next
struct FLVFileposition * next
Definition: flvenc.c:93
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:73
FLVContext::datastart_offset
int64_t datastart_offset
Definition: flvenc.c:104
FLV_CODECID_H263
@ FLV_CODECID_H263
Definition: flv.h:112
flv_write_codec_header
static void flv_write_codec_header(AVFormatContext *s, AVCodecParameters *par, int64_t ts, int stream_index)
Definition: flvenc.c:807
codec_desc.h
put_bits.h
FLV_CODECID_NELLYMOSER_8KHZ_MONO
@ FLV_CODECID_NELLYMOSER_8KHZ_MONO
Definition: flv.h:102
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
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:1294
AVChannelCustom::id
enum AVChannel id
Definition: channel_layout.h:284
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:42
PacketTypeCodedFramesX
@ PacketTypeCodedFramesX
Definition: flv.h:129
AVFMT_EVENT_FLAG_METADATA_UPDATED
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:1637
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:493
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
MultitrackTypeOneTrack
@ MultitrackTypeOneTrack
Definition: flv.h:154
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:237
mux.h
Generated on Tue Apr 28 2026 19:22:59 for FFmpeg by   doxygen 1.8.17