FFmpeg
flvdec.c
Go to the documentation of this file.
1 /*
2  * FLV demuxer
3  * Copyright (c) 2003 The FFmpeg Project
4  *
5  * This demuxer will generate a 1 byte extradata for VP6F content.
6  * It is composed of:
7  * - upper 4 bits: difference between encoded width and visible width
8  * - lower 4 bits: difference between encoded height and visible height
9  *
10  * This file is part of FFmpeg.
11  *
12  * FFmpeg is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2.1 of the License, or (at your option) any later version.
16  *
17  * FFmpeg is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with FFmpeg; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25  */
26 
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
30 #include "libavutil/dict.h"
32 #include "libavutil/mem.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/internal.h"
35 #include "libavutil/intfloat.h"
36 #include "libavutil/intreadwrite.h"
38 #include "avformat.h"
39 #include "demux.h"
40 #include "internal.h"
41 #include "flv.h"
42 
43 #define VALIDATE_INDEX_TS_THRESH 2500
44 
45 #define RESYNC_BUFFER_SIZE (1<<20)
46 
47 #define MAX_DEPTH 16 ///< arbitrary limit to prevent unbounded recursion
48 
49 typedef struct FLVMasteringMeta {
50  double r_x;
51  double r_y;
52  double g_x;
53  double g_y;
54  double b_x;
55  double b_y;
56  double white_x;
57  double white_y;
58  double max_luminance;
59  double min_luminance;
61 
62 typedef struct FLVMetaVideoColor {
65  uint64_t primaries;
66  uint64_t max_cll;
67  uint64_t max_fall;
70 
71 typedef struct FLVContext {
72  const AVClass *class; ///< Class for private options.
73  int trust_metadata; ///< configure streams according onMetaData
74  int trust_datasize; ///< trust data size of FLVTag
75  int dump_full_metadata; ///< Dump full metadata of the onMetadata
76  int wrong_dts; ///< wrong dts due to negative cts
81  struct {
82  int64_t dts;
83  int64_t pos;
84  } validate_index[2];
88 
90 
93 
96  int64_t video_bit_rate;
97  int64_t audio_bit_rate;
98  int64_t *keyframe_times;
102  int64_t last_ts;
103  int64_t time_offset;
104  int64_t time_pos;
105 
108 } FLVContext;
109 
110 /* AMF date type */
111 typedef struct amf_date {
112  double milliseconds;
113  int16_t timezone;
114 } amf_date;
115 
116 static int probe(const AVProbeData *p, int live)
117 {
118  const uint8_t *d = p->buf;
119  unsigned offset = AV_RB32(d + 5);
120 
121  if (d[0] == 'F' &&
122  d[1] == 'L' &&
123  d[2] == 'V' &&
124  d[3] < 5 && d[5] == 0 &&
125  offset + 100 < p->buf_size &&
126  offset > 8) {
127  int is_live = !memcmp(d + offset + 40, "NGINX RTMP", 10);
128 
129  if (live == is_live)
130  return AVPROBE_SCORE_MAX;
131  }
132  return 0;
133 }
134 
135 static int flv_probe(const AVProbeData *p)
136 {
137  return probe(p, 0);
138 }
139 
140 static int live_flv_probe(const AVProbeData *p)
141 {
142  return probe(p, 1);
143 }
144 
145 static int kux_probe(const AVProbeData *p)
146 {
147  const uint8_t *d = p->buf;
148 
149  if (d[0] == 'K' &&
150  d[1] == 'D' &&
151  d[2] == 'K' &&
152  d[3] == 0 &&
153  d[4] == 0) {
154  return AVPROBE_SCORE_EXTENSION + 1;
155  }
156  return 0;
157 }
158 
160 {
161  FLVContext *flv = s->priv_data;
162  AVStream *stream = NULL;
163  unsigned int i = 0;
164 
165  if (flv->last_keyframe_stream_index < 0) {
166  av_log(s, AV_LOG_DEBUG, "keyframe stream hasn't been created\n");
167  return;
168  }
169 
170  av_assert0(flv->last_keyframe_stream_index <= s->nb_streams);
171  stream = s->streams[flv->last_keyframe_stream_index];
172 
173  if (ffstream(stream)->nb_index_entries == 0) {
174  for (i = 0; i < flv->keyframe_count; i++) {
175  av_log(s, AV_LOG_TRACE, "keyframe filepositions = %"PRId64" times = %"PRId64"\n",
178  flv->keyframe_times[i], 0, 0, AVINDEX_KEYFRAME);
179  }
180  } else
181  av_log(s, AV_LOG_WARNING, "Skipping duplicate index\n");
182 
183  if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
184  av_freep(&flv->keyframe_times);
186  flv->keyframe_count = 0;
187  }
188 }
189 
191 {
192  FLVContext *flv = s->priv_data;
194  if (!st)
195  return NULL;
197  if (s->nb_streams>=3 ||( s->nb_streams==2
198  && s->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE
199  && s->streams[1]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE
200  && s->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_DATA
201  && s->streams[1]->codecpar->codec_type != AVMEDIA_TYPE_DATA))
202  s->ctx_flags &= ~AVFMTCTX_NOHEADER;
204  st->codecpar->bit_rate = flv->audio_bit_rate;
206  }
208  st->codecpar->bit_rate = flv->video_bit_rate;
210  st->avg_frame_rate = flv->framerate;
211  }
212 
213 
214  avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
215  flv->last_keyframe_stream_index = s->nb_streams - 1;
217  return st;
218 }
219 
221 {
222  int bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
223  int flv_codecid = flags & FLV_AUDIO_CODECID_MASK;
224  int codec_id;
225 
226  if (!apar->codec_id && !apar->codec_tag)
227  return 1;
228 
229  if (apar->bits_per_coded_sample != bits_per_coded_sample)
230  return 0;
231 
232  switch (flv_codecid) {
233  // no distinction between S16 and S8 PCM codec flags
234  case FLV_CODECID_PCM:
235  codec_id = bits_per_coded_sample == 8
237 #if HAVE_BIGENDIAN
239 #else
241 #endif
242  return codec_id == apar->codec_id;
243  case FLV_CODECID_PCM_LE:
244  codec_id = bits_per_coded_sample == 8
247  return codec_id == apar->codec_id;
248  case FLV_CODECID_AAC:
249  return apar->codec_id == AV_CODEC_ID_AAC;
250  case FLV_CODECID_ADPCM:
251  return apar->codec_id == AV_CODEC_ID_ADPCM_SWF;
252  case FLV_CODECID_SPEEX:
253  return apar->codec_id == AV_CODEC_ID_SPEEX;
254  case FLV_CODECID_MP3:
255  return apar->codec_id == AV_CODEC_ID_MP3;
259  return apar->codec_id == AV_CODEC_ID_NELLYMOSER;
261  return apar->sample_rate == 8000 &&
264  return apar->sample_rate == 8000 &&
266  default:
267  return apar->codec_tag == (flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
268  }
269 }
270 
272  AVCodecParameters *apar, int flv_codecid)
273 {
274  switch (flv_codecid) {
275  // no distinction between S16 and S8 PCM codec flags
276  case FLV_CODECID_PCM:
277  apar->codec_id = apar->bits_per_coded_sample == 8
279 #if HAVE_BIGENDIAN
281 #else
283 #endif
284  break;
285  case FLV_CODECID_PCM_LE:
286  apar->codec_id = apar->bits_per_coded_sample == 8
289  break;
290  case FLV_CODECID_AAC:
291  apar->codec_id = AV_CODEC_ID_AAC;
292  break;
293  case FLV_CODECID_ADPCM:
295  break;
296  case FLV_CODECID_SPEEX:
297  apar->codec_id = AV_CODEC_ID_SPEEX;
298  apar->sample_rate = 16000;
299  break;
300  case FLV_CODECID_MP3:
301  apar->codec_id = AV_CODEC_ID_MP3;
303  break;
305  // in case metadata does not otherwise declare samplerate
306  apar->sample_rate = 8000;
308  break;
310  apar->sample_rate = 16000;
312  break;
315  break;
317  apar->sample_rate = 8000;
319  break;
321  apar->sample_rate = 8000;
323  break;
324  default:
325  avpriv_request_sample(s, "Audio codec (%x)",
326  flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
327  apar->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET;
328  }
329 }
330 
331 static int flv_same_video_codec(AVCodecParameters *vpar, uint32_t flv_codecid)
332 {
333  if (!vpar->codec_id && !vpar->codec_tag)
334  return 1;
335 
336  switch (flv_codecid) {
337  case MKBETAG('h', 'v', 'c', '1'):
338  return vpar->codec_id == AV_CODEC_ID_HEVC;
339  case MKBETAG('a', 'v', '0', '1'):
340  return vpar->codec_id == AV_CODEC_ID_AV1;
341  case MKBETAG('v', 'p', '0', '9'):
342  return vpar->codec_id == AV_CODEC_ID_VP9;
343  case FLV_CODECID_H263:
344  return vpar->codec_id == AV_CODEC_ID_FLV1;
345  case FLV_CODECID_SCREEN:
346  return vpar->codec_id == AV_CODEC_ID_FLASHSV;
347  case FLV_CODECID_SCREEN2:
348  return vpar->codec_id == AV_CODEC_ID_FLASHSV2;
349  case FLV_CODECID_VP6:
350  return vpar->codec_id == AV_CODEC_ID_VP6F;
351  case FLV_CODECID_VP6A:
352  return vpar->codec_id == AV_CODEC_ID_VP6A;
353  case FLV_CODECID_H264:
354  return vpar->codec_id == AV_CODEC_ID_H264;
355  default:
356  return vpar->codec_tag == flv_codecid;
357  }
358 }
359 
361  uint32_t flv_codecid, int read)
362 {
363  FFStream *const vstreami = ffstream(vstream);
364  int ret = 0;
365  AVCodecParameters *par = vstream->codecpar;
366  enum AVCodecID old_codec_id = vstream->codecpar->codec_id;
367 
368  switch (flv_codecid) {
369  case MKBETAG('h', 'v', 'c', '1'):
370  par->codec_id = AV_CODEC_ID_HEVC;
372  break;
373  case MKBETAG('a', 'v', '0', '1'):
374  par->codec_id = AV_CODEC_ID_AV1;
376  break;
377  case MKBETAG('v', 'p', '0', '9'):
378  par->codec_id = AV_CODEC_ID_VP9;
380  break;
381  case FLV_CODECID_H263:
382  par->codec_id = AV_CODEC_ID_FLV1;
383  break;
385  par->codec_id = AV_CODEC_ID_H263;
386  break; // Really mean it this time
387  case FLV_CODECID_SCREEN:
389  break;
390  case FLV_CODECID_SCREEN2:
392  break;
393  case FLV_CODECID_VP6:
394  par->codec_id = AV_CODEC_ID_VP6F;
395  case FLV_CODECID_VP6A:
396  if (flv_codecid == FLV_CODECID_VP6A)
397  par->codec_id = AV_CODEC_ID_VP6A;
398  if (read) {
399  if (par->extradata_size != 1) {
400  ff_alloc_extradata(par, 1);
401  }
402  if (par->extradata)
403  par->extradata[0] = avio_r8(s->pb);
404  else
405  avio_skip(s->pb, 1);
406  }
407  ret = 1; // 1 byte body size adjustment for flv_read_packet()
408  break;
409  case FLV_CODECID_H264:
410  par->codec_id = AV_CODEC_ID_H264;
412  break;
413  case FLV_CODECID_MPEG4:
415  break;
416  default:
417  avpriv_request_sample(s, "Video codec (%x)", flv_codecid);
418  par->codec_tag = flv_codecid;
419  }
420 
421  if (!vstreami->need_context_update && par->codec_id != old_codec_id) {
422  avpriv_request_sample(s, "Changing the codec id midstream");
423  return AVERROR_PATCHWELCOME;
424  }
425 
426  return ret;
427 }
428 
429 static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize)
430 {
431  int ret;
432  int length = avio_rb16(ioc);
433  if (length >= buffsize) {
434  avio_skip(ioc, length);
435  return -1;
436  }
437 
438  ret = avio_read(ioc, buffer, length);
439  if (ret < 0)
440  return ret;
441  if (ret < length)
442  return AVERROR_INVALIDDATA;
443 
444  buffer[length] = '\0';
445 
446  return length;
447 }
448 
450 {
451  FLVContext *flv = s->priv_data;
452  unsigned int timeslen = 0, fileposlen = 0, i;
453  char str_val[256];
454  int64_t *times = NULL;
455  int64_t *filepositions = NULL;
456  int ret = AVERROR(ENOSYS);
457  int64_t initial_pos = avio_tell(ioc);
458 
459  if (flv->keyframe_count > 0) {
460  av_log(s, AV_LOG_DEBUG, "keyframes have been parsed\n");
461  return 0;
462  }
463  av_assert0(!flv->keyframe_times);
465 
466  if (s->flags & AVFMT_FLAG_IGNIDX)
467  return 0;
468 
469  while (avio_tell(ioc) < max_pos - 2 &&
470  amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
471  int64_t **current_array;
472  unsigned int arraylen;
473  int factor;
474 
475  // Expect array object in context
476  if (avio_r8(ioc) != AMF_DATA_TYPE_ARRAY)
477  break;
478 
479  arraylen = avio_rb32(ioc);
480  if (arraylen>>28)
481  break;
482 
483  if (!strcmp(KEYFRAMES_TIMESTAMP_TAG , str_val) && !times) {
484  current_array = &times;
485  timeslen = arraylen;
486  factor = 1000;
487  } else if (!strcmp(KEYFRAMES_BYTEOFFSET_TAG, str_val) &&
488  !filepositions) {
489  current_array = &filepositions;
490  fileposlen = arraylen;
491  factor = 1;
492  } else
493  // unexpected metatag inside keyframes, will not use such
494  // metadata for indexing
495  break;
496 
497  if (!(*current_array = av_mallocz(sizeof(**current_array) * arraylen))) {
498  ret = AVERROR(ENOMEM);
499  goto finish;
500  }
501 
502  for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++) {
503  double d;
504  if (avio_r8(ioc) != AMF_DATA_TYPE_NUMBER)
505  goto invalid;
506  d = av_int2double(avio_rb64(ioc)) * factor;
507  if (isnan(d) || d < INT64_MIN || d > INT64_MAX)
508  goto invalid;
509  if (avio_feof(ioc))
510  goto invalid;
511  current_array[0][i] = d;
512  }
513  if (times && filepositions) {
514  // All done, exiting at a position allowing amf_parse_object
515  // to finish parsing the object
516  ret = 0;
517  break;
518  }
519  }
520 
521  if (timeslen == fileposlen && fileposlen>1 && max_pos <= filepositions[0]) {
522  for (i = 0; i < FFMIN(2,fileposlen); i++) {
523  flv->validate_index[i].pos = filepositions[i];
524  flv->validate_index[i].dts = times[i];
525  flv->validate_count = i + 1;
526  }
527  flv->keyframe_times = times;
528  flv->keyframe_filepositions = filepositions;
529  flv->keyframe_count = timeslen;
530  times = NULL;
531  filepositions = NULL;
532  } else {
533 invalid:
534  av_log(s, AV_LOG_WARNING, "Invalid keyframes object, skipping.\n");
535  }
536 
537 finish:
538  av_freep(&times);
539  av_freep(&filepositions);
540  avio_seek(ioc, initial_pos, SEEK_SET);
541  return ret;
542 }
543 
545  AVStream *vstream, const char *key,
546  int64_t max_pos, int depth)
547 {
548  AVCodecParameters *apar, *vpar;
549  FLVContext *flv = s->priv_data;
550  AVIOContext *ioc;
551  AMFDataType amf_type;
552  FLVMetaVideoColor *meta_video_color = flv->metaVideoColor;
553  char str_val[1024];
554  double num_val;
555  amf_date date;
556 
557  if (depth > MAX_DEPTH)
558  return AVERROR_PATCHWELCOME;
559 
560  num_val = 0;
561  ioc = s->pb;
562  if (avio_feof(ioc))
563  return AVERROR_EOF;
564  amf_type = avio_r8(ioc);
565 
566  switch (amf_type) {
568  num_val = av_int2double(avio_rb64(ioc));
569  break;
570  case AMF_DATA_TYPE_BOOL:
571  num_val = avio_r8(ioc);
572  break;
574  if (amf_get_string(ioc, str_val, sizeof(str_val)) < 0) {
575  av_log(s, AV_LOG_ERROR, "AMF_DATA_TYPE_STRING parsing failed\n");
576  return -1;
577  }
578  break;
580  if (key &&
581  (ioc->seekable & AVIO_SEEKABLE_NORMAL) &&
582  !strcmp(KEYFRAMES_TAG, key) && depth == 1)
583  if (parse_keyframes_index(s, ioc, max_pos) < 0)
584  av_log(s, AV_LOG_ERROR, "Keyframe index parsing failed\n");
585  else
587  while (avio_tell(ioc) < max_pos - 2 &&
588  amf_get_string(ioc, str_val, sizeof(str_val)) > 0)
589  if (amf_parse_object(s, astream, vstream, str_val, max_pos,
590  depth + 1) < 0)
591  return -1; // if we couldn't skip, bomb out.
592  if (avio_r8(ioc) != AMF_END_OF_OBJECT) {
593  av_log(s, AV_LOG_ERROR, "Missing AMF_END_OF_OBJECT in AMF_DATA_TYPE_OBJECT\n");
594  return -1;
595  }
596  break;
597  case AMF_DATA_TYPE_NULL:
600  break; // these take up no additional space
602  {
603  unsigned v;
604  avio_skip(ioc, 4); // skip 32-bit max array index
605  while (avio_tell(ioc) < max_pos - 2 &&
606  amf_get_string(ioc, str_val, sizeof(str_val)) > 0)
607  // this is the only case in which we would want a nested
608  // parse to not skip over the object
609  if (amf_parse_object(s, astream, vstream, str_val, max_pos,
610  depth + 1) < 0)
611  return -1;
612  v = avio_r8(ioc);
613  if (v != AMF_END_OF_OBJECT) {
614  av_log(s, AV_LOG_ERROR, "Missing AMF_END_OF_OBJECT in AMF_DATA_TYPE_MIXEDARRAY, found %d\n", v);
615  return -1;
616  }
617  break;
618  }
619  case AMF_DATA_TYPE_ARRAY:
620  {
621  unsigned int arraylen, i;
622 
623  arraylen = avio_rb32(ioc);
624  for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++)
626  depth + 1) < 0)
627  return -1; // if we couldn't skip, bomb out.
628  }
629  break;
630  case AMF_DATA_TYPE_DATE:
631  // timestamp (double) and UTC offset (int16)
632  date.milliseconds = av_int2double(avio_rb64(ioc));
633  date.timezone = avio_rb16(ioc);
634  break;
635  default: // unsupported type, we couldn't skip
636  av_log(s, AV_LOG_ERROR, "unsupported amf type %d\n", amf_type);
637  return -1;
638  }
639 
640  if (key) {
641  apar = astream ? astream->codecpar : NULL;
642  vpar = vstream ? vstream->codecpar : NULL;
643 
644  // stream info doesn't live any deeper than the first object
645  if (depth == 1) {
646  if (amf_type == AMF_DATA_TYPE_NUMBER ||
647  amf_type == AMF_DATA_TYPE_BOOL) {
648  if (!strcmp(key, "duration"))
649  s->duration = num_val * AV_TIME_BASE;
650  else if (!strcmp(key, "videodatarate") &&
651  0 <= (int)(num_val * 1024.0))
652  flv->video_bit_rate = num_val * 1024.0;
653  else if (!strcmp(key, "audiodatarate") &&
654  0 <= (int)(num_val * 1024.0))
655  flv->audio_bit_rate = num_val * 1024.0;
656  else if (!strcmp(key, "framerate")) {
657  flv->framerate = av_d2q(num_val, 1000);
658  if (vstream)
659  vstream->avg_frame_rate = flv->framerate;
660  } else if (flv->trust_metadata) {
661  if (!strcmp(key, "videocodecid") && vpar) {
662  int ret = flv_set_video_codec(s, vstream, num_val, 0);
663  if (ret < 0)
664  return ret;
665  } else if (!strcmp(key, "audiocodecid") && apar) {
666  int id = ((int)num_val) << FLV_AUDIO_CODECID_OFFSET;
667  flv_set_audio_codec(s, astream, apar, id);
668  } else if (!strcmp(key, "audiosamplerate") && apar) {
669  apar->sample_rate = num_val;
670  } else if (!strcmp(key, "audiosamplesize") && apar) {
671  apar->bits_per_coded_sample = num_val;
672  } else if (!strcmp(key, "stereo") && apar) {
673  av_channel_layout_default(&apar->ch_layout, num_val + 1);
674  } else if (!strcmp(key, "width") && vpar) {
675  vpar->width = num_val;
676  } else if (!strcmp(key, "height") && vpar) {
677  vpar->height = num_val;
678  } else if (!strcmp(key, "datastream")) {
680  if (!st)
681  return AVERROR(ENOMEM);
683  }
684  }
685  }
686  if (amf_type == AMF_DATA_TYPE_STRING) {
687  if (!strcmp(key, "encoder")) {
688  int version = -1;
689  if (1 == sscanf(str_val, "Open Broadcaster Software v0.%d", &version)) {
690  if (version > 0 && version <= 655)
691  flv->broken_sizes = 1;
692  }
693  } else if (!strcmp(key, "metadatacreator")) {
694  if ( !strcmp (str_val, "MEGA")
695  || !strncmp(str_val, "FlixEngine", 10))
696  flv->broken_sizes = 1;
697  }
698  }
699  }
700 
701  if (meta_video_color) {
702  if (amf_type == AMF_DATA_TYPE_NUMBER ||
703  amf_type == AMF_DATA_TYPE_BOOL) {
704  if (!strcmp(key, "colorPrimaries")) {
705  meta_video_color->primaries = num_val;
706  } else if (!strcmp(key, "transferCharacteristics")) {
707  meta_video_color->transfer_characteristics = num_val;
708  } else if (!strcmp(key, "matrixCoefficients")) {
709  meta_video_color->matrix_coefficients = num_val;
710  } else if (!strcmp(key, "maxFall")) {
711  meta_video_color->max_fall = num_val;
712  } else if (!strcmp(key, "maxCLL")) {
713  meta_video_color->max_cll = num_val;
714  } else if (!strcmp(key, "redX")) {
715  meta_video_color->mastering_meta.r_x = num_val;
716  } else if (!strcmp(key, "redY")) {
717  meta_video_color->mastering_meta.r_y = num_val;
718  } else if (!strcmp(key, "greenX")) {
719  meta_video_color->mastering_meta.g_x = num_val;
720  } else if (!strcmp(key, "greenY")) {
721  meta_video_color->mastering_meta.g_y = num_val;
722  } else if (!strcmp(key, "blueX")) {
723  meta_video_color->mastering_meta.b_x = num_val;
724  } else if (!strcmp(key, "blueY")) {
725  meta_video_color->mastering_meta.b_y = num_val;
726  } else if (!strcmp(key, "whitePointX")) {
727  meta_video_color->mastering_meta.white_x = num_val;
728  } else if (!strcmp(key, "whitePointY")) {
729  meta_video_color->mastering_meta.white_y = num_val;
730  } else if (!strcmp(key, "maxLuminance")) {
731  meta_video_color->mastering_meta.max_luminance = num_val;
732  } else if (!strcmp(key, "minLuminance")) {
733  meta_video_color->mastering_meta.min_luminance = num_val;
734  }
735  }
736  }
737 
738  if (amf_type == AMF_DATA_TYPE_OBJECT && s->nb_streams == 1 &&
739  ((!apar && !strcmp(key, "audiocodecid")) ||
740  (!vpar && !strcmp(key, "videocodecid"))))
741  s->ctx_flags &= ~AVFMTCTX_NOHEADER; //If there is either audio/video missing, codecid will be an empty object
742 
743  if ((!strcmp(key, "duration") ||
744  !strcmp(key, "filesize") ||
745  !strcmp(key, "width") ||
746  !strcmp(key, "height") ||
747  !strcmp(key, "videodatarate") ||
748  !strcmp(key, "framerate") ||
749  !strcmp(key, "videocodecid") ||
750  !strcmp(key, "audiodatarate") ||
751  !strcmp(key, "audiosamplerate") ||
752  !strcmp(key, "audiosamplesize") ||
753  !strcmp(key, "stereo") ||
754  !strcmp(key, "audiocodecid") ||
755  !strcmp(key, "datastream")) && !flv->dump_full_metadata)
756  return 0;
757 
758  s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
759  if (amf_type == AMF_DATA_TYPE_BOOL) {
760  av_strlcpy(str_val, num_val > 0 ? "true" : "false",
761  sizeof(str_val));
762  av_dict_set(&s->metadata, key, str_val, 0);
763  } else if (amf_type == AMF_DATA_TYPE_NUMBER) {
764  snprintf(str_val, sizeof(str_val), "%.f", num_val);
765  av_dict_set(&s->metadata, key, str_val, 0);
766  } else if (amf_type == AMF_DATA_TYPE_STRING) {
767  av_dict_set(&s->metadata, key, str_val, 0);
768  } else if ( amf_type == AMF_DATA_TYPE_DATE
769  && isfinite(date.milliseconds)
770  && date.milliseconds > INT64_MIN/1000
771  && date.milliseconds < INT64_MAX/1000
772  ) {
773  // timezone is ignored, since there is no easy way to offset the UTC
774  // timestamp into the specified timezone
775  avpriv_dict_set_timestamp(&s->metadata, key, 1000 * (int64_t)date.milliseconds);
776  }
777  }
778 
779  return 0;
780 }
781 
782 #define TYPE_ONTEXTDATA 1
783 #define TYPE_ONCAPTION 2
784 #define TYPE_ONCAPTIONINFO 3
785 #define TYPE_UNKNOWN 9
786 
787 static int flv_read_metabody(AVFormatContext *s, int64_t next_pos)
788 {
789  FLVContext *flv = s->priv_data;
791  AVStream *stream, *astream, *vstream;
792  AVStream av_unused *dstream;
793  AVIOContext *ioc;
794  int i;
795  char buffer[32];
796 
797  astream = NULL;
798  vstream = NULL;
799  dstream = NULL;
800  ioc = s->pb;
801 
802  // first object needs to be "onMetaData" string
803  type = avio_r8(ioc);
804  if (type != AMF_DATA_TYPE_STRING ||
805  amf_get_string(ioc, buffer, sizeof(buffer)) < 0)
806  return TYPE_UNKNOWN;
807 
808  if (!strcmp(buffer, "onTextData"))
809  return TYPE_ONTEXTDATA;
810 
811  if (!strcmp(buffer, "onCaption"))
812  return TYPE_ONCAPTION;
813 
814  if (!strcmp(buffer, "onCaptionInfo"))
815  return TYPE_ONCAPTIONINFO;
816 
817  if (strcmp(buffer, "onMetaData") && strcmp(buffer, "onCuePoint") && strcmp(buffer, "|RtmpSampleAccess")) {
818  av_log(s, AV_LOG_DEBUG, "Unknown type %s\n", buffer);
819  return TYPE_UNKNOWN;
820  }
821 
822  // find the streams now so that amf_parse_object doesn't need to do
823  // the lookup every time it is called.
824  for (i = 0; i < s->nb_streams; i++) {
825  stream = s->streams[i];
826  if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
827  vstream = stream;
829  } else if (stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
830  astream = stream;
831  if (flv->last_keyframe_stream_index == -1)
833  } else if (stream->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
834  dstream = stream;
835  }
836 
837  // parse the second object (we want a mixed array)
838  if (amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0)
839  return -1;
840 
841  return 0;
842 }
843 
845 {
846  int flags;
847  FLVContext *flv = s->priv_data;
848  int offset;
849  int pre_tag_size = 0;
850 
851  /* Actual FLV data at 0xe40000 in KUX file */
852  if(!strcmp(s->iformat->name, "kux"))
853  avio_skip(s->pb, 0xe40000);
854 
855  avio_skip(s->pb, 4);
856  flags = avio_r8(s->pb);
857 
859 
860  s->ctx_flags |= AVFMTCTX_NOHEADER;
861 
862  offset = avio_rb32(s->pb);
863  avio_seek(s->pb, offset, SEEK_SET);
864 
865  /* Annex E. The FLV File Format
866  * E.3 TheFLVFileBody
867  * Field Type Comment
868  * PreviousTagSize0 UI32 Always 0
869  * */
870  pre_tag_size = avio_rb32(s->pb);
871  if (pre_tag_size) {
872  av_log(s, AV_LOG_WARNING, "Read FLV header error, input file is not a standard flv format, first PreviousTagSize0 always is 0\n");
873  }
874 
875  s->start_time = 0;
876  flv->sum_flv_tag_size = 0;
877  flv->last_keyframe_stream_index = -1;
878 
879  return 0;
880 }
881 
883 {
884  int i;
885  FLVContext *flv = s->priv_data;
886  for (i=0; i<FLV_STREAM_TYPE_NB; i++)
887  av_freep(&flv->new_extradata[i]);
888  av_freep(&flv->keyframe_times);
890  av_freep(&flv->metaVideoColor);
891  return 0;
892 }
893 
895 {
896  int ret;
897  if (!size)
898  return 0;
899 
900  if ((ret = ff_get_extradata(s, st->codecpar, s->pb, size)) < 0)
901  return ret;
902  ffstream(st)->need_context_update = 1;
903  return 0;
904 }
905 
906 static int flv_queue_extradata(FLVContext *flv, AVIOContext *pb, int stream,
907  int size)
908 {
909  if (!size)
910  return 0;
911 
912  av_free(flv->new_extradata[stream]);
913  flv->new_extradata[stream] = av_mallocz(size +
915  if (!flv->new_extradata[stream])
916  return AVERROR(ENOMEM);
917  flv->new_extradata_size[stream] = size;
918  avio_read(pb, flv->new_extradata[stream], size);
919  return 0;
920 }
921 
922 static void clear_index_entries(AVFormatContext *s, int64_t pos)
923 {
925  "Found invalid index entries, clearing the index.\n");
926  for (unsigned i = 0; i < s->nb_streams; i++) {
927  FFStream *const sti = ffstream(s->streams[i]);
928  int out = 0;
929  /* Remove all index entries that point to >= pos */
930  for (int j = 0; j < sti->nb_index_entries; j++)
931  if (sti->index_entries[j].pos < pos)
932  sti->index_entries[out++] = sti->index_entries[j];
933  sti->nb_index_entries = out;
934  }
935 }
936 
937 static int amf_skip_tag(AVIOContext *pb, AMFDataType type, int depth)
938 {
939  int nb = -1, ret, parse_name = 1;
940 
941  if (depth > MAX_DEPTH)
942  return AVERROR_PATCHWELCOME;
943 
944  if (avio_feof(pb))
945  return AVERROR_EOF;
946 
947  switch (type) {
949  avio_skip(pb, 8);
950  break;
951  case AMF_DATA_TYPE_BOOL:
952  avio_skip(pb, 1);
953  break;
955  avio_skip(pb, avio_rb16(pb));
956  break;
957  case AMF_DATA_TYPE_ARRAY:
958  parse_name = 0;
960  nb = avio_rb32(pb);
961  if (nb < 0)
962  return AVERROR_INVALIDDATA;
964  while(!pb->eof_reached && (nb-- > 0 || type != AMF_DATA_TYPE_ARRAY)) {
965  if (parse_name) {
966  int size = avio_rb16(pb);
967  if (!size) {
968  avio_skip(pb, 1);
969  break;
970  }
971  avio_skip(pb, size);
972  }
973  if ((ret = amf_skip_tag(pb, avio_r8(pb), depth + 1)) < 0)
974  return ret;
975  }
976  break;
977  case AMF_DATA_TYPE_NULL:
979  break;
980  default:
981  return AVERROR_INVALIDDATA;
982  }
983  return 0;
984 }
985 
987  int64_t dts, int64_t next)
988 {
989  AVIOContext *pb = s->pb;
990  AVStream *st = NULL;
991  char buf[20];
992  int ret = AVERROR_INVALIDDATA;
993  int i, length = -1;
994  int array = 0;
995 
996  switch (avio_r8(pb)) {
997  case AMF_DATA_TYPE_ARRAY:
998  array = 1;
1000  avio_seek(pb, 4, SEEK_CUR);
1001  case AMF_DATA_TYPE_OBJECT:
1002  break;
1003  default:
1004  goto skip;
1005  }
1006 
1007  while (array || (ret = amf_get_string(pb, buf, sizeof(buf))) > 0) {
1008  AMFDataType type = avio_r8(pb);
1009  if (type == AMF_DATA_TYPE_STRING && (array || !strcmp(buf, "text"))) {
1010  length = avio_rb16(pb);
1011  ret = av_get_packet(pb, pkt, length);
1012  if (ret < 0)
1013  goto skip;
1014  else
1015  break;
1016  } else {
1017  if ((ret = amf_skip_tag(pb, type, 0)) < 0)
1018  goto skip;
1019  }
1020  }
1021 
1022  if (length < 0) {
1024  goto skip;
1025  }
1026 
1027  for (i = 0; i < s->nb_streams; i++) {
1028  st = s->streams[i];
1030  break;
1031  }
1032 
1033  if (i == s->nb_streams) {
1035  if (!st)
1036  return AVERROR(ENOMEM);
1038  }
1039 
1040  pkt->dts = dts;
1041  pkt->pts = dts;
1042  pkt->size = ret;
1043 
1044  pkt->stream_index = st->index;
1046 
1047 skip:
1048  avio_seek(s->pb, next + 4, SEEK_SET);
1049 
1050  return ret;
1051 }
1052 
1054 {
1055  FLVContext *flv = s->priv_data;
1056  int64_t i;
1057  int64_t pos = avio_tell(s->pb);
1058 
1059  for (i=0; !avio_feof(s->pb); i++) {
1060  int j = i & (RESYNC_BUFFER_SIZE-1);
1061  int j1 = j + RESYNC_BUFFER_SIZE;
1062  flv->resync_buffer[j ] =
1063  flv->resync_buffer[j1] = avio_r8(s->pb);
1064 
1065  if (i >= 8 && pos) {
1066  uint8_t *d = flv->resync_buffer + j1 - 8;
1067  if (d[0] == 'F' &&
1068  d[1] == 'L' &&
1069  d[2] == 'V' &&
1070  d[3] < 5 && d[5] == 0) {
1071  av_log(s, AV_LOG_WARNING, "Concatenated FLV detected, might fail to demux, decode and seek %"PRId64"\n", flv->last_ts);
1072  flv->time_offset = flv->last_ts + 1;
1073  flv->time_pos = avio_tell(s->pb);
1074  }
1075  }
1076 
1077  if (i > 22) {
1078  unsigned lsize2 = AV_RB32(flv->resync_buffer + j1 - 4);
1079  if (lsize2 >= 11 && lsize2 + 8LL < FFMIN(i, RESYNC_BUFFER_SIZE)) {
1080  unsigned size2 = AV_RB24(flv->resync_buffer + j1 - lsize2 + 1 - 4);
1081  unsigned lsize1 = AV_RB32(flv->resync_buffer + j1 - lsize2 - 8);
1082  if (lsize1 >= 11 && lsize1 + 8LL + lsize2 < FFMIN(i, RESYNC_BUFFER_SIZE)) {
1083  unsigned size1 = AV_RB24(flv->resync_buffer + j1 - lsize1 + 1 - lsize2 - 8);
1084  if (size1 == lsize1 - 11 && size2 == lsize2 - 11) {
1085  avio_seek(s->pb, pos + i - lsize1 - lsize2 - 8, SEEK_SET);
1086  return 1;
1087  }
1088  }
1089  }
1090  }
1091  }
1092  return AVERROR_EOF;
1093 }
1094 
1095 static int flv_parse_video_color_info(AVFormatContext *s, AVStream *st, int64_t next_pos)
1096 {
1097  FLVContext *flv = s->priv_data;
1098  AMFDataType type;
1099  AVIOContext *ioc;
1100  char buffer[32];
1101  ioc = s->pb;
1102 
1103  // first object needs to be "colorInfo" string
1104  type = avio_r8(ioc);
1105  if (type != AMF_DATA_TYPE_STRING ||
1106  amf_get_string(ioc, buffer, sizeof(buffer)) < 0)
1107  return TYPE_UNKNOWN;
1108 
1109  if (strcmp(buffer, "colorInfo")) {
1110  av_log(s, AV_LOG_DEBUG, "Unknown type %s\n", buffer);
1111  return TYPE_UNKNOWN;
1112  }
1113 
1114  if (!(flv->metaVideoColor = av_mallocz(sizeof(FLVMetaVideoColor)))) {
1115  return AVERROR(ENOMEM);
1116  }
1117  flv->meta_color_info_flag = 1;
1118  amf_parse_object(s, NULL, NULL, buffer, next_pos, 0); // parse metadata
1119  return 0;
1120 }
1121 
1123 {
1124  FLVContext *flv = s->priv_data;
1125  const FLVMetaVideoColor* meta_video_color = flv->metaVideoColor;
1126  const FLVMasteringMeta *mastering_meta = &meta_video_color->mastering_meta;
1127 
1128  int has_mastering_primaries, has_mastering_luminance;
1129  // Mastering primaries are CIE 1931 coords, and must be > 0.
1130  has_mastering_primaries =
1131  mastering_meta->r_x > 0 && mastering_meta->r_y > 0 &&
1132  mastering_meta->g_x > 0 && mastering_meta->g_y > 0 &&
1133  mastering_meta->b_x > 0 && mastering_meta->b_y > 0 &&
1134  mastering_meta->white_x > 0 && mastering_meta->white_y > 0;
1135  has_mastering_luminance = mastering_meta->max_luminance > 0 && mastering_meta->min_luminance > 0;
1136 
1137  if (meta_video_color->matrix_coefficients != AVCOL_SPC_RESERVED)
1138  st->codecpar->color_space = meta_video_color->matrix_coefficients;
1139  if (meta_video_color->primaries != AVCOL_PRI_RESERVED &&
1140  meta_video_color->primaries != AVCOL_PRI_RESERVED0)
1141  st->codecpar->color_primaries = meta_video_color->primaries;
1142  if (meta_video_color->transfer_characteristics != AVCOL_TRC_RESERVED &&
1143  meta_video_color->transfer_characteristics != AVCOL_TRC_RESERVED0)
1144  st->codecpar->color_trc = meta_video_color->transfer_characteristics;
1145 
1146  if (meta_video_color->max_cll && meta_video_color->max_fall) {
1147  size_t size = 0;
1149  if (!metadata)
1150  return AVERROR(ENOMEM);
1152  AV_PKT_DATA_CONTENT_LIGHT_LEVEL, metadata, size, 0)) {
1153  av_freep(&metadata);
1154  return AVERROR(ENOMEM);
1155  }
1156  metadata->MaxCLL = meta_video_color->max_cll;
1157  metadata->MaxFALL = meta_video_color->max_fall;
1158  }
1159 
1160  if (has_mastering_primaries || has_mastering_luminance) {
1161  AVMasteringDisplayMetadata *metadata;
1165  sizeof(AVMasteringDisplayMetadata), 0);
1166  if (!sd)
1167  return AVERROR(ENOMEM);
1168  metadata = (AVMasteringDisplayMetadata*)sd->data;
1169  memset(metadata, 0, sizeof(AVMasteringDisplayMetadata));
1170  // hdrCll
1171  if (has_mastering_luminance) {
1172  metadata->max_luminance = av_d2q(mastering_meta->max_luminance, INT_MAX);
1173  metadata->min_luminance = av_d2q(mastering_meta->min_luminance, INT_MAX);
1174  metadata->has_luminance = 1;
1175  }
1176  // hdrMdcv
1177  if (has_mastering_primaries) {
1178  metadata->display_primaries[0][0] = av_d2q(mastering_meta->r_x, INT_MAX);
1179  metadata->display_primaries[0][1] = av_d2q(mastering_meta->r_y, INT_MAX);
1180  metadata->display_primaries[1][0] = av_d2q(mastering_meta->g_x, INT_MAX);
1181  metadata->display_primaries[1][1] = av_d2q(mastering_meta->g_y, INT_MAX);
1182  metadata->display_primaries[2][0] = av_d2q(mastering_meta->b_x, INT_MAX);
1183  metadata->display_primaries[2][1] = av_d2q(mastering_meta->b_y, INT_MAX);
1184  metadata->white_point[0] = av_d2q(mastering_meta->white_x, INT_MAX);
1185  metadata->white_point[1] = av_d2q(mastering_meta->white_y, INT_MAX);
1186  metadata->has_primaries = 1;
1187  }
1188  }
1189  return 0;
1190 }
1191 
1193 {
1194  FLVContext *flv = s->priv_data;
1195  int ret, i, size, flags;
1196  enum FlvTagType type;
1197  int stream_type=-1;
1198  int64_t next, pos, meta_pos;
1199  int64_t dts, pts = AV_NOPTS_VALUE;
1200  int av_uninit(channels);
1201  int av_uninit(sample_rate);
1202  AVStream *st = NULL;
1203  int last = -1;
1204  int orig_size;
1205  int enhanced_flv = 0;
1206  uint32_t video_codec_id = 0;
1207 
1208 retry:
1209  /* pkt size is repeated at end. skip it */
1210  pos = avio_tell(s->pb);
1211  type = (avio_r8(s->pb) & 0x1F);
1212  orig_size =
1213  size = avio_rb24(s->pb);
1214  flv->sum_flv_tag_size += size + 11LL;
1215  dts = avio_rb24(s->pb);
1216  dts |= (unsigned)avio_r8(s->pb) << 24;
1217  av_log(s, AV_LOG_TRACE, "type:%d, size:%d, last:%d, dts:%"PRId64" pos:%"PRId64"\n", type, size, last, dts, avio_tell(s->pb));
1218  if (avio_feof(s->pb))
1219  return AVERROR_EOF;
1220  avio_skip(s->pb, 3); /* stream id, always 0 */
1221  flags = 0;
1222 
1223  if (flv->validate_next < flv->validate_count) {
1224  int64_t validate_pos = flv->validate_index[flv->validate_next].pos;
1225  if (pos == validate_pos) {
1226  if (FFABS(dts - flv->validate_index[flv->validate_next].dts) <=
1228  flv->validate_next++;
1229  } else {
1230  clear_index_entries(s, validate_pos);
1231  flv->validate_count = 0;
1232  }
1233  } else if (pos > validate_pos) {
1234  clear_index_entries(s, validate_pos);
1235  flv->validate_count = 0;
1236  }
1237  }
1238 
1239  if (size == 0) {
1240  ret = FFERROR_REDO;
1241  goto leave;
1242  }
1243 
1244  next = size + avio_tell(s->pb);
1245 
1246  if (type == FLV_TAG_TYPE_AUDIO) {
1247  stream_type = FLV_STREAM_TYPE_AUDIO;
1248  flags = avio_r8(s->pb);
1249  size--;
1250  } else if (type == FLV_TAG_TYPE_VIDEO) {
1251  stream_type = FLV_STREAM_TYPE_VIDEO;
1252  flags = avio_r8(s->pb);
1253  video_codec_id = flags & FLV_VIDEO_CODECID_MASK;
1254  /*
1255  * Reference Enhancing FLV 2023-03-v1.0.0-B.8
1256  * https://github.com/veovera/enhanced-rtmp/blob/main/enhanced-rtmp-v1.pdf
1257  * */
1258  enhanced_flv = (flags >> 7) & 1;
1259  size--;
1260  if (enhanced_flv) {
1261  video_codec_id = avio_rb32(s->pb);
1262  size -= 4;
1263  }
1264 
1265  if (enhanced_flv && stream_type == FLV_STREAM_TYPE_VIDEO && (flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_VIDEO_INFO_CMD) {
1266  int pkt_type = flags & 0x0F;
1267  if (pkt_type == PacketTypeMetadata) {
1268  int ret = flv_parse_video_color_info(s, st, next);
1269  av_log(s, AV_LOG_DEBUG, "enhanced flv parse metadata ret %d and skip\n", ret);
1270  }
1271  goto skip;
1273  goto skip;
1274  }
1275  } else if (type == FLV_TAG_TYPE_META) {
1276  stream_type=FLV_STREAM_TYPE_SUBTITLE;
1277  if (size > 13 + 1 + 4) { // Header-type metadata stuff
1278  int type;
1279  meta_pos = avio_tell(s->pb);
1280  type = flv_read_metabody(s, next);
1281  if (type == 0 && dts == 0 || type < 0) {
1282  if (type < 0 && flv->validate_count &&
1283  flv->validate_index[0].pos > next &&
1284  flv->validate_index[0].pos - 4 < next) {
1285  av_log(s, AV_LOG_WARNING, "Adjusting next position due to index mismatch\n");
1286  next = flv->validate_index[0].pos - 4;
1287  }
1288  goto skip;
1289  } else if (type == TYPE_ONTEXTDATA) {
1290  avpriv_request_sample(s, "OnTextData packet");
1291  return flv_data_packet(s, pkt, dts, next);
1292  } else if (type == TYPE_ONCAPTION) {
1293  return flv_data_packet(s, pkt, dts, next);
1294  } else if (type == TYPE_UNKNOWN) {
1295  stream_type = FLV_STREAM_TYPE_DATA;
1296  }
1297  avio_seek(s->pb, meta_pos, SEEK_SET);
1298  }
1299  } else {
1301  "Skipping flv packet: type %d, size %d, flags %d.\n",
1302  type, size, flags);
1303 skip:
1304  if (avio_seek(s->pb, next, SEEK_SET) != next) {
1305  // This can happen if flv_read_metabody above read past
1306  // next, on a non-seekable input, and the preceding data has
1307  // been flushed out from the IO buffer.
1308  av_log(s, AV_LOG_ERROR, "Unable to seek to the next packet\n");
1309  return AVERROR_INVALIDDATA;
1310  }
1311  ret = FFERROR_REDO;
1312  goto leave;
1313  }
1314 
1315  /* skip empty data packets */
1316  if (!size) {
1317  ret = FFERROR_REDO;
1318  goto leave;
1319  }
1320 
1321  /* now find stream */
1322  for (i = 0; i < s->nb_streams; i++) {
1323  st = s->streams[i];
1324  if (stream_type == FLV_STREAM_TYPE_AUDIO) {
1325  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1326  (s->audio_codec_id || flv_same_audio_codec(st->codecpar, flags)))
1327  break;
1328  } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {
1329  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1330  (s->video_codec_id || flv_same_video_codec(st->codecpar, video_codec_id)))
1331  break;
1332  } else if (stream_type == FLV_STREAM_TYPE_SUBTITLE) {
1334  break;
1335  } else if (stream_type == FLV_STREAM_TYPE_DATA) {
1337  break;
1338  }
1339  }
1340  if (i == s->nb_streams) {
1342  st = create_stream(s, stream_types[stream_type]);
1343  if (!st)
1344  return AVERROR(ENOMEM);
1345  }
1346  av_log(s, AV_LOG_TRACE, "%d %X %d \n", stream_type, flags, st->discard);
1347 
1348  if (flv->time_pos <= pos) {
1349  dts += flv->time_offset;
1350  }
1351 
1352  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
1354  stream_type == FLV_STREAM_TYPE_AUDIO))
1356 
1357  if ((st->discard >= AVDISCARD_NONKEY && !((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || stream_type == FLV_STREAM_TYPE_AUDIO)) ||
1359  st->discard >= AVDISCARD_ALL) {
1360  avio_seek(s->pb, next, SEEK_SET);
1361  ret = FFERROR_REDO;
1362  goto leave;
1363  }
1364 
1365  // if not streamed and no duration from metadata then seek to end to find
1366  // the duration from the timestamps
1367  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
1368  (!s->duration || s->duration == AV_NOPTS_VALUE) &&
1369  !flv->searched_for_end) {
1370  int size;
1371  const int64_t pos = avio_tell(s->pb);
1372  // Read the last 4 bytes of the file, this should be the size of the
1373  // previous FLV tag. Use the timestamp of its payload as duration.
1374  int64_t fsize = avio_size(s->pb);
1375 retry_duration:
1376  avio_seek(s->pb, fsize - 4, SEEK_SET);
1377  size = avio_rb32(s->pb);
1378  if (size > 0 && size < fsize) {
1379  // Seek to the start of the last FLV tag at position (fsize - 4 - size)
1380  // but skip the byte indicating the type.
1381  avio_seek(s->pb, fsize - 3 - size, SEEK_SET);
1382  if (size == avio_rb24(s->pb) + 11) {
1383  uint32_t ts = avio_rb24(s->pb);
1384  ts |= (unsigned)avio_r8(s->pb) << 24;
1385  if (ts)
1386  s->duration = ts * (int64_t)AV_TIME_BASE / 1000;
1387  else if (fsize >= 8 && fsize - 8 >= size) {
1388  fsize -= size+4;
1389  goto retry_duration;
1390  }
1391  }
1392  }
1393 
1394  avio_seek(s->pb, pos, SEEK_SET);
1395  flv->searched_for_end = 1;
1396  }
1397 
1398  if (stream_type == FLV_STREAM_TYPE_AUDIO) {
1399  int bits_per_coded_sample;
1401  sample_rate = 44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >>
1403  bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
1405  !st->codecpar->sample_rate ||
1409  st->codecpar->bits_per_coded_sample = bits_per_coded_sample;
1410  }
1411  if (!st->codecpar->codec_id) {
1412  flv_set_audio_codec(s, st, st->codecpar,
1414  flv->last_sample_rate =
1416  flv->last_channels =
1418  } else {
1420  if (!par) {
1421  ret = AVERROR(ENOMEM);
1422  goto leave;
1423  }
1424  par->sample_rate = sample_rate;
1425  par->bits_per_coded_sample = bits_per_coded_sample;
1427  sample_rate = par->sample_rate;
1429  }
1430  } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {
1431  int ret = flv_set_video_codec(s, st, video_codec_id, 1);
1432  if (ret < 0)
1433  return ret;
1434  size -= ret;
1435  } else if (stream_type == FLV_STREAM_TYPE_SUBTITLE) {
1437  } else if (stream_type == FLV_STREAM_TYPE_DATA) {
1438  st->codecpar->codec_id = AV_CODEC_ID_NONE; // Opaque AMF data
1439  }
1440 
1441  if (st->codecpar->codec_id == AV_CODEC_ID_AAC ||
1445  st->codecpar->codec_id == AV_CODEC_ID_AV1 ||
1446  st->codecpar->codec_id == AV_CODEC_ID_VP9) {
1447  int type = 0;
1448  if (enhanced_flv && stream_type == FLV_STREAM_TYPE_VIDEO) {
1449  type = flags & 0x0F;
1450  } else {
1451  type = avio_r8(s->pb);
1452  size--;
1453  }
1454 
1455  if (size < 0) {
1457  goto leave;
1458  }
1459 
1460  if (enhanced_flv && stream_type == FLV_STREAM_TYPE_VIDEO && flv->meta_color_info_flag) {
1461  flv_update_video_color_info(s, st); // update av packet side data
1462  flv->meta_color_info_flag = 0;
1463  }
1464 
1467  // sign extension
1468  int32_t cts = (avio_rb24(s->pb) + 0xff800000) ^ 0xff800000;
1469  pts = av_sat_add64(dts, cts);
1470  if (cts < 0) { // dts might be wrong
1471  if (!flv->wrong_dts)
1473  "Negative cts, previous timestamps might be wrong.\n");
1474  flv->wrong_dts = 1;
1475  } else if (FFABS(dts - pts) > 1000*60*15) {
1477  "invalid timestamps %"PRId64" %"PRId64"\n", dts, pts);
1478  dts = pts = AV_NOPTS_VALUE;
1479  }
1480  size -= 3;
1481  }
1482  if (type == 0 && (!st->codecpar->extradata || st->codecpar->codec_id == AV_CODEC_ID_AAC ||
1485  AVDictionaryEntry *t;
1486 
1487  if (st->codecpar->extradata) {
1488  if ((ret = flv_queue_extradata(flv, s->pb, stream_type, size)) < 0)
1489  return ret;
1490  ret = FFERROR_REDO;
1491  goto leave;
1492  }
1493  if ((ret = flv_get_extradata(s, st, size)) < 0)
1494  return ret;
1495 
1496  /* Workaround for buggy Omnia A/XE encoder */
1497  t = av_dict_get(s->metadata, "Encoder", NULL, 0);
1498  if (st->codecpar->codec_id == AV_CODEC_ID_AAC && t && !strcmp(t->value, "Omnia A/XE"))
1499  st->codecpar->extradata_size = 2;
1500 
1501  ret = FFERROR_REDO;
1502  goto leave;
1503  }
1504  }
1505 
1506  /* skip empty data packets */
1507  if (!size) {
1508  ret = FFERROR_REDO;
1509  goto leave;
1510  }
1511 
1512  ret = av_get_packet(s->pb, pkt, size);
1513  if (ret < 0)
1514  return ret;
1515  pkt->dts = dts;
1516  pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts;
1517  pkt->stream_index = st->index;
1518  pkt->pos = pos;
1519  if (flv->new_extradata[stream_type]) {
1521  flv->new_extradata[stream_type],
1522  flv->new_extradata_size[stream_type]);
1523  if (ret >= 0) {
1524  flv->new_extradata[stream_type] = NULL;
1525  flv->new_extradata_size[stream_type] = 0;
1526  }
1527  }
1528  if (stream_type == FLV_STREAM_TYPE_AUDIO &&
1529  (sample_rate != flv->last_sample_rate ||
1530  channels != flv->last_channels)) {
1532  flv->last_channels = channels;
1534  }
1535 
1536  if (stream_type == FLV_STREAM_TYPE_AUDIO ||
1538  stream_type == FLV_STREAM_TYPE_SUBTITLE ||
1539  stream_type == FLV_STREAM_TYPE_DATA)
1541 
1542 leave:
1543  last = avio_rb32(s->pb);
1544  if (!flv->trust_datasize) {
1545  if (last != orig_size + 11 && last != orig_size + 10 &&
1546  !avio_feof(s->pb) &&
1547  (last != orig_size || !last) && last != flv->sum_flv_tag_size &&
1548  !flv->broken_sizes) {
1549  av_log(s, AV_LOG_ERROR, "Packet mismatch %d %d %"PRId64"\n", last, orig_size + 11, flv->sum_flv_tag_size);
1550  avio_seek(s->pb, pos + 1, SEEK_SET);
1551  ret = resync(s);
1553  if (ret >= 0) {
1554  goto retry;
1555  }
1556  }
1557  }
1558 
1559  if (ret >= 0)
1560  flv->last_ts = pkt->dts;
1561 
1562  return ret;
1563 }
1564 
1565 static int flv_read_seek(AVFormatContext *s, int stream_index,
1566  int64_t ts, int flags)
1567 {
1568  FLVContext *flv = s->priv_data;
1569  flv->validate_count = 0;
1570  return avio_seek_time(s->pb, stream_index, ts, flags);
1571 }
1572 
1573 #define OFFSET(x) offsetof(FLVContext, x)
1574 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1575 static const AVOption options[] = {
1576  { "flv_metadata", "Allocate streams according to the onMetaData array", OFFSET(trust_metadata), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
1577  { "flv_full_metadata", "Dump full metadata of the onMetadata", OFFSET(dump_full_metadata), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
1578  { "flv_ignore_prevtag", "Ignore the Size of previous tag", OFFSET(trust_datasize), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
1579  { "missing_streams", "", OFFSET(missing_streams), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 0xFF, VD | AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY },
1580  { NULL }
1581 };
1582 
1583 static const AVClass flv_kux_class = {
1584  .class_name = "(live) flv/kux demuxer",
1585  .item_name = av_default_item_name,
1586  .option = options,
1587  .version = LIBAVUTIL_VERSION_INT,
1588 };
1589 
1591  .p.name = "flv",
1592  .p.long_name = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1593  .p.extensions = "flv",
1594  .p.priv_class = &flv_kux_class,
1595  .priv_data_size = sizeof(FLVContext),
1596  .read_probe = flv_probe,
1601 };
1602 
1604  .p.name = "live_flv",
1605  .p.long_name = NULL_IF_CONFIG_SMALL("live RTMP FLV (Flash Video)"),
1606  .p.extensions = "flv",
1607  .p.priv_class = &flv_kux_class,
1608  .p.flags = AVFMT_TS_DISCONT,
1609  .priv_data_size = sizeof(FLVContext),
1615 };
1616 
1618  .p.name = "kux",
1619  .p.long_name = NULL_IF_CONFIG_SMALL("KUX (YouKu)"),
1620  .p.extensions = "kux",
1621  .p.priv_class = &flv_kux_class,
1622  .priv_data_size = sizeof(FLVContext),
1623  .read_probe = kux_probe,
1628 };
AVCOL_PRI_RESERVED
@ AVCOL_PRI_RESERVED
Definition: pixfmt.h:559
FLV_CODECID_NELLYMOSER_16KHZ_MONO
@ FLV_CODECID_NELLYMOSER_16KHZ_MONO
Definition: flv.h:101
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:328
AVMasteringDisplayMetadata::has_primaries
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
Definition: mastering_display_metadata.h:62
FLVContext::audio_bit_rate
int64_t audio_bit_rate
Definition: flvdec.c:97
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:427
AMF_DATA_TYPE_OBJECT_END
@ AMF_DATA_TYPE_OBJECT_END
Definition: flv.h:147
AMF_END_OF_OBJECT
#define AMF_END_OF_OBJECT
Definition: flv.h:53
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_CODEC_ID_VP6F
@ AV_CODEC_ID_VP6F
Definition: codec_id.h:144
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVMasteringDisplayMetadata::max_luminance
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:57
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
FLV_TAG_TYPE_VIDEO
@ FLV_TAG_TYPE_VIDEO
Definition: flv.h:67
FLVMasteringMeta::g_y
double g_y
Definition: flvdec.c:53
FLVContext::pos
int64_t pos
Definition: flvdec.c:83
FLVMasteringMeta::r_x
double r_x
Definition: flvdec.c:50
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
FLV_FRAME_KEY
@ FLV_FRAME_KEY
key frame (for AVC, a seekable frame)
Definition: flv.h:131
FLVMetaVideoColor::max_cll
uint64_t max_cll
Definition: flvdec.c:66
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
clear_index_entries
static void clear_index_entries(AVFormatContext *s, int64_t pos)
Definition: flvdec.c:922
FLVContext::validate_next
int validate_next
Definition: flvdec.c:85
out
FILE * out
Definition: movenc.c:55
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
AVFMT_FLAG_IGNIDX
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1408
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:169
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
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
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:814
AV_PKT_DATA_MASTERING_DISPLAY_METADATA
@ AV_PKT_DATA_MASTERING_DISPLAY_METADATA
Mastering display metadata (based on SMPTE-2086:2014).
Definition: packet.h:223
av_int2double
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
Definition: intfloat.h:60
AVMasteringDisplayMetadata::display_primaries
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
Definition: mastering_display_metadata.h:42
AVMasteringDisplayMetadata::has_luminance
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
Definition: mastering_display_metadata.h:67
TYPE_ONCAPTIONINFO
#define TYPE_ONCAPTIONINFO
Definition: flvdec.c:784
flv_data_packet
static int flv_data_packet(AVFormatContext *s, AVPacket *pkt, int64_t dts, int64_t next)
Definition: flvdec.c:986
dict_internal.h
av_unused
#define av_unused
Definition: attributes.h:131
FLV_CODECID_SCREEN
@ FLV_CODECID_SCREEN
Definition: flv.h:112
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
AVContentLightMetadata::MaxCLL
unsigned MaxCLL
Max content light level (cd/m^2).
Definition: mastering_display_metadata.h:111
FLVContext::time_offset
int64_t time_offset
Definition: flvdec.c:103
FLVContext::trust_metadata
int trust_metadata
configure streams according onMetaData
Definition: flvdec.c:73
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:375
flv_read_packet
static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: flvdec.c:1192
FLV_CODECID_SPEEX
@ FLV_CODECID_SPEEX
Definition: flv.h:107
TYPE_ONCAPTION
#define TYPE_ONCAPTION
Definition: flvdec.c:783
AVOption
AVOption.
Definition: opt.h:357
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
FLVContext::resync_buffer
uint8_t resync_buffer[2 *RESYNC_BUFFER_SIZE]
Definition: flvdec.c:89
amf_date
Definition: flvdec.c:111
AMF_DATA_TYPE_UNDEFINED
@ AMF_DATA_TYPE_UNDEFINED
Definition: flv.h:144
AMF_DATA_TYPE_DATE
@ AMF_DATA_TYPE_DATE
Definition: flv.h:149
FLV_CODECID_PCM_ALAW
@ FLV_CODECID_PCM_ALAW
Definition: flv.h:104
flv_set_audio_codec
static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream, AVCodecParameters *apar, int flv_codecid)
Definition: flvdec.c:271
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:454
FLVMasteringMeta::b_y
double b_y
Definition: flvdec.c:55
FLV_CODECID_PCM_LE
@ FLV_CODECID_PCM_LE
Definition: flv.h:100
FLVContext::trust_datasize
int trust_datasize
trust data size of FLVTag
Definition: flvdec.c:74
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
intfloat.h
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
AMF_DATA_TYPE_OBJECT
@ AMF_DATA_TYPE_OBJECT
Definition: flv.h:142
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:323
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:579
sample_rate
sample_rate
Definition: ffmpeg_filter.c:424
ff_live_flv_demuxer
const FFInputFormat ff_live_flv_demuxer
Definition: flvdec.c:1603
options
static const AVOption options[]
Definition: flvdec.c:1575
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
FLVMasteringMeta
Definition: flvdec.c:49
FLV_CODECID_VP6A
@ FLV_CODECID_VP6A
Definition: flv.h:114
FLVContext::validate_index
struct FLVContext::@340 validate_index[2]
ff_get_extradata
int ff_get_extradata(void *logctx, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: demux_utils.c:335
AVContentLightMetadata
Content light level needed by to transmit HDR over HDMI (CTA-861.3).
Definition: mastering_display_metadata.h:107
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:167
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
FLVMetaVideoColor::primaries
uint64_t primaries
Definition: flvdec.c:65
FLVContext::video_bit_rate
int64_t video_bit_rate
Definition: flvdec.c:96
FLVContext::searched_for_end
int searched_for_end
Definition: flvdec.c:87
AVCOL_SPC_RESERVED
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
Definition: pixfmt.h:613
FLVContext::keyframe_times
int64_t * keyframe_times
Definition: flvdec.c:98
FLVContext::keyframe_filepositions
int64_t * keyframe_filepositions
Definition: flvdec.c:99
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:853
finish
static void finish(void)
Definition: movenc.c:373
OFFSET
#define OFFSET(x)
Definition: flvdec.c:1573
av_packet_add_side_data
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
Definition: packet.c:197
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:475
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:417
FLVContext::last_ts
int64_t last_ts
Definition: flvdec.c:102
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:329
FLV_FRAME_DISP_INTER
@ FLV_FRAME_DISP_INTER
disposable inter frame (H.263 only)
Definition: flv.h:133
avio_seek_time
int64_t avio_seek_time(AVIOContext *h, int stream_index, int64_t timestamp, int flags)
Seek to a given timestamp relative to some component stream.
Definition: aviobuf.c:1232
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
av_add_index_entry
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: seek.c:121
TYPE_ONTEXTDATA
#define TYPE_ONTEXTDATA
Definition: flvdec.c:782
flv_read_seek
static int flv_read_seek(AVFormatContext *s, int stream_index, int64_t ts, int flags)
Definition: flvdec.c:1565
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
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
pts
static int64_t pts
Definition: transcode_aac.c:644
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:441
FLV_AUDIO_CODECID_OFFSET
#define FLV_AUDIO_CODECID_OFFSET
Definition: flv.h:34
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:168
FLV_CODECID_NELLYMOSER_8KHZ_MONO
@ FLV_CODECID_NELLYMOSER_8KHZ_MONO
Definition: flv.h:102
VD
#define VD
Definition: flvdec.c:1574
avassert.h
AMFDataType
AMFDataType
Definition: flv.h:138
parse_keyframes_index
static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc, int64_t max_pos)
Definition: flvdec.c:449
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:761
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
VALIDATE_INDEX_TS_THRESH
#define VALIDATE_INDEX_TS_THRESH
Definition: flvdec.c:43
AVCOL_PRI_RESERVED0
@ AVCOL_PRI_RESERVED0
Definition: pixfmt.h:556
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
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:62
FLVContext::new_extradata_size
int new_extradata_size[FLV_STREAM_TYPE_NB]
Definition: flvdec.c:78
AVMasteringDisplayMetadata::white_point
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
Definition: mastering_display_metadata.h:47
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AMF_DATA_TYPE_UNSUPPORTED
@ AMF_DATA_TYPE_UNSUPPORTED
Definition: flv.h:151
FLV_CODECID_MPEG4
@ FLV_CODECID_MPEG4
Definition: flv.h:118
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_VP9
@ AV_CODEC_ID_VP9
Definition: codec_id.h:220
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
create_stream
static AVStream * create_stream(AVFormatContext *s, int codec_type)
Definition: flvdec.c:190
FLVContext::dts
int64_t dts
Definition: flvdec.c:82
amf_skip_tag
static int amf_skip_tag(AVIOContext *pb, AMFDataType type, int depth)
Definition: flvdec.c:937
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
FLV_CODECID_MP3
@ FLV_CODECID_MP3
Definition: flv.h:99
FLV_AUDIO_CHANNEL_MASK
#define FLV_AUDIO_CHANNEL_MASK
Definition: flv.h:45
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVPacketSideData::data
uint8_t * data
Definition: packet.h:376
channels
channels
Definition: aptx.h:31
FLVContext::time_pos
int64_t time_pos
Definition: flvdec.c:104
isfinite
#define isfinite(x)
Definition: libm.h:359
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:334
FLVMasteringMeta::g_x
double g_x
Definition: flvdec.c:52
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:392
live_flv_probe
static int live_flv_probe(const AVProbeData *p)
Definition: flvdec.c:140
KEYFRAMES_TIMESTAMP_TAG
#define KEYFRAMES_TIMESTAMP_TAG
Definition: flv.h:56
key
const char * key
Definition: hwcontext_opencl.c:189
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
FLV_STREAM_TYPE_DATA
@ FLV_STREAM_TYPE_DATA
Definition: flv.h:75
FLVContext::sum_flv_tag_size
int64_t sum_flv_tag_size
Definition: flvdec.c:92
FLV_VIDEO_FRAMETYPE_MASK
#define FLV_VIDEO_FRAMETYPE_MASK
Definition: flv.h:51
fsize
static int64_t fsize(FILE *f)
Definition: audiomatch.c:29
AVDISCARD_BIDIR
@ AVDISCARD_BIDIR
discard all bidirectional frames
Definition: defs.h:216
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
av_content_light_metadata_alloc
AVContentLightMetadata * av_content_light_metadata_alloc(size_t *size)
Allocate an AVContentLightMetadata structure and set its fields to default values.
Definition: mastering_display_metadata.c:58
TYPE_UNKNOWN
#define TYPE_UNKNOWN
Definition: flvdec.c:785
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:73
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:386
FLVMasteringMeta::r_y
double r_y
Definition: flvdec.c:51
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:335
flv_read_close
static int flv_read_close(AVFormatContext *s)
Definition: flvdec.c:882
AV_CODEC_ID_FLASHSV2
@ AV_CODEC_ID_FLASHSV2
Definition: codec_id.h:183
internal.h
FLVMasteringMeta::white_y
double white_y
Definition: flvdec.c:57
AVCOL_TRC_RESERVED0
@ AVCOL_TRC_RESERVED0
Definition: pixfmt.h:581
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
FLV_CODECID_NELLYMOSER
@ FLV_CODECID_NELLYMOSER
Definition: flv.h:103
add_keyframes_index
static void add_keyframes_index(AVFormatContext *s)
Definition: flvdec.c:159
NULL
#define NULL
Definition: coverity.c:32
FLV_HEADER_FLAG_HASVIDEO
@ FLV_HEADER_FLAG_HASVIDEO
Definition: flv.h:61
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AV_CODEC_ID_AV1
@ AV_CODEC_ID_AV1
Definition: codec_id.h:280
avcodec_parameters_free
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: codec_par.c:66
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1206
AMF_DATA_TYPE_BOOL
@ AMF_DATA_TYPE_BOOL
Definition: flv.h:140
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
flv_read_header
static int flv_read_header(AVFormatContext *s)
Definition: flvdec.c:844
isnan
#define isnan(x)
Definition: libm.h:340
FLV_STREAM_TYPE_AUDIO
@ FLV_STREAM_TYPE_AUDIO
Definition: flv.h:73
flv_same_audio_codec
static int flv_same_audio_codec(AVCodecParameters *apar, int flags)
Definition: flvdec.c:220
FLVContext::meta_color_info_flag
int meta_color_info_flag
Definition: flvdec.c:107
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:908
FFStream::nb_index_entries
int nb_index_entries
Definition: internal.h:251
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
FLV_HEADER_FLAG_HASAUDIO
@ FLV_HEADER_FLAG_HASAUDIO
Definition: flv.h:62
flv.h
FLVContext::last_channels
int last_channels
Definition: flvdec.c:80
AMF_DATA_TYPE_ARRAY
@ AMF_DATA_TYPE_ARRAY
Definition: flv.h:148
AV_CODEC_ID_FLASHSV
@ AV_CODEC_ID_FLASHSV
Definition: codec_id.h:138
flv_parse_video_color_info
static int flv_parse_video_color_info(AVFormatContext *s, AVStream *st, int64_t next_pos)
Definition: flvdec.c:1095
FLVContext::keyframe_count
int keyframe_count
Definition: flvdec.c:95
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
AV_CODEC_ID_VP6A
@ AV_CODEC_ID_VP6A
Definition: codec_id.h:158
FLV_CODECID_VP6
@ FLV_CODECID_VP6
Definition: flv.h:113
AV_PKT_DATA_CONTENT_LIGHT_LEVEL
@ AV_PKT_DATA_CONTENT_LIGHT_LEVEL
Content light level (based on CTA-861.3).
Definition: packet.h:236
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:461
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
FLVContext::metaVideoColor
FLVMetaVideoColor * metaVideoColor
Definition: flvdec.c:106
FLVContext::missing_streams
int missing_streams
Definition: flvdec.c:100
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
FLVMasteringMeta::white_x
double white_x
Definition: flvdec.c:56
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:218
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
FLV_STEREO
@ FLV_STEREO
Definition: flv.h:81
avio_rb24
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:754
AVMediaType
AVMediaType
Definition: avutil.h:199
AVPacket::size
int size
Definition: packet.h:525
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:94
KEYFRAMES_BYTEOFFSET_TAG
#define KEYFRAMES_BYTEOFFSET_TAG
Definition: flv.h:57
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
FFStream
Definition: internal.h:193
flv_update_video_color_info
static int flv_update_video_color_info(AVFormatContext *s, AVStream *st)
Definition: flvdec.c:1122
PacketTypeCodedFrames
@ PacketTypeCodedFrames
Definition: flv.h:123
FLVMetaVideoColor::mastering_meta
FLVMasteringMeta mastering_meta
Definition: flvdec.c:68
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:56
AV_CODEC_ID_ADPCM_SWF
@ AV_CODEC_ID_ADPCM_SWF
Definition: codec_id.h:380
size
int size
Definition: twinvq_data.h:10344
ff_add_param_change
int ff_add_param_change(AVPacket *pkt, int32_t channels, uint64_t channel_layout, int32_t sample_rate, int32_t width, int32_t height)
Add side data to a packet for changing parameters to the given values.
Definition: demux_utils.c:151
FLVMetaVideoColor
Definition: flvdec.c:62
FLVContext
Definition: flvdec.c:71
FLV_CODECID_H264
@ FLV_CODECID_H264
Definition: flv.h:116
FLV_CODECID_ADPCM
@ FLV_CODECID_ADPCM
Definition: flv.h:98
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
AV_RB32
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_RB32
Definition: bytestream.h:96
FLV_STREAM_TYPE_NB
@ FLV_STREAM_TYPE_NB
Definition: flv.h:76
ff_flv_demuxer
const FFInputFormat ff_flv_demuxer
Definition: flvdec.c:1590
FLV_CODECID_REALH263
@ FLV_CODECID_REALH263
Definition: flv.h:117
FLV_TAG_TYPE_AUDIO
@ FLV_TAG_TYPE_AUDIO
Definition: flv.h:66
MAX_DEPTH
#define MAX_DEPTH
arbitrary limit to prevent unbounded recursion
Definition: flvdec.c:47
amf_date::timezone
int16_t timezone
Definition: flvdec.c:113
KEYFRAMES_TAG
#define KEYFRAMES_TAG
Definition: flv.h:55
FLV_CODECID_H263
@ FLV_CODECID_H263
Definition: flv.h:111
FLVMetaVideoColor::transfer_characteristics
uint64_t transfer_characteristics
Definition: flvdec.c:64
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:41
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:523
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
av_packet_side_data_add
AVPacketSideData * av_packet_side_data_add(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, void *data, size_t size, int flags)
Wrap existing data as packet side data.
Definition: packet.c:697
offset
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 offset
Definition: writing_filters.txt:86
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
version
version
Definition: libkvazaar.c:321
FLVMetaVideoColor::max_fall
uint64_t max_fall
Definition: flvdec.c:67
FLVMasteringMeta::b_x
double b_x
Definition: flvdec.c:54
FFERROR_REDO
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data).
Definition: demux.h:171
FLVMetaVideoColor::matrix_coefficients
uint64_t matrix_coefficients
Definition: flvdec.c:63
kux_probe
static int kux_probe(const AVProbeData *p)
Definition: flvdec.c:145
AV_OPT_FLAG_READONLY
#define AV_OPT_FLAG_READONLY
The option may not be set through the AVOptions API, only read.
Definition: opt.h:296
av_channel_layout_default
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
Definition: channel_layout.c:831
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:56
FLV_CODECID_PCM
@ FLV_CODECID_PCM
Definition: flv.h:97
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:517
FLVContext::last_keyframe_stream_index
int last_keyframe_stream_index
Definition: flvdec.c:94
flv_read_metabody
static int flv_read_metabody(AVFormatContext *s, int64_t next_pos)
Definition: flvdec.c:787
internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:135
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
resync
static int resync(AVFormatContext *s)
Definition: flvdec.c:1053
FLVContext::framerate
AVRational framerate
Definition: flvdec.c:101
flv_probe
static int flv_probe(const AVProbeData *p)
Definition: flvdec.c:135
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
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:256
FLV_AUDIO_SAMPLERATE_OFFSET
#define FLV_AUDIO_SAMPLERATE_OFFSET
Definition: flv.h:33
demux.h
AVMasteringDisplayMetadata
Mastering display metadata capable of representing the color volume of the display used to master the...
Definition: mastering_display_metadata.h:38
FLVContext::wrong_dts
int wrong_dts
wrong dts due to negative cts
Definition: flvdec.c:76
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
flv_queue_extradata
static int flv_queue_extradata(FLVContext *flv, AVIOContext *pb, int stream, int size)
Definition: flvdec.c:906
AMF_DATA_TYPE_MIXEDARRAY
@ AMF_DATA_TYPE_MIXEDARRAY
Definition: flv.h:146
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:91
AMF_DATA_TYPE_STRING
@ AMF_DATA_TYPE_STRING
Definition: flv.h:141
FLVContext::new_extradata
uint8_t * new_extradata[FLV_STREAM_TYPE_NB]
Definition: flvdec.c:77
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
array
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:111
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
probe
static int probe(const AVProbeData *p, int live)
Definition: flvdec.c:116
flv_kux_class
static const AVClass flv_kux_class
Definition: flvdec.c:1583
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
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
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:746
av_channel_layout_check
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
Definition: channel_layout.c:775
FLVMasteringMeta::min_luminance
double min_luminance
Definition: flvdec.c:59
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:594
pos
unsigned int pos
Definition: spdifenc.c:414
avformat.h
dict.h
av_packet_side_data_new
AVPacketSideData * av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, size_t size, int flags)
Allocate a new packet side data.
Definition: packet.c:704
AV_CODEC_ID_TEXT
@ AV_CODEC_ID_TEXT
raw UTF-8 text
Definition: codec_id.h:552
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
amf_get_string
static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize)
Definition: flvdec.c:429
av_sat_add64
#define av_sat_add64
Definition: common.h:141
FLVMasteringMeta::max_luminance
double max_luminance
Definition: flvdec.c:58
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
channel_layout.h
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:245
FLV_TAG_TYPE_META
@ FLV_TAG_TYPE_META
Definition: flv.h:68
flv_set_video_codec
static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream, uint32_t flv_codecid, int read)
Definition: flvdec.c:360
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:612
amf_parse_object
static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, int64_t max_pos, int depth)
Definition: flvdec.c:544
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:603
AVIOContext::eof_reached
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:238
FLV_CODECID_SCREEN2
@ FLV_CODECID_SCREEN2
Definition: flv.h:115
flv_same_video_codec
static int flv_same_video_codec(AVCodecParameters *vpar, uint32_t flv_codecid)
Definition: flvdec.c:331
AVMasteringDisplayMetadata::min_luminance
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
Definition: mastering_display_metadata.h:52
AVPacket::stream_index
int stream_index
Definition: packet.h:526
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
factor
static const int factor[16]
Definition: vf_pp7.c:79
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:249
ff_kux_demuxer
const FFInputFormat ff_kux_demuxer
Definition: flvdec.c:1617
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:110
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:481
mem.h
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:333
mastering_display_metadata.h
FLV_CODECID_AAC
@ FLV_CODECID_AAC
Definition: flv.h:106
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AVCOL_TRC_RESERVED
@ AVCOL_TRC_RESERVED
Definition: pixfmt.h:584
flv_get_extradata
static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size)
Definition: flvdec.c:894
AMF_DATA_TYPE_NUMBER
@ AMF_DATA_TYPE_NUMBER
Definition: flv.h:139
FLV_CODECID_PCM_MULAW
@ FLV_CODECID_PCM_MULAW
Definition: flv.h:105
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AV_OPT_FLAG_EXPORT
#define AV_OPT_FLAG_EXPORT
The option is intended for exporting values to the caller.
Definition: opt.h:291
AVContentLightMetadata::MaxFALL
unsigned MaxFALL
Max average light level per frame (cd/m^2).
Definition: mastering_display_metadata.h:116
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:261
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
FLV_AUDIO_CODECID_MASK
#define FLV_AUDIO_CODECID_MASK
Definition: flv.h:48
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:544
FFInputFormat
Definition: demux.h:37
FLV_AUDIO_SAMPLERATE_MASK
#define FLV_AUDIO_SAMPLERATE_MASK
Definition: flv.h:47
d
d
Definition: ffmpeg_filter.c:424
int32_t
int32_t
Definition: audioconvert.c:56
FLV_VIDEO_CODECID_MASK
#define FLV_VIDEO_CODECID_MASK
Definition: flv.h:50
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:593
FFStream::need_context_update
int need_context_update
Whether the internal avctx needs to be updated from codecpar (after a late change to codecpar)
Definition: internal.h:238
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
FLVContext::validate_count
int validate_count
Definition: flvdec.c:86
PacketTypeMetadata
@ PacketTypeMetadata
Definition: flv.h:126
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
FLV_STREAM_TYPE_VIDEO
@ FLV_STREAM_TYPE_VIDEO
Definition: flv.h:72
FLV_AUDIO_SAMPLESIZE_MASK
#define FLV_AUDIO_SAMPLESIZE_MASK
Definition: flv.h:46
AVDictionaryEntry::value
char * value
Definition: dict.h:91
avstring.h
FlvTagType
FlvTagType
Definition: flv.h:65
FLV_STREAM_TYPE_SUBTITLE
@ FLV_STREAM_TYPE_SUBTITLE
Definition: flv.h:74
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:73
amf_date::milliseconds
double milliseconds
Definition: flvdec.c:112
AV_RB24
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_RB24
Definition: bytestream.h:97
int
int
Definition: ffmpeg_filter.c:424
FLV_FRAME_VIDEO_INFO_CMD
@ FLV_FRAME_VIDEO_INFO_CMD
video info/command frame
Definition: flv.h:135
snprintf
#define snprintf
Definition: snprintf.h:34
FLVContext::dump_full_metadata
int dump_full_metadata
Dump full metadata of the onMetadata.
Definition: flvdec.c:75
avpriv_dict_set_timestamp
int avpriv_dict_set_timestamp(AVDictionary **dict, const char *key, int64_t timestamp)
Set a dictionary value to an ISO-8601 compliant timestamp string.
Definition: dict.c:278
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
FLVContext::last_sample_rate
int last_sample_rate
Definition: flvdec.c:79
max_pos
static const int32_t max_pos[4]
Size of the MP-MLQ fixed excitation codebooks.
Definition: g723_1dec.c:97
read
static uint32_t BS_FUNC() read(BSCTX *bc, unsigned int n)
Return n bits from the buffer, n has to be in the 0-32 range.
Definition: bitstream_template.h:231
AMF_DATA_TYPE_NULL
@ AMF_DATA_TYPE_NULL
Definition: flv.h:143
AVFMT_EVENT_FLAG_METADATA_UPDATED
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
Definition: avformat.h:1632
RESYNC_BUFFER_SIZE
#define RESYNC_BUFFER_SIZE
Definition: flvdec.c:45
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:473
FLVContext::broken_sizes
int broken_sizes
Definition: flvdec.c:91
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:227
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346