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