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