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;
603  st->priv_data = NULL;
604  ff_free_stream(s, st);
605  if (CONFIG_DV_DEMUXER) {
606  avi->dv_demux = avpriv_dv_init_demux(s);
607  if (!avi->dv_demux)
608  goto fail;
609  } else
610  goto fail;
611  s->streams[0]->priv_data = ast;
612  avio_skip(pb, 3 * 4);
613  ast->scale = avio_rl32(pb);
614  ast->rate = avio_rl32(pb);
615  avio_skip(pb, 4); /* start time */
616 
617  dv_dur = avio_rl32(pb);
618  if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) {
619  dv_dur *= AV_TIME_BASE;
620  s->duration = av_rescale(dv_dur, ast->scale, ast->rate);
621  }
622  /* else, leave duration alone; timing estimation in utils.c
623  * will make a guess based on bitrate. */
624 
625  stream_index = s->nb_streams - 1;
626  avio_skip(pb, size - 9 * 4);
627  break;
628  }
629 
630  av_assert0(stream_index < s->nb_streams);
631  ast->handler = handler;
632 
633  avio_rl32(pb); /* flags */
634  avio_rl16(pb); /* priority */
635  avio_rl16(pb); /* language */
636  avio_rl32(pb); /* initial frame */
637  ast->scale = avio_rl32(pb);
638  ast->rate = avio_rl32(pb);
639  if (!(ast->scale && ast->rate)) {
641  "scale/rate is %"PRIu32"/%"PRIu32" which is invalid. "
642  "(This file has been generated by broken software.)\n",
643  ast->scale,
644  ast->rate);
645  if (frame_period) {
646  ast->rate = 1000000;
647  ast->scale = frame_period;
648  } else {
649  ast->rate = 25;
650  ast->scale = 1;
651  }
652  }
653  avpriv_set_pts_info(st, 64, ast->scale, ast->rate);
654 
655  ast->cum_len = avio_rl32(pb); /* start */
656  st->nb_frames = avio_rl32(pb);
657 
658  st->start_time = 0;
659  avio_rl32(pb); /* buffer size */
660  avio_rl32(pb); /* quality */
661  if (ast->cum_len > 3600LL * ast->rate / ast->scale) {
662  av_log(s, AV_LOG_ERROR, "crazy start time, iam scared, giving up\n");
663  ast->cum_len = 0;
664  }
665  ast->sample_size = avio_rl32(pb);
666  ast->cum_len *= FFMAX(1, ast->sample_size);
667  av_log(s, AV_LOG_TRACE, "%"PRIu32" %"PRIu32" %d\n",
668  ast->rate, ast->scale, ast->sample_size);
669 
670  switch (tag1) {
671  case MKTAG('v', 'i', 'd', 's'):
672  codec_type = AVMEDIA_TYPE_VIDEO;
673 
674  ast->sample_size = 0;
675  st->avg_frame_rate = av_inv_q(st->time_base);
676  break;
677  case MKTAG('a', 'u', 'd', 's'):
678  codec_type = AVMEDIA_TYPE_AUDIO;
679  break;
680  case MKTAG('t', 'x', 't', 's'):
681  codec_type = AVMEDIA_TYPE_SUBTITLE;
682  break;
683  case MKTAG('d', 'a', 't', 's'):
684  codec_type = AVMEDIA_TYPE_DATA;
685  break;
686  default:
687  av_log(s, AV_LOG_INFO, "unknown stream type %X\n", tag1);
688  }
689 
690  if (ast->sample_size < 0) {
691  if (s->error_recognition & AV_EF_EXPLODE) {
692  av_log(s, AV_LOG_ERROR,
693  "Invalid sample_size %d at stream %d\n",
694  ast->sample_size,
695  stream_index);
696  goto fail;
697  }
699  "Invalid sample_size %d at stream %d "
700  "setting it to 0\n",
701  ast->sample_size,
702  stream_index);
703  ast->sample_size = 0;
704  }
705 
706  if (ast->sample_size == 0) {
707  st->duration = st->nb_frames;
708  if (st->duration > 0 && avi->io_fsize > 0 && avi->riff_end > avi->io_fsize) {
709  av_log(s, AV_LOG_DEBUG, "File is truncated adjusting duration\n");
710  st->duration = av_rescale(st->duration, avi->io_fsize, avi->riff_end);
711  }
712  }
713  ast->frame_offset = ast->cum_len;
714  avio_skip(pb, size - 12 * 4);
715  break;
716  case MKTAG('s', 't', 'r', 'f'):
717  /* stream header */
718  if (!size && (codec_type == AVMEDIA_TYPE_AUDIO ||
719  codec_type == AVMEDIA_TYPE_VIDEO))
720  break;
721  if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) {
722  avio_skip(pb, size);
723  } else {
724  uint64_t cur_pos = avio_tell(pb);
725  unsigned esize;
726  if (cur_pos < list_end)
727  size = FFMIN(size, list_end - cur_pos);
728  st = s->streams[stream_index];
730  avio_skip(pb, size);
731  break;
732  }
733  switch (codec_type) {
734  case AVMEDIA_TYPE_VIDEO:
735  if (amv_file_format) {
736  st->codecpar->width = avih_width;
737  st->codecpar->height = avih_height;
740  avio_skip(pb, size);
741  break;
742  }
743  tag1 = ff_get_bmp_header(pb, st, &esize);
744 
745  if (tag1 == MKTAG('D', 'X', 'S', 'B') ||
746  tag1 == MKTAG('D', 'X', 'S', 'A')) {
748  st->codecpar->codec_tag = tag1;
750  break;
751  }
752 
753  if (size > 10 * 4 && size < (1 << 30) && size < avi->fsize) {
754  if (esize == size-1 && (esize&1)) {
755  st->codecpar->extradata_size = esize - 10 * 4;
756  } else
757  st->codecpar->extradata_size = size - 10 * 4;
758  if (st->codecpar->extradata) {
759  av_log(s, AV_LOG_WARNING, "New extradata in strf chunk, freeing previous one.\n");
760  }
761  ret = ff_get_extradata(s, st->codecpar, pb,
762  st->codecpar->extradata_size);
763  if (ret < 0)
764  return ret;
765  }
766 
767  // FIXME: check if the encoder really did this correctly
768  if (st->codecpar->extradata_size & 1)
769  avio_r8(pb);
770 
771  /* Extract palette from extradata if bpp <= 8.
772  * This code assumes that extradata contains only palette.
773  * This is true for all paletted codecs implemented in
774  * FFmpeg. */
775  if (st->codecpar->extradata_size &&
776  (st->codecpar->bits_per_coded_sample <= 8)) {
777  int pal_size = (1 << st->codecpar->bits_per_coded_sample) << 2;
778  const uint8_t *pal_src;
779 
780  pal_size = FFMIN(pal_size, st->codecpar->extradata_size);
781  pal_src = st->codecpar->extradata +
782  st->codecpar->extradata_size - pal_size;
783  /* Exclude the "BottomUp" field from the palette */
784  if (pal_src - st->codecpar->extradata >= 9 &&
785  !memcmp(st->codecpar->extradata + st->codecpar->extradata_size - 9, "BottomUp", 9))
786  pal_src -= 9;
787  for (i = 0; i < pal_size / 4; i++)
788  ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src + 4 * i);
789  ast->has_pal = 1;
790  }
791 
792  print_tag(s, "video", tag1, 0);
793 
795  st->codecpar->codec_tag = tag1;
797  tag1);
798  /* If codec is not found yet, try with the mov tags. */
799  if (!st->codecpar->codec_id) {
800  st->codecpar->codec_id =
802  if (st->codecpar->codec_id)
804  "mov tag found in avi (fourcc %s)\n",
805  av_fourcc2str(tag1));
806  }
807  if (!st->codecpar->codec_id)
809 
810  /* This is needed to get the pict type which is necessary
811  * for generating correct pts. */
813 
814  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4 &&
815  ast->handler == MKTAG('X', 'V', 'I', 'D'))
816  st->codecpar->codec_tag = MKTAG('X', 'V', 'I', 'D');
817 
818  if (st->codecpar->codec_tag == MKTAG('V', 'S', 'S', 'H'))
820  if (st->codecpar->codec_id == AV_CODEC_ID_RV40)
822  if (st->codecpar->codec_id == AV_CODEC_ID_HEVC &&
823  st->codecpar->codec_tag == MKTAG('H', '2', '6', '5'))
825 
826  if (st->codecpar->codec_tag == 0 && st->codecpar->height > 0 &&
827  st->codecpar->extradata_size < 1U << 30) {
828  st->codecpar->extradata_size += 9;
829  if ((ret = av_reallocp(&st->codecpar->extradata,
830  st->codecpar->extradata_size +
832  st->codecpar->extradata_size = 0;
833  return ret;
834  } else
835  memcpy(st->codecpar->extradata + st->codecpar->extradata_size - 9,
836  "BottomUp", 9);
837  }
838  st->codecpar->height = FFABS(st->codecpar->height);
839 
840 // avio_skip(pb, size - 5 * 4);
841  break;
842  case AVMEDIA_TYPE_AUDIO:
843  ret = ff_get_wav_header(s, pb, st->codecpar, size, 0);
844  if (ret < 0)
845  return ret;
847  if (ast->sample_size && st->codecpar->block_align &&
848  ast->sample_size != st->codecpar->block_align) {
849  av_log(s,
851  "sample size (%d) != block align (%d)\n",
852  ast->sample_size,
853  st->codecpar->block_align);
854  ast->sample_size = st->codecpar->block_align;
855  }
856  /* 2-aligned
857  * (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
858  if (size & 1)
859  avio_skip(pb, 1);
860  /* Force parsing as several audio frames can be in
861  * one packet and timestamps refer to packet start. */
863  /* ADTS header is in extradata, AAC without header must be
864  * stored as exact frames. Parser not needed and it will
865  * fail. */
866  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
869  // The flac parser does not work with AVSTREAM_PARSE_TIMESTAMPS
870  if (st->codecpar->codec_id == AV_CODEC_ID_FLAC)
872  /* AVI files with Xan DPCM audio (wrongly) declare PCM
873  * audio in the header but have Axan as stream_code_tag. */
874  if (ast->handler == AV_RL32("Axan")) {
876  st->codecpar->codec_tag = 0;
877  ast->dshow_block_align = 0;
878  }
879  if (amv_file_format) {
881  ast->dshow_block_align = 0;
882  }
883  if ((st->codecpar->codec_id == AV_CODEC_ID_AAC ||
885  st->codecpar->codec_id == AV_CODEC_ID_MP2 ) && ast->dshow_block_align <= 4 && ast->dshow_block_align) {
886  av_log(s, AV_LOG_DEBUG, "overriding invalid dshow_block_align of %d\n", ast->dshow_block_align);
887  ast->dshow_block_align = 0;
888  }
889  if (st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 1024 && ast->sample_size == 1024 ||
890  st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 4096 && ast->sample_size == 4096 ||
891  st->codecpar->codec_id == AV_CODEC_ID_MP3 && ast->dshow_block_align == 1152 && ast->sample_size == 1152) {
892  av_log(s, AV_LOG_DEBUG, "overriding sample_size\n");
893  ast->sample_size = 0;
894  }
895  break;
898  st->request_probe= 1;
899  avio_skip(pb, size);
900  break;
901  default:
904  st->codecpar->codec_tag = 0;
905  avio_skip(pb, size);
906  break;
907  }
908  }
909  break;
910  case MKTAG('s', 't', 'r', 'd'):
911  if (stream_index >= (unsigned)s->nb_streams
912  || s->streams[stream_index]->codecpar->extradata_size
913  || s->streams[stream_index]->codecpar->codec_tag == MKTAG('H','2','6','4')) {
914  avio_skip(pb, size);
915  } else {
916  uint64_t cur_pos = avio_tell(pb);
917  if (cur_pos < list_end)
918  size = FFMIN(size, list_end - cur_pos);
919  st = s->streams[stream_index];
920 
921  if (size<(1<<30)) {
922  if (st->codecpar->extradata) {
923  av_log(s, AV_LOG_WARNING, "New extradata in strd chunk, freeing previous one.\n");
924  }
925  if ((ret = ff_get_extradata(s, st->codecpar, pb, size)) < 0)
926  return ret;
927  }
928 
929  if (st->codecpar->extradata_size & 1) //FIXME check if the encoder really did this correctly
930  avio_r8(pb);
931 
932  ret = avi_extract_stream_metadata(s, st);
933  if (ret < 0) {
934  av_log(s, AV_LOG_WARNING, "could not decoding EXIF data in stream header.\n");
935  }
936  }
937  break;
938  case MKTAG('i', 'n', 'd', 'x'):
939  pos = avio_tell(pb);
940  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !(s->flags & AVFMT_FLAG_IGNIDX) &&
941  avi->use_odml &&
942  read_odml_index(s, 0) < 0 &&
944  goto fail;
945  avio_seek(pb, pos + size, SEEK_SET);
946  break;
947  case MKTAG('v', 'p', 'r', 'p'):
948  if (stream_index < (unsigned)s->nb_streams && size > 9 * 4) {
949  AVRational active, active_aspect;
950 
951  st = s->streams[stream_index];
952  avio_rl32(pb);
953  avio_rl32(pb);
954  avio_rl32(pb);
955  avio_rl32(pb);
956  avio_rl32(pb);
957 
958  active_aspect.den = avio_rl16(pb);
959  active_aspect.num = avio_rl16(pb);
960  active.num = avio_rl32(pb);
961  active.den = avio_rl32(pb);
962  avio_rl32(pb); // nbFieldsPerFrame
963 
964  if (active_aspect.num && active_aspect.den &&
965  active.num && active.den) {
966  st->sample_aspect_ratio = av_div_q(active_aspect, active);
967  av_log(s, AV_LOG_TRACE, "vprp %d/%d %d/%d\n",
968  active_aspect.num, active_aspect.den,
969  active.num, active.den);
970  }
971  size -= 9 * 4;
972  }
973  avio_skip(pb, size);
974  break;
975  case MKTAG('s', 't', 'r', 'n'):
976  if (s->nb_streams) {
977  ret = avi_read_tag(s, s->streams[s->nb_streams - 1], tag, size);
978  if (ret < 0)
979  return ret;
980  break;
981  }
982  default:
983  if (size > 1000000) {
984  av_log(s, AV_LOG_ERROR,
985  "Something went wrong during header parsing, "
986  "tag %s has size %u, "
987  "I will ignore it and try to continue anyway.\n",
988  av_fourcc2str(tag), size);
990  goto fail;
991  avi->movi_list = avio_tell(pb) - 4;
992  avi->movi_end = avi->fsize;
993  goto end_of_header;
994  }
995  /* Do not fail for very large idx1 tags */
996  case MKTAG('i', 'd', 'x', '1'):
997  /* skip tag */
998  size += (size & 1);
999  avio_skip(pb, size);
1000  break;
1001  }
1002  }
1003 
1004 end_of_header:
1005  /* check stream number */
1006  if (stream_index != s->nb_streams - 1) {
1007 
1008 fail:
1009  return AVERROR_INVALIDDATA;
1010  }
1011 
1012  if (!avi->index_loaded && (pb->seekable & AVIO_SEEKABLE_NORMAL))
1013  avi_load_index(s);
1014  calculate_bitrate(s);
1015  avi->index_loaded |= 1;
1016 
1017  if ((ret = guess_ni_flag(s)) < 0)
1018  return ret;
1019 
1020  avi->non_interleaved |= ret | (s->flags & AVFMT_FLAG_SORT_DTS);
1021 
1022  dict_entry = av_dict_get(s->metadata, "ISFT", NULL, 0);
1023  if (dict_entry && !strcmp(dict_entry->value, "PotEncoder"))
1024  for (i = 0; i < s->nb_streams; i++) {
1025  AVStream *st = s->streams[i];
1029  }
1030 
1031  for (i = 0; i < s->nb_streams; i++) {
1032  AVStream *st = s->streams[i];
1033  if (st->nb_index_entries)
1034  break;
1035  }
1036  // DV-in-AVI cannot be non-interleaved, if set this must be
1037  // a mis-detection.
1038  if (avi->dv_demux)
1039  avi->non_interleaved = 0;
1040  if (i == s->nb_streams && avi->non_interleaved) {
1042  "Non-interleaved AVI without index, switching to interleaved\n");
1043  avi->non_interleaved = 0;
1044  }
1045 
1046  if (avi->non_interleaved) {
1047  av_log(s, AV_LOG_INFO, "non-interleaved AVI\n");
1048  clean_index(s);
1049  }
1050 
1051  ff_metadata_conv_ctx(s, NULL, avi_metadata_conv);
1053 
1054  return 0;
1055 }
1056 
1058 {
1059  if (pkt->size >= 7 &&
1060  pkt->size < INT_MAX - AVPROBE_PADDING_SIZE &&
1061  !strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data + 5) == 2) {
1062  uint8_t desc[256];
1063  int score = AVPROBE_SCORE_EXTENSION, ret;
1064  AVIStream *ast = st->priv_data;
1065  ff_const59 AVInputFormat *sub_demuxer;
1066  AVRational time_base;
1067  int size;
1068  AVIOContext *pb = avio_alloc_context(pkt->data + 7,
1069  pkt->size - 7,
1070  0, NULL, NULL, NULL, NULL);
1071  AVProbeData pd;
1072  unsigned int desc_len = avio_rl32(pb);
1073 
1074  if (desc_len > pb->buf_end - pb->buf_ptr)
1075  goto error;
1076 
1077  ret = avio_get_str16le(pb, desc_len, desc, sizeof(desc));
1078  avio_skip(pb, desc_len - ret);
1079  if (*desc)
1080  av_dict_set(&st->metadata, "title", desc, 0);
1081 
1082  avio_rl16(pb); /* flags? */
1083  avio_rl32(pb); /* data size */
1084 
1085  size = pb->buf_end - pb->buf_ptr;
1086  pd = (AVProbeData) { .buf = av_mallocz(size + AVPROBE_PADDING_SIZE),
1087  .buf_size = size };
1088  if (!pd.buf)
1089  goto error;
1090  memcpy(pd.buf, pb->buf_ptr, size);
1091  sub_demuxer = av_probe_input_format2(&pd, 1, &score);
1092  av_freep(&pd.buf);
1093  if (!sub_demuxer)
1094  goto error;
1095 
1096  if (strcmp(sub_demuxer->name, "srt") && strcmp(sub_demuxer->name, "ass"))
1097  goto error;
1098 
1099  if (!(ast->sub_ctx = avformat_alloc_context()))
1100  goto error;
1101 
1102  ast->sub_ctx->pb = pb;
1103 
1104  if (ff_copy_whiteblacklists(ast->sub_ctx, s) < 0)
1105  goto error;
1106 
1107  if (!avformat_open_input(&ast->sub_ctx, "", sub_demuxer, NULL)) {
1108  if (ast->sub_ctx->nb_streams != 1)
1109  goto error;
1110  ff_read_packet(ast->sub_ctx, &ast->sub_pkt);
1112  time_base = ast->sub_ctx->streams[0]->time_base;
1113  avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
1114  }
1115  ast->sub_buffer = pkt->data;
1116  memset(pkt, 0, sizeof(*pkt));
1117  return 1;
1118 
1119 error:
1120  av_freep(&ast->sub_ctx);
1121  avio_context_free(&pb);
1122  }
1123  return 0;
1124 }
1125 
1127  AVPacket *pkt)
1128 {
1129  AVIStream *ast, *next_ast = next_st->priv_data;
1130  int64_t ts, next_ts, ts_min = INT64_MAX;
1131  AVStream *st, *sub_st = NULL;
1132  int i;
1133 
1134  next_ts = av_rescale_q(next_ast->frame_offset, next_st->time_base,
1135  AV_TIME_BASE_Q);
1136 
1137  for (i = 0; i < s->nb_streams; i++) {
1138  st = s->streams[i];
1139  ast = st->priv_data;
1140  if (st->discard < AVDISCARD_ALL && ast && ast->sub_pkt.data) {
1141  ts = av_rescale_q(ast->sub_pkt.dts, st->time_base, AV_TIME_BASE_Q);
1142  if (ts <= next_ts && ts < ts_min) {
1143  ts_min = ts;
1144  sub_st = st;
1145  }
1146  }
1147  }
1148 
1149  if (sub_st) {
1150  ast = sub_st->priv_data;
1151  *pkt = ast->sub_pkt;
1152  pkt->stream_index = sub_st->index;
1153 
1154  if (ff_read_packet(ast->sub_ctx, &ast->sub_pkt) < 0)
1155  ast->sub_pkt.data = NULL;
1156  }
1157  return sub_st;
1158 }
1159 
1160 static int get_stream_idx(const unsigned *d)
1161 {
1162  if (d[0] >= '0' && d[0] <= '9' &&
1163  d[1] >= '0' && d[1] <= '9') {
1164  return (d[0] - '0') * 10 + (d[1] - '0');
1165  } else {
1166  return 100; // invalid stream ID
1167  }
1168 }
1169 
1170 /**
1171  *
1172  * @param exit_early set to 1 to just gather packet position without making the changes needed to actually read & return the packet
1173  */
1174 static int avi_sync(AVFormatContext *s, int exit_early)
1175 {
1176  AVIContext *avi = s->priv_data;
1177  AVIOContext *pb = s->pb;
1178  int n;
1179  unsigned int d[8];
1180  unsigned int size;
1181  int64_t i, sync;
1182 
1183 start_sync:
1184  memset(d, -1, sizeof(d));
1185  for (i = sync = avio_tell(pb); !avio_feof(pb); i++) {
1186  int j;
1187 
1188  for (j = 0; j < 7; j++)
1189  d[j] = d[j + 1];
1190  d[7] = avio_r8(pb);
1191 
1192  size = d[4] + (d[5] << 8) + (d[6] << 16) + (d[7] << 24);
1193 
1194  n = get_stream_idx(d + 2);
1195  ff_tlog(s, "%X %X %X %X %X %X %X %X %"PRId64" %u %d\n",
1196  d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n);
1197  if (i*(avi->io_fsize>0) + (uint64_t)size > avi->fsize || d[0] > 127)
1198  continue;
1199 
1200  // parse ix##
1201  if ((d[0] == 'i' && d[1] == 'x' && n < s->nb_streams) ||
1202  // parse JUNK
1203  (d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K') ||
1204  (d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1') ||
1205  (d[0] == 'i' && d[1] == 'n' && d[2] == 'd' && d[3] == 'x')) {
1206  avio_skip(pb, size);
1207  goto start_sync;
1208  }
1209 
1210  // parse stray LIST
1211  if (d[0] == 'L' && d[1] == 'I' && d[2] == 'S' && d[3] == 'T') {
1212  avio_skip(pb, 4);
1213  goto start_sync;
1214  }
1215 
1216  n = get_stream_idx(d);
1217 
1218  if (!((i - avi->last_pkt_pos) & 1) &&
1219  get_stream_idx(d + 1) < s->nb_streams)
1220  continue;
1221 
1222  // detect ##ix chunk and skip
1223  if (d[2] == 'i' && d[3] == 'x' && n < s->nb_streams) {
1224  avio_skip(pb, size);
1225  goto start_sync;
1226  }
1227 
1228  if (d[2] == 'w' && d[3] == 'c' && n < s->nb_streams) {
1229  avio_skip(pb, 16 * 3 + 8);
1230  goto start_sync;
1231  }
1232 
1233  if (avi->dv_demux && n != 0)
1234  continue;
1235 
1236  // parse ##dc/##wb
1237  if (n < s->nb_streams) {
1238  AVStream *st;
1239  AVIStream *ast;
1240  st = s->streams[n];
1241  ast = st->priv_data;
1242 
1243  if (!ast) {
1244  av_log(s, AV_LOG_WARNING, "Skipping foreign stream %d packet\n", n);
1245  continue;
1246  }
1247 
1248  if (s->nb_streams >= 2) {
1249  AVStream *st1 = s->streams[1];
1250  AVIStream *ast1 = st1->priv_data;
1251  // workaround for broken small-file-bug402.avi
1252  if ( d[2] == 'w' && d[3] == 'b'
1253  && n == 0
1254  && st ->codecpar->codec_type == AVMEDIA_TYPE_VIDEO
1256  && ast->prefix == 'd'*256+'c'
1257  && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count)
1258  ) {
1259  n = 1;
1260  st = st1;
1261  ast = ast1;
1263  "Invalid stream + prefix combination, assuming audio.\n");
1264  }
1265  }
1266 
1267  if (d[2] == 'p' && d[3] == 'c' && size <= 4 * 256 + 4) {
1268  int k = avio_r8(pb);
1269  int last = (k + avio_r8(pb) - 1) & 0xFF;
1270 
1271  avio_rl16(pb); // flags
1272 
1273  // b + (g << 8) + (r << 16);
1274  for (; k <= last; k++)
1275  ast->pal[k] = 0xFFU<<24 | avio_rb32(pb)>>8;
1276 
1277  ast->has_pal = 1;
1278  goto start_sync;
1279  } else if (((ast->prefix_count < 5 || sync + 9 > i) &&
1280  d[2] < 128 && d[3] < 128) ||
1281  d[2] * 256 + d[3] == ast->prefix /* ||
1282  (d[2] == 'd' && d[3] == 'c') ||
1283  (d[2] == 'w' && d[3] == 'b') */) {
1284  if (exit_early)
1285  return 0;
1286  if (d[2] * 256 + d[3] == ast->prefix)
1287  ast->prefix_count++;
1288  else {
1289  ast->prefix = d[2] * 256 + d[3];
1290  ast->prefix_count = 0;
1291  }
1292 
1293  if (!avi->dv_demux &&
1294  ((st->discard >= AVDISCARD_DEFAULT && size == 0) /* ||
1295  // FIXME: needs a little reordering
1296  (st->discard >= AVDISCARD_NONKEY &&
1297  !(pkt->flags & AV_PKT_FLAG_KEY)) */
1298  || st->discard >= AVDISCARD_ALL)) {
1299 
1300  ast->frame_offset += get_duration(ast, size);
1301  avio_skip(pb, size);
1302  goto start_sync;
1303  }
1304 
1305  avi->stream_index = n;
1306  ast->packet_size = size + 8;
1307  ast->remaining = size;
1308 
1309  if (size) {
1310  uint64_t pos = avio_tell(pb) - 8;
1311  if (!st->index_entries || !st->nb_index_entries ||
1312  st->index_entries[st->nb_index_entries - 1].pos < pos) {
1313  av_add_index_entry(st, pos, ast->frame_offset, size,
1314  0, AVINDEX_KEYFRAME);
1315  }
1316  }
1317  return 0;
1318  }
1319  }
1320  }
1321 
1322  if (pb->error)
1323  return pb->error;
1324  return AVERROR_EOF;
1325 }
1326 
1328 {
1329  AVIContext *avi = s->priv_data;
1330  int best_stream_index = 0;
1331  AVStream *best_st = NULL;
1332  AVIStream *best_ast;
1333  int64_t best_ts = INT64_MAX;
1334  int i;
1335 
1336  for (i = 0; i < s->nb_streams; i++) {
1337  AVStream *st = s->streams[i];
1338  AVIStream *ast = st->priv_data;
1339  int64_t ts = ast->frame_offset;
1340  int64_t last_ts;
1341 
1342  if (!st->nb_index_entries)
1343  continue;
1344 
1345  last_ts = st->index_entries[st->nb_index_entries - 1].timestamp;
1346  if (!ast->remaining && ts > last_ts)
1347  continue;
1348 
1349  ts = av_rescale_q(ts, st->time_base,
1350  (AVRational) { FFMAX(1, ast->sample_size),
1351  AV_TIME_BASE });
1352 
1353  av_log(s, AV_LOG_TRACE, "%"PRId64" %d/%d %"PRId64"\n", ts,
1354  st->time_base.num, st->time_base.den, ast->frame_offset);
1355  if (ts < best_ts) {
1356  best_ts = ts;
1357  best_st = st;
1358  best_stream_index = i;
1359  }
1360  }
1361  if (!best_st)
1362  return AVERROR_EOF;
1363 
1364  best_ast = best_st->priv_data;
1365  best_ts = best_ast->frame_offset;
1366  if (best_ast->remaining) {
1367  i = av_index_search_timestamp(best_st,
1368  best_ts,
1369  AVSEEK_FLAG_ANY |
1371  } else {
1372  i = av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY);
1373  if (i >= 0)
1374  best_ast->frame_offset = best_st->index_entries[i].timestamp;
1375  }
1376 
1377  if (i >= 0) {
1378  int64_t pos = best_st->index_entries[i].pos;
1379  pos += best_ast->packet_size - best_ast->remaining;
1380  if (avio_seek(s->pb, pos + 8, SEEK_SET) < 0)
1381  return AVERROR_EOF;
1382 
1383  av_assert0(best_ast->remaining <= best_ast->packet_size);
1384 
1385  avi->stream_index = best_stream_index;
1386  if (!best_ast->remaining)
1387  best_ast->packet_size =
1388  best_ast->remaining = best_st->index_entries[i].size;
1389  }
1390  else
1391  return AVERROR_EOF;
1392 
1393  return 0;
1394 }
1395 
1397 {
1398  AVIContext *avi = s->priv_data;
1399  AVIOContext *pb = s->pb;
1400  int err;
1401 
1402  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1403  int size = avpriv_dv_get_packet(avi->dv_demux, pkt);
1404  if (size >= 0)
1405  return size;
1406  else
1407  goto resync;
1408  }
1409 
1410  if (avi->non_interleaved) {
1411  err = ni_prepare_read(s);
1412  if (err < 0)
1413  return err;
1414  }
1415 
1416 resync:
1417  if (avi->stream_index >= 0) {
1418  AVStream *st = s->streams[avi->stream_index];
1419  AVIStream *ast = st->priv_data;
1420  int size, err;
1421 
1422  if (get_subtitle_pkt(s, st, pkt))
1423  return 0;
1424 
1425  // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM
1426  if (ast->sample_size <= 1)
1427  size = INT_MAX;
1428  else if (ast->sample_size < 32)
1429  // arbitrary multiplier to avoid tiny packets for raw PCM data
1430  size = 1024 * ast->sample_size;
1431  else
1432  size = ast->sample_size;
1433 
1434  if (size > ast->remaining)
1435  size = ast->remaining;
1436  avi->last_pkt_pos = avio_tell(pb);
1437  err = av_get_packet(pb, pkt, size);
1438  if (err < 0)
1439  return err;
1440  size = err;
1441 
1442  if (ast->has_pal && pkt->size < (unsigned)INT_MAX / 2) {
1443  uint8_t *pal;
1444  pal = av_packet_new_side_data(pkt,
1446  AVPALETTE_SIZE);
1447  if (!pal) {
1448  av_log(s, AV_LOG_ERROR,
1449  "Failed to allocate data for palette\n");
1450  } else {
1451  memcpy(pal, ast->pal, AVPALETTE_SIZE);
1452  ast->has_pal = 0;
1453  }
1454  }
1455 
1456  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1457  AVBufferRef *avbuf = pkt->buf;
1458  size = avpriv_dv_produce_packet(avi->dv_demux, pkt,
1459  pkt->data, pkt->size, pkt->pos);
1460  pkt->buf = avbuf;
1461  pkt->flags |= AV_PKT_FLAG_KEY;
1462  if (size < 0)
1463  av_packet_unref(pkt);
1464  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE &&
1465  !st->codecpar->codec_tag && read_gab2_sub(s, st, pkt)) {
1466  ast->frame_offset++;
1467  avi->stream_index = -1;
1468  ast->remaining = 0;
1469  goto resync;
1470  } else {
1471  /* XXX: How to handle B-frames in AVI? */
1472  pkt->dts = ast->frame_offset;
1473 // pkt->dts += ast->start;
1474  if (ast->sample_size)
1475  pkt->dts /= ast->sample_size;
1476  pkt->stream_index = avi->stream_index;
1477 
1478  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->index_entries) {
1479  AVIndexEntry *e;
1480  int index;
1481 
1483  e = &st->index_entries[index];
1484 
1485  if (index >= 0 && e->timestamp == ast->frame_offset) {
1486  if (index == st->nb_index_entries-1) {
1487  int key=1;
1488  uint32_t state=-1;
1489  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4) {
1490  const uint8_t *ptr = pkt->data, *end = ptr + FFMIN(size, 256);
1491  while (ptr < end) {
1492  ptr = avpriv_find_start_code(ptr, end, &state);
1493  if (state == 0x1B6 && ptr < end) {
1494  key = !(*ptr & 0xC0);
1495  break;
1496  }
1497  }
1498  }
1499  if (!key)
1500  e->flags &= ~AVINDEX_KEYFRAME;
1501  }
1502  if (e->flags & AVINDEX_KEYFRAME)
1503  pkt->flags |= AV_PKT_FLAG_KEY;
1504  }
1505  } else {
1506  pkt->flags |= AV_PKT_FLAG_KEY;
1507  }
1508  ast->frame_offset += get_duration(ast, pkt->size);
1509  }
1510  ast->remaining -= err;
1511  if (!ast->remaining) {
1512  avi->stream_index = -1;
1513  ast->packet_size = 0;
1514  }
1515 
1516  if (!avi->non_interleaved && pkt->pos >= 0 && ast->seek_pos > pkt->pos) {
1517  av_packet_unref(pkt);
1518  goto resync;
1519  }
1520  ast->seek_pos= 0;
1521 
1522  if (!avi->non_interleaved && st->nb_index_entries>1 && avi->index_loaded>1) {
1523  int64_t dts= av_rescale_q(pkt->dts, st->time_base, AV_TIME_BASE_Q);
1524 
1525  if (avi->dts_max < dts) {
1526  avi->dts_max = dts;
1527  } else if (avi->dts_max - (uint64_t)dts > 2*AV_TIME_BASE) {
1528  avi->non_interleaved= 1;
1529  av_log(s, AV_LOG_INFO, "Switching to NI mode, due to poor interleaving\n");
1530  }
1531  }
1532 
1533  return 0;
1534  }
1535 
1536  if ((err = avi_sync(s, 0)) < 0)
1537  return err;
1538  goto resync;
1539 }
1540 
1541 /* XXX: We make the implicit supposition that the positions are sorted
1542  * for each stream. */
1544 {
1545  AVIContext *avi = s->priv_data;
1546  AVIOContext *pb = s->pb;
1547  int nb_index_entries, i;
1548  AVStream *st;
1549  AVIStream *ast;
1550  int64_t pos;
1551  unsigned int index, tag, flags, len, first_packet = 1;
1552  int64_t last_pos = -1;
1553  unsigned last_idx = -1;
1554  int64_t idx1_pos, first_packet_pos = 0, data_offset = 0;
1555  int anykey = 0;
1556 
1557  nb_index_entries = size / 16;
1558  if (nb_index_entries <= 0)
1559  return AVERROR_INVALIDDATA;
1560 
1561  idx1_pos = avio_tell(pb);
1562  avio_seek(pb, avi->movi_list + 4, SEEK_SET);
1563  if (avi_sync(s, 1) == 0)
1564  first_packet_pos = avio_tell(pb) - 8;
1565  avi->stream_index = -1;
1566  avio_seek(pb, idx1_pos, SEEK_SET);
1567 
1568  if (s->nb_streams == 1 && s->streams[0]->codecpar->codec_tag == AV_RL32("MMES")) {
1569  first_packet_pos = 0;
1570  data_offset = avi->movi_list;
1571  }
1572 
1573  /* Read the entries and sort them in each stream component. */
1574  for (i = 0; i < nb_index_entries; i++) {
1575  if (avio_feof(pb))
1576  return -1;
1577 
1578  tag = avio_rl32(pb);
1579  flags = avio_rl32(pb);
1580  pos = avio_rl32(pb);
1581  len = avio_rl32(pb);
1582  av_log(s, AV_LOG_TRACE, "%d: tag=0x%x flags=0x%x pos=0x%"PRIx64" len=%d/",
1583  i, tag, flags, pos, len);
1584 
1585  index = ((tag & 0xff) - '0') * 10;
1586  index += (tag >> 8 & 0xff) - '0';
1587  if (index >= s->nb_streams)
1588  continue;
1589  st = s->streams[index];
1590  ast = st->priv_data;
1591 
1592  /* Skip 'xxpc' palette change entries in the index until a logic
1593  * to process these is properly implemented. */
1594  if ((tag >> 16 & 0xff) == 'p' && (tag >> 24 & 0xff) == 'c')
1595  continue;
1596 
1597  if (first_packet && first_packet_pos) {
1598  if (avi->movi_list + 4 != pos || pos + 500 > first_packet_pos)
1599  data_offset = first_packet_pos - pos;
1600  first_packet = 0;
1601  }
1602  pos += data_offset;
1603 
1604  av_log(s, AV_LOG_TRACE, "%d cum_len=%"PRId64"\n", len, ast->cum_len);
1605 
1606  // even if we have only a single stream, we should
1607  // switch to non-interleaved to get correct timestamps
1608  if (last_pos == pos)
1609  avi->non_interleaved = 1;
1610  if (last_idx != pos && len) {
1611  av_add_index_entry(st, pos, ast->cum_len, len, 0,
1612  (flags & AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);
1613  last_idx= pos;
1614  }
1615  ast->cum_len += get_duration(ast, len);
1616  last_pos = pos;
1617  anykey |= flags&AVIIF_INDEX;
1618  }
1619  if (!anykey) {
1620  for (index = 0; index < s->nb_streams; index++) {
1621  st = s->streams[index];
1622  if (st->nb_index_entries)
1624  }
1625  }
1626  return 0;
1627 }
1628 
1629 /* Scan the index and consider any file with streams more than
1630  * 2 seconds or 64MB apart non-interleaved. */
1632 {
1633  int64_t min_pos, pos;
1634  int i;
1635  int *idx = av_mallocz_array(s->nb_streams, sizeof(*idx));
1636  if (!idx)
1637  return AVERROR(ENOMEM);
1638  for (min_pos = pos = 0; min_pos != INT64_MAX; pos = min_pos + 1LU) {
1639  int64_t max_dts = INT64_MIN / 2;
1640  int64_t min_dts = INT64_MAX / 2;
1641  int64_t max_buffer = 0;
1642 
1643  min_pos = INT64_MAX;
1644 
1645  for (i = 0; i < s->nb_streams; i++) {
1646  AVStream *st = s->streams[i];
1647  AVIStream *ast = st->priv_data;
1648  int n = st->nb_index_entries;
1649  while (idx[i] < n && st->index_entries[idx[i]].pos < pos)
1650  idx[i]++;
1651  if (idx[i] < n) {
1652  int64_t dts;
1653  dts = av_rescale_q(st->index_entries[idx[i]].timestamp /
1654  FFMAX(ast->sample_size, 1),
1655  st->time_base, AV_TIME_BASE_Q);
1656  min_dts = FFMIN(min_dts, dts);
1657  min_pos = FFMIN(min_pos, st->index_entries[idx[i]].pos);
1658  }
1659  }
1660  for (i = 0; i < s->nb_streams; i++) {
1661  AVStream *st = s->streams[i];
1662  AVIStream *ast = st->priv_data;
1663 
1664  if (idx[i] && min_dts != INT64_MAX / 2) {
1665  int64_t dts;
1666  dts = av_rescale_q(st->index_entries[idx[i] - 1].timestamp /
1667  FFMAX(ast->sample_size, 1),
1668  st->time_base, AV_TIME_BASE_Q);
1669  max_dts = FFMAX(max_dts, dts);
1670  max_buffer = FFMAX(max_buffer,
1671  av_rescale(dts - min_dts,
1672  st->codecpar->bit_rate,
1673  AV_TIME_BASE));
1674  }
1675  }
1676  if (max_dts - min_dts > 2 * AV_TIME_BASE ||
1677  max_buffer > 1024 * 1024 * 8 * 8) {
1678  av_free(idx);
1679  return 1;
1680  }
1681  }
1682  av_free(idx);
1683  return 0;
1684 }
1685 
1687 {
1688  int i;
1689  int64_t last_start = 0;
1690  int64_t first_end = INT64_MAX;
1691  int64_t oldpos = avio_tell(s->pb);
1692 
1693  for (i = 0; i < s->nb_streams; i++) {
1694  AVStream *st = s->streams[i];
1695  int n = st->nb_index_entries;
1696  unsigned int size;
1697 
1698  if (n <= 0)
1699  continue;
1700 
1701  if (n >= 2) {
1702  int64_t pos = st->index_entries[0].pos;
1703  unsigned tag[2];
1704  avio_seek(s->pb, pos, SEEK_SET);
1705  tag[0] = avio_r8(s->pb);
1706  tag[1] = avio_r8(s->pb);
1707  avio_rl16(s->pb);
1708  size = avio_rl32(s->pb);
1709  if (get_stream_idx(tag) == i && pos + size > st->index_entries[1].pos)
1710  last_start = INT64_MAX;
1711  if (get_stream_idx(tag) == i && size == st->index_entries[0].size + 8)
1712  last_start = INT64_MAX;
1713  }
1714 
1715  if (st->index_entries[0].pos > last_start)
1716  last_start = st->index_entries[0].pos;
1717  if (st->index_entries[n - 1].pos < first_end)
1718  first_end = st->index_entries[n - 1].pos;
1719  }
1720  avio_seek(s->pb, oldpos, SEEK_SET);
1721 
1722  if (last_start > first_end)
1723  return 1;
1724 
1725  return check_stream_max_drift(s);
1726 }
1727 
1729 {
1730  AVIContext *avi = s->priv_data;
1731  AVIOContext *pb = s->pb;
1732  uint32_t tag, size;
1733  int64_t pos = avio_tell(pb);
1734  int64_t next;
1735  int ret = -1;
1736 
1737  if (avio_seek(pb, avi->movi_end, SEEK_SET) < 0)
1738  goto the_end; // maybe truncated file
1739  av_log(s, AV_LOG_TRACE, "movi_end=0x%"PRIx64"\n", avi->movi_end);
1740  for (;;) {
1741  tag = avio_rl32(pb);
1742  size = avio_rl32(pb);
1743  if (avio_feof(pb))
1744  break;
1745  next = avio_tell(pb) + size + (size & 1);
1746 
1747  if (tag == MKTAG('i', 'd', 'x', '1') &&
1748  avi_read_idx1(s, size) >= 0) {
1749  avi->index_loaded=2;
1750  ret = 0;
1751  }else if (tag == MKTAG('L', 'I', 'S', 'T')) {
1752  uint32_t tag1 = avio_rl32(pb);
1753 
1754  if (tag1 == MKTAG('I', 'N', 'F', 'O'))
1755  ff_read_riff_info(s, size - 4);
1756  }else if (!ret)
1757  break;
1758 
1759  if (avio_seek(pb, next, SEEK_SET) < 0)
1760  break; // something is wrong here
1761  }
1762 
1763 the_end:
1764  avio_seek(pb, pos, SEEK_SET);
1765  return ret;
1766 }
1767 
1768 static void seek_subtitle(AVStream *st, AVStream *st2, int64_t timestamp)
1769 {
1770  AVIStream *ast2 = st2->priv_data;
1771  int64_t ts2 = av_rescale_q(timestamp, st->time_base, st2->time_base);
1772  av_packet_unref(&ast2->sub_pkt);
1773  if (avformat_seek_file(ast2->sub_ctx, 0, INT64_MIN, ts2, ts2, 0) >= 0 ||
1774  avformat_seek_file(ast2->sub_ctx, 0, ts2, ts2, INT64_MAX, 0) >= 0)
1775  ff_read_packet(ast2->sub_ctx, &ast2->sub_pkt);
1776 }
1777 
1778 static int avi_read_seek(AVFormatContext *s, int stream_index,
1779  int64_t timestamp, int flags)
1780 {
1781  AVIContext *avi = s->priv_data;
1782  AVStream *st;
1783  int i, index;
1784  int64_t pos, pos_min;
1785  AVIStream *ast;
1786 
1787  /* Does not matter which stream is requested dv in avi has the
1788  * stream information in the first video stream.
1789  */
1790  if (avi->dv_demux)
1791  stream_index = 0;
1792 
1793  if (!avi->index_loaded) {
1794  /* we only load the index on demand */
1795  avi_load_index(s);
1796  avi->index_loaded |= 1;
1797  }
1798  av_assert0(stream_index >= 0);
1799 
1800  st = s->streams[stream_index];
1801  ast = st->priv_data;
1802  index = av_index_search_timestamp(st,
1803  timestamp * FFMAX(ast->sample_size, 1),
1804  flags);
1805  if (index < 0) {
1806  if (st->nb_index_entries > 0)
1807  av_log(s, AV_LOG_DEBUG, "Failed to find timestamp %"PRId64 " in index %"PRId64 " .. %"PRId64 "\n",
1808  timestamp * FFMAX(ast->sample_size, 1),
1809  st->index_entries[0].timestamp,
1811  return AVERROR_INVALIDDATA;
1812  }
1813 
1814  /* find the position */
1815  pos = st->index_entries[index].pos;
1816  timestamp = st->index_entries[index].timestamp / FFMAX(ast->sample_size, 1);
1817 
1818  av_log(s, AV_LOG_TRACE, "XX %"PRId64" %d %"PRId64"\n",
1819  timestamp, index, st->index_entries[index].timestamp);
1820 
1821  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1822  /* One and only one real stream for DV in AVI, and it has video */
1823  /* offsets. Calling with other stream indexes should have failed */
1824  /* the av_index_search_timestamp call above. */
1825 
1826  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
1827  return -1;
1828 
1829  /* Feed the DV video stream version of the timestamp to the */
1830  /* DV demux so it can synthesize correct timestamps. */
1831  ff_dv_offset_reset(avi->dv_demux, timestamp);
1832 
1833  avi->stream_index = -1;
1834  return 0;
1835  }
1836 
1837  pos_min = pos;
1838  for (i = 0; i < s->nb_streams; i++) {
1839  AVStream *st2 = s->streams[i];
1840  AVIStream *ast2 = st2->priv_data;
1841 
1842  ast2->packet_size =
1843  ast2->remaining = 0;
1844 
1845  if (ast2->sub_ctx) {
1846  seek_subtitle(st, st2, timestamp);
1847  continue;
1848  }
1849 
1850  if (st2->nb_index_entries <= 0)
1851  continue;
1852 
1853 // av_assert1(st2->codecpar->block_align);
1854  index = av_index_search_timestamp(st2,
1855  av_rescale_q(timestamp,
1856  st->time_base,
1857  st2->time_base) *
1858  FFMAX(ast2->sample_size, 1),
1859  flags |
1862  if (index < 0)
1863  index = 0;
1864  ast2->seek_pos = st2->index_entries[index].pos;
1865  pos_min = FFMIN(pos_min,ast2->seek_pos);
1866  }
1867  for (i = 0; i < s->nb_streams; i++) {
1868  AVStream *st2 = s->streams[i];
1869  AVIStream *ast2 = st2->priv_data;
1870 
1871  if (ast2->sub_ctx || st2->nb_index_entries <= 0)
1872  continue;
1873 
1874  index = av_index_search_timestamp(
1875  st2,
1876  av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1),
1878  if (index < 0)
1879  index = 0;
1880  while (!avi->non_interleaved && index>0 && st2->index_entries[index-1].pos >= pos_min)
1881  index--;
1882  ast2->frame_offset = st2->index_entries[index].timestamp;
1883  }
1884 
1885  /* do the seek */
1886  if (avio_seek(s->pb, pos_min, SEEK_SET) < 0) {
1887  av_log(s, AV_LOG_ERROR, "Seek failed\n");
1888  return -1;
1889  }
1890  avi->stream_index = -1;
1891  avi->dts_max = INT_MIN;
1892  return 0;
1893 }
1894 
1896 {
1897  int i;
1898  AVIContext *avi = s->priv_data;
1899 
1900  for (i = 0; i < s->nb_streams; i++) {
1901  AVStream *st = s->streams[i];
1902  AVIStream *ast = st->priv_data;
1903  if (ast) {
1904  if (ast->sub_ctx) {
1905  av_freep(&ast->sub_ctx->pb);
1907  }
1908  av_freep(&ast->sub_buffer);
1909  av_packet_unref(&ast->sub_pkt);
1910  }
1911  }
1912 
1913  av_freep(&avi->dv_demux);
1914 
1915  return 0;
1916 }
1917 
1918 static int avi_probe(const AVProbeData *p)
1919 {
1920  int i;
1921 
1922  /* check file header */
1923  for (i = 0; avi_headers[i][0]; i++)
1924  if (AV_RL32(p->buf ) == AV_RL32(avi_headers[i] ) &&
1925  AV_RL32(p->buf + 8) == AV_RL32(avi_headers[i] + 4))
1926  return AVPROBE_SCORE_MAX;
1927 
1928  return 0;
1929 }
1930 
1932  .name = "avi",
1933  .long_name = NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"),
1934  .priv_data_size = sizeof(AVIContext),
1935  .extensions = "avi",
1936  .read_probe = avi_probe,
1941  .priv_class = &demuxer_class,
1942 };
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:1126
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2514
#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:797
uint32_t handler
Definition: avidec.c:47
Bytestream IO Context.
Definition: avio.h:161
static struct @305 state
#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:805
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2516
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:938
int dshow_block_align
Definition: avidec.c:58
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:877
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:1105
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:891
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:1327
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:1631
static const AVMetadataConv avi_metadata_conv[]
Definition: avidec.c:111
uint8_t base
Definition: vp3data.h:202
Format I/O context.
Definition: avformat.h:1353
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:1486
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:1895
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:1094
int id
Format-specific stream ID.
Definition: avformat.h:883
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:1421
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:1484
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:1057
uint32_t tag
Definition: movenc.c:1534
#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:812
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:1593
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:806
#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:1160
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:949
#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:796
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:1409
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:1918
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
void ff_free_stream(AVFormatContext *s, AVStream *st)
Definition: utils.c:4445
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:1768
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:1505
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2761
AVDictionary * metadata
Definition: avformat.h:940
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:876
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:1396
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
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:1395
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
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
int nb_index_entries
Definition: avformat.h:1107
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:1543
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:1728
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVInputFormat ff_avi_demuxer
Definition: avidec.c:1931
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:925
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:795
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
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:915
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1620
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:927
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
int len
int has_pal
Definition: avidec.c:57
static int guess_ni_flag(AVFormatContext *s)
Definition: avidec.c:1686
void * priv_data
Format private data.
Definition: avformat.h:1381
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
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:1778
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1468
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
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:905
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:931
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:1134
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:1174
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