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