FFmpeg
avidec.c
Go to the documentation of this file.
1 /*
2  * AVI demuxer
3  * Copyright (c) 2001 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <inttypes.h>
23 
24 #include "libavutil/avassert.h"
25 #include "libavutil/avstring.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/dict.h"
28 #include "libavutil/internal.h"
29 #include "libavutil/intreadwrite.h"
30 #include "libavutil/mathematics.h"
31 #include "avformat.h"
32 #include "avi.h"
33 #include "dv.h"
34 #include "internal.h"
35 #include "isom.h"
36 #include "riff.h"
37 #include "libavcodec/bytestream.h"
38 #include "libavcodec/exif.h"
39 #include "libavcodec/internal.h"
40 
41 typedef struct AVIStream {
42  int64_t frame_offset; /* current frame (video) or byte (audio) counter
43  * (used to compute the pts) */
44  int remaining;
46 
47  uint32_t handler;
48  uint32_t scale;
49  uint32_t rate;
50  int sample_size; /* size of one sample (or packet)
51  * (in the rate/scale sense) in bytes */
52 
53  int64_t cum_len; /* temporary storage (used during seek) */
54  int prefix; /* normally 'd'<<8 + 'c' or 'w'<<8 + 'b' */
56  uint32_t pal[256];
57  int has_pal;
58  int dshow_block_align; /* block align variable used to emulate bugs in
59  * the MS dshow demuxer */
60 
64 
65  int64_t seek_pos;
66 } AVIStream;
67 
68 typedef struct AVIContext {
69  const AVClass *class;
70  int64_t riff_end;
71  int64_t movi_end;
72  int64_t fsize;
73  int64_t io_fsize;
74  int64_t movi_list;
75  int64_t last_pkt_pos;
77  int is_odml;
82  int use_odml;
83 #define MAX_ODML_DEPTH 1000
84  int64_t dts_max;
85 } AVIContext;
86 
87 
88 static const AVOption options[] = {
89  { "use_odml", "use odml index", offsetof(AVIContext, use_odml), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM},
90  { NULL },
91 };
92 
93 static const AVClass demuxer_class = {
94  .class_name = "avi",
95  .item_name = av_default_item_name,
96  .option = options,
97  .version = LIBAVUTIL_VERSION_INT,
98  .category = AV_CLASS_CATEGORY_DEMUXER,
99 };
100 
101 
102 static const char avi_headers[][8] = {
103  { 'R', 'I', 'F', 'F', 'A', 'V', 'I', ' ' },
104  { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 'X' },
105  { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 0x19 },
106  { 'O', 'N', '2', ' ', 'O', 'N', '2', 'f' },
107  { 'R', 'I', 'F', 'F', 'A', 'M', 'V', ' ' },
108  { 0 }
109 };
110 
112  { "strn", "title" },
113  { 0 },
114 };
115 
116 static int avi_load_index(AVFormatContext *s);
117 static int guess_ni_flag(AVFormatContext *s);
118 
119 #define print_tag(s, str, tag, size) \
120  av_log(s, AV_LOG_TRACE, "pos:%"PRIX64" %s: tag=%s size=0x%x\n", \
121  avio_tell(pb), str, av_fourcc2str(tag), size) \
122 
123 static inline int get_duration(AVIStream *ast, int len)
124 {
125  if (ast->sample_size)
126  return len;
127  else if (ast->dshow_block_align)
128  return (len + ast->dshow_block_align - 1) / ast->dshow_block_align;
129  else
130  return 1;
131 }
132 
134 {
135  AVIContext *avi = s->priv_data;
136  char header[8] = {0};
137  int i;
138 
139  /* check RIFF header */
140  avio_read(pb, header, 4);
141  avi->riff_end = avio_rl32(pb); /* RIFF chunk size */
142  avi->riff_end += avio_tell(pb); /* RIFF chunk end */
143  avio_read(pb, header + 4, 4);
144 
145  for (i = 0; avi_headers[i][0]; i++)
146  if (!memcmp(header, avi_headers[i], 8))
147  break;
148  if (!avi_headers[i][0])
149  return AVERROR_INVALIDDATA;
150 
151  if (header[7] == 0x19)
152  av_log(s, AV_LOG_INFO,
153  "This file has been generated by a totally broken muxer.\n");
154 
155  return 0;
156 }
157 
158 static int read_odml_index(AVFormatContext *s, int frame_num)
159 {
160  AVIContext *avi = s->priv_data;
161  AVIOContext *pb = s->pb;
162  int longs_per_entry = avio_rl16(pb);
163  int index_sub_type = avio_r8(pb);
164  int index_type = avio_r8(pb);
165  int entries_in_use = avio_rl32(pb);
166  int chunk_id = avio_rl32(pb);
167  int64_t base = avio_rl64(pb);
168  int stream_id = ((chunk_id & 0xFF) - '0') * 10 +
169  ((chunk_id >> 8 & 0xFF) - '0');
170  AVStream *st;
171  AVIStream *ast;
172  int i;
173  int64_t last_pos = -1;
174  int64_t filesize = avi->fsize;
175 
176  av_log(s, AV_LOG_TRACE,
177  "longs_per_entry:%d index_type:%d entries_in_use:%d "
178  "chunk_id:%X base:%16"PRIX64" frame_num:%d\n",
179  longs_per_entry,
180  index_type,
181  entries_in_use,
182  chunk_id,
183  base,
184  frame_num);
185 
186  if (stream_id >= s->nb_streams || stream_id < 0)
187  return AVERROR_INVALIDDATA;
188  st = s->streams[stream_id];
189  ast = st->priv_data;
190 
191  if (index_sub_type)
192  return AVERROR_INVALIDDATA;
193 
194  avio_rl32(pb);
195 
196  if (index_type && longs_per_entry != 2)
197  return AVERROR_INVALIDDATA;
198  if (index_type > 1)
199  return AVERROR_INVALIDDATA;
200 
201  if (filesize > 0 && base >= filesize) {
202  av_log(s, AV_LOG_ERROR, "ODML index invalid\n");
203  if (base >> 32 == (base & 0xFFFFFFFF) &&
204  (base & 0xFFFFFFFF) < filesize &&
205  filesize <= 0xFFFFFFFF)
206  base &= 0xFFFFFFFF;
207  else
208  return AVERROR_INVALIDDATA;
209  }
210 
211  for (i = 0; i < entries_in_use; i++) {
212  if (index_type) {
213  int64_t pos = avio_rl32(pb) + base - 8;
214  int len = avio_rl32(pb);
215  int key = len >= 0;
216  len &= 0x7FFFFFFF;
217 
218  av_log(s, AV_LOG_TRACE, "pos:%"PRId64", len:%X\n", pos, len);
219 
220  if (avio_feof(pb))
221  return AVERROR_INVALIDDATA;
222 
223  if (last_pos == pos || pos == base - 8)
224  avi->non_interleaved = 1;
225  if (last_pos != pos && len)
226  av_add_index_entry(st, pos, ast->cum_len, len, 0,
227  key ? AVINDEX_KEYFRAME : 0);
228 
229  ast->cum_len += get_duration(ast, len);
230  last_pos = pos;
231  } else {
232  int64_t offset, pos;
233  int duration;
234  offset = avio_rl64(pb);
235  avio_rl32(pb); /* size */
236  duration = avio_rl32(pb);
237 
238  if (avio_feof(pb))
239  return AVERROR_INVALIDDATA;
240 
241  pos = avio_tell(pb);
242 
243  if (avi->odml_depth > MAX_ODML_DEPTH) {
244  av_log(s, AV_LOG_ERROR, "Too deeply nested ODML indexes\n");
245  return AVERROR_INVALIDDATA;
246  }
247 
248  if (avio_seek(pb, offset + 8, SEEK_SET) < 0)
249  return -1;
250  avi->odml_depth++;
251  read_odml_index(s, frame_num);
252  avi->odml_depth--;
253  frame_num += duration;
254 
255  if (avio_seek(pb, pos, SEEK_SET) < 0) {
256  av_log(s, AV_LOG_ERROR, "Failed to restore position after reading index\n");
257  return -1;
258  }
259 
260  }
261  }
262  avi->index_loaded = 2;
263  return 0;
264 }
265 
267 {
268  int i;
269  int64_t j;
270 
271  for (i = 0; i < s->nb_streams; i++) {
272  AVStream *st = s->streams[i];
273  AVIStream *ast = st->priv_data;
274  int n = st->nb_index_entries;
275  int max = ast->sample_size;
276  int64_t pos, size, ts;
277 
278  if (n != 1 || ast->sample_size == 0)
279  continue;
280 
281  while (max < 1024)
282  max += max;
283 
284  pos = st->index_entries[0].pos;
285  size = st->index_entries[0].size;
286  ts = st->index_entries[0].timestamp;
287 
288  for (j = 0; j < size; j += max)
289  av_add_index_entry(st, pos + j, ts + j, FFMIN(max, size - j), 0,
291  }
292 }
293 
294 static int avi_read_tag(AVFormatContext *s, AVStream *st, uint32_t tag,
295  uint32_t size)
296 {
297  AVIOContext *pb = s->pb;
298  char key[5] = { 0 };
299  char *value;
300 
301  size += (size & 1);
302 
303  if (size == UINT_MAX)
304  return AVERROR(EINVAL);
305  value = av_malloc(size + 1);
306  if (!value)
307  return AVERROR(ENOMEM);
308  if (avio_read(pb, value, size) != size) {
309  av_freep(&value);
310  return AVERROR_INVALIDDATA;
311  }
312  value[size] = 0;
313 
314  AV_WL32(key, tag);
315 
316  return av_dict_set(st ? &st->metadata : &s->metadata, key, value,
318 }
319 
320 static const char months[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
321  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
322 
323 static void avi_metadata_creation_time(AVDictionary **metadata, char *date)
324 {
325  char month[4], time[9], buffer[64];
326  int i, day, year;
327  /* parse standard AVI date format (ie. "Mon Mar 10 15:04:43 2003") */
328  if (sscanf(date, "%*3s%*[ ]%3s%*[ ]%2d%*[ ]%8s%*[ ]%4d",
329  month, &day, time, &year) == 4) {
330  for (i = 0; i < 12; i++)
331  if (!av_strcasecmp(month, months[i])) {
332  snprintf(buffer, sizeof(buffer), "%.4d-%.2d-%.2d %s",
333  year, i + 1, day, time);
334  av_dict_set(metadata, "creation_time", buffer, 0);
335  }
336  } else if (date[4] == '/' && date[7] == '/') {
337  date[4] = date[7] = '-';
338  av_dict_set(metadata, "creation_time", date, 0);
339  }
340 }
341 
342 static void avi_read_nikon(AVFormatContext *s, uint64_t end)
343 {
344  while (avio_tell(s->pb) < end && !avio_feof(s->pb)) {
345  uint32_t tag = avio_rl32(s->pb);
346  uint32_t size = avio_rl32(s->pb);
347  switch (tag) {
348  case MKTAG('n', 'c', 't', 'g'): /* Nikon Tags */
349  {
350  uint64_t tag_end = avio_tell(s->pb) + size;
351  while (avio_tell(s->pb) < tag_end && !avio_feof(s->pb)) {
352  uint16_t tag = avio_rl16(s->pb);
353  uint16_t size = avio_rl16(s->pb);
354  const char *name = NULL;
355  char buffer[64] = { 0 };
356  size = FFMIN(size, tag_end - avio_tell(s->pb));
357  size -= avio_read(s->pb, buffer,
358  FFMIN(size, sizeof(buffer) - 1));
359  switch (tag) {
360  case 0x03:
361  name = "maker";
362  break;
363  case 0x04:
364  name = "model";
365  break;
366  case 0x13:
367  name = "creation_time";
368  if (buffer[4] == ':' && buffer[7] == ':')
369  buffer[4] = buffer[7] = '-';
370  break;
371  }
372  if (name)
373  av_dict_set(&s->metadata, name, buffer, 0);
374  avio_skip(s->pb, size);
375  }
376  break;
377  }
378  default:
379  avio_skip(s->pb, size);
380  break;
381  }
382  }
383 }
384 
386 {
387  GetByteContext gb;
388  uint8_t *data = st->codecpar->extradata;
389  int data_size = st->codecpar->extradata_size;
390  int tag, offset;
391 
392  if (!data || data_size < 8) {
393  return AVERROR_INVALIDDATA;
394  }
395 
396  bytestream2_init(&gb, data, data_size);
397 
398  tag = bytestream2_get_le32(&gb);
399 
400  switch (tag) {
401  case MKTAG('A', 'V', 'I', 'F'):
402  // skip 4 byte padding
403  bytestream2_skip(&gb, 4);
404  offset = bytestream2_tell(&gb);
405 
406  // decode EXIF tags from IFD, AVI is always little-endian
407  return avpriv_exif_decode_ifd(s, data + offset, data_size - offset,
408  1, 0, &st->metadata);
409  break;
410  case MKTAG('C', 'A', 'S', 'I'):
411  avpriv_request_sample(s, "RIFF stream data tag type CASI (%u)", tag);
412  break;
413  case MKTAG('Z', 'o', 'r', 'a'):
414  avpriv_request_sample(s, "RIFF stream data tag type Zora (%u)", tag);
415  break;
416  default:
417  break;
418  }
419 
420  return 0;
421 }
422 
424 {
425  AVIContext *avi = s->priv_data;
426  int i, j;
427  int64_t lensum = 0;
428  int64_t maxpos = 0;
429 
430  for (i = 0; i<s->nb_streams; i++) {
431  int64_t len = 0;
432  AVStream *st = s->streams[i];
433 
434  if (!st->nb_index_entries)
435  continue;
436 
437  for (j = 0; j < st->nb_index_entries; j++)
438  len += st->index_entries[j].size;
439  maxpos = FFMAX(maxpos, st->index_entries[j-1].pos);
440  lensum += len;
441  }
442  if (maxpos < avi->io_fsize*9/10) // index does not cover the whole file
443  return 0;
444  if (lensum*9/10 > maxpos || lensum < maxpos*9/10) // frame sum and filesize mismatch
445  return 0;
446 
447  for (i = 0; i<s->nb_streams; i++) {
448  int64_t len = 0;
449  AVStream *st = s->streams[i];
450  int64_t duration;
451  int64_t bitrate;
452 
453  for (j = 0; j < st->nb_index_entries; j++)
454  len += st->index_entries[j].size;
455 
456  if (st->nb_index_entries < 2 || st->codecpar->bit_rate > 0)
457  continue;
458  duration = st->index_entries[j-1].timestamp - st->index_entries[0].timestamp;
459  bitrate = av_rescale(8*len, st->time_base.den, duration * st->time_base.num);
460  if (bitrate > 0) {
461  st->codecpar->bit_rate = bitrate;
462  }
463  }
464  return 1;
465 }
466 
468 {
469  AVIContext *avi = s->priv_data;
470  AVIOContext *pb = s->pb;
471  unsigned int tag, tag1, handler;
472  int codec_type, stream_index, frame_period;
473  unsigned int size;
474  int i;
475  AVStream *st;
476  AVIStream *ast = NULL;
477  int avih_width = 0, avih_height = 0;
478  int amv_file_format = 0;
479  uint64_t list_end = 0;
480  int64_t pos;
481  int ret;
482  AVDictionaryEntry *dict_entry;
483 
484  avi->stream_index = -1;
485 
486  ret = get_riff(s, pb);
487  if (ret < 0)
488  return ret;
489 
490  av_log(avi, AV_LOG_DEBUG, "use odml:%d\n", avi->use_odml);
491 
492  avi->io_fsize = avi->fsize = avio_size(pb);
493  if (avi->fsize <= 0 || avi->fsize < avi->riff_end)
494  avi->fsize = avi->riff_end == 8 ? INT64_MAX : avi->riff_end;
495 
496  /* first list tag */
497  stream_index = -1;
498  codec_type = -1;
499  frame_period = 0;
500  for (;;) {
501  if (avio_feof(pb))
502  goto fail;
503  tag = avio_rl32(pb);
504  size = avio_rl32(pb);
505 
506  print_tag(s, "tag", tag, size);
507 
508  switch (tag) {
509  case MKTAG('L', 'I', 'S', 'T'):
510  list_end = avio_tell(pb) + size;
511  /* Ignored, except at start of video packets. */
512  tag1 = avio_rl32(pb);
513 
514  print_tag(s, "list", tag1, 0);
515 
516  if (tag1 == MKTAG('m', 'o', 'v', 'i')) {
517  avi->movi_list = avio_tell(pb) - 4;
518  if (size)
519  avi->movi_end = avi->movi_list + size + (size & 1);
520  else
521  avi->movi_end = avi->fsize;
522  av_log(s, AV_LOG_TRACE, "movi end=%"PRIx64"\n", avi->movi_end);
523  goto end_of_header;
524  } else if (tag1 == MKTAG('I', 'N', 'F', 'O'))
525  ff_read_riff_info(s, size - 4);
526  else if (tag1 == MKTAG('n', 'c', 'd', 't'))
527  avi_read_nikon(s, list_end);
528 
529  break;
530  case MKTAG('I', 'D', 'I', 'T'):
531  {
532  unsigned char date[64] = { 0 };
533  size += (size & 1);
534  size -= avio_read(pb, date, FFMIN(size, sizeof(date) - 1));
535  avio_skip(pb, size);
537  break;
538  }
539  case MKTAG('d', 'm', 'l', 'h'):
540  avi->is_odml = 1;
541  avio_skip(pb, size + (size & 1));
542  break;
543  case MKTAG('a', 'm', 'v', 'h'):
544  amv_file_format = 1;
545  case MKTAG('a', 'v', 'i', 'h'):
546  /* AVI header */
547  /* using frame_period is bad idea */
548  frame_period = avio_rl32(pb);
549  avio_rl32(pb); /* max. bytes per second */
550  avio_rl32(pb);
552 
553  avio_skip(pb, 2 * 4);
554  avio_rl32(pb);
555  avio_rl32(pb);
556  avih_width = avio_rl32(pb);
557  avih_height = avio_rl32(pb);
558 
559  avio_skip(pb, size - 10 * 4);
560  break;
561  case MKTAG('s', 't', 'r', 'h'):
562  /* stream header */
563 
564  tag1 = avio_rl32(pb);
565  handler = avio_rl32(pb); /* codec tag */
566 
567  if (tag1 == MKTAG('p', 'a', 'd', 's')) {
568  avio_skip(pb, size - 8);
569  break;
570  } else {
571  stream_index++;
572  st = avformat_new_stream(s, NULL);
573  if (!st)
574  goto fail;
575 
576  st->id = stream_index;
577  ast = av_mallocz(sizeof(AVIStream));
578  if (!ast)
579  goto fail;
580  st->priv_data = ast;
581  }
582  if (amv_file_format)
583  tag1 = stream_index ? MKTAG('a', 'u', 'd', 's')
584  : MKTAG('v', 'i', 'd', 's');
585 
586  print_tag(s, "strh", tag1, -1);
587 
588  if (tag1 == MKTAG('i', 'a', 'v', 's') ||
589  tag1 == MKTAG('i', 'v', 'a', 's')) {
590  int64_t dv_dur;
591 
592  /* After some consideration -- I don't think we
593  * have to support anything but DV in type1 AVIs. */
594  if (s->nb_streams != 1)
595  goto fail;
596 
597  if (handler != MKTAG('d', 'v', 's', 'd') &&
598  handler != MKTAG('d', 'v', 'h', 'd') &&
599  handler != MKTAG('d', 'v', 's', 'l'))
600  goto fail;
601 
602  ast = s->streams[0]->priv_data;
604  av_freep(&s->streams[0]->codecpar);
605 #if FF_API_LAVF_AVCTX
607  av_freep(&s->streams[0]->codec);
609 #endif
610  if (s->streams[0]->info)
612  av_freep(&s->streams[0]->info);
613  if (s->streams[0]->internal)
614  av_freep(&s->streams[0]->internal->avctx);
615  av_freep(&s->streams[0]->internal);
616  av_freep(&s->streams[0]);
617  s->nb_streams = 0;
618  if (CONFIG_DV_DEMUXER) {
619  avi->dv_demux = avpriv_dv_init_demux(s);
620  if (!avi->dv_demux)
621  goto fail;
622  } else
623  goto fail;
624  s->streams[0]->priv_data = ast;
625  avio_skip(pb, 3 * 4);
626  ast->scale = avio_rl32(pb);
627  ast->rate = avio_rl32(pb);
628  avio_skip(pb, 4); /* start time */
629 
630  dv_dur = avio_rl32(pb);
631  if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) {
632  dv_dur *= AV_TIME_BASE;
633  s->duration = av_rescale(dv_dur, ast->scale, ast->rate);
634  }
635  /* else, leave duration alone; timing estimation in utils.c
636  * will make a guess based on bitrate. */
637 
638  stream_index = s->nb_streams - 1;
639  avio_skip(pb, size - 9 * 4);
640  break;
641  }
642 
643  av_assert0(stream_index < s->nb_streams);
644  ast->handler = handler;
645 
646  avio_rl32(pb); /* flags */
647  avio_rl16(pb); /* priority */
648  avio_rl16(pb); /* language */
649  avio_rl32(pb); /* initial frame */
650  ast->scale = avio_rl32(pb);
651  ast->rate = avio_rl32(pb);
652  if (!(ast->scale && ast->rate)) {
654  "scale/rate is %"PRIu32"/%"PRIu32" which is invalid. "
655  "(This file has been generated by broken software.)\n",
656  ast->scale,
657  ast->rate);
658  if (frame_period) {
659  ast->rate = 1000000;
660  ast->scale = frame_period;
661  } else {
662  ast->rate = 25;
663  ast->scale = 1;
664  }
665  }
666  avpriv_set_pts_info(st, 64, ast->scale, ast->rate);
667 
668  ast->cum_len = avio_rl32(pb); /* start */
669  st->nb_frames = avio_rl32(pb);
670 
671  st->start_time = 0;
672  avio_rl32(pb); /* buffer size */
673  avio_rl32(pb); /* quality */
674  if (ast->cum_len > 3600LL * ast->rate / ast->scale) {
675  av_log(s, AV_LOG_ERROR, "crazy start time, iam scared, giving up\n");
676  ast->cum_len = 0;
677  }
678  ast->sample_size = avio_rl32(pb);
679  ast->cum_len *= FFMAX(1, ast->sample_size);
680  av_log(s, AV_LOG_TRACE, "%"PRIu32" %"PRIu32" %d\n",
681  ast->rate, ast->scale, ast->sample_size);
682 
683  switch (tag1) {
684  case MKTAG('v', 'i', 'd', 's'):
685  codec_type = AVMEDIA_TYPE_VIDEO;
686 
687  ast->sample_size = 0;
688  st->avg_frame_rate = av_inv_q(st->time_base);
689  break;
690  case MKTAG('a', 'u', 'd', 's'):
691  codec_type = AVMEDIA_TYPE_AUDIO;
692  break;
693  case MKTAG('t', 'x', 't', 's'):
694  codec_type = AVMEDIA_TYPE_SUBTITLE;
695  break;
696  case MKTAG('d', 'a', 't', 's'):
697  codec_type = AVMEDIA_TYPE_DATA;
698  break;
699  default:
700  av_log(s, AV_LOG_INFO, "unknown stream type %X\n", tag1);
701  }
702 
703  if (ast->sample_size < 0) {
704  if (s->error_recognition & AV_EF_EXPLODE) {
705  av_log(s, AV_LOG_ERROR,
706  "Invalid sample_size %d at stream %d\n",
707  ast->sample_size,
708  stream_index);
709  goto fail;
710  }
712  "Invalid sample_size %d at stream %d "
713  "setting it to 0\n",
714  ast->sample_size,
715  stream_index);
716  ast->sample_size = 0;
717  }
718 
719  if (ast->sample_size == 0) {
720  st->duration = st->nb_frames;
721  if (st->duration > 0 && avi->io_fsize > 0 && avi->riff_end > avi->io_fsize) {
722  av_log(s, AV_LOG_DEBUG, "File is truncated adjusting duration\n");
723  st->duration = av_rescale(st->duration, avi->io_fsize, avi->riff_end);
724  }
725  }
726  ast->frame_offset = ast->cum_len;
727  avio_skip(pb, size - 12 * 4);
728  break;
729  case MKTAG('s', 't', 'r', 'f'):
730  /* stream header */
731  if (!size && (codec_type == AVMEDIA_TYPE_AUDIO ||
732  codec_type == AVMEDIA_TYPE_VIDEO))
733  break;
734  if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) {
735  avio_skip(pb, size);
736  } else {
737  uint64_t cur_pos = avio_tell(pb);
738  unsigned esize;
739  if (cur_pos < list_end)
740  size = FFMIN(size, list_end - cur_pos);
741  st = s->streams[stream_index];
743  avio_skip(pb, size);
744  break;
745  }
746  switch (codec_type) {
747  case AVMEDIA_TYPE_VIDEO:
748  if (amv_file_format) {
749  st->codecpar->width = avih_width;
750  st->codecpar->height = avih_height;
753  avio_skip(pb, size);
754  break;
755  }
756  tag1 = ff_get_bmp_header(pb, st, &esize);
757 
758  if (tag1 == MKTAG('D', 'X', 'S', 'B') ||
759  tag1 == MKTAG('D', 'X', 'S', 'A')) {
761  st->codecpar->codec_tag = tag1;
763  break;
764  }
765 
766  if (size > 10 * 4 && size < (1 << 30) && size < avi->fsize) {
767  if (esize == size-1 && (esize&1)) {
768  st->codecpar->extradata_size = esize - 10 * 4;
769  } else
770  st->codecpar->extradata_size = size - 10 * 4;
771  if (st->codecpar->extradata) {
772  av_log(s, AV_LOG_WARNING, "New extradata in strf chunk, freeing previous one.\n");
773  }
774  ret = ff_get_extradata(s, st->codecpar, pb,
775  st->codecpar->extradata_size);
776  if (ret < 0)
777  return ret;
778  }
779 
780  // FIXME: check if the encoder really did this correctly
781  if (st->codecpar->extradata_size & 1)
782  avio_r8(pb);
783 
784  /* Extract palette from extradata if bpp <= 8.
785  * This code assumes that extradata contains only palette.
786  * This is true for all paletted codecs implemented in
787  * FFmpeg. */
788  if (st->codecpar->extradata_size &&
789  (st->codecpar->bits_per_coded_sample <= 8)) {
790  int pal_size = (1 << st->codecpar->bits_per_coded_sample) << 2;
791  const uint8_t *pal_src;
792 
793  pal_size = FFMIN(pal_size, st->codecpar->extradata_size);
794  pal_src = st->codecpar->extradata +
795  st->codecpar->extradata_size - pal_size;
796  /* Exclude the "BottomUp" field from the palette */
797  if (pal_src - st->codecpar->extradata >= 9 &&
798  !memcmp(st->codecpar->extradata + st->codecpar->extradata_size - 9, "BottomUp", 9))
799  pal_src -= 9;
800  for (i = 0; i < pal_size / 4; i++)
801  ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src + 4 * i);
802  ast->has_pal = 1;
803  }
804 
805  print_tag(s, "video", tag1, 0);
806 
808  st->codecpar->codec_tag = tag1;
810  tag1);
811  /* If codec is not found yet, try with the mov tags. */
812  if (!st->codecpar->codec_id) {
813  st->codecpar->codec_id =
815  if (st->codecpar->codec_id)
817  "mov tag found in avi (fourcc %s)\n",
818  av_fourcc2str(tag1));
819  }
820  if (!st->codecpar->codec_id)
822 
823  /* This is needed to get the pict type which is necessary
824  * for generating correct pts. */
826 
827  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4 &&
828  ast->handler == MKTAG('X', 'V', 'I', 'D'))
829  st->codecpar->codec_tag = MKTAG('X', 'V', 'I', 'D');
830 
831  if (st->codecpar->codec_tag == MKTAG('V', 'S', 'S', 'H'))
833  if (st->codecpar->codec_id == AV_CODEC_ID_RV40)
835  if (st->codecpar->codec_id == AV_CODEC_ID_HEVC &&
836  st->codecpar->codec_tag == MKTAG('H', '2', '6', '5'))
838 
839  if (st->codecpar->codec_tag == 0 && st->codecpar->height > 0 &&
840  st->codecpar->extradata_size < 1U << 30) {
841  st->codecpar->extradata_size += 9;
842  if ((ret = av_reallocp(&st->codecpar->extradata,
843  st->codecpar->extradata_size +
845  st->codecpar->extradata_size = 0;
846  return ret;
847  } else
848  memcpy(st->codecpar->extradata + st->codecpar->extradata_size - 9,
849  "BottomUp", 9);
850  }
851  st->codecpar->height = FFABS(st->codecpar->height);
852 
853 // avio_skip(pb, size - 5 * 4);
854  break;
855  case AVMEDIA_TYPE_AUDIO:
856  ret = ff_get_wav_header(s, pb, st->codecpar, size, 0);
857  if (ret < 0)
858  return ret;
860  if (ast->sample_size && st->codecpar->block_align &&
861  ast->sample_size != st->codecpar->block_align) {
862  av_log(s,
864  "sample size (%d) != block align (%d)\n",
865  ast->sample_size,
866  st->codecpar->block_align);
867  ast->sample_size = st->codecpar->block_align;
868  }
869  /* 2-aligned
870  * (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
871  if (size & 1)
872  avio_skip(pb, 1);
873  /* Force parsing as several audio frames can be in
874  * one packet and timestamps refer to packet start. */
876  /* ADTS header is in extradata, AAC without header must be
877  * stored as exact frames. Parser not needed and it will
878  * fail. */
879  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
882  // The flac parser does not work with AVSTREAM_PARSE_TIMESTAMPS
883  if (st->codecpar->codec_id == AV_CODEC_ID_FLAC)
885  /* AVI files with Xan DPCM audio (wrongly) declare PCM
886  * audio in the header but have Axan as stream_code_tag. */
887  if (ast->handler == AV_RL32("Axan")) {
889  st->codecpar->codec_tag = 0;
890  ast->dshow_block_align = 0;
891  }
892  if (amv_file_format) {
894  ast->dshow_block_align = 0;
895  }
896  if ((st->codecpar->codec_id == AV_CODEC_ID_AAC ||
898  st->codecpar->codec_id == AV_CODEC_ID_MP2 ) && ast->dshow_block_align <= 4 && ast->dshow_block_align) {
899  av_log(s, AV_LOG_DEBUG, "overriding invalid dshow_block_align of %d\n", ast->dshow_block_align);
900  ast->dshow_block_align = 0;
901  }
902  if (st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 1024 && ast->sample_size == 1024 ||
903  st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 4096 && ast->sample_size == 4096 ||
904  st->codecpar->codec_id == AV_CODEC_ID_MP3 && ast->dshow_block_align == 1152 && ast->sample_size == 1152) {
905  av_log(s, AV_LOG_DEBUG, "overriding sample_size\n");
906  ast->sample_size = 0;
907  }
908  break;
911  st->request_probe= 1;
912  avio_skip(pb, size);
913  break;
914  default:
917  st->codecpar->codec_tag = 0;
918  avio_skip(pb, size);
919  break;
920  }
921  }
922  break;
923  case MKTAG('s', 't', 'r', 'd'):
924  if (stream_index >= (unsigned)s->nb_streams
925  || s->streams[stream_index]->codecpar->extradata_size
926  || s->streams[stream_index]->codecpar->codec_tag == MKTAG('H','2','6','4')) {
927  avio_skip(pb, size);
928  } else {
929  uint64_t cur_pos = avio_tell(pb);
930  if (cur_pos < list_end)
931  size = FFMIN(size, list_end - cur_pos);
932  st = s->streams[stream_index];
933 
934  if (size<(1<<30)) {
935  if (st->codecpar->extradata) {
936  av_log(s, AV_LOG_WARNING, "New extradata in strd chunk, freeing previous one.\n");
937  }
938  if ((ret = ff_get_extradata(s, st->codecpar, pb, size)) < 0)
939  return ret;
940  }
941 
942  if (st->codecpar->extradata_size & 1) //FIXME check if the encoder really did this correctly
943  avio_r8(pb);
944 
945  ret = avi_extract_stream_metadata(s, st);
946  if (ret < 0) {
947  av_log(s, AV_LOG_WARNING, "could not decoding EXIF data in stream header.\n");
948  }
949  }
950  break;
951  case MKTAG('i', 'n', 'd', 'x'):
952  pos = avio_tell(pb);
953  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !(s->flags & AVFMT_FLAG_IGNIDX) &&
954  avi->use_odml &&
955  read_odml_index(s, 0) < 0 &&
957  goto fail;
958  avio_seek(pb, pos + size, SEEK_SET);
959  break;
960  case MKTAG('v', 'p', 'r', 'p'):
961  if (stream_index < (unsigned)s->nb_streams && size > 9 * 4) {
962  AVRational active, active_aspect;
963 
964  st = s->streams[stream_index];
965  avio_rl32(pb);
966  avio_rl32(pb);
967  avio_rl32(pb);
968  avio_rl32(pb);
969  avio_rl32(pb);
970 
971  active_aspect.den = avio_rl16(pb);
972  active_aspect.num = avio_rl16(pb);
973  active.num = avio_rl32(pb);
974  active.den = avio_rl32(pb);
975  avio_rl32(pb); // nbFieldsPerFrame
976 
977  if (active_aspect.num && active_aspect.den &&
978  active.num && active.den) {
979  st->sample_aspect_ratio = av_div_q(active_aspect, active);
980  av_log(s, AV_LOG_TRACE, "vprp %d/%d %d/%d\n",
981  active_aspect.num, active_aspect.den,
982  active.num, active.den);
983  }
984  size -= 9 * 4;
985  }
986  avio_skip(pb, size);
987  break;
988  case MKTAG('s', 't', 'r', 'n'):
989  if (s->nb_streams) {
990  ret = avi_read_tag(s, s->streams[s->nb_streams - 1], tag, size);
991  if (ret < 0)
992  return ret;
993  break;
994  }
995  default:
996  if (size > 1000000) {
997  av_log(s, AV_LOG_ERROR,
998  "Something went wrong during header parsing, "
999  "tag %s has size %u, "
1000  "I will ignore it and try to continue anyway.\n",
1001  av_fourcc2str(tag), size);
1003  goto fail;
1004  avi->movi_list = avio_tell(pb) - 4;
1005  avi->movi_end = avi->fsize;
1006  goto end_of_header;
1007  }
1008  /* Do not fail for very large idx1 tags */
1009  case MKTAG('i', 'd', 'x', '1'):
1010  /* skip tag */
1011  size += (size & 1);
1012  avio_skip(pb, size);
1013  break;
1014  }
1015  }
1016 
1017 end_of_header:
1018  /* check stream number */
1019  if (stream_index != s->nb_streams - 1) {
1020 
1021 fail:
1022  return AVERROR_INVALIDDATA;
1023  }
1024 
1025  if (!avi->index_loaded && (pb->seekable & AVIO_SEEKABLE_NORMAL))
1026  avi_load_index(s);
1027  calculate_bitrate(s);
1028  avi->index_loaded |= 1;
1029 
1030  if ((ret = guess_ni_flag(s)) < 0)
1031  return ret;
1032 
1033  avi->non_interleaved |= ret | (s->flags & AVFMT_FLAG_SORT_DTS);
1034 
1035  dict_entry = av_dict_get(s->metadata, "ISFT", NULL, 0);
1036  if (dict_entry && !strcmp(dict_entry->value, "PotEncoder"))
1037  for (i = 0; i < s->nb_streams; i++) {
1038  AVStream *st = s->streams[i];
1042  }
1043 
1044  for (i = 0; i < s->nb_streams; i++) {
1045  AVStream *st = s->streams[i];
1046  if (st->nb_index_entries)
1047  break;
1048  }
1049  // DV-in-AVI cannot be non-interleaved, if set this must be
1050  // a mis-detection.
1051  if (avi->dv_demux)
1052  avi->non_interleaved = 0;
1053  if (i == s->nb_streams && avi->non_interleaved) {
1055  "Non-interleaved AVI without index, switching to interleaved\n");
1056  avi->non_interleaved = 0;
1057  }
1058 
1059  if (avi->non_interleaved) {
1060  av_log(s, AV_LOG_INFO, "non-interleaved AVI\n");
1061  clean_index(s);
1062  }
1063 
1064  ff_metadata_conv_ctx(s, NULL, avi_metadata_conv);
1066 
1067  return 0;
1068 }
1069 
1071 {
1072  if (pkt->size >= 7 &&
1073  pkt->size < INT_MAX - AVPROBE_PADDING_SIZE &&
1074  !strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data + 5) == 2) {
1075  uint8_t desc[256];
1076  int score = AVPROBE_SCORE_EXTENSION, ret;
1077  AVIStream *ast = st->priv_data;
1078  ff_const59 AVInputFormat *sub_demuxer;
1079  AVRational time_base;
1080  int size;
1081  AVIOContext *pb = avio_alloc_context(pkt->data + 7,
1082  pkt->size - 7,
1083  0, NULL, NULL, NULL, NULL);
1084  AVProbeData pd;
1085  unsigned int desc_len = avio_rl32(pb);
1086 
1087  if (desc_len > pb->buf_end - pb->buf_ptr)
1088  goto error;
1089 
1090  ret = avio_get_str16le(pb, desc_len, desc, sizeof(desc));
1091  avio_skip(pb, desc_len - ret);
1092  if (*desc)
1093  av_dict_set(&st->metadata, "title", desc, 0);
1094 
1095  avio_rl16(pb); /* flags? */
1096  avio_rl32(pb); /* data size */
1097 
1098  size = pb->buf_end - pb->buf_ptr;
1099  pd = (AVProbeData) { .buf = av_mallocz(size + AVPROBE_PADDING_SIZE),
1100  .buf_size = size };
1101  if (!pd.buf)
1102  goto error;
1103  memcpy(pd.buf, pb->buf_ptr, size);
1104  sub_demuxer = av_probe_input_format2(&pd, 1, &score);
1105  av_freep(&pd.buf);
1106  if (!sub_demuxer)
1107  goto error;
1108 
1109  if (strcmp(sub_demuxer->name, "srt") && strcmp(sub_demuxer->name, "ass"))
1110  goto error;
1111 
1112  if (!(ast->sub_ctx = avformat_alloc_context()))
1113  goto error;
1114 
1115  ast->sub_ctx->pb = pb;
1116 
1117  if (ff_copy_whiteblacklists(ast->sub_ctx, s) < 0)
1118  goto error;
1119 
1120  if (!avformat_open_input(&ast->sub_ctx, "", sub_demuxer, NULL)) {
1121  if (ast->sub_ctx->nb_streams != 1)
1122  goto error;
1123  ff_read_packet(ast->sub_ctx, &ast->sub_pkt);
1125  time_base = ast->sub_ctx->streams[0]->time_base;
1126  avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
1127  }
1128  ast->sub_buffer = pkt->data;
1129  memset(pkt, 0, sizeof(*pkt));
1130  return 1;
1131 
1132 error:
1133  av_freep(&ast->sub_ctx);
1134  avio_context_free(&pb);
1135  }
1136  return 0;
1137 }
1138 
1140  AVPacket *pkt)
1141 {
1142  AVIStream *ast, *next_ast = next_st->priv_data;
1143  int64_t ts, next_ts, ts_min = INT64_MAX;
1144  AVStream *st, *sub_st = NULL;
1145  int i;
1146 
1147  next_ts = av_rescale_q(next_ast->frame_offset, next_st->time_base,
1148  AV_TIME_BASE_Q);
1149 
1150  for (i = 0; i < s->nb_streams; i++) {
1151  st = s->streams[i];
1152  ast = st->priv_data;
1153  if (st->discard < AVDISCARD_ALL && ast && ast->sub_pkt.data) {
1154  ts = av_rescale_q(ast->sub_pkt.dts, st->time_base, AV_TIME_BASE_Q);
1155  if (ts <= next_ts && ts < ts_min) {
1156  ts_min = ts;
1157  sub_st = st;
1158  }
1159  }
1160  }
1161 
1162  if (sub_st) {
1163  ast = sub_st->priv_data;
1164  *pkt = ast->sub_pkt;
1165  pkt->stream_index = sub_st->index;
1166 
1167  if (ff_read_packet(ast->sub_ctx, &ast->sub_pkt) < 0)
1168  ast->sub_pkt.data = NULL;
1169  }
1170  return sub_st;
1171 }
1172 
1173 static int get_stream_idx(const unsigned *d)
1174 {
1175  if (d[0] >= '0' && d[0] <= '9' &&
1176  d[1] >= '0' && d[1] <= '9') {
1177  return (d[0] - '0') * 10 + (d[1] - '0');
1178  } else {
1179  return 100; // invalid stream ID
1180  }
1181 }
1182 
1183 /**
1184  *
1185  * @param exit_early set to 1 to just gather packet position without making the changes needed to actually read & return the packet
1186  */
1187 static int avi_sync(AVFormatContext *s, int exit_early)
1188 {
1189  AVIContext *avi = s->priv_data;
1190  AVIOContext *pb = s->pb;
1191  int n;
1192  unsigned int d[8];
1193  unsigned int size;
1194  int64_t i, sync;
1195 
1196 start_sync:
1197  memset(d, -1, sizeof(d));
1198  for (i = sync = avio_tell(pb); !avio_feof(pb); i++) {
1199  int j;
1200 
1201  for (j = 0; j < 7; j++)
1202  d[j] = d[j + 1];
1203  d[7] = avio_r8(pb);
1204 
1205  size = d[4] + (d[5] << 8) + (d[6] << 16) + (d[7] << 24);
1206 
1207  n = get_stream_idx(d + 2);
1208  ff_tlog(s, "%X %X %X %X %X %X %X %X %"PRId64" %u %d\n",
1209  d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n);
1210  if (i*(avi->io_fsize>0) + (uint64_t)size > avi->fsize || d[0] > 127)
1211  continue;
1212 
1213  // parse ix##
1214  if ((d[0] == 'i' && d[1] == 'x' && n < s->nb_streams) ||
1215  // parse JUNK
1216  (d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K') ||
1217  (d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1') ||
1218  (d[0] == 'i' && d[1] == 'n' && d[2] == 'd' && d[3] == 'x')) {
1219  avio_skip(pb, size);
1220  goto start_sync;
1221  }
1222 
1223  // parse stray LIST
1224  if (d[0] == 'L' && d[1] == 'I' && d[2] == 'S' && d[3] == 'T') {
1225  avio_skip(pb, 4);
1226  goto start_sync;
1227  }
1228 
1229  n = get_stream_idx(d);
1230 
1231  if (!((i - avi->last_pkt_pos) & 1) &&
1232  get_stream_idx(d + 1) < s->nb_streams)
1233  continue;
1234 
1235  // detect ##ix chunk and skip
1236  if (d[2] == 'i' && d[3] == 'x' && n < s->nb_streams) {
1237  avio_skip(pb, size);
1238  goto start_sync;
1239  }
1240 
1241  if (d[2] == 'w' && d[3] == 'c' && n < s->nb_streams) {
1242  avio_skip(pb, 16 * 3 + 8);
1243  goto start_sync;
1244  }
1245 
1246  if (avi->dv_demux && n != 0)
1247  continue;
1248 
1249  // parse ##dc/##wb
1250  if (n < s->nb_streams) {
1251  AVStream *st;
1252  AVIStream *ast;
1253  st = s->streams[n];
1254  ast = st->priv_data;
1255 
1256  if (!ast) {
1257  av_log(s, AV_LOG_WARNING, "Skipping foreign stream %d packet\n", n);
1258  continue;
1259  }
1260 
1261  if (s->nb_streams >= 2) {
1262  AVStream *st1 = s->streams[1];
1263  AVIStream *ast1 = st1->priv_data;
1264  // workaround for broken small-file-bug402.avi
1265  if ( d[2] == 'w' && d[3] == 'b'
1266  && n == 0
1267  && st ->codecpar->codec_type == AVMEDIA_TYPE_VIDEO
1269  && ast->prefix == 'd'*256+'c'
1270  && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count)
1271  ) {
1272  n = 1;
1273  st = st1;
1274  ast = ast1;
1276  "Invalid stream + prefix combination, assuming audio.\n");
1277  }
1278  }
1279 
1280  if (d[2] == 'p' && d[3] == 'c' && size <= 4 * 256 + 4) {
1281  int k = avio_r8(pb);
1282  int last = (k + avio_r8(pb) - 1) & 0xFF;
1283 
1284  avio_rl16(pb); // flags
1285 
1286  // b + (g << 8) + (r << 16);
1287  for (; k <= last; k++)
1288  ast->pal[k] = 0xFFU<<24 | avio_rb32(pb)>>8;
1289 
1290  ast->has_pal = 1;
1291  goto start_sync;
1292  } else if (((ast->prefix_count < 5 || sync + 9 > i) &&
1293  d[2] < 128 && d[3] < 128) ||
1294  d[2] * 256 + d[3] == ast->prefix /* ||
1295  (d[2] == 'd' && d[3] == 'c') ||
1296  (d[2] == 'w' && d[3] == 'b') */) {
1297  if (exit_early)
1298  return 0;
1299  if (d[2] * 256 + d[3] == ast->prefix)
1300  ast->prefix_count++;
1301  else {
1302  ast->prefix = d[2] * 256 + d[3];
1303  ast->prefix_count = 0;
1304  }
1305 
1306  if (!avi->dv_demux &&
1307  ((st->discard >= AVDISCARD_DEFAULT && size == 0) /* ||
1308  // FIXME: needs a little reordering
1309  (st->discard >= AVDISCARD_NONKEY &&
1310  !(pkt->flags & AV_PKT_FLAG_KEY)) */
1311  || st->discard >= AVDISCARD_ALL)) {
1312 
1313  ast->frame_offset += get_duration(ast, size);
1314  avio_skip(pb, size);
1315  goto start_sync;
1316  }
1317 
1318  avi->stream_index = n;
1319  ast->packet_size = size + 8;
1320  ast->remaining = size;
1321 
1322  if (size) {
1323  uint64_t pos = avio_tell(pb) - 8;
1324  if (!st->index_entries || !st->nb_index_entries ||
1325  st->index_entries[st->nb_index_entries - 1].pos < pos) {
1326  av_add_index_entry(st, pos, ast->frame_offset, size,
1327  0, AVINDEX_KEYFRAME);
1328  }
1329  }
1330  return 0;
1331  }
1332  }
1333  }
1334 
1335  if (pb->error)
1336  return pb->error;
1337  return AVERROR_EOF;
1338 }
1339 
1341 {
1342  AVIContext *avi = s->priv_data;
1343  int best_stream_index = 0;
1344  AVStream *best_st = NULL;
1345  AVIStream *best_ast;
1346  int64_t best_ts = INT64_MAX;
1347  int i;
1348 
1349  for (i = 0; i < s->nb_streams; i++) {
1350  AVStream *st = s->streams[i];
1351  AVIStream *ast = st->priv_data;
1352  int64_t ts = ast->frame_offset;
1353  int64_t last_ts;
1354 
1355  if (!st->nb_index_entries)
1356  continue;
1357 
1358  last_ts = st->index_entries[st->nb_index_entries - 1].timestamp;
1359  if (!ast->remaining && ts > last_ts)
1360  continue;
1361 
1362  ts = av_rescale_q(ts, st->time_base,
1363  (AVRational) { FFMAX(1, ast->sample_size),
1364  AV_TIME_BASE });
1365 
1366  av_log(s, AV_LOG_TRACE, "%"PRId64" %d/%d %"PRId64"\n", ts,
1367  st->time_base.num, st->time_base.den, ast->frame_offset);
1368  if (ts < best_ts) {
1369  best_ts = ts;
1370  best_st = st;
1371  best_stream_index = i;
1372  }
1373  }
1374  if (!best_st)
1375  return AVERROR_EOF;
1376 
1377  best_ast = best_st->priv_data;
1378  best_ts = best_ast->frame_offset;
1379  if (best_ast->remaining) {
1380  i = av_index_search_timestamp(best_st,
1381  best_ts,
1382  AVSEEK_FLAG_ANY |
1384  } else {
1385  i = av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY);
1386  if (i >= 0)
1387  best_ast->frame_offset = best_st->index_entries[i].timestamp;
1388  }
1389 
1390  if (i >= 0) {
1391  int64_t pos = best_st->index_entries[i].pos;
1392  pos += best_ast->packet_size - best_ast->remaining;
1393  if (avio_seek(s->pb, pos + 8, SEEK_SET) < 0)
1394  return AVERROR_EOF;
1395 
1396  av_assert0(best_ast->remaining <= best_ast->packet_size);
1397 
1398  avi->stream_index = best_stream_index;
1399  if (!best_ast->remaining)
1400  best_ast->packet_size =
1401  best_ast->remaining = best_st->index_entries[i].size;
1402  }
1403  else
1404  return AVERROR_EOF;
1405 
1406  return 0;
1407 }
1408 
1410 {
1411  AVIContext *avi = s->priv_data;
1412  AVIOContext *pb = s->pb;
1413  int err;
1414 
1415  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1416  int size = avpriv_dv_get_packet(avi->dv_demux, pkt);
1417  if (size >= 0)
1418  return size;
1419  else
1420  goto resync;
1421  }
1422 
1423  if (avi->non_interleaved) {
1424  err = ni_prepare_read(s);
1425  if (err < 0)
1426  return err;
1427  }
1428 
1429 resync:
1430  if (avi->stream_index >= 0) {
1431  AVStream *st = s->streams[avi->stream_index];
1432  AVIStream *ast = st->priv_data;
1433  int size, err;
1434 
1435  if (get_subtitle_pkt(s, st, pkt))
1436  return 0;
1437 
1438  // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM
1439  if (ast->sample_size <= 1)
1440  size = INT_MAX;
1441  else if (ast->sample_size < 32)
1442  // arbitrary multiplier to avoid tiny packets for raw PCM data
1443  size = 1024 * ast->sample_size;
1444  else
1445  size = ast->sample_size;
1446 
1447  if (size > ast->remaining)
1448  size = ast->remaining;
1449  avi->last_pkt_pos = avio_tell(pb);
1450  err = av_get_packet(pb, pkt, size);
1451  if (err < 0)
1452  return err;
1453  size = err;
1454 
1455  if (ast->has_pal && pkt->size < (unsigned)INT_MAX / 2) {
1456  uint8_t *pal;
1457  pal = av_packet_new_side_data(pkt,
1459  AVPALETTE_SIZE);
1460  if (!pal) {
1461  av_log(s, AV_LOG_ERROR,
1462  "Failed to allocate data for palette\n");
1463  } else {
1464  memcpy(pal, ast->pal, AVPALETTE_SIZE);
1465  ast->has_pal = 0;
1466  }
1467  }
1468 
1469  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1470  AVBufferRef *avbuf = pkt->buf;
1471  size = avpriv_dv_produce_packet(avi->dv_demux, pkt,
1472  pkt->data, pkt->size, pkt->pos);
1473  pkt->buf = avbuf;
1474  pkt->flags |= AV_PKT_FLAG_KEY;
1475  if (size < 0)
1476  av_packet_unref(pkt);
1477  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE &&
1478  !st->codecpar->codec_tag && read_gab2_sub(s, st, pkt)) {
1479  ast->frame_offset++;
1480  avi->stream_index = -1;
1481  ast->remaining = 0;
1482  goto resync;
1483  } else {
1484  /* XXX: How to handle B-frames in AVI? */
1485  pkt->dts = ast->frame_offset;
1486 // pkt->dts += ast->start;
1487  if (ast->sample_size)
1488  pkt->dts /= ast->sample_size;
1489  pkt->stream_index = avi->stream_index;
1490 
1491  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->index_entries) {
1492  AVIndexEntry *e;
1493  int index;
1494 
1496  e = &st->index_entries[index];
1497 
1498  if (index >= 0 && e->timestamp == ast->frame_offset) {
1499  if (index == st->nb_index_entries-1) {
1500  int key=1;
1501  uint32_t state=-1;
1502  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4) {
1503  const uint8_t *ptr = pkt->data, *end = ptr + FFMIN(size, 256);
1504  while (ptr < end) {
1505  ptr = avpriv_find_start_code(ptr, end, &state);
1506  if (state == 0x1B6 && ptr < end) {
1507  key = !(*ptr & 0xC0);
1508  break;
1509  }
1510  }
1511  }
1512  if (!key)
1513  e->flags &= ~AVINDEX_KEYFRAME;
1514  }
1515  if (e->flags & AVINDEX_KEYFRAME)
1516  pkt->flags |= AV_PKT_FLAG_KEY;
1517  }
1518  } else {
1519  pkt->flags |= AV_PKT_FLAG_KEY;
1520  }
1521  ast->frame_offset += get_duration(ast, pkt->size);
1522  }
1523  ast->remaining -= err;
1524  if (!ast->remaining) {
1525  avi->stream_index = -1;
1526  ast->packet_size = 0;
1527  }
1528 
1529  if (!avi->non_interleaved && pkt->pos >= 0 && ast->seek_pos > pkt->pos) {
1530  av_packet_unref(pkt);
1531  goto resync;
1532  }
1533  ast->seek_pos= 0;
1534 
1535  if (!avi->non_interleaved && st->nb_index_entries>1 && avi->index_loaded>1) {
1536  int64_t dts= av_rescale_q(pkt->dts, st->time_base, AV_TIME_BASE_Q);
1537 
1538  if (avi->dts_max < dts) {
1539  avi->dts_max = dts;
1540  } else if (avi->dts_max - (uint64_t)dts > 2*AV_TIME_BASE) {
1541  avi->non_interleaved= 1;
1542  av_log(s, AV_LOG_INFO, "Switching to NI mode, due to poor interleaving\n");
1543  }
1544  }
1545 
1546  return 0;
1547  }
1548 
1549  if ((err = avi_sync(s, 0)) < 0)
1550  return err;
1551  goto resync;
1552 }
1553 
1554 /* XXX: We make the implicit supposition that the positions are sorted
1555  * for each stream. */
1557 {
1558  AVIContext *avi = s->priv_data;
1559  AVIOContext *pb = s->pb;
1560  int nb_index_entries, i;
1561  AVStream *st;
1562  AVIStream *ast;
1563  int64_t pos;
1564  unsigned int index, tag, flags, len, first_packet = 1;
1565  int64_t last_pos = -1;
1566  unsigned last_idx = -1;
1567  int64_t idx1_pos, first_packet_pos = 0, data_offset = 0;
1568  int anykey = 0;
1569 
1570  nb_index_entries = size / 16;
1571  if (nb_index_entries <= 0)
1572  return AVERROR_INVALIDDATA;
1573 
1574  idx1_pos = avio_tell(pb);
1575  avio_seek(pb, avi->movi_list + 4, SEEK_SET);
1576  if (avi_sync(s, 1) == 0)
1577  first_packet_pos = avio_tell(pb) - 8;
1578  avi->stream_index = -1;
1579  avio_seek(pb, idx1_pos, SEEK_SET);
1580 
1581  if (s->nb_streams == 1 && s->streams[0]->codecpar->codec_tag == AV_RL32("MMES")) {
1582  first_packet_pos = 0;
1583  data_offset = avi->movi_list;
1584  }
1585 
1586  /* Read the entries and sort them in each stream component. */
1587  for (i = 0; i < nb_index_entries; i++) {
1588  if (avio_feof(pb))
1589  return -1;
1590 
1591  tag = avio_rl32(pb);
1592  flags = avio_rl32(pb);
1593  pos = avio_rl32(pb);
1594  len = avio_rl32(pb);
1595  av_log(s, AV_LOG_TRACE, "%d: tag=0x%x flags=0x%x pos=0x%"PRIx64" len=%d/",
1596  i, tag, flags, pos, len);
1597 
1598  index = ((tag & 0xff) - '0') * 10;
1599  index += (tag >> 8 & 0xff) - '0';
1600  if (index >= s->nb_streams)
1601  continue;
1602  st = s->streams[index];
1603  ast = st->priv_data;
1604 
1605  /* Skip 'xxpc' palette change entries in the index until a logic
1606  * to process these is properly implemented. */
1607  if ((tag >> 16 & 0xff) == 'p' && (tag >> 24 & 0xff) == 'c')
1608  continue;
1609 
1610  if (first_packet && first_packet_pos) {
1611  if (avi->movi_list + 4 != pos || pos + 500 > first_packet_pos)
1612  data_offset = first_packet_pos - pos;
1613  first_packet = 0;
1614  }
1615  pos += data_offset;
1616 
1617  av_log(s, AV_LOG_TRACE, "%d cum_len=%"PRId64"\n", len, ast->cum_len);
1618 
1619  // even if we have only a single stream, we should
1620  // switch to non-interleaved to get correct timestamps
1621  if (last_pos == pos)
1622  avi->non_interleaved = 1;
1623  if (last_idx != pos && len) {
1624  av_add_index_entry(st, pos, ast->cum_len, len, 0,
1625  (flags & AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);
1626  last_idx= pos;
1627  }
1628  ast->cum_len += get_duration(ast, len);
1629  last_pos = pos;
1630  anykey |= flags&AVIIF_INDEX;
1631  }
1632  if (!anykey) {
1633  for (index = 0; index < s->nb_streams; index++) {
1634  st = s->streams[index];
1635  if (st->nb_index_entries)
1637  }
1638  }
1639  return 0;
1640 }
1641 
1642 /* Scan the index and consider any file with streams more than
1643  * 2 seconds or 64MB apart non-interleaved. */
1645 {
1646  int64_t min_pos, pos;
1647  int i;
1648  int *idx = av_mallocz_array(s->nb_streams, sizeof(*idx));
1649  if (!idx)
1650  return AVERROR(ENOMEM);
1651  for (min_pos = pos = 0; min_pos != INT64_MAX; pos = min_pos + 1LU) {
1652  int64_t max_dts = INT64_MIN / 2;
1653  int64_t min_dts = INT64_MAX / 2;
1654  int64_t max_buffer = 0;
1655 
1656  min_pos = INT64_MAX;
1657 
1658  for (i = 0; i < s->nb_streams; i++) {
1659  AVStream *st = s->streams[i];
1660  AVIStream *ast = st->priv_data;
1661  int n = st->nb_index_entries;
1662  while (idx[i] < n && st->index_entries[idx[i]].pos < pos)
1663  idx[i]++;
1664  if (idx[i] < n) {
1665  int64_t dts;
1666  dts = av_rescale_q(st->index_entries[idx[i]].timestamp /
1667  FFMAX(ast->sample_size, 1),
1668  st->time_base, AV_TIME_BASE_Q);
1669  min_dts = FFMIN(min_dts, dts);
1670  min_pos = FFMIN(min_pos, st->index_entries[idx[i]].pos);
1671  }
1672  }
1673  for (i = 0; i < s->nb_streams; i++) {
1674  AVStream *st = s->streams[i];
1675  AVIStream *ast = st->priv_data;
1676 
1677  if (idx[i] && min_dts != INT64_MAX / 2) {
1678  int64_t dts;
1679  dts = av_rescale_q(st->index_entries[idx[i] - 1].timestamp /
1680  FFMAX(ast->sample_size, 1),
1681  st->time_base, AV_TIME_BASE_Q);
1682  max_dts = FFMAX(max_dts, dts);
1683  max_buffer = FFMAX(max_buffer,
1684  av_rescale(dts - min_dts,
1685  st->codecpar->bit_rate,
1686  AV_TIME_BASE));
1687  }
1688  }
1689  if (max_dts - min_dts > 2 * AV_TIME_BASE ||
1690  max_buffer > 1024 * 1024 * 8 * 8) {
1691  av_free(idx);
1692  return 1;
1693  }
1694  }
1695  av_free(idx);
1696  return 0;
1697 }
1698 
1700 {
1701  int i;
1702  int64_t last_start = 0;
1703  int64_t first_end = INT64_MAX;
1704  int64_t oldpos = avio_tell(s->pb);
1705 
1706  for (i = 0; i < s->nb_streams; i++) {
1707  AVStream *st = s->streams[i];
1708  int n = st->nb_index_entries;
1709  unsigned int size;
1710 
1711  if (n <= 0)
1712  continue;
1713 
1714  if (n >= 2) {
1715  int64_t pos = st->index_entries[0].pos;
1716  unsigned tag[2];
1717  avio_seek(s->pb, pos, SEEK_SET);
1718  tag[0] = avio_r8(s->pb);
1719  tag[1] = avio_r8(s->pb);
1720  avio_rl16(s->pb);
1721  size = avio_rl32(s->pb);
1722  if (get_stream_idx(tag) == i && pos + size > st->index_entries[1].pos)
1723  last_start = INT64_MAX;
1724  if (get_stream_idx(tag) == i && size == st->index_entries[0].size + 8)
1725  last_start = INT64_MAX;
1726  }
1727 
1728  if (st->index_entries[0].pos > last_start)
1729  last_start = st->index_entries[0].pos;
1730  if (st->index_entries[n - 1].pos < first_end)
1731  first_end = st->index_entries[n - 1].pos;
1732  }
1733  avio_seek(s->pb, oldpos, SEEK_SET);
1734 
1735  if (last_start > first_end)
1736  return 1;
1737 
1738  return check_stream_max_drift(s);
1739 }
1740 
1742 {
1743  AVIContext *avi = s->priv_data;
1744  AVIOContext *pb = s->pb;
1745  uint32_t tag, size;
1746  int64_t pos = avio_tell(pb);
1747  int64_t next;
1748  int ret = -1;
1749 
1750  if (avio_seek(pb, avi->movi_end, SEEK_SET) < 0)
1751  goto the_end; // maybe truncated file
1752  av_log(s, AV_LOG_TRACE, "movi_end=0x%"PRIx64"\n", avi->movi_end);
1753  for (;;) {
1754  tag = avio_rl32(pb);
1755  size = avio_rl32(pb);
1756  if (avio_feof(pb))
1757  break;
1758  next = avio_tell(pb) + size + (size & 1);
1759 
1760  if (tag == MKTAG('i', 'd', 'x', '1') &&
1761  avi_read_idx1(s, size) >= 0) {
1762  avi->index_loaded=2;
1763  ret = 0;
1764  }else if (tag == MKTAG('L', 'I', 'S', 'T')) {
1765  uint32_t tag1 = avio_rl32(pb);
1766 
1767  if (tag1 == MKTAG('I', 'N', 'F', 'O'))
1768  ff_read_riff_info(s, size - 4);
1769  }else if (!ret)
1770  break;
1771 
1772  if (avio_seek(pb, next, SEEK_SET) < 0)
1773  break; // something is wrong here
1774  }
1775 
1776 the_end:
1777  avio_seek(pb, pos, SEEK_SET);
1778  return ret;
1779 }
1780 
1781 static void seek_subtitle(AVStream *st, AVStream *st2, int64_t timestamp)
1782 {
1783  AVIStream *ast2 = st2->priv_data;
1784  int64_t ts2 = av_rescale_q(timestamp, st->time_base, st2->time_base);
1785  av_packet_unref(&ast2->sub_pkt);
1786  if (avformat_seek_file(ast2->sub_ctx, 0, INT64_MIN, ts2, ts2, 0) >= 0 ||
1787  avformat_seek_file(ast2->sub_ctx, 0, ts2, ts2, INT64_MAX, 0) >= 0)
1788  ff_read_packet(ast2->sub_ctx, &ast2->sub_pkt);
1789 }
1790 
1791 static int avi_read_seek(AVFormatContext *s, int stream_index,
1792  int64_t timestamp, int flags)
1793 {
1794  AVIContext *avi = s->priv_data;
1795  AVStream *st;
1796  int i, index;
1797  int64_t pos, pos_min;
1798  AVIStream *ast;
1799 
1800  /* Does not matter which stream is requested dv in avi has the
1801  * stream information in the first video stream.
1802  */
1803  if (avi->dv_demux)
1804  stream_index = 0;
1805 
1806  if (!avi->index_loaded) {
1807  /* we only load the index on demand */
1808  avi_load_index(s);
1809  avi->index_loaded |= 1;
1810  }
1811  av_assert0(stream_index >= 0);
1812 
1813  st = s->streams[stream_index];
1814  ast = st->priv_data;
1815  index = av_index_search_timestamp(st,
1816  timestamp * FFMAX(ast->sample_size, 1),
1817  flags);
1818  if (index < 0) {
1819  if (st->nb_index_entries > 0)
1820  av_log(s, AV_LOG_DEBUG, "Failed to find timestamp %"PRId64 " in index %"PRId64 " .. %"PRId64 "\n",
1821  timestamp * FFMAX(ast->sample_size, 1),
1822  st->index_entries[0].timestamp,
1824  return AVERROR_INVALIDDATA;
1825  }
1826 
1827  /* find the position */
1828  pos = st->index_entries[index].pos;
1829  timestamp = st->index_entries[index].timestamp / FFMAX(ast->sample_size, 1);
1830 
1831  av_log(s, AV_LOG_TRACE, "XX %"PRId64" %d %"PRId64"\n",
1832  timestamp, index, st->index_entries[index].timestamp);
1833 
1834  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1835  /* One and only one real stream for DV in AVI, and it has video */
1836  /* offsets. Calling with other stream indexes should have failed */
1837  /* the av_index_search_timestamp call above. */
1838 
1839  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
1840  return -1;
1841 
1842  /* Feed the DV video stream version of the timestamp to the */
1843  /* DV demux so it can synthesize correct timestamps. */
1844  ff_dv_offset_reset(avi->dv_demux, timestamp);
1845 
1846  avi->stream_index = -1;
1847  return 0;
1848  }
1849 
1850  pos_min = pos;
1851  for (i = 0; i < s->nb_streams; i++) {
1852  AVStream *st2 = s->streams[i];
1853  AVIStream *ast2 = st2->priv_data;
1854 
1855  ast2->packet_size =
1856  ast2->remaining = 0;
1857 
1858  if (ast2->sub_ctx) {
1859  seek_subtitle(st, st2, timestamp);
1860  continue;
1861  }
1862 
1863  if (st2->nb_index_entries <= 0)
1864  continue;
1865 
1866 // av_assert1(st2->codecpar->block_align);
1867  index = av_index_search_timestamp(st2,
1868  av_rescale_q(timestamp,
1869  st->time_base,
1870  st2->time_base) *
1871  FFMAX(ast2->sample_size, 1),
1872  flags |
1875  if (index < 0)
1876  index = 0;
1877  ast2->seek_pos = st2->index_entries[index].pos;
1878  pos_min = FFMIN(pos_min,ast2->seek_pos);
1879  }
1880  for (i = 0; i < s->nb_streams; i++) {
1881  AVStream *st2 = s->streams[i];
1882  AVIStream *ast2 = st2->priv_data;
1883 
1884  if (ast2->sub_ctx || st2->nb_index_entries <= 0)
1885  continue;
1886 
1887  index = av_index_search_timestamp(
1888  st2,
1889  av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1),
1891  if (index < 0)
1892  index = 0;
1893  while (!avi->non_interleaved && index>0 && st2->index_entries[index-1].pos >= pos_min)
1894  index--;
1895  ast2->frame_offset = st2->index_entries[index].timestamp;
1896  }
1897 
1898  /* do the seek */
1899  if (avio_seek(s->pb, pos_min, SEEK_SET) < 0) {
1900  av_log(s, AV_LOG_ERROR, "Seek failed\n");
1901  return -1;
1902  }
1903  avi->stream_index = -1;
1904  avi->dts_max = INT_MIN;
1905  return 0;
1906 }
1907 
1909 {
1910  int i;
1911  AVIContext *avi = s->priv_data;
1912 
1913  for (i = 0; i < s->nb_streams; i++) {
1914  AVStream *st = s->streams[i];
1915  AVIStream *ast = st->priv_data;
1916  if (ast) {
1917  if (ast->sub_ctx) {
1918  av_freep(&ast->sub_ctx->pb);
1920  }
1921  av_freep(&ast->sub_buffer);
1922  av_packet_unref(&ast->sub_pkt);
1923  }
1924  }
1925 
1926  av_freep(&avi->dv_demux);
1927 
1928  return 0;
1929 }
1930 
1931 static int avi_probe(const AVProbeData *p)
1932 {
1933  int i;
1934 
1935  /* check file header */
1936  for (i = 0; avi_headers[i][0]; i++)
1937  if (AV_RL32(p->buf ) == AV_RL32(avi_headers[i] ) &&
1938  AV_RL32(p->buf + 8) == AV_RL32(avi_headers[i] + 4))
1939  return AVPROBE_SCORE_MAX;
1940 
1941  return 0;
1942 }
1943 
1945  .name = "avi",
1946  .long_name = NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"),
1947  .priv_data_size = sizeof(AVIContext),
1948  .extensions = "avi",
1949  .read_probe = avi_probe,
1954  .priv_class = &demuxer_class,
1955 };
int ff_read_riff_info(AVFormatContext *s, int64_t size)
Definition: riffdec.c:228
static AVStream * get_subtitle_pkt(AVFormatContext *s, AVStream *next_st, AVPacket *pkt)
Definition: avidec.c:1139
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2515
#define ff_tlog(ctx,...)
Definition: internal.h:81
#define NULL
Definition: coverity.c:32
full parsing and interpolation of timestamps for frames not starting on a packet boundary ...
Definition: avformat.h:796
uint32_t handler
Definition: avidec.c:47
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:59
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:334
uint32_t pal[256]
Definition: avidec.c:56
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
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:2049
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3160
AVFormatContext * sub_ctx
Definition: avidec.c:61
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
unsigned char * buf_ptr
Current position in the buffer.
Definition: avio.h:228
unsigned char * buf_end
End of the data, may be less than buffer+buffer_size if the read function returned less data than req...
Definition: avio.h:229
#define MAX_ODML_DEPTH
Definition: avidec.c:83
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1553
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:4943
#define print_tag(s, str, tag, size)
Definition: avidec.c:119
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:164
const char * desc
Definition: nvenc.c:68
int64_t pos
Definition: avformat.h:804
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2517
int64_t last_pkt_pos
Definition: avidec.c:75
uint32_t rate
Definition: avidec.c:49
#define avpriv_request_sample(...)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4036
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:937
int dshow_block_align
Definition: avidec.c:58
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:876
int size
Definition: avcodec.h:1534
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:455
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1104
int is_odml
Definition: avidec.c:77
enum AVMediaType codec_type
Definition: rtp.c:37
int64_t movi_end
Definition: avidec.c:71
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
uint32_t scale
Definition: avidec.c:48
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:537
static int get_duration(AVIStream *ast, int len)
Definition: avidec.c:123
void * priv_data
Definition: avformat.h:890
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
#define AVIIF_INDEX
Definition: avi.h:38
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
discard all
Definition: avcodec.h:829
static AVPacket pkt
static void error(const char *err)
static int ni_prepare_read(AVFormatContext *s)
Definition: avidec.c:1340
EXIF metadata parser.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a UTF-16 string from pb and convert it to UTF-8.
static int check_stream_max_drift(AVFormatContext *s)
Definition: avidec.c:1644
static const AVMetadataConv avi_metadata_conv[]
Definition: avidec.c:111
uint8_t base
Definition: vp3data.h:202
Format I/O context.
Definition: avformat.h:1352
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1485
Public dictionary API.
int stream_index
Definition: avidec.c:79
uint8_t
static int nb_streams
Definition: ffprobe.c:281
#define av_malloc(s)
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: avcodec.h:4102
AVOptions.
static int avi_read_close(AVFormatContext *s)
Definition: avidec.c:1908
int64_t riff_end
Definition: avidec.c:70
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom.c:75
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:202
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:798
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
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
int use_odml
Definition: avidec.c:82
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
enum AVStreamParseType need_parsing
Definition: avformat.h:1093
int id
Format-specific stream ID.
Definition: avformat.h:882
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int64_t movi_list
Definition: avidec.c:74
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4524
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1420
int64_t duration
Definition: movenc.c:63
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
static void clean_index(AVFormatContext *s)
Definition: avidec.c:266
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
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1483
DVDemuxContext * avpriv_dv_init_demux(AVFormatContext *s)
Definition: dv.c:324
uint8_t * data
Definition: avcodec.h:1533
static int read_gab2_sub(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: avidec.c:1070
uint32_t tag
Definition: movenc.c:1533
#define AVERROR_EOF
End of file.
Definition: error.h:55
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
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:308
const AVCodecTag ff_codec_bmp_tags_unofficial[]
Definition: riff.c:498
#define max(a, b)
Definition: cuda_runtime.h:33
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
static const uint8_t header[24]
Definition: sdr2.c:67
#define av_log(a,...)
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:645
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
Definition: riffdec.c:91
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:4065
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1565
int packet_size
Definition: avidec.c:45
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
#define U(x)
Definition: vp56_arith.h:37
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning...
Definition: avformat.h:544
#define AVIF_MUSTUSEINDEX
Definition: avi.h:25
#define AVINDEX_KEYFRAME
Definition: avformat.h:811
AVIOContext * avio_alloc_context(unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Allocate and initialize an AVIOContext for buffered I/O.
Definition: aviobuf.c:126
ff_const59 AVInputFormat * av_probe_input_format2(ff_const59 AVProbeData *pd, int is_opened, int *score_max)
Guess the file format.
Definition: format.c:205
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2051
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1592
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: avcodec.h:1233
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2166
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:767
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
int remaining
Definition: avidec.c:44
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:805
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:578
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4032
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1516
static int avi_read_tag(AVFormatContext *s, AVStream *st, uint32_t tag, uint32_t size)
Definition: avidec.c:294
simple assert() macros that are a bit more flexible than ISO C assert().
static int get_stream_idx(const unsigned *d)
Definition: avidec.c:1173
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:948
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:122
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1539
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:4054
Only parse headers, do not repack.
Definition: avformat.h:795
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:636
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1408
int prefix_count
Definition: avidec.c:55
int non_interleaved
Definition: avidec.c:78
int block_align
Audio only.
Definition: avcodec.h:4153
static int avi_probe(const AVProbeData *p)
Definition: avidec.c:1931
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
#define FFMIN(a, b)
Definition: common.h:96
void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset)
Definition: dv.c:436
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that&#39;s been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:76
int64_t cum_len
Definition: avidec.c:53
static int avi_read_header(AVFormatContext *s)
Definition: avidec.c:467
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
static const char months[12][4]
Definition: avidec.c:320
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
static void seek_subtitle(AVStream *st, AVStream *st2, int64_t timestamp)
Definition: avidec.c:1781
static int avi_extract_stream_metadata(AVFormatContext *s, AVStream *st)
Definition: avidec.c:385
#define AVFMT_FLAG_SORT_DTS
try to interleave outputted packets by dts (using this flag can slow demuxing down) ...
Definition: avformat.h:1504
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2761
int n
Definition: avisynth_c.h:760
AVDictionary * metadata
Definition: avformat.h:939
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:222
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
Read a transport packet from a media file.
Definition: utils.c:829
static int calculate_bitrate(AVFormatContext *s)
Definition: avidec.c:423
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
if(ret)
Stream structure.
Definition: avformat.h:875
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
static const char avi_headers[][8]
Definition: avidec.c:102
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
static int avi_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: avidec.c:1409
int prefix
Definition: avidec.c:54
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:163
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1232
int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, uint8_t *buf, int buf_size, int64_t pos)
Definition: dv.c:364
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVIOContext * pb
I/O context.
Definition: avformat.h:1394
static int resync(AVFormatContext *s)
Definition: flvdec.c:948
int index_loaded
Definition: avidec.c:76
int avpriv_exif_decode_ifd(void *logctx, const uint8_t *buf, int size, int le, int depth, AVDictionary **metadata)
Recursively decodes all IFD&#39;s and adds included TAGS into the metadata dictionary.
Definition: exif.c:144
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:600
double(* duration_error)[2][MAX_STD_TIMEBASES]
Definition: avformat.h:1043
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
static struct @327 state
int nb_index_entries
Definition: avformat.h:1106
static const AVOption options[]
Definition: avidec.c:88
Describe the class of an AVClass context structure.
Definition: log.h:67
static int avi_read_idx1(AVFormatContext *s, int size)
Definition: avidec.c:1556
int index
Definition: gxfenc.c:89
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
discard useless packets like 0 size packets in avi
Definition: avcodec.h:824
#define snprintf
Definition: snprintf.h:34
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Seek to timestamp ts.
Definition: utils.c:2547
const AVMetadataConv ff_riff_info_conv[]
Definition: riff.c:589
int64_t seek_pos
Definition: avidec.c:65
#define flags(name, subs,...)
Definition: cbs_av1.c:564
static int avi_load_index(AVFormatContext *s)
Definition: avidec.c:1741
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVInputFormat ff_avi_demuxer
Definition: avidec.c:1944
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:924
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
int64_t io_fsize
Definition: avidec.c:73
int64_t bitrate
Definition: h264_levels.c:131
A reference to a data buffer.
Definition: buffer.h:81
static const AVClass demuxer_class
Definition: avidec.c:93
full parsing and repack
Definition: avformat.h:794
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:751
Main libavformat public API header.
static void avi_read_nikon(AVFormatContext *s, uint64_t end)
Definition: avidec.c:342
static void avi_metadata_creation_time(AVDictionary **metadata, char *date)
Definition: avidec.c:323
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
AVPacket sub_pkt
Definition: avidec.c:62
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:914
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1619
static int get_riff(AVFormatContext *s, AVIOContext *pb)
Definition: avidec.c:133
void avio_context_free(AVIOContext **s)
Free the supplied IO context and everything associated with it.
Definition: aviobuf.c:143
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:3341
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:926
int den
Denominator.
Definition: rational.h:60
int avpriv_dv_get_packet(DVDemuxContext *c, AVPacket *pkt)
Definition: dv.c:347
int ff_get_bmp_header(AVIOContext *pb, AVStream *st, uint32_t *size)
Read BITMAPINFOHEADER structure and set AVStream codec width, height and bits_per_encoded_sample fiel...
Definition: riffdec.c:209
int sample_size
Definition: avidec.c:50
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4496
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:808
#define av_free(p)
char * value
Definition: dict.h:87
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int len
int has_pal
Definition: avidec.c:57
static int guess_ni_flag(AVFormatContext *s)
Definition: avidec.c:1699
void * priv_data
Format private data.
Definition: avformat.h:1380
int64_t frame_offset
Definition: avidec.c:42
int64_t dts_max
Definition: avidec.c:84
int64_t fsize
Definition: avidec.c:72
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:4078
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:4050
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:170
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1532
static int avi_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: avidec.c:1791
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1467
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:649
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1022
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:356
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:4040
static int64_t fsize(FILE *f)
Definition: audiomatch.c:28
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:329
int stream_index
Definition: avcodec.h:1535
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:904
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
static int read_odml_index(AVFormatContext *s, int frame_num)
Definition: avidec.c:158
#define MKTAG(a, b, c, d)
Definition: common.h:366
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:930
struct AVStream::@257 * info
Stream information used internally by avformat_find_stream_info()
int odml_depth
Definition: avidec.c:81
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: avformat.h:1133
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1510
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:775
static int avi_sync(AVFormatContext *s, int exit_early)
Definition: avidec.c:1187
GLuint buffer
Definition: opengl_enc.c:101
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
const char * name
Definition: opengl_enc.c:102
uint8_t * sub_buffer
Definition: avidec.c:63
DVDemuxContext * dv_demux
Definition: avidec.c:80