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