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 
109 
113 
116  double framerate;
118 
119  int flags;
120 } FLVContext;
121 
122 typedef struct FLVStreamContext {
123  int64_t last_ts; ///< last timestamp for each stream
125 
127 {
130 
131  if (par->codec_id == AV_CODEC_ID_AAC) // specs force these parameters
134  else if (par->codec_id == AV_CODEC_ID_SPEEX) {
135  if (par->sample_rate != 16000) {
137  "FLV only supports wideband (16kHz) Speex audio\n");
138  return AVERROR(EINVAL);
139  }
140  if (par->ch_layout.nb_channels != 1) {
141  av_log(s, AV_LOG_ERROR, "FLV only supports mono Speex audio\n");
142  return AVERROR(EINVAL);
143  }
145  } else {
146  switch (par->sample_rate) {
147  case 48000:
148  // 48khz mp3 is stored with 44k1 samplerate identifer
149  if (par->codec_id == AV_CODEC_ID_MP3) {
151  break;
152  } else {
153  goto error;
154  }
155  case 44100:
157  break;
158  case 22050:
160  break;
161  case 11025:
163  break;
164  case 16000: // nellymoser only
165  case 8000: // nellymoser only
166  case 5512: // not MP3
167  if (par->codec_id != AV_CODEC_ID_MP3) {
169  break;
170  }
171  default:
172 error:
174  "FLV does not support sample rate %d, "
175  "choose from (44100, 22050, 11025)\n", par->sample_rate);
176  return AVERROR(EINVAL);
177  }
178  }
179 
180  if (par->ch_layout.nb_channels > 1)
181  flags |= FLV_STEREO;
182 
183  switch (par->codec_id) {
184  case AV_CODEC_ID_MP3:
186  break;
187  case AV_CODEC_ID_PCM_U8:
189  break;
192  break;
195  break;
198  break;
200  if (par->sample_rate == 8000)
202  else if (par->sample_rate == 16000)
204  else
206  break;
209  break;
212  break;
213  case 0:
214  flags |= par->codec_tag << 4;
215  break;
216  default:
217  av_log(s, AV_LOG_ERROR, "Audio codec '%s' not compatible with FLV\n",
218  avcodec_get_name(par->codec_id));
219  return AVERROR(EINVAL);
220  }
221 
222  return flags;
223 }
224 
225 static void put_amf_string(AVIOContext *pb, const char *str)
226 {
227  size_t len = strlen(str);
228  avio_wb16(pb, len);
229  avio_write(pb, str, len);
230 }
231 
232 // FLV timestamps are 32 bits signed, RTMP timestamps should be 32-bit unsigned
233 static void put_timestamp(AVIOContext *pb, int64_t ts) {
234  avio_wb24(pb, ts & 0xFFFFFF);
235  avio_w8(pb, (ts >> 24) & 0x7F);
236 }
237 
238 static void put_avc_eos_tag(AVIOContext *pb, unsigned ts)
239 {
241  avio_wb24(pb, 5); /* Tag Data Size */
242  put_timestamp(pb, ts);
243  avio_wb24(pb, 0); /* StreamId = 0 */
244  avio_w8(pb, 23); /* ub[4] FrameType = 1, ub[4] CodecId = 7 */
245  avio_w8(pb, 2); /* AVC end of sequence */
246  avio_wb24(pb, 0); /* Always 0 for AVC EOS. */
247  avio_wb32(pb, 16); /* Size of FLV tag */
248 }
249 
250 static void put_amf_double(AVIOContext *pb, double d)
251 {
253  avio_wb64(pb, av_double2int(d));
254 }
255 
256 static void put_amf_byte(AVIOContext *pb, unsigned char abyte)
257 {
258  avio_w8(pb, abyte);
259 }
260 
261 static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
262 {
264  avio_wb32(pb, dw);
265 }
266 
267 static void put_amf_bool(AVIOContext *pb, int b)
268 {
270  avio_w8(pb, !!b);
271 }
272 
273 static void write_metadata(AVFormatContext *s, unsigned int ts)
274 {
275  AVIOContext *pb = s->pb;
276  FLVContext *flv = s->priv_data;
277  int write_duration_filesize = !(flv->flags & FLV_NO_DURATION_FILESIZE);
278  int metadata_count = 0;
279  int64_t metadata_count_pos;
281 
282  /* write meta_tag */
283  avio_w8(pb, FLV_TAG_TYPE_META); // tag type META
284  flv->metadata_size_pos = avio_tell(pb);
285  avio_wb24(pb, 0); // size of data part (sum of all parts below)
286  put_timestamp(pb, ts); // timestamp
287  avio_wb24(pb, 0); // reserved
288 
289  /* now data of data_size size */
290 
291  /* first event name as a string */
293  put_amf_string(pb, "onMetaData"); // 12 bytes
294 
295  /* mixed array (hash) with size and string/type/data tuples */
297  metadata_count_pos = avio_tell(pb);
298  metadata_count = 4 * !!flv->video_par +
299  5 * !!flv->audio_par +
300  1 * !!flv->data_par;
301  if (write_duration_filesize) {
302  metadata_count += 2; // +2 for duration and file size
303  }
304  avio_wb32(pb, metadata_count);
305 
306  if (write_duration_filesize) {
307  put_amf_string(pb, "duration");
308  flv->duration_offset = avio_tell(pb);
309  // fill in the guessed duration, it'll be corrected later if incorrect
310  put_amf_double(pb, s->duration / AV_TIME_BASE);
311  }
312 
313  if (flv->video_par) {
314  put_amf_string(pb, "width");
315  put_amf_double(pb, flv->video_par->width);
316 
317  put_amf_string(pb, "height");
318  put_amf_double(pb, flv->video_par->height);
319 
320  put_amf_string(pb, "videodatarate");
321  put_amf_double(pb, flv->video_par->bit_rate / 1024.0);
322 
323  if (flv->framerate != 0.0) {
324  put_amf_string(pb, "framerate");
325  put_amf_double(pb, flv->framerate);
326  metadata_count++;
327  }
328 
329  put_amf_string(pb, "videocodecid");
331  }
332 
333  if (flv->audio_par) {
334  put_amf_string(pb, "audiodatarate");
335  put_amf_double(pb, flv->audio_par->bit_rate / 1024.0);
336 
337  put_amf_string(pb, "audiosamplerate");
339 
340  put_amf_string(pb, "audiosamplesize");
341  put_amf_double(pb, flv->audio_par->codec_id == AV_CODEC_ID_PCM_U8 ? 8 : 16);
342 
343  put_amf_string(pb, "stereo");
345 
346  put_amf_string(pb, "audiocodecid");
348  }
349 
350  if (flv->data_par) {
351  put_amf_string(pb, "datastream");
352  put_amf_double(pb, 0.0);
353  }
354 
356  while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
357  if( !strcmp(tag->key, "width")
358  ||!strcmp(tag->key, "height")
359  ||!strcmp(tag->key, "videodatarate")
360  ||!strcmp(tag->key, "framerate")
361  ||!strcmp(tag->key, "videocodecid")
362  ||!strcmp(tag->key, "audiodatarate")
363  ||!strcmp(tag->key, "audiosamplerate")
364  ||!strcmp(tag->key, "audiosamplesize")
365  ||!strcmp(tag->key, "stereo")
366  ||!strcmp(tag->key, "audiocodecid")
367  ||!strcmp(tag->key, "duration")
368  ||!strcmp(tag->key, "onMetaData")
369  ||!strcmp(tag->key, "datasize")
370  ||!strcmp(tag->key, "lasttimestamp")
371  ||!strcmp(tag->key, "totalframes")
372  ||!strcmp(tag->key, "hasAudio")
373  ||!strcmp(tag->key, "hasVideo")
374  ||!strcmp(tag->key, "hasCuePoints")
375  ||!strcmp(tag->key, "hasMetadata")
376  ||!strcmp(tag->key, "hasKeyframes")
377  ){
378  av_log(s, AV_LOG_DEBUG, "Ignoring metadata for %s\n", tag->key);
379  continue;
380  }
381  put_amf_string(pb, tag->key);
383  put_amf_string(pb, tag->value);
384  metadata_count++;
385  }
386 
387  if (write_duration_filesize) {
388  put_amf_string(pb, "filesize");
389  flv->filesize_offset = avio_tell(pb);
390  put_amf_double(pb, 0); // delayed write
391  }
392 
393  if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
394  flv->acurframeindex = 0;
395  flv->keyframe_index_size = 0;
396 
397  put_amf_string(pb, "hasVideo");
398  put_amf_bool(pb, !!flv->video_par);
399  metadata_count++;
400 
401  put_amf_string(pb, "hasKeyframes");
402  put_amf_bool(pb, 1);
403  metadata_count++;
404 
405  put_amf_string(pb, "hasAudio");
406  put_amf_bool(pb, !!flv->audio_par);
407  metadata_count++;
408 
409  put_amf_string(pb, "hasMetadata");
410  put_amf_bool(pb, 1);
411  metadata_count++;
412 
413  put_amf_string(pb, "canSeekToEnd");
414  put_amf_bool(pb, 1);
415  metadata_count++;
416 
417  put_amf_string(pb, "datasize");
418  flv->datasize_offset = avio_tell(pb);
419  flv->datasize = 0;
420  put_amf_double(pb, flv->datasize);
421  metadata_count++;
422 
423  put_amf_string(pb, "videosize");
424  flv->videosize_offset = avio_tell(pb);
425  flv->videosize = 0;
426  put_amf_double(pb, flv->videosize);
427  metadata_count++;
428 
429  put_amf_string(pb, "audiosize");
430  flv->audiosize_offset = avio_tell(pb);
431  flv->audiosize = 0;
432  put_amf_double(pb, flv->audiosize);
433  metadata_count++;
434 
435  put_amf_string(pb, "lasttimestamp");
436  flv->lasttimestamp_offset = avio_tell(pb);
437  flv->lasttimestamp = 0;
438  put_amf_double(pb, 0);
439  metadata_count++;
440 
441  put_amf_string(pb, "lastkeyframetimestamp");
443  flv->lastkeyframetimestamp = 0;
444  put_amf_double(pb, 0);
445  metadata_count++;
446 
447  put_amf_string(pb, "lastkeyframelocation");
449  flv->lastkeyframelocation = 0;
450  put_amf_double(pb, 0);
451  metadata_count++;
452 
453  put_amf_string(pb, "keyframes");
455  metadata_count++;
456 
457  flv->keyframes_info_offset = avio_tell(pb);
458  }
459 
460  put_amf_string(pb, "");
462 
463  /* write total size of tag */
464  flv->metadata_totalsize = avio_tell(pb) - flv->metadata_size_pos - 10;
465 
466  avio_seek(pb, metadata_count_pos, SEEK_SET);
467  avio_wb32(pb, metadata_count);
468 
469  avio_seek(pb, flv->metadata_size_pos, SEEK_SET);
470  avio_wb24(pb, flv->metadata_totalsize);
471  avio_skip(pb, flv->metadata_totalsize + 10 - 3);
473  avio_wb32(pb, flv->metadata_totalsize + 11);
474 }
475 
477  const char* type, int codec_id)
478 {
481  "%s codec %s not compatible with flv\n",
482  type,
483  desc ? desc->name : "unknown");
484  return AVERROR(ENOSYS);
485 }
486 
488  int64_t data_size;
489  AVIOContext *pb = s->pb;
490  FLVContext *flv = s->priv_data;
491 
492  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
493  || par->codec_id == AV_CODEC_ID_MPEG4) {
494  int64_t pos;
495  avio_w8(pb,
498  avio_wb24(pb, 0); // size patched later
499  put_timestamp(pb, ts);
500  avio_wb24(pb, 0); // streamid
501  pos = avio_tell(pb);
502  if (par->codec_id == AV_CODEC_ID_AAC) {
503  avio_w8(pb, get_audio_flags(s, par));
504  avio_w8(pb, 0); // AAC sequence header
505 
506  if (!par->extradata_size && (flv->flags & FLV_AAC_SEQ_HEADER_DETECT)) {
507  PutBitContext pbc;
508  int samplerate_index;
510  - (flv->audio_par->ch_layout.nb_channels == 8 ? 1 : 0);
511  uint8_t data[2];
512 
513  for (samplerate_index = 0; samplerate_index < 16;
514  samplerate_index++)
515  if (flv->audio_par->sample_rate
516  == ff_mpeg4audio_sample_rates[samplerate_index])
517  break;
518 
519  init_put_bits(&pbc, data, sizeof(data));
520  put_bits(&pbc, 5, flv->audio_par->profile + 1); //profile
521  put_bits(&pbc, 4, samplerate_index); //sample rate index
522  put_bits(&pbc, 4, channels);
523  put_bits(&pbc, 1, 0); //frame length - 1024 samples
524  put_bits(&pbc, 1, 0); //does not depend on core coder
525  put_bits(&pbc, 1, 0); //is not extension
526  flush_put_bits(&pbc);
527 
528  avio_w8(pb, data[0]);
529  avio_w8(pb, data[1]);
530 
531  av_log(s, AV_LOG_WARNING, "AAC sequence header: %02x %02x.\n",
532  data[0], data[1]);
533  }
534  avio_write(pb, par->extradata, par->extradata_size);
535  } else {
536  avio_w8(pb, par->codec_tag | FLV_FRAME_KEY); // flags
537  avio_w8(pb, 0); // AVC sequence header
538  avio_wb24(pb, 0); // composition time
540  }
541  data_size = avio_tell(pb) - pos;
542  avio_seek(pb, -data_size - 10, SEEK_CUR);
543  avio_wb24(pb, data_size);
544  avio_skip(pb, data_size + 10 - 3);
545  avio_wb32(pb, data_size + 11); // previous tag size
546  }
547 }
548 
549 static int flv_append_keyframe_info(AVFormatContext *s, FLVContext *flv, double ts, int64_t pos)
550 {
551  FLVFileposition *position = av_malloc(sizeof(FLVFileposition));
552 
553  if (!position) {
554  av_log(s, AV_LOG_WARNING, "no mem for add keyframe index!\n");
555  return AVERROR(ENOMEM);
556  }
557 
558  position->keyframe_timestamp = ts;
559  position->keyframe_position = pos;
560 
561  if (!flv->filepositions_count) {
562  flv->filepositions = position;
563  flv->head_filepositions = flv->filepositions;
564  position->next = NULL;
565  } else {
566  flv->filepositions->next = position;
567  position->next = NULL;
568  flv->filepositions = flv->filepositions->next;
569  }
570 
571  flv->filepositions_count++;
572 
573  return 0;
574 }
575 
577 {
578  int ret;
579  int64_t metadata_size = 0;
580  FLVContext *flv = s->priv_data;
581 
582  metadata_size = flv->filepositions_count * 9 * 2 + 10; /* filepositions and times value */
583  metadata_size += 2 + 13; /* filepositions String */
584  metadata_size += 2 + 5; /* times String */
585  metadata_size += 3; /* Object end */
586 
587  flv->keyframe_index_size = metadata_size;
588 
589  if (metadata_size < 0)
590  return metadata_size;
591 
592  ret = ff_format_shift_data(s, flv->keyframes_info_offset, metadata_size);
593  if (ret < 0)
594  return ret;
595 
596  avio_seek(s->pb, flv->metadata_size_pos, SEEK_SET);
597  avio_wb24(s->pb, flv->metadata_totalsize + metadata_size);
598 
599  avio_seek(s->pb, flv->metadata_totalsize_pos + metadata_size, SEEK_SET);
600  avio_wb32(s->pb, flv->metadata_totalsize + 11 + metadata_size);
601 
602  return 0;
603 }
604 
605 static int flv_init(struct AVFormatContext *s)
606 {
607  int i;
608  FLVContext *flv = s->priv_data;
609 
610  for (i = 0; i < s->nb_streams; i++) {
611  AVCodecParameters *par = s->streams[i]->codecpar;
612  FLVStreamContext *sc;
613  switch (par->codec_type) {
614  case AVMEDIA_TYPE_VIDEO:
615  if (s->streams[i]->avg_frame_rate.den &&
616  s->streams[i]->avg_frame_rate.num) {
617  flv->framerate = av_q2d(s->streams[i]->avg_frame_rate);
618  }
619  if (flv->video_par) {
621  "at most one video stream is supported in flv\n");
622  return AVERROR(EINVAL);
623  }
624  flv->video_par = par;
626  return unsupported_codec(s, "Video", par->codec_id);
627 
628  if (par->codec_id == AV_CODEC_ID_MPEG4 ||
629  par->codec_id == AV_CODEC_ID_H263) {
630  int error = s->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL;
632  "Codec %s is not supported in the official FLV specification,\n", avcodec_get_name(par->codec_id));
633 
634  if (error) {
636  "use vstrict=-1 / -strict -1 to use it anyway.\n");
637  return AVERROR(EINVAL);
638  }
639  } else if (par->codec_id == AV_CODEC_ID_VP6) {
641  "Muxing VP6 in flv will produce flipped video on playback.\n");
642  }
643  break;
644  case AVMEDIA_TYPE_AUDIO:
645  if (flv->audio_par) {
647  "at most one audio stream is supported in flv\n");
648  return AVERROR(EINVAL);
649  }
650  flv->audio_par = par;
651  if (get_audio_flags(s, par) < 0)
652  return unsupported_codec(s, "Audio", par->codec_id);
653  if (par->codec_id == AV_CODEC_ID_PCM_S16BE)
655  "16-bit big-endian audio in flv is valid but most likely unplayable (hardware dependent); use s16le\n");
656  break;
657  case AVMEDIA_TYPE_DATA:
658  if (par->codec_id != AV_CODEC_ID_TEXT && par->codec_id != AV_CODEC_ID_NONE)
659  return unsupported_codec(s, "Data", par->codec_id);
660  flv->data_par = par;
661  break;
663  if (par->codec_id != AV_CODEC_ID_TEXT) {
664  av_log(s, AV_LOG_ERROR, "Subtitle codec '%s' for stream %d is not compatible with FLV\n",
665  avcodec_get_name(par->codec_id), i);
666  return AVERROR_INVALIDDATA;
667  }
668  flv->data_par = par;
669  break;
670  default:
671  av_log(s, AV_LOG_ERROR, "Codec type '%s' for stream %d is not compatible with FLV\n",
673  return AVERROR(EINVAL);
674  }
675  avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */
676 
677  sc = av_mallocz(sizeof(FLVStreamContext));
678  if (!sc)
679  return AVERROR(ENOMEM);
680  s->streams[i]->priv_data = sc;
681  sc->last_ts = -1;
682  }
683 
684  flv->delay = AV_NOPTS_VALUE;
685 
686  return 0;
687 }
688 
690 {
691  int i;
692  AVIOContext *pb = s->pb;
693  FLVContext *flv = s->priv_data;
694 
695  avio_write(pb, "FLV", 3);
696  avio_w8(pb, 1);
699  avio_wb32(pb, 9);
700  avio_wb32(pb, 0);
701 
702  for (i = 0; i < s->nb_streams; i++)
703  if (s->streams[i]->codecpar->codec_tag == 5) {
704  avio_w8(pb, 8); // message type
705  avio_wb24(pb, 0); // include flags
706  avio_wb24(pb, 0); // time stamp
707  avio_wb32(pb, 0); // reserved
708  avio_wb32(pb, 11); // size
709  flv->reserved = 5;
710  }
711 
712  if (flv->flags & FLV_NO_METADATA) {
713  pb->seekable = 0;
714  } else {
715  write_metadata(s, 0);
716  }
717 
718  for (i = 0; i < s->nb_streams; i++) {
719  flv_write_codec_header(s, s->streams[i]->codecpar, 0);
720  }
721 
722  flv->datastart_offset = avio_tell(pb);
723  return 0;
724 }
725 
727 {
728  int64_t file_size;
729  AVIOContext *pb = s->pb;
730  FLVContext *flv = s->priv_data;
731  int build_keyframes_idx = flv->flags & FLV_ADD_KEYFRAME_INDEX;
732  int i, res;
733  int64_t cur_pos = avio_tell(s->pb);
734 
735  if (build_keyframes_idx) {
736  FLVFileposition *newflv_posinfo, *p;
737 
738  avio_seek(pb, flv->videosize_offset, SEEK_SET);
739  put_amf_double(pb, flv->videosize);
740 
741  avio_seek(pb, flv->audiosize_offset, SEEK_SET);
742  put_amf_double(pb, flv->audiosize);
743 
744  avio_seek(pb, flv->lasttimestamp_offset, SEEK_SET);
745  put_amf_double(pb, flv->lasttimestamp);
746 
747  avio_seek(pb, flv->lastkeyframetimestamp_offset, SEEK_SET);
749 
750  avio_seek(pb, flv->lastkeyframelocation_offset, SEEK_SET);
752  avio_seek(pb, cur_pos, SEEK_SET);
753 
754  res = shift_data(s);
755  if (res < 0) {
756  goto end;
757  }
758  avio_seek(pb, flv->keyframes_info_offset, SEEK_SET);
759  put_amf_string(pb, "filepositions");
761  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
762  put_amf_double(pb, newflv_posinfo->keyframe_position + flv->keyframe_index_size);
763  }
764 
765  put_amf_string(pb, "times");
767  for (newflv_posinfo = flv->head_filepositions; newflv_posinfo; newflv_posinfo = newflv_posinfo->next) {
768  put_amf_double(pb, newflv_posinfo->keyframe_timestamp);
769  }
770 
771  newflv_posinfo = flv->head_filepositions;
772  while (newflv_posinfo) {
773  p = newflv_posinfo->next;
774  if (p) {
775  newflv_posinfo->next = p->next;
776  av_free(p);
777  p = NULL;
778  } else {
779  av_free(newflv_posinfo);
780  newflv_posinfo = NULL;
781  }
782  }
783 
784  put_amf_string(pb, "");
786 
787  avio_seek(pb, cur_pos + flv->keyframe_index_size, SEEK_SET);
788  }
789 
790 end:
791  if (flv->flags & FLV_NO_SEQUENCE_END) {
792  av_log(s, AV_LOG_DEBUG, "FLV no sequence end mode open\n");
793  } else {
794  /* Add EOS tag */
795  for (i = 0; i < s->nb_streams; i++) {
796  AVCodecParameters *par = s->streams[i]->codecpar;
797  FLVStreamContext *sc = s->streams[i]->priv_data;
798  if (par->codec_type == AVMEDIA_TYPE_VIDEO &&
800  put_avc_eos_tag(pb, sc->last_ts);
801  }
802  }
803 
804  file_size = avio_tell(pb);
805 
806  if (build_keyframes_idx) {
807  flv->datasize = file_size - flv->datastart_offset;
808  avio_seek(pb, flv->datasize_offset, SEEK_SET);
809  put_amf_double(pb, flv->datasize);
810  }
811  if (!(flv->flags & FLV_NO_METADATA)) {
812  if (!(flv->flags & FLV_NO_DURATION_FILESIZE)) {
813  /* update information */
814  if (avio_seek(pb, flv->duration_offset, SEEK_SET) < 0) {
815  av_log(s, AV_LOG_WARNING, "Failed to update header with correct duration.\n");
816  } else {
817  put_amf_double(pb, flv->duration / (double)1000);
818  }
819  if (avio_seek(pb, flv->filesize_offset, SEEK_SET) < 0) {
820  av_log(s, AV_LOG_WARNING, "Failed to update header with correct filesize.\n");
821  } else {
822  put_amf_double(pb, file_size);
823  }
824  }
825  }
826 
827  return 0;
828 }
829 
831 {
832  AVIOContext *pb = s->pb;
833  AVCodecParameters *par = s->streams[pkt->stream_index]->codecpar;
834  FLVContext *flv = s->priv_data;
835  FLVStreamContext *sc = s->streams[pkt->stream_index]->priv_data;
836  unsigned ts;
837  int size = pkt->size;
838  uint8_t *data = NULL;
839  int flags = -1, flags_size, ret = 0;
840  int64_t cur_offset = avio_tell(pb);
841 
842  if (par->codec_type == AVMEDIA_TYPE_AUDIO && !pkt->size) {
843  av_log(s, AV_LOG_WARNING, "Empty audio Packet\n");
844  return AVERROR(EINVAL);
845  }
846 
847  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A ||
849  flags_size = 2;
850  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4)
851  flags_size = 5;
852  else
853  flags_size = 1;
854 
855  if (par->codec_id == AV_CODEC_ID_AAC || par->codec_id == AV_CODEC_ID_H264
856  || par->codec_id == AV_CODEC_ID_MPEG4) {
857  size_t side_size;
858  uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
859  if (side && side_size > 0 && (side_size != par->extradata_size || memcmp(side, par->extradata, side_size))) {
860  ret = ff_alloc_extradata(par, side_size);
861  if (ret < 0)
862  return ret;
863  memcpy(par->extradata, side, side_size);
865  }
866  }
867 
868  if (flv->delay == AV_NOPTS_VALUE)
869  flv->delay = -pkt->dts;
870 
871  if (pkt->dts < -flv->delay) {
873  "Packets are not in the proper order with respect to DTS\n");
874  return AVERROR(EINVAL);
875  }
876  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
877  if (pkt->pts == AV_NOPTS_VALUE) {
878  av_log(s, AV_LOG_ERROR, "Packet is missing PTS\n");
879  return AVERROR(EINVAL);
880  }
881  }
882 
883  ts = pkt->dts;
884 
885  if (s->event_flags & AVSTREAM_EVENT_FLAG_METADATA_UPDATED) {
886  write_metadata(s, ts);
887  s->event_flags &= ~AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
888  }
889 
892 
893  switch (par->codec_type) {
894  case AVMEDIA_TYPE_VIDEO:
896 
898 
900  break;
901  case AVMEDIA_TYPE_AUDIO:
902  flags = get_audio_flags(s, par);
903 
904  av_assert0(size);
905 
907  break;
909  case AVMEDIA_TYPE_DATA:
911  break;
912  default:
913  return AVERROR(EINVAL);
914  }
915 
916  if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
917  /* check if extradata looks like mp4 formatted */
918  if (par->extradata_size > 0 && *(uint8_t*)par->extradata != 1)
919  if ((ret = ff_avc_parse_nal_units_buf(pkt->data, &data, &size)) < 0)
920  return ret;
921  } else if (par->codec_id == AV_CODEC_ID_AAC && pkt->size > 2 &&
922  (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
923  if (!s->streams[pkt->stream_index]->nb_frames) {
924  av_log(s, AV_LOG_ERROR, "Malformed AAC bitstream detected: "
925  "use the audio bitstream filter 'aac_adtstoasc' to fix it "
926  "('-bsf:a aac_adtstoasc' option with ffmpeg)\n");
927  return AVERROR_INVALIDDATA;
928  }
929  av_log(s, AV_LOG_WARNING, "aac bitstream error\n");
930  }
931 
932  /* check Speex packet duration */
933  if (par->codec_id == AV_CODEC_ID_SPEEX && ts - sc->last_ts > 160)
934  av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
935  "8 frames per packet. Adobe Flash "
936  "Player cannot handle this!\n");
937 
938  if (sc->last_ts < ts)
939  sc->last_ts = ts;
940 
941  if (size + flags_size >= 1<<24) {
942  av_log(s, AV_LOG_ERROR, "Too large packet with size %u >= %u\n",
943  size + flags_size, 1<<24);
944  ret = AVERROR(EINVAL);
945  goto fail;
946  }
947 
948  avio_wb24(pb, size + flags_size);
949  put_timestamp(pb, ts);
950  avio_wb24(pb, flv->reserved);
951 
952  if (par->codec_type == AVMEDIA_TYPE_DATA ||
954  int data_size;
955  int64_t metadata_size_pos = avio_tell(pb);
956  if (par->codec_id == AV_CODEC_ID_TEXT) {
957  // legacy FFmpeg magic?
959  put_amf_string(pb, "onTextData");
961  avio_wb32(pb, 2);
962  put_amf_string(pb, "type");
964  put_amf_string(pb, "Text");
965  put_amf_string(pb, "text");
967  put_amf_string(pb, pkt->data);
968  put_amf_string(pb, "");
970  } else {
971  // just pass the metadata through
972  avio_write(pb, data ? data : pkt->data, size);
973  }
974  /* write total size of tag */
975  data_size = avio_tell(pb) - metadata_size_pos;
976  avio_seek(pb, metadata_size_pos - 10, SEEK_SET);
977  avio_wb24(pb, data_size);
978  avio_seek(pb, data_size + 10 - 3, SEEK_CUR);
979  avio_wb32(pb, data_size + 11);
980  } else {
981  av_assert1(flags>=0);
982  avio_w8(pb,flags);
983  if (par->codec_id == AV_CODEC_ID_VP6)
984  avio_w8(pb,0);
985  if (par->codec_id == AV_CODEC_ID_VP6F || par->codec_id == AV_CODEC_ID_VP6A) {
986  if (par->extradata_size)
987  avio_w8(pb, par->extradata[0]);
988  else
989  avio_w8(pb, ((FFALIGN(par->width, 16) - par->width) << 4) |
990  (FFALIGN(par->height, 16) - par->height));
991  } else if (par->codec_id == AV_CODEC_ID_AAC)
992  avio_w8(pb, 1); // AAC raw
993  else if (par->codec_id == AV_CODEC_ID_H264 || par->codec_id == AV_CODEC_ID_MPEG4) {
994  avio_w8(pb, 1); // AVC NALU
995  avio_wb24(pb, pkt->pts - pkt->dts);
996  }
997 
998  avio_write(pb, data ? data : pkt->data, size);
999 
1000  avio_wb32(pb, size + flags_size + 11); // previous tag size
1001  flv->duration = FFMAX(flv->duration,
1002  pkt->pts + flv->delay + pkt->duration);
1003  }
1004 
1005  if (flv->flags & FLV_ADD_KEYFRAME_INDEX) {
1006  switch (par->codec_type) {
1007  case AVMEDIA_TYPE_VIDEO:
1008  flv->videosize += (avio_tell(pb) - cur_offset);
1009  flv->lasttimestamp = flv->acurframeindex / flv->framerate;
1010  flv->acurframeindex++;
1011  if (pkt->flags & AV_PKT_FLAG_KEY) {
1012  double ts = flv->lasttimestamp;
1013  int64_t pos = cur_offset;
1014 
1015  flv->lastkeyframetimestamp = ts;
1016  flv->lastkeyframelocation = pos;
1017  ret = flv_append_keyframe_info(s, flv, ts, pos);
1018  if (ret < 0)
1019  goto fail;
1020  }
1021  break;
1022 
1023  case AVMEDIA_TYPE_AUDIO:
1024  flv->audiosize += (avio_tell(pb) - cur_offset);
1025  break;
1026 
1027  default:
1028  av_log(s, AV_LOG_WARNING, "par->codec_type is type = [%d]\n", par->codec_type);
1029  break;
1030  }
1031  }
1032 fail:
1033  av_free(data);
1034 
1035  return ret;
1036 }
1037 
1039  const AVPacket *pkt)
1040 {
1041  int ret = 1;
1042 
1043  if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
1044  if (pkt->size > 2 && (AV_RB16(pkt->data) & 0xfff0) == 0xfff0)
1045  ret = ff_stream_add_bitstream_filter(st, "aac_adtstoasc", NULL);
1046  }
1047  return ret;
1048 }
1049 
1050 static const AVOption options[] = {
1051  { "flvflags", "FLV muxer flags", offsetof(FLVContext, flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "flvflags" },
1052  { "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" },
1053  { "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" },
1054  { "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" },
1055  { "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" },
1056  { "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" },
1057  { NULL },
1058 };
1059 
1060 static const AVClass flv_muxer_class = {
1061  .class_name = "flv muxer",
1062  .item_name = av_default_item_name,
1063  .option = options,
1064  .version = LIBAVUTIL_VERSION_INT,
1065 };
1066 
1068  .name = "flv",
1069  .long_name = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1070  .mime_type = "video/x-flv",
1071  .extensions = "flv",
1072  .priv_data_size = sizeof(FLVContext),
1073  .audio_codec = CONFIG_LIBMP3LAME ? AV_CODEC_ID_MP3 : AV_CODEC_ID_ADPCM_SWF,
1074  .video_codec = AV_CODEC_ID_FLV1,
1075  .init = flv_init,
1080  .codec_tag = (const AVCodecTag* const []) {
1082  },
1085  .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:316
FLVContext::metadata_totalsize
int64_t metadata_totalsize
Definition: flvenc.c:97
FLVContext::audio_par
AVCodecParameters * audio_par
Definition: flvenc.c:114
AMF_END_OF_OBJECT
#define AMF_END_OF_OBJECT
Definition: flv.h:47
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_CODEC_ID_VP6F
@ AV_CODEC_ID_VP6F
Definition: codec_id.h: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:1067
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_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:238
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
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: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
FLV_HEADER_FLAG_HASAUDIO
@ FLV_HEADER_FLAG_HASAUDIO
Definition: flv.h:56
FLVContext::acurframeindex
int acurframeindex
Definition: flvenc.c:107
FLV_CODECID_H264
@ FLV_CODECID_H264
Definition: flv.h:110
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
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:96
AV_CODEC_ID_VP6
@ AV_CODEC_ID_VP6
Definition: codec_id.h:141
FLV_CODECID_SCREEN
@ FLV_CODECID_SCREEN
Definition: flv.h:106
AVOption
AVOption.
Definition: opt.h:251
b
#define b
Definition: input.c:34
data
const char data[16]
Definition: mxf.c:143
FLV_CODECID_SCREEN2
@ FLV_CODECID_SCREEN2
Definition: flv.h:109
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
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
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:267
AMF_DATA_TYPE_OBJECT
@ AMF_DATA_TYPE_OBJECT
Definition: flv.h:127
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1304
FLVContext::lasttimestamp_offset
int64_t lasttimestamp_offset
Definition: flvenc.c:100
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
FLV_SAMPLERATE_SPECIAL
@ FLV_SAMPLERATE_SPECIAL
signifies 5512Hz and 8000Hz in the case of NELLYMOSER
Definition: flv.h:84
init
static int init
Definition: av_tx.c:47
FLV_CODECID_SPEEX
@ FLV_CODECID_SPEEX
Definition: flv.h:101
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:549
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
FLV_CODECID_PCM_ALAW
@ FLV_CODECID_PCM_ALAW
Definition: flv.h:98
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:460
flv_write_packet
static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: flvenc.c:830
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:317
fail
#define fail()
Definition: checkasm.h:130
FLVContext::lastkeyframetimestamp
double lastkeyframetimestamp
Definition: flvenc.c:103
put_amf_double
static void put_amf_double(AVIOContext *pb, double d)
Definition: flvenc.c:250
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:505
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:426
FLV_AUDIO_CODECID_OFFSET
#define FLV_AUDIO_CODECID_OFFSET
Definition: flv.h:34
FLV_CODECID_AAC
@ FLV_CODECID_AAC
Definition: flv.h:100
FLVContext::duration
int64_t duration
Definition: flvenc.c:84
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
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: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_CODECID_MP3
@ FLV_CODECID_MP3
Definition: flv.h:93
flv_write_header
static int flv_write_header(AVFormatContext *s)
Definition: flvenc.c:689
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_SAMPLERATE_22050HZ
@ FLV_SAMPLERATE_22050HZ
Definition: flv.h:86
FLV_SAMPLESSIZE_16BIT
@ FLV_SAMPLESSIZE_16BIT
Definition: flv.h:80
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:322
FLVContext::audiosize
int64_t audiosize
Definition: flvenc.c:93
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:371
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
FLVContext::head_filepositions
FLVFileposition * head_filepositions
Definition: flvenc.c:112
ff_format_shift_data
int ff_format_shift_data(AVFormatContext *s, int64_t read_start, int shift_size)
Make shift_size amount of space at read_start by shifting data in the output at read_start until the ...
Definition: mux_utils.c: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:116
AVFormatContext
Format I/O context.
Definition: avformat.h:1213
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:323
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
FLV_CODECID_MPEG4
@ FLV_CODECID_MPEG4
Definition: flv.h:112
FLVContext::datasize_offset
int64_t datasize_offset
Definition: flvenc.c:88
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:100
FLV_SAMPLESSIZE_8BIT
@ FLV_SAMPLESSIZE_8BIT
Definition: flv.h:79
FLV_ADD_KEYFRAME_INDEX
@ FLV_ADD_KEYFRAME_INDEX
Definition: flvenc.c:68
AMF_DATA_TYPE_BOOL
@ AMF_DATA_TYPE_BOOL
Definition: flv.h:125
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
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_CODECID_PCM
@ FLV_CODECID_PCM
Definition: flv.h:91
FLV_CODECID_NELLYMOSER_8KHZ_MONO
@ FLV_CODECID_NELLYMOSER_8KHZ_MONO
Definition: flv.h:96
flv.h
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:210
AMF_DATA_TYPE_ARRAY
@ AMF_DATA_TYPE_ARRAY
Definition: flv.h:133
AV_CODEC_ID_FLASHSV
@ AV_CODEC_ID_FLASHSV
Definition: codec_id.h:136
FLV_CODECID_NELLYMOSER
@ FLV_CODECID_NELLYMOSER
Definition: flv.h:97
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
AVSTREAM_EVENT_FLAG_METADATA_UPDATED
#define AVSTREAM_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:1081
FLV_CODECID_H263
@ FLV_CODECID_H263
Definition: flv.h:105
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:108
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:427
FLV_HEADER_FLAG_HASVIDEO
@ FLV_HEADER_FLAG_HASVIDEO
Definition: flv.h:55
AVIOContext
Bytestream IO Context.
Definition: avio.h:162
flv_muxer_class
static const AVClass flv_muxer_class
Definition: flvenc.c:1060
AVPacket::size
int size
Definition: packet.h:375
flv_init
static int flv_init(struct AVFormatContext *s)
Definition: flvenc.c:605
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:116
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:576
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:368
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:126
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:117
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:256
flv_video_codec_ids
static const AVCodecTag flv_video_codec_ids[]
Definition: flvenc.c:38
FLV_FRAME_KEY
@ FLV_FRAME_KEY
key frame (for AVC, a seekable frame)
Definition: flv.h:116
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:1038
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:271
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:476
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
FLV_CODECID_VP6A
@ FLV_CODECID_VP6A
Definition: flv.h:108
FLV_CODECID_NELLYMOSER_16KHZ_MONO
@ FLV_CODECID_NELLYMOSER_16KHZ_MONO
Definition: flv.h:95
AMF_DATA_TYPE_MIXEDARRAY
@ AMF_DATA_TYPE_MIXEDARRAY
Definition: flv.h:131
AMF_DATA_TYPE_STRING
@ AMF_DATA_TYPE_STRING
Definition: flv.h:126
put_timestamp
static void put_timestamp(AVIOContext *pb, int64_t ts)
Definition: flvenc.c:233
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:491
FLVStreamContext
Definition: flvenc.c:122
tag
uint32_t tag
Definition: movenc.c:1630
FLV_CODECID_PCM_MULAW
@ FLV_CODECID_PCM_MULAW
Definition: flv.h:99
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:948
put_amf_dword_array
static void put_amf_dword_array(AVIOContext *pb, uint32_t dw)
Definition: flvenc.c:261
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c: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:527
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_CODECID_REALH263
@ FLV_CODECID_REALH263
Definition: flv.h:111
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
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_FRAME_INTER
@ FLV_FRAME_INTER
inter frame (for AVC, a non-seekable frame)
Definition: flv.h:117
FLV_CODECID_ADPCM
@ FLV_CODECID_ADPCM
Definition: flv.h:92
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:347
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
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
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:321
flv_write_trailer
static int flv_write_trailer(AVFormatContext *s)
Definition: flvenc.c:726
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
FLV_STEREO
@ FLV_STEREO
Definition: flv.h:75
write_metadata
static void write_metadata(AVFormatContext *s, unsigned int ts)
Definition: flvenc.c:273
FLV_CODECID_VP6
@ FLV_CODECID_VP6
Definition: flv.h:107
d
d
Definition: ffmpeg_filter.c:153
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: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
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
options
static const AVOption options[]
Definition: flvenc.c:1050
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3545
FLV_SAMPLERATE_44100HZ
@ FLV_SAMPLERATE_44100HZ
Definition: flv.h:87
write_packet
static int write_packet(AVFormatContext *s1, AVPacket *pkt)
Definition: v4l2enc.c:92
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:347
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
flv_write_codec_header
static void flv_write_codec_header(AVFormatContext *s, AVCodecParameters *par, int64_t ts)
Definition: flvenc.c:487
FLV_CODECID_PCM_LE
@ FLV_CODECID_PCM_LE
Definition: flv.h:94
FLV_SAMPLERATE_11025HZ
@ FLV_SAMPLERATE_11025HZ
Definition: flv.h:85
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:458
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