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