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