FFmpeg: libavformat/flvenc.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /