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