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_eos_tag(AVIOContext *pb, unsigned ts, enum AVCodecID codec_id)
239 {
241  /* ub[4] FrameType = 1, ub[4] CodecId */
242  tag |= 1 << 4;
244  avio_wb24(pb, 5); /* Tag Data Size */
245  put_timestamp(pb, ts);
246  avio_wb24(pb, 0); /* StreamId = 0 */
247  avio_w8(pb, tag);
248  avio_w8(pb, 2); /* AVC end of sequence */
249  avio_wb24(pb, 0); /* Always 0 for AVC EOS. */
250  avio_wb32(pb, 16); /* Size of FLV tag */
251 }
252 
253 static void put_amf_double(AVIOContext *pb, double d)
254 {
256  avio_wb64(pb, av_double2int(d));
257 }
258 
259 static void put_amf_byte(AVIOContext *pb, unsigned char abyte)
260 {
261  avio_w8(pb, abyte);
262 }
263 
264 static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
265 {
267  avio_wb32(pb, dw);
268 }
269 
270 static void put_amf_bool(AVIOContext *pb, int b)
271 {
273  avio_w8(pb, !!b);
274 }
275 
276 static void write_metadata(AVFormatContext *s, unsigned int ts)
277 {
278  AVIOContext *pb = s->pb;
279  FLVContext *flv = s->priv_data;
280  int write_duration_filesize = !(flv->flags & FLV_NO_DURATION_FILESIZE);
281  int metadata_count = 0;
282  int64_t metadata_count_pos;
283  const AVDictionaryEntry *tag = NULL;
284 
285  /* write meta_tag */
286  avio_w8(pb, FLV_TAG_TYPE_META); // tag type META
287  flv->metadata_size_pos = avio_tell(pb);
288  avio_wb24(pb, 0); // size of data part (sum of all parts below)
289  put_timestamp(pb, ts); // timestamp
290  avio_wb24(pb, 0); // reserved
291 
292  /* now data of data_size size */
293 
294  /* first event name as a string */
296  put_amf_string(pb, "onMetaData"); // 12 bytes
297 
298  /* mixed array (hash) with size and string/type/data tuples */
300  metadata_count_pos = avio_tell(pb);
301  metadata_count = 4 * !!flv->video_par +
302  5 * !!flv->audio_par +
303  1 * !!flv->data_par;
304  if (write_duration_filesize) {
305  metadata_count += 2; // +2 for duration and file size
306  }
307  avio_wb32(pb, metadata_count);
308 
309  if (write_duration_filesize) {
310  put_amf_string(pb, "duration");
311  flv->duration_offset = avio_tell(pb);
312  // fill in the guessed duration, it'll be corrected later if incorrect
313  put_amf_double(pb, s->duration / AV_TIME_BASE);
314  }
315 
316  if (flv->video_par) {
317  put_amf_string(pb, "width");
318  put_amf_double(pb, flv->video_par->width);
319 
320  put_amf_string(pb, "height");
321  put_amf_double(pb, flv->video_par->height);
322 
323  put_amf_string(pb, "videodatarate");
324  put_amf_double(pb, flv->video_par->bit_rate / 1024.0);
325 
326  if (flv->framerate != 0.0) {
327  put_amf_string(pb, "framerate");
328  put_amf_double(pb, flv->framerate);
329  metadata_count++;
330  }
331 
332  put_amf_string(pb, "videocodecid");
334  }
335 
336  if (flv->audio_par) {
337  put_amf_string(pb, "audiodatarate");
338  put_amf_double(pb, flv->audio_par->bit_rate / 1024.0);
339 
340  put_amf_string(pb, "audiosamplerate");
342 
343  put_amf_string(pb, "audiosamplesize");
344  put_amf_double(pb, flv->audio_par->codec_id == AV_CODEC_ID_PCM_U8 ? 8 : 16);
345 
346  put_amf_string(pb, "stereo");
348 
349  put_amf_string(pb, "audiocodecid");
351  }
352 
353  if (flv->data_par) {
354  put_amf_string(pb, "datastream");
355  put_amf_double(pb, 0.0);
356  }
357 
359  while ((tag = av_dict_iterate(s->metadata, tag))) {
360  if( !strcmp(tag->key, "width")
361  ||!strcmp(tag->key, "height")
362  ||!strcmp(tag->key, "videodatarate")
363  ||!strcmp(tag->key, "framerate")
364  ||!strcmp(tag->key, "videocodecid")
365  ||!strcmp(tag->key, "audiodatarate")
366  ||!strcmp(tag->key, "audiosamplerate")
367  ||!strcmp(tag->key, "audiosamplesize")
368  ||!strcmp(tag->key, "stereo")
369  ||!strcmp(tag->key, "audiocodecid")
370  ||!strcmp(tag->key, "duration")
371  ||!strcmp(tag->key, "onMetaData")
372  ||!strcmp(tag->key, "datasize")
373  ||!strcmp(tag->key, "lasttimestamp")
374  ||!strcmp(tag->key, "totalframes")
375  ||!strcmp(tag->key, "hasAudio")
376  ||!strcmp(tag->key, "hasVideo")
377  ||!strcmp(tag->key, "hasCuePoints")
378  ||!strcmp(tag->key, "hasMetadata")
379  ||!strcmp(tag->key, "hasKeyframes")
380  ){
381  av_log(s, AV_LOG_DEBUG, "Ignoring metadata for %s\n", tag->key);
382  continue;
383  }
384  put_amf_string(pb, tag->key);
386  put_amf_string(pb, tag->value);
387  metadata_count++;
388  }
389 
390  if (write_duration_filesize) {
391  put_amf_string(pb, "filesize");
392  flv->filesize_offset = avio_tell(pb);
393  put_amf_double(pb, 0); // delayed write
394  }
395 
396  if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
397  flv->keyframe_index_size = 0;
398 
399  put_amf_string(pb, "hasVideo");
400  put_amf_bool(pb, !!flv->video_par);
401  metadata_count++;
402 
403  put_amf_string(pb, "hasKeyframes");
404  put_amf_bool(pb, 1);
405  metadata_count++;
406 
407  put_amf_string(pb, "hasAudio");
408  put_amf_bool(pb, !!flv->audio_par);
409  metadata_count++;
410 
411  put_amf_string(pb, "hasMetadata");
412  put_amf_bool(pb, 1);
413  metadata_count++;
414 
415  put_amf_string(pb, "canSeekToEnd");
416  put_amf_bool(pb, 1);
417  metadata_count++;
418 
419  put_amf_string(pb, "datasize");
420  flv->datasize_offset = avio_tell(pb);
421  flv->datasize = 0;
422  put_amf_double(pb, flv->datasize);
423  metadata_count++;
424 
425  put_amf_string(pb, "videosize");
426  flv->videosize_offset = avio_tell(pb);
427  flv->videosize = 0;
428  put_amf_double(pb, flv->videosize);
429  metadata_count++;
430 
431  put_amf_string(pb, "audiosize");
432  flv->audiosize_offset = avio_tell(pb);
433  flv->audiosize = 0;
434  put_amf_double(pb, flv->audiosize);
435  metadata_count++;
436 
437  put_amf_string(pb, "lasttimestamp");
438  flv->lasttimestamp_offset = avio_tell(pb);
439  flv->lasttimestamp = 0;
440  put_amf_double(pb, 0);
441  metadata_count++;
442 
443  put_amf_string(pb, "lastkeyframetimestamp");
445  flv->lastkeyframetimestamp = 0;
446  put_amf_double(pb, 0);
447  metadata_count++;
448 
449  put_amf_string(pb, "lastkeyframelocation");
451  flv->lastkeyframelocation = 0;
452  put_amf_double(pb, 0);
453  metadata_count++;
454 
455  put_amf_string(pb, "keyframes");
457  metadata_count++;
458 
459  flv->keyframes_info_offset = avio_tell(pb);
460  }
461 
462  put_amf_string(pb, "");
464 
465  /* write total size of tag */
466  flv->metadata_totalsize = avio_tell(pb) - flv->metadata_size_pos - 10;
467 
468  avio_seek(pb, metadata_count_pos, SEEK_SET);
469  avio_wb32(pb, metadata_count);
470 
471  avio_seek(pb, flv->metadata_size_pos, SEEK_SET);
472  avio_wb24(pb, flv->metadata_totalsize);
473  avio_skip(pb, flv->metadata_totalsize + 10 - 3);
475  avio_wb32(pb, flv->metadata_totalsize + 11);
476 }
477 
479  const char* type, int codec_id)
480 {
483  "%s codec %s not compatible with flv\n",
484  type,
485  desc ? desc->name : "unknown");
486  return AVERROR(ENOSYS);
487 }
488 
490  int64_t data_size;
491  AVIOContext *pb = s->pb;
492  FLVContext *flv = s->priv_data;
493 
494  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
495  || par->codec_id == AV_CODEC_ID_MPEG4) {
496  int64_t pos;
497  avio_w8(pb,
500  avio_wb24(pb, 0); // size patched later
501  put_timestamp(pb, ts);
502  avio_wb24(pb, 0); // streamid
503  pos = avio_tell(pb);
504  if (par->codec_id == AV_CODEC_ID_AAC) {
505  avio_w8(pb, get_audio_flags(s, par));
506  avio_w8(pb, 0); // AAC sequence header
507 
508  if (!par->extradata_size && (flv->flags & FLV_AAC_SEQ_HEADER_DETECT)) {
509  PutBitContext pbc;
510  int samplerate_index;
512  - (flv->audio_par->ch_layout.nb_channels == 8 ? 1 : 0);
513  uint8_t data[2];
514 
515  for (samplerate_index = 0; samplerate_index < 16;
516  samplerate_index++)
517  if (flv->audio_par->sample_rate
518  == ff_mpeg4audio_sample_rates[samplerate_index])
519  break;
520 
521  init_put_bits(&pbc, data, sizeof(data));
522  put_bits(&pbc, 5, flv->audio_par->profile + 1); //profile
523  put_bits(&pbc, 4, samplerate_index); //sample rate index
524  put_bits(&pbc, 4, channels);
525  put_bits(&pbc, 1, 0); //frame length - 1024 samples
526  put_bits(&pbc, 1, 0); //does not depend on core coder
527  put_bits(&pbc, 1, 0); //is not extension
528  flush_put_bits(&pbc);
529 
530  avio_w8(pb, data[0]);
531  avio_w8(pb, data[1]);
532 
533  av_log(s, AV_LOG_WARNING, "AAC sequence header: %02x %02x.\n",
534  data[0], data[1]);
535  }
536  avio_write(pb, par->extradata, par->extradata_size);
537  } else {
538  avio_w8(pb, par->codec_tag | FLV_FRAME_KEY); // flags
539  avio_w8(pb, 0); // AVC sequence header
540  avio_wb24(pb, 0); // composition time
542  }
543  data_size = avio_tell(pb) - pos;
544  avio_seek(pb, -data_size - 10, SEEK_CUR);
545  avio_wb24(pb, data_size);
546  avio_skip(pb, data_size + 10 - 3);
547  avio_wb32(pb, data_size + 11); // previous tag size
548  }
549 }
550 
551 static int flv_append_keyframe_info(AVFormatContext *s, FLVContext *flv, double ts, int64_t pos)
552 {
553  FLVFileposition *position = av_malloc(sizeof(FLVFileposition));
554 
555  if (!position) {
556  av_log(s, AV_LOG_WARNING, "no mem for add keyframe index!\n");
557  return AVERROR(ENOMEM);
558  }
559 
560  position->keyframe_timestamp = ts;
561  position->keyframe_position = pos;
562 
563  if (!flv->filepositions_count) {
564  flv->filepositions = position;
565  flv->head_filepositions = flv->filepositions;
566  position->next = NULL;
567  } else {
568  flv->filepositions->next = position;
569  position->next = NULL;
570  flv->filepositions = flv->filepositions->next;
571  }
572 
573  flv->filepositions_count++;
574 
575  return 0;
576 }
577 
579 {
580  int ret;
581  int64_t metadata_size = 0;
582  FLVContext *flv = s->priv_data;
583 
584  metadata_size = flv->filepositions_count * 9 * 2 + 10; /* filepositions and times value */
585  metadata_size += 2 + 13; /* filepositions String */
586  metadata_size += 2 + 5; /* times String */
587  metadata_size += 3; /* Object end */
588 
589  flv->keyframe_index_size = metadata_size;
590 
591  if (metadata_size < 0)
592  return metadata_size;
593 
594  ret = ff_format_shift_data(s, flv->keyframes_info_offset, metadata_size);
595  if (ret < 0)
596  return ret;
597 
598  avio_seek(s->pb, flv->metadata_size_pos, SEEK_SET);
599  avio_wb24(s->pb, flv->metadata_totalsize + metadata_size);
600 
601  avio_seek(s->pb, flv->metadata_totalsize_pos + metadata_size, SEEK_SET);
602  avio_wb32(s->pb, flv->metadata_totalsize + 11 + metadata_size);
603 
604  return 0;
605 }
606 
607 static int flv_init(struct AVFormatContext *s)
608 {
609  int i;
610  FLVContext *flv = s->priv_data;
611 
612  for (i = 0; i < s->nb_streams; i++) {
613  AVCodecParameters *par = s->streams[i]->codecpar;
614  FLVStreamContext *sc;
615  switch (par->codec_type) {
616  case AVMEDIA_TYPE_VIDEO:
617  if (s->streams[i]->avg_frame_rate.den &&
618  s->streams[i]->avg_frame_rate.num) {
619  flv->framerate = av_q2d(s->streams[i]->avg_frame_rate);
620  }
621  if (flv->video_par) {
623  "at most one video stream is supported in flv\n");
624  return AVERROR(EINVAL);
625  }
626  flv->video_par = par;
628  return unsupported_codec(s, "Video", par->codec_id);
629 
630  if (par->codec_id == AV_CODEC_ID_MPEG4 ||
631  par->codec_id == AV_CODEC_ID_H263) {
632  int error = s->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL;
634  "Codec %s is not supported in the official FLV specification,\n", avcodec_get_name(par->codec_id));
635 
636  if (error) {
638  "use vstrict=-1 / -strict -1 to use it anyway.\n");
639  return AVERROR(EINVAL);
640  }
641  } else if (par->codec_id == AV_CODEC_ID_VP6) {
643  "Muxing VP6 in flv will produce flipped video on playback.\n");
644  }
645  break;
646  case AVMEDIA_TYPE_AUDIO:
647  if (flv->audio_par) {
649  "at most one audio stream is supported in flv\n");
650  return AVERROR(EINVAL);
651  }
652  flv->audio_par = par;
653  if (get_audio_flags(s, par) < 0)
654  return unsupported_codec(s, "Audio", par->codec_id);
655  if (par->codec_id == AV_CODEC_ID_PCM_S16BE)
657  "16-bit big-endian audio in flv is valid but most likely unplayable (hardware dependent); use s16le\n");
658  break;
659  case AVMEDIA_TYPE_DATA:
660  if (par->codec_id != AV_CODEC_ID_TEXT && par->codec_id != AV_CODEC_ID_NONE)
661  return unsupported_codec(s, "Data", par->codec_id);
662  flv->data_par = par;
663  break;
665  if (par->codec_id != AV_CODEC_ID_TEXT) {
666  av_log(s, AV_LOG_ERROR, "Subtitle codec '%s' for stream %d is not compatible with FLV\n",
667  avcodec_get_name(par->codec_id), i);
668  return AVERROR_INVALIDDATA;
669  }
670  flv->data_par = par;
671  break;
672  default:
673  av_log(s, AV_LOG_ERROR, "Codec type '%s' for stream %d is not compatible with FLV\n",
675  return AVERROR(EINVAL);
676  }
677  avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
678 
679  sc = av_mallocz(sizeof(FLVStreamContext));
680  if (!sc)
681  return AVERROR(ENOMEM);
682  s->streams[i]->priv_data = sc;
683  sc->last_ts = -1;
684  }
685 
686  flv->delay = AV_NOPTS_VALUE;
687 
688  return 0;
689 }
690 
692 {
693  int i;
694  AVIOContext *pb = s->pb;
695  FLVContext *flv = s->priv_data;
696 
697  avio_write(pb, "FLV", 3);
698  avio_w8(pb, 1);
701  avio_wb32(pb, 9);
702  avio_wb32(pb, 0);
703 
704  for (i = 0; i < s->nb_streams; i++)
705  if (s->streams[i]->codecpar->codec_tag == 5) {
706  avio_w8(pb, 8); // message type
707  avio_wb24(pb, 0); // include flags
708  avio_wb24(pb, 0); // time stamp
709  avio_wb32(pb, 0); // reserved
710  avio_wb32(pb, 11); // size
711  flv->reserved = 5;
712  }
713 
714  if (flv->flags & FLV_NO_METADATA) {
715  pb->seekable = 0;
716  } else {
717  write_metadata(s, 0);
718  }
719 
720  for (i = 0; i < s->nb_streams; i++) {
721  flv_write_codec_header(s, s->streams[i]->codecpar, 0);
722  }
723 
724  flv->datastart_offset = avio_tell(pb);
725  return 0;
726 }
727 
729 {
730  int64_t file_size;
731  AVIOContext *pb = s->pb;
732  FLVContext *flv = s->priv_data;
733  int build_keyframes_idx = flv->flags & FLV_ADD_KEYFRAME_INDEX;
734  int i, res;
735  int64_t cur_pos = avio_tell(s->pb);
736 
737  if (build_keyframes_idx) {
738  const FLVFileposition *newflv_posinfo;
739 
740  avio_seek(pb, flv->videosize_offset, SEEK_SET);
741  put_amf_double(pb, flv->videosize);
742 
743  avio_seek(pb, flv->audiosize_offset, SEEK_SET);
744  put_amf_double(pb, flv->audiosize);
745 
746  avio_seek(pb, flv->lasttimestamp_offset, SEEK_SET);
747  put_amf_double(pb, flv->lasttimestamp);
748 
749  avio_seek(pb, flv->lastkeyframetimestamp_offset, SEEK_SET);
751 
752  avio_seek(pb, flv->lastkeyframelocation_offset, SEEK_SET);
754  avio_seek(pb, cur_pos, SEEK_SET);
755 
756  res = shift_data(s);
757  if (res < 0) {
758  goto end;
759  }
760  avio_seek(pb, flv->keyframes_info_offset, SEEK_SET);
761  put_amf_string(pb, "filepositions");
763  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
764  put_amf_double(pb, newflv_posinfo->keyframe_position + flv->keyframe_index_size);
765  }
766 
767  put_amf_string(pb, "times");
769  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
770  put_amf_double(pb, newflv_posinfo->keyframe_timestamp);
771  }
772 
773  put_amf_string(pb, "");
775 
776  avio_seek(pb, cur_pos + flv->keyframe_index_size, SEEK_SET);
777  }
778 
779 end:
780  if (flv->flags & FLV_NO_SEQUENCE_END) {
781  av_log(s, AV_LOG_DEBUG, "FLV no sequence end mode open\n");
782  } else {
783  /* Add EOS tag */
784  for (i = 0; i < s->nb_streams; i++) {
785  AVCodecParameters *par = s->streams[i]->codecpar;
786  FLVStreamContext *sc = s->streams[i]->priv_data;
787  if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
789  put_eos_tag(pb, sc->last_ts, par->codec_id);
790  }
791  }
792 
793  file_size = avio_tell(pb);
794 
795  if (build_keyframes_idx) {
796  flv->datasize = file_size - flv->datastart_offset;
797  avio_seek(pb, flv->datasize_offset, SEEK_SET);
798  put_amf_double(pb, flv->datasize);
799  }
800  if (!(flv->flags & FLV_NO_METADATA)) {
801  if (!(flv->flags & FLV_NO_DURATION_FILESIZE)) {
802  /* update information */
803  if (avio_seek(pb, flv->duration_offset, SEEK_SET) < 0) {
804  av_log(s, AV_LOG_WARNING, "Failed to update header with correct duration.\n");
805  } else {
806  put_amf_double(pb, flv->duration / (double)1000);
807  }
808  if (avio_seek(pb, flv->filesize_offset, SEEK_SET) < 0) {
809  av_log(s, AV_LOG_WARNING, "Failed to update header with correct filesize.\n");
810  } else {
811  put_amf_double(pb, file_size);
812  }
813  }
814  }
815 
816  return 0;
817 }
818 
820 {
821  AVIOContext *pb = s->pb;
822  AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
823  FLVContext *flv = s->priv_data;
824  FLVStreamContext *sc = s->streams[pkt->stream_index]->priv_data;
825  unsigned ts;
826  int size = pkt->size;
827  uint8_t *data = NULL;
828  int flags = -1, flags_size, ret = 0;
829  int64_t cur_offset = avio_tell(pb);
830 
831  if (par->codec_type == AVMEDIA_TYPE_AUDIO && !pkt->size) {
832  av_log(s, AV_LOG_WARNING, "Empty audio Packet\n");
833  return AVERROR(EINVAL);
834  }
835 
836  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A ||
838  flags_size = 2;
839  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4)
840  flags_size = 5;
841  else
842  flags_size = 1;
843 
844  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
845  || par->codec_id == AV_CODEC_ID_MPEG4) {
846  size_t side_size;
847  uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
848  if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
849  ret = ff_alloc_extradata(par, side_size);
850  if (ret < 0)
851  return ret;
852  memcpy(par->extradata, side, side_size);
854  }
855  }
856 
857  if (flv->delay == AV_NOPTS_VALUE)
858  flv->delay = -pkt->dts;
859 
860  if (pkt->dts < -flv->delay) {
862  "Packets are not in the proper order with respect to DTS\n");
863  return AVERROR(EINVAL);
864  }
865  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
866  if (pkt->pts == AV_NOPTS_VALUE) {
867  av_log(s, AV_LOG_ERROR, "Packet is missing PTS\n");
868  return AVERROR(EINVAL);
869  }
870  }
871 
872  ts = pkt->dts;
873 
874  if (s->event_flags & AVSTREAM_EVENT_FLAG_METADATA_UPDATED) {
875  write_metadata(s, ts);
876  s->event_flags &= ~AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
877  }
878 
881 
882  switch (par->codec_type) {
883  case AVMEDIA_TYPE_VIDEO:
885 
887 
889  break;
890  case AVMEDIA_TYPE_AUDIO:
891  flags = get_audio_flags(s, par);
892 
893  av_assert0(size);
894 
896  break;
898  case AVMEDIA_TYPE_DATA:
900  break;
901  default:
902  return AVERROR(EINVAL);
903  }
904 
905  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
906  /* check if extradata looks like mp4 formatted */
907  if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
908  if ((ret = ff_avc_parse_nal_units_buf(pkt->data, &data, &size)) < 0)
909  return ret;
910  } else if (par->codec_id == AV_CODEC_ID_AAC && pkt->size > 2 &&
911  (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
912  if (!s->streams[pkt->stream_index]->nb_frames) {
913  av_log(s, AV_LOG_ERROR, "Malformed AAC bitstream detected: "
914  "use the audio bitstream filter 'aac_adtstoasc' to fix it "
915  "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
916  return AVERROR_INVALIDDATA;
917  }
918  av_log(s, AV_LOG_WARNING, "aac bitstream error\n");
919  }
920 
921  /* check Speex packet duration */
922  if (par->codec_id == AV_CODEC_ID_SPEEX && ts - sc->last_ts > 160)
923  av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
924  "8 frames per packet. Adobe Flash "
925  "Player cannot handle this!\n");
926 
927  if (sc->last_ts < ts)
928  sc->last_ts = ts;
929 
930  if (size + flags_size >= 1<<24) {
931  av_log(s, AV_LOG_ERROR, "Too large packet with size %u >= %u\n",
932  size + flags_size, 1<<24);
933  ret = AVERROR(EINVAL);
934  goto fail;
935  }
936 
937  avio_wb24(pb, size + flags_size);
938  put_timestamp(pb, ts);
939  avio_wb24(pb, flv->reserved);
940 
941  if (par->codec_type == AVMEDIA_TYPE_DATA ||
943  int data_size;
944  int64_t metadata_size_pos = avio_tell(pb);
945  if (par->codec_id == AV_CODEC_ID_TEXT) {
946  // legacy FFmpeg magic?
948  put_amf_string(pb, "onTextData");
950  avio_wb32(pb, 2);
951  put_amf_string(pb, "type");
953  put_amf_string(pb, "Text");
954  put_amf_string(pb, "text");
956  put_amf_string(pb, pkt->data);
957  put_amf_string(pb, "");
959  } else {
960  // just pass the metadata through
961  avio_write(pb, data ? data : pkt->data, size);
962  }
963  /* write total size of tag */
964  data_size = avio_tell(pb) - metadata_size_pos;
965  avio_seek(pb, metadata_size_pos - 10, SEEK_SET);
966  avio_wb24(pb, data_size);
967  avio_seek(pb, data_size + 10 - 3, SEEK_CUR);
968  avio_wb32(pb, data_size + 11);
969  } else {
970  av_assert1(flags>=0);
971  avio_w8(pb,flags);
972  if (par->codec_id == AV_CODEC_ID_VP6)
973  avio_w8(pb,0);
974  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A) {
975  if (par->extradata_size)
976  avio_w8(pb, par->extradata[0]);
977  else
978  avio_w8(pb, ((FFALIGN(par->width, 16) - par->width) << 4) |
979  (FFALIGN(par->height, 16) - par->height));
980  } else if (par->codec_id == AV_CODEC_ID_AAC)
981  avio_w8(pb, 1); // AAC raw
982  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
983  avio_w8(pb, 1); // AVC NALU
984  avio_wb24(pb, pkt->pts - pkt->dts);
985  }
986 
987  avio_write(pb, data ? data : pkt->data, size);
988 
989  avio_wb32(pb, size + flags_size + 11); // previous tag size
990  flv->duration = FFMAX(flv->duration,
991  pkt->pts + flv->delay + pkt->duration);
992  }
993 
994  if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
995  switch (par->codec_type) {
996  case AVMEDIA_TYPE_VIDEO:
997  flv->videosize += (avio_tell(pb) - cur_offset);
998  flv->lasttimestamp = pkt->dts / 1000.0;
999  if (pkt->flags & AV_PKT_FLAG_KEY) {
1001  flv->lastkeyframelocation = cur_offset;
1002  ret = flv_append_keyframe_info(s, flv, flv->lasttimestamp, cur_offset);
1003  if (ret < 0)
1004  goto fail;
1005  }
1006  break;
1007 
1008  case AVMEDIA_TYPE_AUDIO:
1009  flv->audiosize += (avio_tell(pb) - cur_offset);
1010  break;
1011 
1012  default:
1013  av_log(s, AV_LOG_WARNING, "par->codec_type is type = [%d]\n", par->codec_type);
1014  break;
1015  }
1016  }
1017 fail:
1018  av_free(data);
1019 
1020  return ret;
1021 }
1022 
1024  const AVPacket *pkt)
1025 {
1026  int ret = 1;
1027 
1028  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
1029  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
1030  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
1031  }
1032  return ret;
1033 }
1034 
1036 {
1037  FLVContext *flv = s->priv_data;
1038  FLVFileposition *filepos = flv->head_filepositions;
1039 
1040  while (filepos) {
1041  FLVFileposition *next = filepos->next;
1042  av_free(filepos);
1043  filepos = next;
1044  }
1045  flv->filepositions = flv->head_filepositions = NULL;
1046  flv->filepositions_count = 0;
1047 }
1048 
1049 static const AVOption options[] = {
1050  { "flvflags", "FLV muxer flags", offsetof(FLVContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1051  { "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" },
1052  { "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" },
1053  { "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" },
1054  { "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" },
1055  { "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" },
1056  { NULL },
1057 };
1058 
1059 static const AVClass flv_muxer_class = {
1060  .class_name = "flv muxer",
1061  .item_name = av_default_item_name,
1062  .option = options,
1063  .version = LIBAVUTIL_VERSION_INT,
1064 };
1065 
1067  .p.name = "flv",
1068  .p.long_name = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1069  .p.mime_type = "video/x-flv",
1070  .p.extensions = "flv",
1071  .priv_data_size = sizeof(FLVContext),
1072  .p.audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_ADPCM_SWF,
1073  .p.video_codec = AV_CODEC_ID_FLV1,
1074  .init = flv_init,
1075  .write_header = flv_write_header,
1076  .write_packet = flv_write_packet,
1077  .write_trailer = flv_write_trailer,
1078  .deinit = flv_deinit,
1079  .check_bitstream= flv_check_bitstream,
1080  .p.codec_tag = (const AVCodecTag* const []) {
1082  },
1083  .p.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS |
1085  .p.priv_class = &flv_muxer_class,
1086 };
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
FLV_CODECID_AAC
@ FLV_CODECID_AAC
Definition: flv.h:100
FLV_SAMPLERATE_22050HZ
@ FLV_SAMPLERATE_22050HZ
Definition: flv.h:86
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
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:508
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h: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:482
FLV_CODECID_NELLYMOSER
@ FLV_CODECID_NELLYMOSER
Definition: flv.h:97
FLVContext::delay
int64_t delay
first dts delay (needed for AVC & Speex)
Definition: flvenc.c:86
FLV_CODECID_PCM_MULAW
@ FLV_CODECID_PCM_MULAW
Definition: flv.h:99
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
FLV_CODECID_MPEG4
@ FLV_CODECID_MPEG4
Definition: flv.h:112
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
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
AVOption
AVOption.
Definition: opt.h:251
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:146
FLV_SAMPLESSIZE_8BIT
@ FLV_SAMPLESSIZE_8BIT
Definition: flv.h:79
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
FLV_CODECID_SCREEN
@ FLV_CODECID_SCREEN
Definition: flv.h:106
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:270
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
FFOutputFormat::p
AVOutputFormat p
The public AVOutputFormat.
Definition: mux.h:34
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
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:482
flv_append_keyframe_info
static int flv_append_keyframe_info(AVFormatContext *s, FLVContext *flv, double ts, int64_t pos)
Definition: flvenc.c:551
FLVContext::lastkeyframelocation_offset
int64_t lastkeyframelocation_offset
Definition: flvenc.c:105
FLV_SAMPLESSIZE_16BIT
@ FLV_SAMPLESSIZE_16BIT
Definition: flv.h:80
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:771
mpeg4audio.h
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:473
flv_write_packet
static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: flvenc.c:819
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:327
ff_flv_muxer
const FFOutputFormat ff_flv_muxer
Definition: flvenc.c:1066
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:253
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:500
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:439
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
FLV_SAMPLERATE_SPECIAL
@ FLV_SAMPLERATE_SPECIAL
signifies 5512Hz and 8000Hz in the case of NELLYMOSER
Definition: flv.h:84
FLVContext::lastkeyframelocation
int64_t lastkeyframelocation
Definition: flvenc.c:106
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:691
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
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
FLV_CODECID_NELLYMOSER_8KHZ_MONO
@ FLV_CODECID_NELLYMOSER_8KHZ_MONO
Definition: flv.h:96
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
channels
channels
Definition: aptx.h:31
FLV_HEADER_FLAG_HASAUDIO
@ FLV_HEADER_FLAG_HASAUDIO
Definition: flv.h:56
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
FLV_CODECID_H263
@ FLV_CODECID_H263
Definition: flv.h:105
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:60
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
AVFormatContext
Format I/O context.
Definition: avformat.h:1104
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:333
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:861
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
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
FLV_CODECID_PCM
@ FLV_CODECID_PCM
Definition: flv.h:91
avc.h
FLV_CODECID_PCM_LE
@ FLV_CODECID_PCM_LE
Definition: flv.h:94
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
FFOutputFormat
Definition: mux.h:30
flv.h
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:200
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_STEREO
@ FLV_STEREO
Definition: flv.h:75
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:980
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
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
FLVContext::keyframes_info_offset
int64_t keyframes_info_offset
Definition: flvenc.c: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:440
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
flv_muxer_class
static const AVClass flv_muxer_class
Definition: flvenc.c:1059
AVPacket::size
int size
Definition: packet.h:375
flv_init
static int flv_init(struct AVFormatContext *s)
Definition: flvenc.c:607
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:143
put_eos_tag
static void put_eos_tag(AVIOContext *pb, unsigned ts, enum AVCodecID codec_id)
Definition: flvenc.c:238
FLV_CODECID_H264
@ FLV_CODECID_H264
Definition: flv.h:110
shift_data
static int shift_data(AVFormatContext *s)
Definition: flvenc.c:578
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
FLV_CODECID_VP6A
@ FLV_CODECID_VP6A
Definition: flv.h:108
size
int size
Definition: twinvq_data.h:10344
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
FLV_CODECID_MP3
@ FLV_CODECID_MP3
Definition: flv.h:93
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
FLV_CODECID_SPEEX
@ FLV_CODECID_SPEEX
Definition: flv.h:101
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:222
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:386
FLVContext::data_par
AVCodecParameters * data_par
Definition: flvenc.c:117
FLVContext::filesize_offset
int64_t filesize_offset
Definition: flvenc.c:84
FLV_CODECID_SCREEN2
@ FLV_CODECID_SCREEN2
Definition: flv.h:109
FLV_FRAME_KEY
@ FLV_FRAME_KEY
key frame (for AVC, a seekable frame)
Definition: flv.h:116
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
FLV_SAMPLERATE_44100HZ
@ FLV_SAMPLERATE_44100HZ
Definition: flv.h:87
FLV_CODECID_VP6
@ FLV_CODECID_VP6
Definition: flv.h:107
put_amf_byte
static void put_amf_byte(AVIOContext *pb, unsigned char abyte)
Definition: flvenc.c:259
FLV_FRAME_INTER
@ FLV_FRAME_INTER
inter frame (for AVC, a non-seekable frame)
Definition: flv.h:117
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:442
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:1023
AVFMT_GLOBALHEADER
#define AVFMT_GLOBALHEADER
Format wants global header.
Definition: avformat.h:478
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c: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:478
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:254
len
int len
Definition: vorbis_enc_data.h:426
FLVContext::metadata_size_pos
int64_t metadata_size_pos
Definition: flvenc.c:96
FLV_SAMPLERATE_11025HZ
@ FLV_SAMPLERATE_11025HZ
Definition: flv.h:85
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
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:489
FLVStreamContext
Definition: flvenc.c:122
tag
uint32_t tag
Definition: movenc.c:1641
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:838
put_amf_dword_array
static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
Definition: flvenc.c:264
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:252
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
pos
unsigned int pos
Definition: spdifenc.c:413
FLV_CODECID_ADPCM
@ FLV_CODECID_ADPCM
Definition: flv.h:92
avformat.h
dict.h
AV_CODEC_ID_TEXT
@ AV_CODEC_ID_TEXT
raw UTF-8 text
Definition: codec_id.h:546
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
flv_deinit
static void flv_deinit(AVFormatContext *s)
Definition: flvenc.c:1035
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_NELLYMOSER_16KHZ_MONO
@ FLV_CODECID_NELLYMOSER_16KHZ_MONO
Definition: flv.h:95
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
put_amf_string
static void put_amf_string(AVIOContext *pb, const char *str)
Definition: flvenc.c:225
AVPacket::stream_index
int stream_index
Definition: packet.h:376
FLVStreamContext::last_ts
int64_t last_ts
last timestamp for each stream
Definition: flvenc.c:123
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:339
avio_wb64
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:452
ff_mpeg4audio_sample_rates
const int ff_mpeg4audio_sample_rates[16]
Definition: mpeg4audio_sample_rates.h:26
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h: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_CODECID_PCM_ALAW
@ FLV_CODECID_PCM_ALAW
Definition: flv.h:98
flv_write_trailer
static int flv_write_trailer(AVFormatContext *s)
Definition: flvenc.c:728
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:476
AMF_DATA_TYPE_NUMBER
@ AMF_DATA_TYPE_NUMBER
Definition: flv.h:124
FLV_HEADER_FLAG_HASVIDEO
@ FLV_HEADER_FLAG_HASVIDEO
Definition: flv.h:55
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
write_metadata
static void write_metadata(AVFormatContext *s, unsigned int ts)
Definition: flvenc.c:276
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:464
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
FLV_CODECID_REALH263
@ FLV_CODECID_REALH263
Definition: flv.h:111
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
options
static const AVOption options[]
Definition: flvenc.c:1049
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3664
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
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
ff_stream_add_bitstream_filter
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: mux.c:1312
flv_write_codec_header
static void flv_write_codec_header(AVFormatContext *s, AVCodecParameters *par, int64_t ts)
Definition: flvenc.c:489
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:42
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:471
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