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