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);
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  avio_seek(s->pb, pos_end, SEEK_SET);
612 
613  /* Shift the data: the AVIO context of the output can only be used for
614  * writing, so we re-open the same output, but for reading. It also avoids
615  * a read/seek/write/seek back and forth. */
616  avio_flush(s->pb);
617  ret = s->io_open(s, &read_pb, s->url, AVIO_FLAG_READ, NULL);
618  if (ret < 0) {
619  av_log(s, AV_LOG_ERROR, "Unable to re-open %s output file for "
620  "the second pass (add_keyframe_index)\n", s->url);
621  goto end;
622  }
623 
624  /* mark the end of the shift to up to the last data we wrote, and get ready
625  * for writing */
626  pos_end = avio_tell(s->pb);
627  avio_seek(s->pb, flv->keyframes_info_offset + metadata_size, SEEK_SET);
628 
629  /* start reading at where the keyframe index information will be placed */
630  avio_seek(read_pb, flv->keyframes_info_offset, SEEK_SET);
631  pos = avio_tell(read_pb);
632 
633 #define READ_BLOCK do { \
634  read_size[read_buf_id] = avio_read(read_pb, read_buf[read_buf_id], metadata_size); \
635  read_buf_id ^= 1; \
636 } while (0)
637 
638  /* shift data by chunk of at most keyframe *filepositions* and *times* size */
639  READ_BLOCK;
640  do {
641  READ_BLOCK;
642  n = read_size[read_buf_id];
643  if (n < 0)
644  break;
645  avio_write(s->pb, read_buf[read_buf_id], n);
646  pos += n;
647  } while (pos <= pos_end);
648 
649  ff_format_io_close(s, &read_pb);
650 
651 end:
652  av_free(buf);
653  return ret;
654 }
655 
656 static int flv_init(struct AVFormatContext *s)
657 {
658  int i;
659  FLVContext *flv = s->priv_data;
660 
661  for (i = 0; i < s->nb_streams; i++) {
662  AVCodecParameters *par = s->streams[i]->codecpar;
663  FLVStreamContext *sc;
664  switch (par->codec_type) {
665  case AVMEDIA_TYPE_VIDEO:
666  if (s->streams[i]->avg_frame_rate.den &&
667  s->streams[i]->avg_frame_rate.num) {
668  flv->framerate = av_q2d(s->streams[i]->avg_frame_rate);
669  }
670  if (flv->video_par) {
671  av_log(s, AV_LOG_ERROR,
672  "at most one video stream is supported in flv\n");
673  return AVERROR(EINVAL);
674  }
675  flv->video_par = par;
676  if (!ff_codec_get_tag(flv_video_codec_ids, par->codec_id))
677  return unsupported_codec(s, "Video", par->codec_id);
678 
679  if (par->codec_id == AV_CODEC_ID_MPEG4 ||
680  par->codec_id == AV_CODEC_ID_H263) {
681  int error = s->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL;
682  av_log(s, error ? AV_LOG_ERROR : AV_LOG_WARNING,
683  "Codec %s is not supported in the official FLV specification,\n", avcodec_get_name(par->codec_id));
684 
685  if (error) {
686  av_log(s, AV_LOG_ERROR,
687  "use vstrict=-1 / -strict -1 to use it anyway.\n");
688  return AVERROR(EINVAL);
689  }
690  } else if (par->codec_id == AV_CODEC_ID_VP6) {
691  av_log(s, AV_LOG_WARNING,
692  "Muxing VP6 in flv will produce flipped video on playback.\n");
693  }
694  break;
695  case AVMEDIA_TYPE_AUDIO:
696  if (flv->audio_par) {
697  av_log(s, AV_LOG_ERROR,
698  "at most one audio stream is supported in flv\n");
699  return AVERROR(EINVAL);
700  }
701  flv->audio_par = par;
702  if (get_audio_flags(s, par) < 0)
703  return unsupported_codec(s, "Audio", par->codec_id);
704  if (par->codec_id == AV_CODEC_ID_PCM_S16BE)
705  av_log(s, AV_LOG_WARNING,
706  "16-bit big-endian audio in flv is valid but most likely unplayable (hardware dependent); use s16le\n");
707  break;
708  case AVMEDIA_TYPE_DATA:
709  if (par->codec_id != AV_CODEC_ID_TEXT && par->codec_id != AV_CODEC_ID_NONE)
710  return unsupported_codec(s, "Data", par->codec_id);
711  flv->data_par = par;
712  break;
713  case AVMEDIA_TYPE_SUBTITLE:
714  if (par->codec_id != AV_CODEC_ID_TEXT) {
715  av_log(s, AV_LOG_ERROR, "Subtitle codec '%s' for stream %d is not compatible with FLV\n",
716  avcodec_get_name(par->codec_id), i);
717  return AVERROR_INVALIDDATA;
718  }
719  flv->data_par = par;
720  break;
721  default:
722  av_log(s, AV_LOG_ERROR, "Codec type '%s' for stream %d is not compatible with FLV\n",
723  av_get_media_type_string(par->codec_type), i);
724  return AVERROR(EINVAL);
725  }
726  avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
727 
728  sc = av_mallocz(sizeof(FLVStreamContext));
729  if (!sc)
730  return AVERROR(ENOMEM);
731  s->streams[i]->priv_data = sc;
732  sc->last_ts = -1;
733  }
734 
735  flv->delay = AV_NOPTS_VALUE;
736 
737  return 0;
738 }
739 
740 static int flv_write_header(AVFormatContext *s)
741 {
742  int i;
743  AVIOContext *pb = s->pb;
744  FLVContext *flv = s->priv_data;
745 
746  avio_write(pb, "FLV", 3);
747  avio_w8(pb, 1);
748  avio_w8(pb, FLV_HEADER_FLAG_HASAUDIO * !!flv->audio_par +
749  FLV_HEADER_FLAG_HASVIDEO * !!flv->video_par);
750  avio_wb32(pb, 9);
751  avio_wb32(pb, 0);
752 
753  for (i = 0; i < s->nb_streams; i++)
754  if (s->streams[i]->codecpar->codec_tag == 5) {
755  avio_w8(pb, 8); // message type
756  avio_wb24(pb, 0); // include flags
757  avio_wb24(pb, 0); // time stamp
758  avio_wb32(pb, 0); // reserved
759  avio_wb32(pb, 11); // size
760  flv->reserved = 5;
761  }
762 
763  if (flv->flags & FLV_NO_METADATA) {
764  pb->seekable = 0;
765  } else {
766  write_metadata(s, 0);
767  }
768 
769  for (i = 0; i < s->nb_streams; i++) {
770  flv_write_codec_header(s, s->streams[i]->codecpar, 0);
771  }
772 
773  flv->datastart_offset = avio_tell(pb);
774  return 0;
775 }
776 
777 static int flv_write_trailer(AVFormatContext *s)
778 {
779  int64_t file_size;
780  AVIOContext *pb = s->pb;
781  FLVContext *flv = s->priv_data;
782  int build_keyframes_idx = flv->flags & FLV_ADD_KEYFRAME_INDEX;
783  int i, res;
784  int64_t cur_pos = avio_tell(s->pb);
785 
786  if (build_keyframes_idx) {
787  FLVFileposition *newflv_posinfo, *p;
788 
789  avio_seek(pb, flv->videosize_offset, SEEK_SET);
790  put_amf_double(pb, flv->videosize);
791 
792  avio_seek(pb, flv->audiosize_offset, SEEK_SET);
793  put_amf_double(pb, flv->audiosize);
794 
795  avio_seek(pb, flv->lasttimestamp_offset, SEEK_SET);
796  put_amf_double(pb, flv->lasttimestamp);
797 
798  avio_seek(pb, flv->lastkeyframetimestamp_offset, SEEK_SET);
799  put_amf_double(pb, flv->lastkeyframetimestamp);
800 
801  avio_seek(pb, flv->lastkeyframelocation_offset, SEEK_SET);
802  put_amf_double(pb, flv->lastkeyframelocation + flv->keyframe_index_size);
803  avio_seek(pb, cur_pos, SEEK_SET);
804 
805  res = shift_data(s);
806  if (res < 0) {
807  goto end;
808  }
809  avio_seek(pb, flv->keyframes_info_offset, SEEK_SET);
810  put_amf_string(pb, "filepositions");
811  put_amf_dword_array(pb, flv->filepositions_count);
812  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
813  put_amf_double(pb, newflv_posinfo->keyframe_position + flv->keyframe_index_size);
814  }
815 
816  put_amf_string(pb, "times");
817  put_amf_dword_array(pb, flv->filepositions_count);
818  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
819  put_amf_double(pb, newflv_posinfo->keyframe_timestamp);
820  }
821 
822  newflv_posinfo = flv->head_filepositions;
823  while (newflv_posinfo) {
824  p = newflv_posinfo->next;
825  if (p) {
826  newflv_posinfo->next = p->next;
827  av_free(p);
828  p = NULL;
829  } else {
830  av_free(newflv_posinfo);
831  newflv_posinfo = NULL;
832  }
833  }
834 
835  put_amf_string(pb, "");
836  avio_w8(pb, AMF_END_OF_OBJECT);
837 
838  avio_seek(pb, cur_pos + flv->keyframe_index_size, SEEK_SET);
839  }
840 
841 end:
842  if (flv->flags & FLV_NO_SEQUENCE_END) {
843  av_log(s, AV_LOG_DEBUG, "FLV no sequence end mode open\n");
844  } else {
845  /* Add EOS tag */
846  for (i = 0; i < s->nb_streams; i++) {
847  AVCodecParameters *par = s->streams[i]->codecpar;
848  FLVStreamContext *sc = s->streams[i]->priv_data;
849  if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
850  (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4))
851  put_avc_eos_tag(pb, sc->last_ts);
852  }
853  }
854 
855  file_size = avio_tell(pb);
856 
857  if (build_keyframes_idx) {
858  flv->datasize = file_size - flv->datastart_offset;
859  avio_seek(pb, flv->datasize_offset, SEEK_SET);
860  put_amf_double(pb, flv->datasize);
861  }
862  if (!(flv->flags & FLV_NO_METADATA)) {
863  if (!(flv->flags & FLV_NO_DURATION_FILESIZE)) {
864  /* update information */
865  if (avio_seek(pb, flv->duration_offset, SEEK_SET) < 0) {
866  av_log(s, AV_LOG_WARNING, "Failed to update header with correct duration.\n");
867  } else {
868  put_amf_double(pb, flv->duration / (double)1000);
869  }
870  if (avio_seek(pb, flv->filesize_offset, SEEK_SET) < 0) {
871  av_log(s, AV_LOG_WARNING, "Failed to update header with correct filesize.\n");
872  } else {
873  put_amf_double(pb, file_size);
874  }
875  }
876  }
877 
878  return 0;
879 }
880 
881 static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
882 {
883  AVIOContext *pb = s->pb;
884  AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
885  FLVContext *flv = s->priv_data;
886  FLVStreamContext *sc = s->streams[pkt->stream_index]->priv_data;
887  unsigned ts;
888  int size = pkt->size;
889  uint8_t *data = NULL;
890  int flags = -1, flags_size, ret;
891  int64_t cur_offset = avio_tell(pb);
892 
893  if (par->codec_type == AVMEDIA_TYPE_AUDIO && !pkt->size) {
894  av_log(s, AV_LOG_WARNING, "Empty audio Packet\n");
895  return AVERROR(EINVAL);
896  }
897 
898  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A ||
899  par->codec_id == AV_CODEC_ID_VP6 || par->codec_id == AV_CODEC_ID_AAC)
900  flags_size = 2;
901  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4)
902  flags_size = 5;
903  else
904  flags_size = 1;
905 
906  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
907  || par->codec_id == AV_CODEC_ID_MPEG4) {
908  int side_size = 0;
909  uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
910  if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
911  av_free(par->extradata);
912  par->extradata = av_mallocz(side_size + AV_INPUT_BUFFER_PADDING_SIZE);
913  if (!par->extradata) {
914  par->extradata_size = 0;
915  return AVERROR(ENOMEM);
916  }
917  memcpy(par->extradata, side, side_size);
918  par->extradata_size = side_size;
919  flv_write_codec_header(s, par, pkt->dts);
920  }
921  }
922 
923  if (flv->delay == AV_NOPTS_VALUE)
924  flv->delay = -pkt->dts;
925 
926  if (pkt->dts < -flv->delay) {
927  av_log(s, AV_LOG_WARNING,
928  "Packets are not in the proper order with respect to DTS\n");
929  return AVERROR(EINVAL);
930  }
931 
932  ts = pkt->dts;
933 
934  if (s->event_flags & AVSTREAM_EVENT_FLAG_METADATA_UPDATED) {
935  write_metadata(s, ts);
936  s->event_flags &= ~AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
937  }
938 
939  avio_write_marker(pb, av_rescale(ts, AV_TIME_BASE, 1000),
940  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);
941 
942  switch (par->codec_type) {
943  case AVMEDIA_TYPE_VIDEO:
944  avio_w8(pb, FLV_TAG_TYPE_VIDEO);
945 
946  flags = ff_codec_get_tag(flv_video_codec_ids, par->codec_id);
947 
948  flags |= pkt->flags & AV_PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER;
949  break;
950  case AVMEDIA_TYPE_AUDIO:
951  flags = get_audio_flags(s, par);
952 
953  av_assert0(size);
954 
955  avio_w8(pb, FLV_TAG_TYPE_AUDIO);
956  break;
957  case AVMEDIA_TYPE_SUBTITLE:
958  case AVMEDIA_TYPE_DATA:
959  avio_w8(pb, FLV_TAG_TYPE_META);
960  break;
961  default:
962  return AVERROR(EINVAL);
963  }
964 
965  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
966  /* check if extradata looks like mp4 formatted */
967  if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
968  if ((ret = ff_avc_parse_nal_units_buf(pkt->data, &data, &size)) < 0)
969  return ret;
970  } else if (par->codec_id == AV_CODEC_ID_AAC && pkt->size > 2 &&
971  (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
972  if (!s->streams[pkt->stream_index]->nb_frames) {
973  av_log(s, AV_LOG_ERROR, "Malformed AAC bitstream detected: "
974  "use the audio bitstream filter 'aac_adtstoasc' to fix it "
975  "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
976  return AVERROR_INVALIDDATA;
977  }
978  av_log(s, AV_LOG_WARNING, "aac bitstream error\n");
979  }
980 
981  /* check Speex packet duration */
982  if (par->codec_id == AV_CODEC_ID_SPEEX && ts - sc->last_ts > 160)
983  av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
984  "8 frames per packet. Adobe Flash "
985  "Player cannot handle this!\n");
986 
987  if (sc->last_ts < ts)
988  sc->last_ts = ts;
989 
990  if (size + flags_size >= 1<<24) {
991  av_log(s, AV_LOG_ERROR, "Too large packet with size %u >= %u\n",
992  size + flags_size, 1<<24);
993  return AVERROR(EINVAL);
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  if (pkt->flags & AV_PKT_FLAG_KEY) {
1059  double ts = flv->acurframeindex / flv->framerate;
1060  int64_t pos = cur_offset;
1061 
1062  flv->lastkeyframetimestamp = flv->acurframeindex / flv->framerate;
1063  flv->lastkeyframelocation = pos;
1064  flv_append_keyframe_info(s, flv, ts, pos);
1065  }
1066  flv->acurframeindex++;
1067  break;
1068 
1069  case AVMEDIA_TYPE_AUDIO:
1070  flv->audiosize += (avio_tell(pb) - cur_offset);
1071  break;
1072 
1073  default:
1074  av_log(s, AV_LOG_WARNING, "par->codec_type is type = [%d]\n", par->codec_type);
1075  break;
1076  }
1077  }
1078 
1079  av_free(data);
1080 
1081  return pb->error;
1082 }
1083 
1084 static int flv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
1085 {
1086  int ret = 1;
1087  AVStream *st = s->streams[pkt->stream_index];
1088 
1089  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
1090  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
1091  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
1092  }
1093  return ret;
1094 }
1095 
1096 static const AVOption options[] = {
1097  { "flvflags", "FLV muxer flags", offsetof(FLVContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1098  { "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" },
1099  { "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" },
1100  { "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" },
1101  { "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" },
1102  { "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" },
1103  { NULL },
1104 };
1105 
1106 static const AVClass flv_muxer_class = {
1107  .class_name = "flv muxer",
1108  .item_name = av_default_item_name,
1109  .option = options,
1110  .version = LIBAVUTIL_VERSION_INT,
1111 };
1112 
1113 AVOutputFormat ff_flv_muxer = {
1114  .name = "flv",
1115  .long_name = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1116  .mime_type = "video/x-flv",
1117  .extensions = "flv",
1118  .priv_data_size = sizeof(FLVContext),
1119  .audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_ADPCM_SWF,
1120  .video_codec = AV_CODEC_ID_FLV1,
1121  .init = flv_init,
1122  .write_header = flv_write_header,
1123  .write_packet = flv_write_packet,
1124  .write_trailer = flv_write_trailer,
1125  .check_bitstream= flv_check_bitstream,
1126  .codec_tag = (const AVCodecTag* const []) {
1127  flv_video_codec_ids, flv_audio_codec_ids, 0
1128  },
1129  .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS |
1130  AVFMT_TS_NONSTRICT,
1131  .priv_class = &flv_muxer_class,
1132 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: avcodec.h:463
FLVContext::metadata_totalsize
int64_t metadata_totalsize
Definition: flvenc.c:98
FLV_CODECID_H263
@ FLV_CODECID_H263
Definition: flv.h:105
FLVContext::audio_par
AVCodecParameters * audio_par
Definition: flvenc.c:115
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_CODEC_ID_VP6F
@ AV_CODEC_ID_VP6F
Definition: avcodec.h:310
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: avcodec.h:3971
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:496
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: avcodec.h:3953
FLV_CODECID_NELLYMOSER
@ FLV_CODECID_NELLYMOSER
Definition: flv.h:97
codec_id
enum AVCodecID codec_id
Definition: qsv.c:72
flv_check_bitstream
static int flv_check_bitstream(struct AVFormatContext *s, const AVPacket *pkt)
Definition: flvenc.c:1084
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: avcodec.h:3949
n
int n
Definition: avisynth_c.h:760
FLV_CODECID_MP3
@ FLV_CODECID_MP3
Definition: flv.h:93
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:470
FLVContext::delay
int64_t delay
first dts delay (needed for AVC & Speex)
Definition: flvenc.c:86
FLV_CODECID_H264
@ FLV_CODECID_H264
Definition: flv.h:110
FLVContext::acurframeindex
int acurframeindex
Definition: flvenc.c:108
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: avcodec.h:230
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
FLV_CODECID_PCM
@ FLV_CODECID_PCM
Definition: flv.h:91
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
FLV_CODECID_SCREEN
@ FLV_CODECID_SCREEN
Definition: flv.h:106
FLVContext::metadata_totalsize_pos
int64_t metadata_totalsize_pos
Definition: flvenc.c:97
AV_CODEC_ID_VP6
@ AV_CODEC_ID_VP6
Definition: avcodec.h:309
AVOption
AVOption.
Definition: opt.h:246
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:91
AVIOContext::error
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
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
channels
channels
Definition: aptx.c:30
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: avcodec.h:1495
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3961
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: avcodec.h:1509
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:2632
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:493
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: avcodec.h:4063
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: avcodec.h:599
flv_write_packet
static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: flvenc.c:881
AMF_DATA_TYPE_STRING
@ AMF_DATA_TYPE_STRING
Definition: flv.h:126
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: avcodec.h:464
FLV_SAMPLERATE_22050HZ
@ FLV_SAMPLERATE_22050HZ
Definition: flv.h:86
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: avcodec.h:565
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
buf
void * buf
Definition: avisynth_c.h:766
AVCodecTag
Definition: internal.h:44
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: avcodec.h:716
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:740
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: avcodec.h:4023
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
FLV_CODECID_MPEG4
@ FLV_CODECID_MPEG4
Definition: flv.h:112
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
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: avcodec.h:469
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1183
FLVContext::audiosize
int64_t audiosize
Definition: flvenc.c:94
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: avcodec.h:245
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:350
FLVContext::framerate
double framerate
Definition: flvenc.c:117
AVFormatContext
Format I/O context.
Definition: avformat.h:1342
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: avcodec.h:470
AV_CODEC_ID_FLASHSV2
@ AV_CODEC_ID_FLASHSV2
Definition: avcodec.h:349
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1017
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_CODECID_NELLYMOSER_8KHZ_MONO
@ FLV_CODECID_NELLYMOSER_8KHZ_MONO
Definition: flv.h:96
FLVContext::datasize_offset
int64_t datasize_offset
Definition: flvenc.c:89
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:94
FLV_ADD_KEYFRAME_INDEX
@ FLV_ADD_KEYFRAME_INDEX
Definition: flvenc.c:69
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:191
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:5540
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:94
FLVFileposition
Definition: flvenc.c:74
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:196
FLV_SAMPLESSIZE_8BIT
@ FLV_SAMPLESSIZE_8BIT
Definition: flv.h:79
AV_CODEC_ID_FLASHSV
@ AV_CODEC_ID_FLASHSV
Definition: avcodec.h:304
AV_CODEC_ID_VP6A
@ AV_CODEC_ID_VP6A
Definition: avcodec.h:324
AVSTREAM_EVENT_FLAG_METADATA_UPDATED
#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED
The call resulted in updated metadata.
Definition: avformat.h:984
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: avcodec.h:4067
FLVFileposition::keyframe_timestamp
double keyframe_timestamp
Definition: flvenc.c:76
error
static void error(const char *err)
Definition: target_dec_fuzzer.c:61
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: avcodec.h:3975
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: avcodec.h:566
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:68
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
flv_muxer_class
static const AVClass flv_muxer_class
Definition: flvenc.c:1106
AVPacket::size
int size
Definition: avcodec.h:1478
flv_init
static int flv_init(struct AVFormatContext *s)
Definition: flvenc.c:656
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
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:4910
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: avcodec.h:222
AV_CODEC_ID_ADPCM_SWF
@ AV_CODEC_ID_ADPCM_SWF
Definition: avcodec.h:515
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:47
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
FLV_SAMPLERATE_11025HZ
@ FLV_SAMPLERATE_11025HZ
Definition: flv.h:85
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: avcodec.h:4017
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
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: avcodec.h:1476
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:377
FLV_SAMPLERATE_SPECIAL
@ FLV_SAMPLERATE_SPECIAL
signifies 5512Hz and 8000Hz in the case of NELLYMOSER
Definition: flv.h:84
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
FLV_SAMPLERATE_44100HZ
@ FLV_SAMPLERATE_44100HZ
Definition: flv.h:87
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
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:690
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:5694
FLV_CODECID_PCM_LE
@ FLV_CODECID_PCM_LE
Definition: flv.h:94
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_CODECID_NELLYMOSER_16KHZ_MONO
@ FLV_CODECID_NELLYMOSER_16KHZ_MONO
Definition: flv.h:95
AMF_DATA_TYPE_ARRAY
@ AMF_DATA_TYPE_ARRAY
Definition: flv.h:133
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:466
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: avcodec.h:216
AVOutputFormat
Definition: avformat.h:495
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
FLV_CODECID_PCM_MULAW
@ FLV_CODECID_PCM_MULAW
Definition: flv.h:99
avio_internal.h
FLVContext::keyframe_index_size
int64_t keyframe_index_size
Definition: flvenc.c:99
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3257
unsupported_codec
static int unsupported_codec(AVFormatContext *s, const char *type, int codec_id)
Definition: flvenc.c:477
AVCodecParameters::height
int height
Definition: avcodec.h:4024
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_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
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:236
FLV_CODECID_REALH263
@ FLV_CODECID_REALH263
Definition: flv.h:111
FLV_STEREO
@ FLV_STEREO
Definition: flv.h:75
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
FLV_CODECID_VP6
@ FLV_CODECID_VP6
Definition: flv.h:107
FLV_HEADER_FLAG_HASAUDIO
@ FLV_HEADER_FLAG_HASAUDIO
Definition: flv.h:56
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:477
FLVStreamContext
Definition: flvenc.c:123
tag
uint32_t tag
Definition: movenc.c:1496
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:870
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:246
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
FLV_CODECID_PCM_ALAW
@ FLV_CODECID_PCM_ALAW
Definition: flv.h:98
ff_flv_muxer
AVOutputFormat ff_flv_muxer
Definition: flvenc.c:1113
avformat.h
dict.h
AV_CODEC_ID_TEXT
@ AV_CODEC_ID_TEXT
raw UTF-8 text
Definition: avcodec.h:660
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:790
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_CODECID_VP6A
@ FLV_CODECID_VP6A
Definition: flv.h:108
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
FLV_CODECID_AAC
@ FLV_CODECID_AAC
Definition: flv.h:100
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: avcodec.h:1199
ff_codec_get_tag
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:3136
FLV_HEADER_FLAG_HASVIDEO
@ FLV_HEADER_FLAG_HASVIDEO
Definition: flv.h:55
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: avcodec.h:1479
FLV_SAMPLESSIZE_16BIT
@ FLV_SAMPLESSIZE_16BIT
Definition: flv.h:80
FLV_CODECID_SCREEN2
@ FLV_CODECID_SCREEN2
Definition: flv.h:109
FLVStreamContext::last_ts
int64_t last_ts
last timestamp for each stream
Definition: flvenc.c:124
FLV_FRAME_KEY
@ FLV_FRAME_KEY
key frame (for AVC, a seekable frame)
Definition: flv.h:116
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:331
avio_wb64
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:463
ff_format_io_close
void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: utils.c:5665
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:654
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: avcodec.h:3999
FLVContext::lasttimestamp
double lasttimestamp
Definition: flvenc.c:102
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: avcodec.h:468
FLV_CODECID_SPEEX
@ FLV_CODECID_SPEEX
Definition: flv.h:101
flv_write_trailer
static int flv_write_trailer(AVFormatContext *s)
Definition: flvenc.c:777
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:487
avio_flush
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
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: avcodec.h:3957
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
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
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:475
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: avcodec.h:3986
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:1096
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:337
FLVFileposition::next
struct FLVFileposition * next
Definition: flvenc.c:77
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: avcodec.h:239
FLVContext::datastart_offset
int64_t datastart_offset
Definition: flvenc.c:88
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
FLV_CODECID_ADPCM
@ FLV_CODECID_ADPCM
Definition: flv.h:92
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: avcodec.h:597
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
FLV_FRAME_INTER
@ FLV_FRAME_INTER
inter frame (for AVC, a non-seekable frame)
Definition: flv.h:117
Generated on Wed Aug 24 2022 21:26:40 for FFmpeg by   doxygen 1.8.17