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