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

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