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