FFmpeg: libavformat/flvdec.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /