FFmpeg  4.3
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/avstring.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/intfloat.h"
32 #include "libavutil/mathematics.h"
34 #include "libavcodec/bytestream.h"
35 #include "avformat.h"
36 #include "internal.h"
37 #include "avio_internal.h"
38 #include "flv.h"
39 
40 #define VALIDATE_INDEX_TS_THRESH 2500
41 
42 #define RESYNC_BUFFER_SIZE (1<<20)
43 
44 typedef struct FLVContext {
45  const AVClass *class; ///< Class for private options.
46  int trust_metadata; ///< configure streams according onMetaData
47  int trust_datasize; ///< trust data size of FLVTag
48  int dump_full_metadata; ///< Dump full metadata of the onMetadata
49  int wrong_dts; ///< wrong dts due to negative cts
54  struct {
55  int64_t dts;
56  int64_t pos;
57  } validate_index[2];
61 
63 
66 
69  int64_t video_bit_rate;
70  int64_t audio_bit_rate;
71  int64_t *keyframe_times;
75  int64_t last_ts;
76  int64_t time_offset;
77  int64_t time_pos;
78 } FLVContext;
79 
80 /* AMF date type */
81 typedef struct amf_date {
82  double milliseconds;
83  int16_t timezone;
84 } amf_date;
85 
86 static int probe(const AVProbeData *p, int live)
87 {
88  const uint8_t *d = p->buf;
89  unsigned offset = AV_RB32(d + 5);
90 
91  if (d[0] == 'F' &&
92  d[1] == 'L' &&
93  d[2] == 'V' &&
94  d[3] < 5 && d[5] == 0 &&
95  offset + 100 < p->buf_size &&
96  offset > 8) {
97  int is_live = !memcmp(d + offset + 40, "NGINX RTMP", 10);
98 
99  if (live == is_live)
100  return AVPROBE_SCORE_MAX;
101  }
102  return 0;
103 }
104 
105 static int flv_probe(const AVProbeData *p)
106 {
107  return probe(p, 0);
108 }
109 
110 static int live_flv_probe(const AVProbeData *p)
111 {
112  return probe(p, 1);
113 }
114 
115 static int kux_probe(const AVProbeData *p)
116 {
117  const uint8_t *d = p->buf;
118 
119  if (d[0] == 'K' &&
120  d[1] == 'D' &&
121  d[2] == 'K' &&
122  d[3] == 0 &&
123  d[4] == 0) {
124  return AVPROBE_SCORE_EXTENSION + 1;
125  }
126  return 0;
127 }
128 
130 {
131  FLVContext *flv = s->priv_data;
132  AVStream *stream = NULL;
133  unsigned int i = 0;
134 
135  if (flv->last_keyframe_stream_index < 0) {
136  av_log(s, AV_LOG_DEBUG, "keyframe stream hasn't been created\n");
137  return;
138  }
139 
140  av_assert0(flv->last_keyframe_stream_index <= s->nb_streams);
141  stream = s->streams[flv->last_keyframe_stream_index];
142 
143  if (stream->nb_index_entries == 0) {
144  for (i = 0; i < flv->keyframe_count; i++) {
145  av_log(s, AV_LOG_TRACE, "keyframe filepositions = %"PRId64" times = %"PRId64"\n",
146  flv->keyframe_filepositions[i], flv->keyframe_times[i] * 1000);
148  flv->keyframe_times[i] * 1000, 0, 0, AVINDEX_KEYFRAME);
149  }
150  } else
151  av_log(s, AV_LOG_WARNING, "Skipping duplicate index\n");
152 
153  if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
154  av_freep(&flv->keyframe_times);
156  flv->keyframe_count = 0;
157  }
158 }
159 
161 {
162  FLVContext *flv = s->priv_data;
164  if (!st)
165  return NULL;
167  if (s->nb_streams>=3 ||( s->nb_streams==2
168  && s->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE
169  && s->streams[1]->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE
170  && s->streams[0]->codecpar->codec_type != AVMEDIA_TYPE_DATA
171  && s->streams[1]->codecpar->codec_type != AVMEDIA_TYPE_DATA))
172  s->ctx_flags &= ~AVFMTCTX_NOHEADER;
174  st->codecpar->bit_rate = flv->audio_bit_rate;
176  }
178  st->codecpar->bit_rate = flv->video_bit_rate;
180  st->avg_frame_rate = flv->framerate;
181  }
182 
183 
184  avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
185  flv->last_keyframe_stream_index = s->nb_streams - 1;
187  return st;
188 }
189 
191 {
192  int bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
193  int flv_codecid = flags & FLV_AUDIO_CODECID_MASK;
194  int codec_id;
195 
196  if (!apar->codec_id && !apar->codec_tag)
197  return 1;
198 
199  if (apar->bits_per_coded_sample != bits_per_coded_sample)
200  return 0;
201 
202  switch (flv_codecid) {
203  // no distinction between S16 and S8 PCM codec flags
204  case FLV_CODECID_PCM:
205  codec_id = bits_per_coded_sample == 8
207 #if HAVE_BIGENDIAN
209 #else
211 #endif
212  return codec_id == apar->codec_id;
213  case FLV_CODECID_PCM_LE:
214  codec_id = bits_per_coded_sample == 8
217  return codec_id == apar->codec_id;
218  case FLV_CODECID_AAC:
219  return apar->codec_id == AV_CODEC_ID_AAC;
220  case FLV_CODECID_ADPCM:
221  return apar->codec_id == AV_CODEC_ID_ADPCM_SWF;
222  case FLV_CODECID_SPEEX:
223  return apar->codec_id == AV_CODEC_ID_SPEEX;
224  case FLV_CODECID_MP3:
225  return apar->codec_id == AV_CODEC_ID_MP3;
229  return apar->codec_id == AV_CODEC_ID_NELLYMOSER;
231  return apar->sample_rate == 8000 &&
234  return apar->sample_rate == 8000 &&
236  default:
237  return apar->codec_tag == (flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
238  }
239 }
240 
242  AVCodecParameters *apar, int flv_codecid)
243 {
244  switch (flv_codecid) {
245  // no distinction between S16 and S8 PCM codec flags
246  case FLV_CODECID_PCM:
247  apar->codec_id = apar->bits_per_coded_sample == 8
249 #if HAVE_BIGENDIAN
251 #else
253 #endif
254  break;
255  case FLV_CODECID_PCM_LE:
256  apar->codec_id = apar->bits_per_coded_sample == 8
259  break;
260  case FLV_CODECID_AAC:
261  apar->codec_id = AV_CODEC_ID_AAC;
262  break;
263  case FLV_CODECID_ADPCM:
265  break;
266  case FLV_CODECID_SPEEX:
267  apar->codec_id = AV_CODEC_ID_SPEEX;
268  apar->sample_rate = 16000;
269  break;
270  case FLV_CODECID_MP3:
271  apar->codec_id = AV_CODEC_ID_MP3;
273  break;
275  // in case metadata does not otherwise declare samplerate
276  apar->sample_rate = 8000;
278  break;
280  apar->sample_rate = 16000;
282  break;
285  break;
287  apar->sample_rate = 8000;
289  break;
291  apar->sample_rate = 8000;
293  break;
294  default:
295  avpriv_request_sample(s, "Audio codec (%x)",
296  flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
297  apar->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET;
298  }
299 }
300 
302 {
303  int flv_codecid = flags & FLV_VIDEO_CODECID_MASK;
304 
305  if (!vpar->codec_id && !vpar->codec_tag)
306  return 1;
307 
308  switch (flv_codecid) {
309  case FLV_CODECID_H263:
310  return vpar->codec_id == AV_CODEC_ID_FLV1;
311  case FLV_CODECID_SCREEN:
312  return vpar->codec_id == AV_CODEC_ID_FLASHSV;
313  case FLV_CODECID_SCREEN2:
314  return vpar->codec_id == AV_CODEC_ID_FLASHSV2;
315  case FLV_CODECID_VP6:
316  return vpar->codec_id == AV_CODEC_ID_VP6F;
317  case FLV_CODECID_VP6A:
318  return vpar->codec_id == AV_CODEC_ID_VP6A;
319  case FLV_CODECID_H264:
320  return vpar->codec_id == AV_CODEC_ID_H264;
321  default:
322  return vpar->codec_tag == flv_codecid;
323  }
324 }
325 
327  int flv_codecid, int read)
328 {
329  int ret = 0;
330  AVCodecParameters *par = vstream->codecpar;
331  enum AVCodecID old_codec_id = vstream->codecpar->codec_id;
332  switch (flv_codecid) {
333  case FLV_CODECID_H263:
334  par->codec_id = AV_CODEC_ID_FLV1;
335  break;
337  par->codec_id = AV_CODEC_ID_H263;
338  break; // Really mean it this time
339  case FLV_CODECID_SCREEN:
341  break;
342  case FLV_CODECID_SCREEN2:
344  break;
345  case FLV_CODECID_VP6:
346  par->codec_id = AV_CODEC_ID_VP6F;
347  case FLV_CODECID_VP6A:
348  if (flv_codecid == FLV_CODECID_VP6A)
349  par->codec_id = AV_CODEC_ID_VP6A;
350  if (read) {
351  if (par->extradata_size != 1) {
352  ff_alloc_extradata(par, 1);
353  }
354  if (par->extradata)
355  par->extradata[0] = avio_r8(s->pb);
356  else
357  avio_skip(s->pb, 1);
358  }
359  ret = 1; // 1 byte body size adjustment for flv_read_packet()
360  break;
361  case FLV_CODECID_H264:
362  par->codec_id = AV_CODEC_ID_H264;
364  ret = 3; // not 4, reading packet type will consume one byte
365  break;
366  case FLV_CODECID_MPEG4:
368  ret = 3;
369  break;
370  default:
371  avpriv_request_sample(s, "Video codec (%x)", flv_codecid);
372  par->codec_tag = flv_codecid;
373  }
374 
375  if (!vstream->internal->need_context_update && par->codec_id != old_codec_id) {
376  avpriv_request_sample(s, "Changing the codec id midstream");
377  return AVERROR_PATCHWELCOME;
378  }
379 
380  return ret;
381 }
382 
383 static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize)
384 {
385  int length = avio_rb16(ioc);
386  if (length >= buffsize) {
387  avio_skip(ioc, length);
388  return -1;
389  }
390 
391  avio_read(ioc, buffer, length);
392 
393  buffer[length] = '\0';
394 
395  return length;
396 }
397 
399 {
400  FLVContext *flv = s->priv_data;
401  unsigned int timeslen = 0, fileposlen = 0, i;
402  char str_val[256];
403  int64_t *times = NULL;
404  int64_t *filepositions = NULL;
405  int ret = AVERROR(ENOSYS);
406  int64_t initial_pos = avio_tell(ioc);
407 
408  if (flv->keyframe_count > 0) {
409  av_log(s, AV_LOG_DEBUG, "keyframes have been parsed\n");
410  return 0;
411  }
412  av_assert0(!flv->keyframe_times);
414 
415  if (s->flags & AVFMT_FLAG_IGNIDX)
416  return 0;
417 
418  while (avio_tell(ioc) < max_pos - 2 &&
419  amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
420  int64_t **current_array;
421  unsigned int arraylen;
422 
423  // Expect array object in context
424  if (avio_r8(ioc) != AMF_DATA_TYPE_ARRAY)
425  break;
426 
427  arraylen = avio_rb32(ioc);
428  if (arraylen>>28)
429  break;
430 
431  if (!strcmp(KEYFRAMES_TIMESTAMP_TAG , str_val) && !times) {
432  current_array = &times;
433  timeslen = arraylen;
434  } else if (!strcmp(KEYFRAMES_BYTEOFFSET_TAG, str_val) &&
435  !filepositions) {
436  current_array = &filepositions;
437  fileposlen = arraylen;
438  } else
439  // unexpected metatag inside keyframes, will not use such
440  // metadata for indexing
441  break;
442 
443  if (!(*current_array = av_mallocz(sizeof(**current_array) * arraylen))) {
444  ret = AVERROR(ENOMEM);
445  goto finish;
446  }
447 
448  for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++) {
449  if (avio_r8(ioc) != AMF_DATA_TYPE_NUMBER)
450  goto invalid;
451  current_array[0][i] = av_int2double(avio_rb64(ioc));
452  }
453  if (times && filepositions) {
454  // All done, exiting at a position allowing amf_parse_object
455  // to finish parsing the object
456  ret = 0;
457  break;
458  }
459  }
460 
461  if (timeslen == fileposlen && fileposlen>1 && max_pos <= filepositions[0]) {
462  for (i = 0; i < FFMIN(2,fileposlen); i++) {
463  flv->validate_index[i].pos = filepositions[i];
464  flv->validate_index[i].dts = times[i] * 1000;
465  flv->validate_count = i + 1;
466  }
467  flv->keyframe_times = times;
468  flv->keyframe_filepositions = filepositions;
469  flv->keyframe_count = timeslen;
470  times = NULL;
471  filepositions = NULL;
472  } else {
473 invalid:
474  av_log(s, AV_LOG_WARNING, "Invalid keyframes object, skipping.\n");
475  }
476 
477 finish:
478  av_freep(&times);
479  av_freep(&filepositions);
480  avio_seek(ioc, initial_pos, SEEK_SET);
481  return ret;
482 }
483 
485  AVStream *vstream, const char *key,
486  int64_t max_pos, int depth)
487 {
488  AVCodecParameters *apar, *vpar;
489  FLVContext *flv = s->priv_data;
490  AVIOContext *ioc;
491  AMFDataType amf_type;
492  char str_val[1024];
493  double num_val;
494  amf_date date;
495 
496  num_val = 0;
497  ioc = s->pb;
498  amf_type = avio_r8(ioc);
499 
500  switch (amf_type) {
502  num_val = av_int2double(avio_rb64(ioc));
503  break;
504  case AMF_DATA_TYPE_BOOL:
505  num_val = avio_r8(ioc);
506  break;
508  if (amf_get_string(ioc, str_val, sizeof(str_val)) < 0) {
509  av_log(s, AV_LOG_ERROR, "AMF_DATA_TYPE_STRING parsing failed\n");
510  return -1;
511  }
512  break;
514  if (key &&
515  (ioc->seekable & AVIO_SEEKABLE_NORMAL) &&
516  !strcmp(KEYFRAMES_TAG, key) && depth == 1)
517  if (parse_keyframes_index(s, ioc,
518  max_pos) < 0)
519  av_log(s, AV_LOG_ERROR, "Keyframe index parsing failed\n");
520  else
522  while (avio_tell(ioc) < max_pos - 2 &&
523  amf_get_string(ioc, str_val, sizeof(str_val)) > 0)
524  if (amf_parse_object(s, astream, vstream, str_val, max_pos,
525  depth + 1) < 0)
526  return -1; // if we couldn't skip, bomb out.
527  if (avio_r8(ioc) != AMF_END_OF_OBJECT) {
528  av_log(s, AV_LOG_ERROR, "Missing AMF_END_OF_OBJECT in AMF_DATA_TYPE_OBJECT\n");
529  return -1;
530  }
531  break;
532  case AMF_DATA_TYPE_NULL:
535  break; // these take up no additional space
537  {
538  unsigned v;
539  avio_skip(ioc, 4); // skip 32-bit max array index
540  while (avio_tell(ioc) < max_pos - 2 &&
541  amf_get_string(ioc, str_val, sizeof(str_val)) > 0)
542  // this is the only case in which we would want a nested
543  // parse to not skip over the object
544  if (amf_parse_object(s, astream, vstream, str_val, max_pos,
545  depth + 1) < 0)
546  return -1;
547  v = avio_r8(ioc);
548  if (v != AMF_END_OF_OBJECT) {
549  av_log(s, AV_LOG_ERROR, "Missing AMF_END_OF_OBJECT in AMF_DATA_TYPE_MIXEDARRAY, found %d\n", v);
550  return -1;
551  }
552  break;
553  }
554  case AMF_DATA_TYPE_ARRAY:
555  {
556  unsigned int arraylen, i;
557 
558  arraylen = avio_rb32(ioc);
559  for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++)
561  depth + 1) < 0)
562  return -1; // if we couldn't skip, bomb out.
563  }
564  break;
565  case AMF_DATA_TYPE_DATE:
566  // timestamp (double) and UTC offset (int16)
567  date.milliseconds = av_int2double(avio_rb64(ioc));
568  date.timezone = avio_rb16(ioc);
569  break;
570  default: // unsupported type, we couldn't skip
571  av_log(s, AV_LOG_ERROR, "unsupported amf type %d\n", amf_type);
572  return -1;
573  }
574 
575  if (key) {
576  apar = astream ? astream->codecpar : NULL;
577  vpar = vstream ? vstream->codecpar : NULL;
578 
579  // stream info doesn't live any deeper than the first object
580  if (depth == 1) {
581  if (amf_type == AMF_DATA_TYPE_NUMBER ||
582  amf_type == AMF_DATA_TYPE_BOOL) {
583  if (!strcmp(key, "duration"))
584  s->duration = num_val * AV_TIME_BASE;
585  else if (!strcmp(key, "videodatarate") &&
586  0 <= (int)(num_val * 1024.0))
587  flv->video_bit_rate = num_val * 1024.0;
588  else if (!strcmp(key, "audiodatarate") &&
589  0 <= (int)(num_val * 1024.0))
590  flv->audio_bit_rate = num_val * 1024.0;
591  else if (!strcmp(key, "datastream")) {
593  if (!st)
594  return AVERROR(ENOMEM);
596  } else if (!strcmp(key, "framerate")) {
597  flv->framerate = av_d2q(num_val, 1000);
598  if (vstream)
599  vstream->avg_frame_rate = flv->framerate;
600  } else if (flv->trust_metadata) {
601  if (!strcmp(key, "videocodecid") && vpar) {
602  int ret = flv_set_video_codec(s, vstream, num_val, 0);
603  if (ret < 0)
604  return ret;
605  } else if (!strcmp(key, "audiocodecid") && apar) {
606  int id = ((int)num_val) << FLV_AUDIO_CODECID_OFFSET;
607  flv_set_audio_codec(s, astream, apar, id);
608  } else if (!strcmp(key, "audiosamplerate") && apar) {
609  apar->sample_rate = num_val;
610  } else if (!strcmp(key, "audiosamplesize") && apar) {
611  apar->bits_per_coded_sample = num_val;
612  } else if (!strcmp(key, "stereo") && apar) {
613  apar->channels = num_val + 1;
614  apar->channel_layout = apar->channels == 2 ?
617  } else if (!strcmp(key, "width") && vpar) {
618  vpar->width = num_val;
619  } else if (!strcmp(key, "height") && vpar) {
620  vpar->height = num_val;
621  }
622  }
623  }
624  if (amf_type == AMF_DATA_TYPE_STRING) {
625  if (!strcmp(key, "encoder")) {
626  int version = -1;
627  if (1 == sscanf(str_val, "Open Broadcaster Software v0.%d", &version)) {
628  if (version > 0 && version <= 655)
629  flv->broken_sizes = 1;
630  }
631  } else if (!strcmp(key, "metadatacreator")) {
632  if ( !strcmp (str_val, "MEGA")
633  || !strncmp(str_val, "FlixEngine", 10))
634  flv->broken_sizes = 1;
635  }
636  }
637  }
638 
639  if (amf_type == AMF_DATA_TYPE_OBJECT && s->nb_streams == 1 &&
640  ((!apar && !strcmp(key, "audiocodecid")) ||
641  (!vpar && !strcmp(key, "videocodecid"))))
642  s->ctx_flags &= ~AVFMTCTX_NOHEADER; //If there is either audio/video missing, codecid will be an empty object
643 
644  if ((!strcmp(key, "duration") ||
645  !strcmp(key, "filesize") ||
646  !strcmp(key, "width") ||
647  !strcmp(key, "height") ||
648  !strcmp(key, "videodatarate") ||
649  !strcmp(key, "framerate") ||
650  !strcmp(key, "videocodecid") ||
651  !strcmp(key, "audiodatarate") ||
652  !strcmp(key, "audiosamplerate") ||
653  !strcmp(key, "audiosamplesize") ||
654  !strcmp(key, "stereo") ||
655  !strcmp(key, "audiocodecid") ||
656  !strcmp(key, "datastream")) && !flv->dump_full_metadata)
657  return 0;
658 
659  s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
660  if (amf_type == AMF_DATA_TYPE_BOOL) {
661  av_strlcpy(str_val, num_val > 0 ? "true" : "false",
662  sizeof(str_val));
663  av_dict_set(&s->metadata, key, str_val, 0);
664  } else if (amf_type == AMF_DATA_TYPE_NUMBER) {
665  snprintf(str_val, sizeof(str_val), "%.f", num_val);
666  av_dict_set(&s->metadata, key, str_val, 0);
667  } else if (amf_type == AMF_DATA_TYPE_STRING) {
668  av_dict_set(&s->metadata, key, str_val, 0);
669  } else if (amf_type == AMF_DATA_TYPE_DATE) {
670  time_t time;
671  struct tm t;
672  char datestr[128];
673  time = date.milliseconds / 1000; // to seconds
674  localtime_r(&time, &t);
675  strftime(datestr, sizeof(datestr), "%a, %d %b %Y %H:%M:%S %z", &t);
676 
677  av_dict_set(&s->metadata, key, datestr, 0);
678  }
679  }
680 
681  return 0;
682 }
683 
684 #define TYPE_ONTEXTDATA 1
685 #define TYPE_ONCAPTION 2
686 #define TYPE_ONCAPTIONINFO 3
687 #define TYPE_UNKNOWN 9
688 
689 static int flv_read_metabody(AVFormatContext *s, int64_t next_pos)
690 {
691  FLVContext *flv = s->priv_data;
693  AVStream *stream, *astream, *vstream;
694  AVStream av_unused *dstream;
695  AVIOContext *ioc;
696  int i;
697  char buffer[32];
698 
699  astream = NULL;
700  vstream = NULL;
701  dstream = NULL;
702  ioc = s->pb;
703 
704  // first object needs to be "onMetaData" string
705  type = avio_r8(ioc);
706  if (type != AMF_DATA_TYPE_STRING ||
707  amf_get_string(ioc, buffer, sizeof(buffer)) < 0)
708  return TYPE_UNKNOWN;
709 
710  if (!strcmp(buffer, "onTextData"))
711  return TYPE_ONTEXTDATA;
712 
713  if (!strcmp(buffer, "onCaption"))
714  return TYPE_ONCAPTION;
715 
716  if (!strcmp(buffer, "onCaptionInfo"))
717  return TYPE_ONCAPTIONINFO;
718 
719  if (strcmp(buffer, "onMetaData") && strcmp(buffer, "onCuePoint")) {
720  av_log(s, AV_LOG_DEBUG, "Unknown type %s\n", buffer);
721  return TYPE_UNKNOWN;
722  }
723 
724  // find the streams now so that amf_parse_object doesn't need to do
725  // the lookup every time it is called.
726  for (i = 0; i < s->nb_streams; i++) {
727  stream = s->streams[i];
728  if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
729  vstream = stream;
731  } else if (stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
732  astream = stream;
733  if (flv->last_keyframe_stream_index == -1)
735  }
736  else if (stream->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
737  dstream = stream;
738  }
739 
740  // parse the second object (we want a mixed array)
741  if (amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0)
742  return -1;
743 
744  return 0;
745 }
746 
748 {
749  int flags;
750  FLVContext *flv = s->priv_data;
751  int offset;
752  int pre_tag_size = 0;
753 
754  /* Actual FLV data at 0xe40000 in KUX file */
755  if(!strcmp(s->iformat->name, "kux"))
756  avio_skip(s->pb, 0xe40000);
757 
758  avio_skip(s->pb, 4);
759  flags = avio_r8(s->pb);
760 
762 
763  s->ctx_flags |= AVFMTCTX_NOHEADER;
764 
765  offset = avio_rb32(s->pb);
766  avio_seek(s->pb, offset, SEEK_SET);
767 
768  /* Annex E. The FLV File Format
769  * E.3 TheFLVFileBody
770  * Field Type Comment
771  * PreviousTagSize0 UI32 Always 0
772  * */
773  pre_tag_size = avio_rb32(s->pb);
774  if (pre_tag_size) {
775  av_log(s, AV_LOG_WARNING, "Read FLV header error, input file is not a standard flv format, first PreviousTagSize0 always is 0\n");
776  }
777 
778  s->start_time = 0;
779  flv->sum_flv_tag_size = 0;
780  flv->last_keyframe_stream_index = -1;
781 
782  return 0;
783 }
784 
786 {
787  int i;
788  FLVContext *flv = s->priv_data;
789  for (i=0; i<FLV_STREAM_TYPE_NB; i++)
790  av_freep(&flv->new_extradata[i]);
791  av_freep(&flv->keyframe_times);
793  return 0;
794 }
795 
797 {
798  int ret;
799  if (!size)
800  return 0;
801 
802  if ((ret = ff_get_extradata(s, st->codecpar, s->pb, size)) < 0)
803  return ret;
804  st->internal->need_context_update = 1;
805  return 0;
806 }
807 
808 static int flv_queue_extradata(FLVContext *flv, AVIOContext *pb, int stream,
809  int size)
810 {
811  if (!size)
812  return 0;
813 
814  av_free(flv->new_extradata[stream]);
815  flv->new_extradata[stream] = av_mallocz(size +
817  if (!flv->new_extradata[stream])
818  return AVERROR(ENOMEM);
819  flv->new_extradata_size[stream] = size;
820  avio_read(pb, flv->new_extradata[stream], size);
821  return 0;
822 }
823 
824 static void clear_index_entries(AVFormatContext *s, int64_t pos)
825 {
826  int i, j, out;
828  "Found invalid index entries, clearing the index.\n");
829  for (i = 0; i < s->nb_streams; i++) {
830  AVStream *st = s->streams[i];
831  /* Remove all index entries that point to >= pos */
832  out = 0;
833  for (j = 0; j < st->nb_index_entries; j++)
834  if (st->index_entries[j].pos < pos)
835  st->index_entries[out++] = st->index_entries[j];
836  st->nb_index_entries = out;
837  }
838 }
839 
841 {
842  int nb = -1, ret, parse_name = 1;
843 
844  switch (type) {
846  avio_skip(pb, 8);
847  break;
848  case AMF_DATA_TYPE_BOOL:
849  avio_skip(pb, 1);
850  break;
852  avio_skip(pb, avio_rb16(pb));
853  break;
854  case AMF_DATA_TYPE_ARRAY:
855  parse_name = 0;
857  nb = avio_rb32(pb);
859  while(!pb->eof_reached && (nb-- > 0 || type != AMF_DATA_TYPE_ARRAY)) {
860  if (parse_name) {
861  int size = avio_rb16(pb);
862  if (!size) {
863  avio_skip(pb, 1);
864  break;
865  }
866  avio_skip(pb, size);
867  }
868  if ((ret = amf_skip_tag(pb, avio_r8(pb))) < 0)
869  return ret;
870  }
871  break;
872  case AMF_DATA_TYPE_NULL:
874  break;
875  default:
876  return AVERROR_INVALIDDATA;
877  }
878  return 0;
879 }
880 
882  int64_t dts, int64_t next)
883 {
884  AVIOContext *pb = s->pb;
885  AVStream *st = NULL;
886  char buf[20];
887  int ret = AVERROR_INVALIDDATA;
888  int i, length = -1;
889  int array = 0;
890 
891  switch (avio_r8(pb)) {
892  case AMF_DATA_TYPE_ARRAY:
893  array = 1;
895  avio_seek(pb, 4, SEEK_CUR);
897  break;
898  default:
899  goto skip;
900  }
901 
902  while (array || (ret = amf_get_string(pb, buf, sizeof(buf))) > 0) {
903  AMFDataType type = avio_r8(pb);
904  if (type == AMF_DATA_TYPE_STRING && (array || !strcmp(buf, "text"))) {
905  length = avio_rb16(pb);
906  ret = av_get_packet(pb, pkt, length);
907  if (ret < 0)
908  goto skip;
909  else
910  break;
911  } else {
912  if ((ret = amf_skip_tag(pb, type)) < 0)
913  goto skip;
914  }
915  }
916 
917  if (length < 0) {
919  goto skip;
920  }
921 
922  for (i = 0; i < s->nb_streams; i++) {
923  st = s->streams[i];
925  break;
926  }
927 
928  if (i == s->nb_streams) {
930  if (!st)
931  return AVERROR(ENOMEM);
933  }
934 
935  pkt->dts = dts;
936  pkt->pts = dts;
937  pkt->size = ret;
938 
939  pkt->stream_index = st->index;
941 
942 skip:
943  avio_seek(s->pb, next + 4, SEEK_SET);
944 
945  return ret;
946 }
947 
949 {
950  FLVContext *flv = s->priv_data;
951  int64_t i;
952  int64_t pos = avio_tell(s->pb);
953 
954  for (i=0; !avio_feof(s->pb); i++) {
955  int j = i & (RESYNC_BUFFER_SIZE-1);
956  int j1 = j + RESYNC_BUFFER_SIZE;
957  flv->resync_buffer[j ] =
958  flv->resync_buffer[j1] = avio_r8(s->pb);
959 
960  if (i >= 8 && pos) {
961  uint8_t *d = flv->resync_buffer + j1 - 8;
962  if (d[0] == 'F' &&
963  d[1] == 'L' &&
964  d[2] == 'V' &&
965  d[3] < 5 && d[5] == 0) {
966  av_log(s, AV_LOG_WARNING, "Concatenated FLV detected, might fail to demux, decode and seek %"PRId64"\n", flv->last_ts);
967  flv->time_offset = flv->last_ts + 1;
968  flv->time_pos = avio_tell(s->pb);
969  }
970  }
971 
972  if (i > 22) {
973  unsigned lsize2 = AV_RB32(flv->resync_buffer + j1 - 4);
974  if (lsize2 >= 11 && lsize2 + 8LL < FFMIN(i, RESYNC_BUFFER_SIZE)) {
975  unsigned size2 = AV_RB24(flv->resync_buffer + j1 - lsize2 + 1 - 4);
976  unsigned lsize1 = AV_RB32(flv->resync_buffer + j1 - lsize2 - 8);
977  if (lsize1 >= 11 && lsize1 + 8LL + lsize2 < FFMIN(i, RESYNC_BUFFER_SIZE)) {
978  unsigned size1 = AV_RB24(flv->resync_buffer + j1 - lsize1 + 1 - lsize2 - 8);
979  if (size1 == lsize1 - 11 && size2 == lsize2 - 11) {
980  avio_seek(s->pb, pos + i - lsize1 - lsize2 - 8, SEEK_SET);
981  return 1;
982  }
983  }
984  }
985  }
986  }
987  return AVERROR_EOF;
988 }
989 
991 {
992  FLVContext *flv = s->priv_data;
993  int ret, i, size, flags;
994  enum FlvTagType type;
995  int stream_type=-1;
996  int64_t next, pos, meta_pos;
997  int64_t dts, pts = AV_NOPTS_VALUE;
998  int av_uninit(channels);
999  int av_uninit(sample_rate);
1000  AVStream *st = NULL;
1001  int last = -1;
1002  int orig_size;
1003 
1004 retry:
1005  /* pkt size is repeated at end. skip it */
1006  pos = avio_tell(s->pb);
1007  type = (avio_r8(s->pb) & 0x1F);
1008  orig_size =
1009  size = avio_rb24(s->pb);
1010  flv->sum_flv_tag_size += size + 11;
1011  dts = avio_rb24(s->pb);
1012  dts |= (unsigned)avio_r8(s->pb) << 24;
1013  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));
1014  if (avio_feof(s->pb))
1015  return AVERROR_EOF;
1016  avio_skip(s->pb, 3); /* stream id, always 0 */
1017  flags = 0;
1018 
1019  if (flv->validate_next < flv->validate_count) {
1020  int64_t validate_pos = flv->validate_index[flv->validate_next].pos;
1021  if (pos == validate_pos) {
1022  if (FFABS(dts - flv->validate_index[flv->validate_next].dts) <=
1024  flv->validate_next++;
1025  } else {
1026  clear_index_entries(s, validate_pos);
1027  flv->validate_count = 0;
1028  }
1029  } else if (pos > validate_pos) {
1030  clear_index_entries(s, validate_pos);
1031  flv->validate_count = 0;
1032  }
1033  }
1034 
1035  if (size == 0) {
1036  ret = FFERROR_REDO;
1037  goto leave;
1038  }
1039 
1040  next = size + avio_tell(s->pb);
1041 
1042  if (type == FLV_TAG_TYPE_AUDIO) {
1043  stream_type = FLV_STREAM_TYPE_AUDIO;
1044  flags = avio_r8(s->pb);
1045  size--;
1046  } else if (type == FLV_TAG_TYPE_VIDEO) {
1047  stream_type = FLV_STREAM_TYPE_VIDEO;
1048  flags = avio_r8(s->pb);
1049  size--;
1051  goto skip;
1052  } else if (type == FLV_TAG_TYPE_META) {
1053  stream_type=FLV_STREAM_TYPE_SUBTITLE;
1054  if (size > 13 + 1 + 4) { // Header-type metadata stuff
1055  int type;
1056  meta_pos = avio_tell(s->pb);
1057  type = flv_read_metabody(s, next);
1058  if (type == 0 && dts == 0 || type < 0) {
1059  if (type < 0 && flv->validate_count &&
1060  flv->validate_index[0].pos > next &&
1061  flv->validate_index[0].pos - 4 < next
1062  ) {
1063  av_log(s, AV_LOG_WARNING, "Adjusting next position due to index mismatch\n");
1064  next = flv->validate_index[0].pos - 4;
1065  }
1066  goto skip;
1067  } else if (type == TYPE_ONTEXTDATA) {
1068  avpriv_request_sample(s, "OnTextData packet");
1069  return flv_data_packet(s, pkt, dts, next);
1070  } else if (type == TYPE_ONCAPTION) {
1071  return flv_data_packet(s, pkt, dts, next);
1072  } else if (type == TYPE_UNKNOWN) {
1073  stream_type = FLV_STREAM_TYPE_DATA;
1074  }
1075  avio_seek(s->pb, meta_pos, SEEK_SET);
1076  }
1077  } else {
1079  "Skipping flv packet: type %d, size %d, flags %d.\n",
1080  type, size, flags);
1081 skip:
1082  if (avio_seek(s->pb, next, SEEK_SET) != next) {
1083  // This can happen if flv_read_metabody above read past
1084  // next, on a non-seekable input, and the preceding data has
1085  // been flushed out from the IO buffer.
1086  av_log(s, AV_LOG_ERROR, "Unable to seek to the next packet\n");
1087  return AVERROR_INVALIDDATA;
1088  }
1089  ret = FFERROR_REDO;
1090  goto leave;
1091  }
1092 
1093  /* skip empty data packets */
1094  if (!size) {
1095  ret = FFERROR_REDO;
1096  goto leave;
1097  }
1098 
1099  /* now find stream */
1100  for (i = 0; i < s->nb_streams; i++) {
1101  st = s->streams[i];
1102  if (stream_type == FLV_STREAM_TYPE_AUDIO) {
1103  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1104  (s->audio_codec_id || flv_same_audio_codec(st->codecpar, flags)))
1105  break;
1106  } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {
1107  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1108  (s->video_codec_id || flv_same_video_codec(st->codecpar, flags)))
1109  break;
1110  } else if (stream_type == FLV_STREAM_TYPE_SUBTITLE) {
1112  break;
1113  } else if (stream_type == FLV_STREAM_TYPE_DATA) {
1115  break;
1116  }
1117  }
1118  if (i == s->nb_streams) {
1120  st = create_stream(s, stream_types[stream_type]);
1121  if (!st)
1122  return AVERROR(ENOMEM);
1123 
1124  }
1125  av_log(s, AV_LOG_TRACE, "%d %X %d \n", stream_type, flags, st->discard);
1126 
1127  if (flv->time_pos <= pos) {
1128  dts += flv->time_offset;
1129  }
1130 
1131  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
1133  stream_type == FLV_STREAM_TYPE_AUDIO))
1135 
1136  if ( (st->discard >= AVDISCARD_NONKEY && !((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || (stream_type == FLV_STREAM_TYPE_AUDIO)))
1138  || st->discard >= AVDISCARD_ALL
1139  ) {
1140  avio_seek(s->pb, next, SEEK_SET);
1141  ret = FFERROR_REDO;
1142  goto leave;
1143  }
1144 
1145  // if not streamed and no duration from metadata then seek to end to find
1146  // the duration from the timestamps
1147  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) &&
1148  (!s->duration || s->duration == AV_NOPTS_VALUE) &&
1149  !flv->searched_for_end) {
1150  int size;
1151  const int64_t pos = avio_tell(s->pb);
1152  // Read the last 4 bytes of the file, this should be the size of the
1153  // previous FLV tag. Use the timestamp of its payload as duration.
1154  int64_t fsize = avio_size(s->pb);
1155 retry_duration:
1156  avio_seek(s->pb, fsize - 4, SEEK_SET);
1157  size = avio_rb32(s->pb);
1158  if (size > 0 && size < fsize) {
1159  // Seek to the start of the last FLV tag at position (fsize - 4 - size)
1160  // but skip the byte indicating the type.
1161  avio_seek(s->pb, fsize - 3 - size, SEEK_SET);
1162  if (size == avio_rb24(s->pb) + 11) {
1163  uint32_t ts = avio_rb24(s->pb);
1164  ts |= avio_r8(s->pb) << 24;
1165  if (ts)
1166  s->duration = ts * (int64_t)AV_TIME_BASE / 1000;
1167  else if (fsize >= 8 && fsize - 8 >= size) {
1168  fsize -= size+4;
1169  goto retry_duration;
1170  }
1171  }
1172  }
1173 
1174  avio_seek(s->pb, pos, SEEK_SET);
1175  flv->searched_for_end = 1;
1176  }
1177 
1178  if (stream_type == FLV_STREAM_TYPE_AUDIO) {
1179  int bits_per_coded_sample;
1181  sample_rate = 44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >>
1183  bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
1184  if (!st->codecpar->channels || !st->codecpar->sample_rate ||
1186  st->codecpar->channels = channels;
1187  st->codecpar->channel_layout = channels == 1
1191  st->codecpar->bits_per_coded_sample = bits_per_coded_sample;
1192  }
1193  if (!st->codecpar->codec_id) {
1194  flv_set_audio_codec(s, st, st->codecpar,
1196  flv->last_sample_rate =
1198  flv->last_channels =
1199  channels = st->codecpar->channels;
1200  } else {
1202  if (!par) {
1203  ret = AVERROR(ENOMEM);
1204  goto leave;
1205  }
1206  par->sample_rate = sample_rate;
1207  par->bits_per_coded_sample = bits_per_coded_sample;
1209  sample_rate = par->sample_rate;
1211  }
1212  } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {
1214  if (ret < 0)
1215  return ret;
1216  size -= ret;
1217  } else if (stream_type == FLV_STREAM_TYPE_SUBTITLE) {
1219  } else if (stream_type == FLV_STREAM_TYPE_DATA) {
1220  st->codecpar->codec_id = AV_CODEC_ID_NONE; // Opaque AMF data
1221  }
1222 
1223  if (st->codecpar->codec_id == AV_CODEC_ID_AAC ||
1226  int type = avio_r8(s->pb);
1227  size--;
1228 
1229  if (size < 0) {
1231  goto leave;
1232  }
1233 
1235  // sign extension
1236  int32_t cts = (avio_rb24(s->pb) + 0xff800000) ^ 0xff800000;
1237  pts = dts + cts;
1238  if (cts < 0) { // dts might be wrong
1239  if (!flv->wrong_dts)
1241  "Negative cts, previous timestamps might be wrong.\n");
1242  flv->wrong_dts = 1;
1243  } else if (FFABS(dts - pts) > 1000*60*15) {
1245  "invalid timestamps %"PRId64" %"PRId64"\n", dts, pts);
1246  dts = pts = AV_NOPTS_VALUE;
1247  }
1248  }
1249  if (type == 0 && (!st->codecpar->extradata || st->codecpar->codec_id == AV_CODEC_ID_AAC ||
1250  st->codecpar->codec_id == AV_CODEC_ID_H264)) {
1251  AVDictionaryEntry *t;
1252 
1253  if (st->codecpar->extradata) {
1254  if ((ret = flv_queue_extradata(flv, s->pb, stream_type, size)) < 0)
1255  return ret;
1256  ret = FFERROR_REDO;
1257  goto leave;
1258  }
1259  if ((ret = flv_get_extradata(s, st, size)) < 0)
1260  return ret;
1261 
1262  /* Workaround for buggy Omnia A/XE encoder */
1263  t = av_dict_get(s->metadata, "Encoder", NULL, 0);
1264  if (st->codecpar->codec_id == AV_CODEC_ID_AAC && t && !strcmp(t->value, "Omnia A/XE"))
1265  st->codecpar->extradata_size = 2;
1266 
1267  ret = FFERROR_REDO;
1268  goto leave;
1269  }
1270  }
1271 
1272  /* skip empty data packets */
1273  if (!size) {
1274  ret = FFERROR_REDO;
1275  goto leave;
1276  }
1277 
1278  ret = av_get_packet(s->pb, pkt, size);
1279  if (ret < 0)
1280  return ret;
1281  pkt->dts = dts;
1282  pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts;
1283  pkt->stream_index = st->index;
1284  pkt->pos = pos;
1285  if (flv->new_extradata[stream_type]) {
1287  flv->new_extradata[stream_type],
1288  flv->new_extradata_size[stream_type]);
1289  if (ret >= 0) {
1290  flv->new_extradata[stream_type] = NULL;
1291  flv->new_extradata_size[stream_type] = 0;
1292  }
1293  }
1294  if (stream_type == FLV_STREAM_TYPE_AUDIO &&
1295  (sample_rate != flv->last_sample_rate ||
1296  channels != flv->last_channels)) {
1298  flv->last_channels = channels;
1300  }
1301 
1302  if ( stream_type == FLV_STREAM_TYPE_AUDIO ||
1304  stream_type == FLV_STREAM_TYPE_SUBTITLE ||
1305  stream_type == FLV_STREAM_TYPE_DATA)
1307 
1308 leave:
1309  last = avio_rb32(s->pb);
1310  if (!flv->trust_datasize) {
1311  if (last != orig_size + 11 && last != orig_size + 10 &&
1312  !avio_feof(s->pb) &&
1313  (last != orig_size || !last) && last != flv->sum_flv_tag_size &&
1314  !flv->broken_sizes) {
1315  av_log(s, AV_LOG_ERROR, "Packet mismatch %d %d %d\n", last, orig_size + 11, flv->sum_flv_tag_size);
1316  avio_seek(s->pb, pos + 1, SEEK_SET);
1317  ret = resync(s);
1319  if (ret >= 0) {
1320  goto retry;
1321  }
1322  }
1323  }
1324 
1325  if (ret >= 0)
1326  flv->last_ts = pkt->dts;
1327 
1328  return ret;
1329 }
1330 
1331 static int flv_read_seek(AVFormatContext *s, int stream_index,
1332  int64_t ts, int flags)
1333 {
1334  FLVContext *flv = s->priv_data;
1335  flv->validate_count = 0;
1336  return avio_seek_time(s->pb, stream_index, ts, flags);
1337 }
1338 
1339 #define OFFSET(x) offsetof(FLVContext, x)
1340 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1341 static const AVOption options[] = {
1342  { "flv_metadata", "Allocate streams according to the onMetaData array", OFFSET(trust_metadata), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
1343  { "flv_full_metadata", "Dump full metadata of the onMetadata", OFFSET(dump_full_metadata), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
1344  { "flv_ignore_prevtag", "Ignore the Size of previous tag", OFFSET(trust_datasize), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
1345  { "missing_streams", "", OFFSET(missing_streams), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 0xFF, VD | AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY },
1346  { NULL }
1347 };
1348 
1349 static const AVClass flv_class = {
1350  .class_name = "flvdec",
1351  .item_name = av_default_item_name,
1352  .option = options,
1353  .version = LIBAVUTIL_VERSION_INT,
1354 };
1355 
1357  .name = "flv",
1358  .long_name = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1359  .priv_data_size = sizeof(FLVContext),
1360  .read_probe = flv_probe,
1365  .extensions = "flv",
1366  .priv_class = &flv_class,
1367 };
1368 
1369 static const AVClass live_flv_class = {
1370  .class_name = "live_flvdec",
1371  .item_name = av_default_item_name,
1372  .option = options,
1373  .version = LIBAVUTIL_VERSION_INT,
1374 };
1375 
1377  .name = "live_flv",
1378  .long_name = NULL_IF_CONFIG_SMALL("live RTMP FLV (Flash Video)"),
1379  .priv_data_size = sizeof(FLVContext),
1385  .extensions = "flv",
1386  .priv_class = &live_flv_class,
1388 };
1389 
1390 static const AVClass kux_class = {
1391  .class_name = "kuxdec",
1392  .item_name = av_default_item_name,
1393  .option = options,
1394  .version = LIBAVUTIL_VERSION_INT,
1395 };
1396 
1398  .name = "kux",
1399  .long_name = NULL_IF_CONFIG_SMALL("KUX (YouKu)"),
1400  .priv_data_size = sizeof(FLVContext),
1401  .read_probe = kux_probe,
1406  .extensions = "kux",
1407  .priv_class = &kux_class,
1408 };
AVStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1094
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:301
FLVContext::audio_bit_rate
int64_t audio_bit_rate
Definition: flvdec.c:70
FLV_HEADER_FLAG_HASAUDIO
@ FLV_HEADER_FLAG_HASAUDIO
Definition: flv.h:56
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:605
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_CODEC_ID_VP6F
@ AV_CODEC_ID_VP6F
Definition: codec_id.h:141
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
flv_same_video_codec
static int flv_same_video_codec(AVCodecParameters *vpar, int flags)
Definition: flvdec.c:301
FLVContext::pos
int64_t pos
Definition: flvdec.c:56
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
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4519
AV_OPT_FLAG_READONLY
#define AV_OPT_FLAG_READONLY
The option may not be set through the AVOptions API, only read.
Definition: opt.h:289
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
ff_get_extradata
int ff_get_extradata(AVFormatContext *s, 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: utils.c:3339
clear_index_entries
static void clear_index_entries(AVFormatContext *s, int64_t pos)
Definition: flvdec.c:824
FLV_CODECID_NELLYMOSER_8KHZ_MONO
@ FLV_CODECID_NELLYMOSER_8KHZ_MONO
Definition: flv.h:96
FLVContext::validate_next
int validate_next
Definition: flvdec.c:58
FFERROR_REDO
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data).
Definition: internal.h:633
out
FILE * out
Definition: movenc.c:54
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
AVFMT_FLAG_IGNIDX
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1468
AMF_END_OF_OBJECT
#define AMF_END_OF_OBJECT
Definition: flv.h:47
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:920
FLVContext::validate_index
struct FLVContext::@252 validate_index[2]
av_int2double
static av_always_inline double av_int2double(uint64_t i)
Reinterpret a 64-bit integer as a double.
Definition: intfloat.h:60
AMF_DATA_TYPE_UNSUPPORTED
@ AMF_DATA_TYPE_UNSUPPORTED
Definition: flv.h:136
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:85
TYPE_ONCAPTIONINFO
#define TYPE_ONCAPTIONINFO
Definition: flvdec.c:686
flv_data_packet
static int flv_data_packet(AVFormatContext *s, AVPacket *pkt, int64_t dts, int64_t next)
Definition: flvdec.c:881
FLV_CODECID_NELLYMOSER_16KHZ_MONO
@ FLV_CODECID_NELLYMOSER_16KHZ_MONO
Definition: flv.h:95
FLV_CODECID_AAC
@ FLV_CODECID_AAC
Definition: flv.h:100
av_unused
#define av_unused
Definition: attributes.h:131
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:61
FLVContext::time_offset
int64_t time_offset
Definition: flvdec.c:76
FLVContext::trust_metadata
int trust_metadata
configure streams according onMetaData
Definition: flvdec.c:46
FLV_CODECID_VP6A
@ FLV_CODECID_VP6A
Definition: flv.h:108
FLV_CODECID_PCM_MULAW
@ FLV_CODECID_PCM_MULAW
Definition: flv.h:99
flv_read_packet
static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: flvdec.c:990
max_pos
static const int32_t max_pos[4]
Size of the MP-MLQ fixed excitation codebooks.
Definition: g723_1.h:728
AVStream::internal
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1220
TYPE_ONCAPTION
#define TYPE_ONCAPTION
Definition: flvdec.c:685
AVOption
AVOption.
Definition: opt.h:246
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:938
FLVContext::resync_buffer
uint8_t resync_buffer[2 *RESYNC_BUFFER_SIZE]
Definition: flvdec.c:62
FLV_CODECID_PCM
@ FLV_CODECID_PCM
Definition: flv.h:91
amf_date
Definition: flvdec.c:81
FLV_CODECID_NELLYMOSER
@ FLV_CODECID_NELLYMOSER
Definition: flv.h:97
flv_set_audio_codec
static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream, AVCodecParameters *apar, int flv_codecid)
Definition: flvdec.c:241
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
mathematics.h
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
FLVContext::trust_datasize
int trust_datasize
trust data size of FLVTag
Definition: flvdec.c:47
intfloat.h
codec_type
enum AVMediaType codec_type
Definition: rtp.c:37
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:334
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:388
sample_rate
sample_rate
Definition: ffmpeg_filter.c:192
options
static const AVOption options[]
Definition: flvdec.c:1341
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:803
FLV_AUDIO_SAMPLERATE_OFFSET
#define FLV_AUDIO_SAMPLERATE_OFFSET
Definition: flv.h:33
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
FLVContext::video_bit_rate
int64_t video_bit_rate
Definition: flvdec.c:69
FLVContext::searched_for_end
int searched_for_end
Definition: flvdec.c:60
FLVContext::keyframe_times
int64_t * keyframe_times
Definition: flvdec.c:71
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
FLVContext::keyframe_filepositions
int64_t * keyframe_filepositions
Definition: flvdec.c:72
finish
static void finish(void)
Definition: movenc.c:345
avcodec_parameters_free
void avcodec_parameters_free(AVCodecParameters **par)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: utils.c:2053
OFFSET
#define OFFSET(x)
Definition: flvdec.c:1339
av_packet_add_side_data
FF_ENABLE_DEPRECATION_WARNINGS 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: avpacket.c:298
AV_CODEC_ID_SPEEX
@ AV_CODEC_ID_SPEEX
Definition: codec_id.h:445
FLVContext::last_ts
int64_t last_ts
Definition: flvdec.c:75
AMF_DATA_TYPE_STRING
@ AMF_DATA_TYPE_STRING
Definition: flv.h:126
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:302
FLV_STREAM_TYPE_AUDIO
@ FLV_STREAM_TYPE_AUDIO
Definition: flv.h:67
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:1209
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
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: utils.c:2045
TYPE_ONTEXTDATA
#define TYPE_ONTEXTDATA
Definition: flvdec.c:684
flv_read_seek
static int flv_read_seek(AVFormatContext *s, int stream_index, int64_t ts, int flags)
Definition: flvdec.c:1331
FLV_STREAM_TYPE_NB
@ FLV_STREAM_TYPE_NB
Definition: flv.h:70
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
ff_kux_demuxer
AVInputFormat ff_kux_demuxer
Definition: flvdec.c:1397
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:647
AV_RB24
#define AV_RB24
Definition: intreadwrite.h:64
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:411
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:86
FLV_STREAM_TYPE_VIDEO
@ FLV_STREAM_TYPE_VIDEO
Definition: flv.h:66
FLV_TAG_TYPE_META
@ FLV_TAG_TYPE_META
Definition: flv.h:62
FLV_AUDIO_CODECID_MASK
#define FLV_AUDIO_CODECID_MASK
Definition: flv.h:42
VD
#define VD
Definition: flvdec.c:1340
AMF_DATA_TYPE_BOOL
@ AMF_DATA_TYPE_BOOL
Definition: flv.h:125
parse_keyframes_index
static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc, int64_t max_pos)
Definition: flvdec.c:398
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:778
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
FLV_CODECID_PCM_ALAW
@ FLV_CODECID_PCM_ALAW
Definition: flv.h:98
AVInputFormat
Definition: avformat.h:636
VALIDATE_INDEX_TS_THRESH
#define VALIDATE_INDEX_TS_THRESH
Definition: flvdec.c:40
FLVContext::sum_flv_tag_size
int sum_flv_tag_size
Definition: flvdec.c:65
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::new_extradata_size
int new_extradata_size[FLV_STREAM_TYPE_NB]
Definition: flvdec.c:51
FLV_FRAME_KEY
@ FLV_FRAME_KEY
key frame (for AVC, a seekable frame)
Definition: flv.h:116
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:641
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
create_stream
static AVStream * create_stream(AVFormatContext *s, int codec_type)
Definition: flvdec.c:160
FLVContext::dts
int64_t dts
Definition: flvdec.c:55
FLV_VIDEO_FRAMETYPE_MASK
#define FLV_VIDEO_FRAMETYPE_MASK
Definition: flv.h:45
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
kux_class
static const AVClass kux_class
Definition: flvdec.c:1390
FLV_FRAME_VIDEO_INFO_CMD
@ FLV_FRAME_VIDEO_INFO_CMD
video info/command frame
Definition: flv.h:120
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
AVStream::need_parsing
enum AVStreamParseType need_parsing
Definition: avformat.h:1083
channels
channels
Definition: aptx.h:33
FLVContext::time_pos
int64_t time_pos
Definition: flvdec.c:77
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:237
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:307
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
live_flv_probe
static int live_flv_probe(const AVProbeData *p)
Definition: flvdec.c:110
key
const char * key
Definition: hwcontext_opencl.c:168
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
fsize
static int64_t fsize(FILE *f)
Definition: audiomatch.c:28
AVDISCARD_BIDIR
@ AVDISCARD_BIDIR
discard all bidirectional frames
Definition: avcodec.h:233
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
TYPE_UNKNOWN
#define TYPE_UNKNOWN
Definition: flvdec.c:687
FLV_STREAM_TYPE_DATA
@ FLV_STREAM_TYPE_DATA
Definition: flv.h:69
flv_set_video_codec
static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream, int flv_codecid, int read)
Definition: flvdec.c:326
int32_t
int32_t
Definition: audio_convert.c:194
FLV_HEADER_FLAG_HASVIDEO
@ FLV_HEADER_FLAG_HASVIDEO
Definition: flv.h:55
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
time_internal.h
FLV_CODECID_H263
@ FLV_CODECID_H263
Definition: flv.h:105
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: avcodec.h:236
AVFormatContext
Format I/O context.
Definition: avformat.h:1335
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:308
flv_read_close
static int flv_read_close(AVFormatContext *s)
Definition: flvdec.c:785
AV_CODEC_ID_FLASHSV2
@ AV_CODEC_ID_FLASHSV2
Definition: codec_id.h:180
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1012
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
add_keyframes_index
static void add_keyframes_index(AVFormatContext *s)
Definition: flvdec.c:129
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AMF_DATA_TYPE_DATE
@ AMF_DATA_TYPE_DATE
Definition: flv.h:134
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1284
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:747
FLV_AUDIO_SAMPLERATE_MASK
#define FLV_AUDIO_SAMPLERATE_MASK
Definition: flv.h:41
flv_same_audio_codec
static int flv_same_audio_codec(AVCodecParameters *apar, int flags)
Definition: flvdec.c:190
FLV_STEREO
@ FLV_STEREO
Definition: flv.h:75
KEYFRAMES_TAG
#define KEYFRAMES_TAG
Definition: flv.h:49
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:899
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
FLVContext::last_channels
int last_channels
Definition: flvdec.c:53
AV_CODEC_ID_FLASHSV
@ AV_CODEC_ID_FLASHSV
Definition: codec_id.h:135
FLVContext::keyframe_count
int keyframe_count
Definition: flvdec.c:68
AMF_DATA_TYPE_OBJECT_END
@ AMF_DATA_TYPE_OBJECT_END
Definition: flv.h:132
FLV_CODECID_REALH263
@ FLV_CODECID_REALH263
Definition: flv.h:111
AV_CODEC_ID_VP6A
@ AV_CODEC_ID_VP6A
Definition: codec_id.h:155
FLV_VIDEO_CODECID_MASK
#define FLV_VIDEO_CODECID_MASK
Definition: flv.h:44
AV_RB32
#define AV_RB32
Definition: intreadwrite.h:130
FLV_CODECID_SCREEN
@ FLV_CODECID_SCREEN
Definition: flv.h:106
KEYFRAMES_BYTEOFFSET_TAG
#define KEYFRAMES_BYTEOFFSET_TAG
Definition: flv.h:51
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
FLVContext::missing_streams
int missing_streams
Definition: flvdec.c:73
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
AMFDataType
AMFDataType
Definition: flv.h:123
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:412
FLV_TAG_TYPE_VIDEO
@ FLV_TAG_TYPE_VIDEO
Definition: flv.h:61
AMF_DATA_TYPE_MIXEDARRAY
@ AMF_DATA_TYPE_MIXEDARRAY
Definition: flv.h:131
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: avcodec.h:235
flv.h
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
live_flv_class
static const AVClass live_flv_class
Definition: flvdec.c:1369
avio_rb24
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:771
AVMediaType
AVMediaType
Definition: avutil.h:199
AVPacket::size
int size
Definition: packet.h:356
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:186
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
AVStream::nb_index_entries
int nb_index_entries
Definition: avformat.h:1096
FLV_CODECID_MPEG4
@ FLV_CODECID_MPEG4
Definition: flv.h:112
AMF_DATA_TYPE_OBJECT
@ AMF_DATA_TYPE_OBJECT
Definition: flv.h:127
localtime_r
#define localtime_r
Definition: time_internal.h:46
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4938
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:53
AV_CODEC_ID_ADPCM_SWF
@ AV_CODEC_ID_ADPCM_SWF
Definition: codec_id.h:353
size
int size
Definition: twinvq_data.h:11134
FLVContext
Definition: flvdec.c:44
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
amf_date::timezone
int16_t timezone
Definition: flvdec.c:83
FLV_CODECID_ADPCM
@ FLV_CODECID_ADPCM
Definition: flv.h:92
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:354
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:616
FLV_AUDIO_CODECID_OFFSET
#define FLV_AUDIO_CODECID_OFFSET
Definition: flv.h:34
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
flv_class
static const AVClass flv_class
Definition: flvdec.c:1349
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
FLV_AUDIO_SAMPLESIZE_MASK
#define FLV_AUDIO_SAMPLESIZE_MASK
Definition: flv.h:40
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:361
version
version
Definition: libkvazaar.c:292
AMF_DATA_TYPE_UNDEFINED
@ AMF_DATA_TYPE_UNDEFINED
Definition: flv.h:129
KEYFRAMES_TIMESTAMP_TAG
#define KEYFRAMES_TIMESTAMP_TAG
Definition: flv.h:50
kux_probe
static int kux_probe(const AVProbeData *p)
Definition: flvdec.c:115
AMF_DATA_TYPE_ARRAY
@ AMF_DATA_TYPE_ARRAY
Definition: flv.h:133
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
avio_internal.h
FLVContext::last_keyframe_stream_index
int last_keyframe_stream_index
Definition: flvdec.c:67
flv_read_metabody
static int flv_read_metabody(AVFormatContext *s, int64_t next_pos)
Definition: flvdec.c:689
FLV_CODECID_MP3
@ FLV_CODECID_MP3
Definition: flv.h:93
AVCodecParameters::height
int height
Definition: codec_par.h:127
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:948
FLVContext::framerate
AVRational framerate
Definition: flvdec.c:74
FLV_CODECID_PCM_LE
@ FLV_CODECID_PCM_LE
Definition: flv.h:94
flv_probe
static int flv_probe(const AVProbeData *p)
Definition: flvdec.c:105
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
uint8_t
uint8_t
Definition: audio_convert.c:194
FLVContext::wrong_dts
int wrong_dts
wrong dts due to negative cts
Definition: flvdec.c:49
FLV_AUDIO_CHANNEL_MASK
#define FLV_AUDIO_CHANNEL_MASK
Definition: flv.h:39
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: utils.c:5070
flv_queue_extradata
static int flv_queue_extradata(FLVContext *flv, AVIOContext *pb, int stream, int size)
Definition: flvdec.c:808
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:304
FLVContext::new_extradata
uint8_t * new_extradata[FLV_STREAM_TYPE_NB]
Definition: flvdec.c:50
FLV_CODECID_H264
@ FLV_CODECID_H264
Definition: flv.h:110
av_uninit
#define av_uninit(x)
Definition: attributes.h:154
array
static int array[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:106
ret
ret
Definition: filter_design.txt:187
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVStream
Stream structure.
Definition: avformat.h:865
probe
static int probe(const AVProbeData *p, int live)
Definition: flvdec.c:86
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
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:72
ff_live_flv_demuxer
AVInputFormat ff_live_flv_demuxer
Definition: flvdec.c:1376
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:763
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: utils.c:2043
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:787
pos
unsigned int pos
Definition: spdifenc.c:410
avformat.h
dict.h
AV_CODEC_ID_TEXT
@ AV_CODEC_ID_TEXT
raw UTF-8 text
Definition: codec_id.h:510
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:215
FLV_CODECID_VP6
@ FLV_CODECID_VP6
Definition: flv.h:107
amf_get_string
static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize)
Definition: flvdec.c:383
FLV_CODECID_SCREEN2
@ FLV_CODECID_SCREEN2
Definition: flv.h:109
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:866
FLV_TAG_TYPE_AUDIO
@ FLV_TAG_TYPE_AUDIO
Definition: flv.h:60
channel_layout.h
ff_flv_demuxer
AVInputFormat ff_flv_demuxer
Definition: flvdec.c:1356
AV_OPT_FLAG_EXPORT
#define AV_OPT_FLAG_EXPORT
The option is intended for exporting values to the caller.
Definition: opt.h:284
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
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_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:55
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:625
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:484
AMF_DATA_TYPE_NUMBER
@ AMF_DATA_TYPE_NUMBER
Definition: flv.h:124
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:796
AVIOContext::eof_reached
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:239
AVPacket::stream_index
int stream_index
Definition: packet.h:357
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
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:102
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:464
AVStreamInternal::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:189
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:306
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
flv_get_extradata
static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size)
Definition: flvdec.c:796
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:81
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:240
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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:70
FLV_CODECID_SPEEX
@ FLV_CODECID_SPEEX
Definition: flv.h:101
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:375
FlvTagType
FlvTagType
Definition: flv.h:59
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
bytestream.h
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:786
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:564
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:83
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AMF_DATA_TYPE_NULL
@ AMF_DATA_TYPE_NULL
Definition: flv.h:128
FLVContext::validate_count
int validate_count
Definition: flvdec.c:59
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
amf_skip_tag
static int amf_skip_tag(AVIOContext *pb, AMFDataType type)
Definition: flvdec.c:840
FLV_FRAME_DISP_INTER
@ FLV_FRAME_DISP_INTER
disposable inter frame (H.263 only)
Definition: flv.h:118
AVDictionaryEntry::value
char * value
Definition: dict.h:83
avstring.h
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:70
FLV_STREAM_TYPE_SUBTITLE
@ FLV_STREAM_TYPE_SUBTITLE
Definition: flv.h:68
amf_date::milliseconds
double milliseconds
Definition: flvdec.c:82
int
int
Definition: ffmpeg_filter.c:192
snprintf
#define snprintf
Definition: snprintf.h:34
FLVContext::dump_full_metadata
int dump_full_metadata
Dump full metadata of the onMetadata.
Definition: flvdec.c:48
FLVContext::last_sample_rate
int last_sample_rate
Definition: flvdec.c:52
AVFMT_EVENT_FLAG_METADATA_UPDATED
#define AVFMT_EVENT_FLAG_METADATA_UPDATED
The call resulted in updated metadata.
Definition: avformat.h:1651
RESYNC_BUFFER_SIZE
#define RESYNC_BUFFER_SIZE
Definition: flvdec.c:42
AV_CODEC_ID_NELLYMOSER
@ AV_CODEC_ID_NELLYMOSER
Definition: codec_id.h:443
FLVContext::broken_sizes
int broken_sizes
Definition: flvdec.c:64
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:3321
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:356