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