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/bswap.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/mathematics.h"
32 #include "avformat.h"
33 #include "avi.h"
34 #include "dv.h"
35 #include "internal.h"
36 #include "isom.h"
37 #include "riff.h"
38 #include "libavcodec/bytestream.h"
39 #include "libavcodec/exif.h"
40 #include "libavcodec/internal.h"
41 
42 typedef struct AVIStream {
43  int64_t frame_offset; /* current frame (video) or byte (audio) counter
44  * (used to compute the pts) */
45  int remaining;
47 
48  uint32_t handler;
49  uint32_t scale;
50  uint32_t rate;
51  int sample_size; /* size of one sample (or packet)
52  * (in the rate/scale sense) in bytes */
53 
54  int64_t cum_len; /* temporary storage (used during seek) */
55  int prefix; /* normally 'd'<<8 + 'c' or 'w'<<8 + 'b' */
57  uint32_t pal[256];
58  int has_pal;
59  int dshow_block_align; /* block align variable used to emulate bugs in
60  * the MS dshow demuxer */
61 
65 
66  int64_t seek_pos;
67 } AVIStream;
68 
69 typedef struct AVIContext {
70  const AVClass *class;
71  int64_t riff_end;
72  int64_t movi_end;
73  int64_t fsize;
74  int64_t io_fsize;
75  int64_t movi_list;
76  int64_t last_pkt_pos;
78  int is_odml;
83  int use_odml;
84 #define MAX_ODML_DEPTH 1000
85  int64_t dts_max;
86 } AVIContext;
87 
88 
89 static const AVOption options[] = {
90  { "use_odml", "use odml index", offsetof(AVIContext, use_odml), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM},
91  { NULL },
92 };
93 
94 static const AVClass demuxer_class = {
95  .class_name = "avi",
96  .item_name = av_default_item_name,
97  .option = options,
98  .version = LIBAVUTIL_VERSION_INT,
99  .category = AV_CLASS_CATEGORY_DEMUXER,
100 };
101 
102 
103 static const char avi_headers[][8] = {
104  { 'R', 'I', 'F', 'F', 'A', 'V', 'I', ' ' },
105  { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 'X' },
106  { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 0x19 },
107  { 'O', 'N', '2', ' ', 'O', 'N', '2', 'f' },
108  { 'R', 'I', 'F', 'F', 'A', 'M', 'V', ' ' },
109  { 0 }
110 };
111 
113  { "strn", "title" },
114  { 0 },
115 };
116 
117 static int avi_load_index(AVFormatContext *s);
118 static int guess_ni_flag(AVFormatContext *s);
119 
120 #define print_tag(str, tag, size) \
121  av_log(NULL, AV_LOG_TRACE, "pos:%"PRIX64" %s: tag=%s size=0x%x\n", \
122  avio_tell(pb), str, av_fourcc2str(tag), size) \
123 
124 static inline int get_duration(AVIStream *ast, int len)
125 {
126  if (ast->sample_size)
127  return len;
128  else if (ast->dshow_block_align)
129  return (len + ast->dshow_block_align - 1) / ast->dshow_block_align;
130  else
131  return 1;
132 }
133 
135 {
136  AVIContext *avi = s->priv_data;
137  char header[8] = {0};
138  int i;
139 
140  /* check RIFF header */
141  avio_read(pb, header, 4);
142  avi->riff_end = avio_rl32(pb); /* RIFF chunk size */
143  avi->riff_end += avio_tell(pb); /* RIFF chunk end */
144  avio_read(pb, header + 4, 4);
145 
146  for (i = 0; avi_headers[i][0]; i++)
147  if (!memcmp(header, avi_headers[i], 8))
148  break;
149  if (!avi_headers[i][0])
150  return AVERROR_INVALIDDATA;
151 
152  if (header[7] == 0x19)
153  av_log(s, AV_LOG_INFO,
154  "This file has been generated by a totally broken muxer.\n");
155 
156  return 0;
157 }
158 
159 static int read_odml_index(AVFormatContext *s, int frame_num)
160 {
161  AVIContext *avi = s->priv_data;
162  AVIOContext *pb = s->pb;
163  int longs_per_entry = avio_rl16(pb);
164  int index_sub_type = avio_r8(pb);
165  int index_type = avio_r8(pb);
166  int entries_in_use = avio_rl32(pb);
167  int chunk_id = avio_rl32(pb);
168  int64_t base = avio_rl64(pb);
169  int stream_id = ((chunk_id & 0xFF) - '0') * 10 +
170  ((chunk_id >> 8 & 0xFF) - '0');
171  AVStream *st;
172  AVIStream *ast;
173  int i;
174  int64_t last_pos = -1;
175  int64_t filesize = avi->fsize;
176 
177  av_log(s, AV_LOG_TRACE,
178  "longs_per_entry:%d index_type:%d entries_in_use:%d "
179  "chunk_id:%X base:%16"PRIX64" frame_num:%d\n",
180  longs_per_entry,
181  index_type,
182  entries_in_use,
183  chunk_id,
184  base,
185  frame_num);
186 
187  if (stream_id >= s->nb_streams || stream_id < 0)
188  return AVERROR_INVALIDDATA;
189  st = s->streams[stream_id];
190  ast = st->priv_data;
191 
192  if (index_sub_type)
193  return AVERROR_INVALIDDATA;
194 
195  avio_rl32(pb);
196 
197  if (index_type && longs_per_entry != 2)
198  return AVERROR_INVALIDDATA;
199  if (index_type > 1)
200  return AVERROR_INVALIDDATA;
201 
202  if (filesize > 0 && base >= filesize) {
203  av_log(s, AV_LOG_ERROR, "ODML index invalid\n");
204  if (base >> 32 == (base & 0xFFFFFFFF) &&
205  (base & 0xFFFFFFFF) < filesize &&
206  filesize <= 0xFFFFFFFF)
207  base &= 0xFFFFFFFF;
208  else
209  return AVERROR_INVALIDDATA;
210  }
211 
212  for (i = 0; i < entries_in_use; i++) {
213  if (index_type) {
214  int64_t pos = avio_rl32(pb) + base - 8;
215  int len = avio_rl32(pb);
216  int key = len >= 0;
217  len &= 0x7FFFFFFF;
218 
219  av_log(s, AV_LOG_TRACE, "pos:%"PRId64", len:%X\n", pos, len);
220 
221  if (avio_feof(pb))
222  return AVERROR_INVALIDDATA;
223 
224  if (last_pos == pos || pos == base - 8)
225  avi->non_interleaved = 1;
226  if (last_pos != pos && len)
227  av_add_index_entry(st, pos, ast->cum_len, len, 0,
228  key ? AVINDEX_KEYFRAME : 0);
229 
230  ast->cum_len += get_duration(ast, len);
231  last_pos = pos;
232  } else {
233  int64_t offset, pos;
234  int duration;
235  offset = avio_rl64(pb);
236  avio_rl32(pb); /* size */
237  duration = avio_rl32(pb);
238 
239  if (avio_feof(pb))
240  return AVERROR_INVALIDDATA;
241 
242  pos = avio_tell(pb);
243 
244  if (avi->odml_depth > MAX_ODML_DEPTH) {
245  av_log(s, AV_LOG_ERROR, "Too deeply nested ODML indexes\n");
246  return AVERROR_INVALIDDATA;
247  }
248 
249  if (avio_seek(pb, offset + 8, SEEK_SET) < 0)
250  return -1;
251  avi->odml_depth++;
252  read_odml_index(s, frame_num);
253  avi->odml_depth--;
254  frame_num += duration;
255 
256  if (avio_seek(pb, pos, SEEK_SET) < 0) {
257  av_log(s, AV_LOG_ERROR, "Failed to restore position after reading index\n");
258  return -1;
259  }
260 
261  }
262  }
263  avi->index_loaded = 2;
264  return 0;
265 }
266 
268 {
269  int i;
270  int64_t j;
271 
272  for (i = 0; i < s->nb_streams; i++) {
273  AVStream *st = s->streams[i];
274  AVIStream *ast = st->priv_data;
275  int n = st->nb_index_entries;
276  int max = ast->sample_size;
277  int64_t pos, size, ts;
278 
279  if (n != 1 || ast->sample_size == 0)
280  continue;
281 
282  while (max < 1024)
283  max += max;
284 
285  pos = st->index_entries[0].pos;
286  size = st->index_entries[0].size;
287  ts = st->index_entries[0].timestamp;
288 
289  for (j = 0; j < size; j += max)
290  av_add_index_entry(st, pos + j, ts + j, FFMIN(max, size - j), 0,
292  }
293 }
294 
295 static int avi_read_tag(AVFormatContext *s, AVStream *st, uint32_t tag,
296  uint32_t size)
297 {
298  AVIOContext *pb = s->pb;
299  char key[5] = { 0 };
300  char *value;
301 
302  size += (size & 1);
303 
304  if (size == UINT_MAX)
305  return AVERROR(EINVAL);
306  value = av_malloc(size + 1);
307  if (!value)
308  return AVERROR(ENOMEM);
309  if (avio_read(pb, value, size) != size)
310  return AVERROR_INVALIDDATA;
311  value[size] = 0;
312 
313  AV_WL32(key, tag);
314 
315  return av_dict_set(st ? &st->metadata : &s->metadata, key, value,
317 }
318 
319 static const char months[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
320  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
321 
322 static void avi_metadata_creation_time(AVDictionary **metadata, char *date)
323 {
324  char month[4], time[9], buffer[64];
325  int i, day, year;
326  /* parse standard AVI date format (ie. "Mon Mar 10 15:04:43 2003") */
327  if (sscanf(date, "%*3s%*[ ]%3s%*[ ]%2d%*[ ]%8s%*[ ]%4d",
328  month, &day, time, &year) == 4) {
329  for (i = 0; i < 12; i++)
330  if (!av_strcasecmp(month, months[i])) {
331  snprintf(buffer, sizeof(buffer), "%.4d-%.2d-%.2d %s",
332  year, i + 1, day, time);
333  av_dict_set(metadata, "creation_time", buffer, 0);
334  }
335  } else if (date[4] == '/' && date[7] == '/') {
336  date[4] = date[7] = '-';
337  av_dict_set(metadata, "creation_time", date, 0);
338  }
339 }
340 
341 static void avi_read_nikon(AVFormatContext *s, uint64_t end)
342 {
343  while (avio_tell(s->pb) < end && !avio_feof(s->pb)) {
344  uint32_t tag = avio_rl32(s->pb);
345  uint32_t size = avio_rl32(s->pb);
346  switch (tag) {
347  case MKTAG('n', 'c', 't', 'g'): /* Nikon Tags */
348  {
349  uint64_t tag_end = avio_tell(s->pb) + size;
350  while (avio_tell(s->pb) < tag_end && !avio_feof(s->pb)) {
351  uint16_t tag = avio_rl16(s->pb);
352  uint16_t size = avio_rl16(s->pb);
353  const char *name = NULL;
354  char buffer[64] = { 0 };
355  size = FFMIN(size, tag_end - avio_tell(s->pb));
356  size -= avio_read(s->pb, buffer,
357  FFMIN(size, sizeof(buffer) - 1));
358  switch (tag) {
359  case 0x03:
360  name = "maker";
361  break;
362  case 0x04:
363  name = "model";
364  break;
365  case 0x13:
366  name = "creation_time";
367  if (buffer[4] == ':' && buffer[7] == ':')
368  buffer[4] = buffer[7] = '-';
369  break;
370  }
371  if (name)
372  av_dict_set(&s->metadata, name, buffer, 0);
373  avio_skip(s->pb, size);
374  }
375  break;
376  }
377  default:
378  avio_skip(s->pb, size);
379  break;
380  }
381  }
382 }
383 
385 {
386  GetByteContext gb;
387  uint8_t *data = st->codecpar->extradata;
388  int data_size = st->codecpar->extradata_size;
389  int tag, offset;
390 
391  if (!data || data_size < 8) {
392  return AVERROR_INVALIDDATA;
393  }
394 
395  bytestream2_init(&gb, data, data_size);
396 
397  tag = bytestream2_get_le32(&gb);
398 
399  switch (tag) {
400  case MKTAG('A', 'V', 'I', 'F'):
401  // skip 4 byte padding
402  bytestream2_skip(&gb, 4);
403  offset = bytestream2_tell(&gb);
404 
405  // decode EXIF tags from IFD, AVI is always little-endian
406  return avpriv_exif_decode_ifd(s, data + offset, data_size - offset,
407  1, 0, &st->metadata);
408  break;
409  case MKTAG('C', 'A', 'S', 'I'):
410  avpriv_request_sample(s, "RIFF stream data tag type CASI (%u)", tag);
411  break;
412  case MKTAG('Z', 'o', 'r', 'a'):
413  avpriv_request_sample(s, "RIFF stream data tag type Zora (%u)", tag);
414  break;
415  default:
416  break;
417  }
418 
419  return 0;
420 }
421 
423 {
424  AVIContext *avi = s->priv_data;
425  int i, j;
426  int64_t lensum = 0;
427  int64_t maxpos = 0;
428 
429  for (i = 0; i<s->nb_streams; i++) {
430  int64_t len = 0;
431  AVStream *st = s->streams[i];
432 
433  if (!st->nb_index_entries)
434  continue;
435 
436  for (j = 0; j < st->nb_index_entries; j++)
437  len += st->index_entries[j].size;
438  maxpos = FFMAX(maxpos, st->index_entries[j-1].pos);
439  lensum += len;
440  }
441  if (maxpos < avi->io_fsize*9/10) // index does not cover the whole file
442  return 0;
443  if (lensum*9/10 > maxpos || lensum < maxpos*9/10) // frame sum and filesize mismatch
444  return 0;
445 
446  for (i = 0; i<s->nb_streams; i++) {
447  int64_t len = 0;
448  AVStream *st = s->streams[i];
449  int64_t duration;
450  int64_t bitrate;
451 
452  for (j = 0; j < st->nb_index_entries; j++)
453  len += st->index_entries[j].size;
454 
455  if (st->nb_index_entries < 2 || st->codecpar->bit_rate > 0)
456  continue;
457  duration = st->index_entries[j-1].timestamp - st->index_entries[0].timestamp;
458  bitrate = av_rescale(8*len, st->time_base.den, duration * st->time_base.num);
459  if (bitrate > 0) {
460  st->codecpar->bit_rate = bitrate;
461  }
462  }
463  return 1;
464 }
465 
467 {
468  AVIContext *avi = s->priv_data;
469  AVIOContext *pb = s->pb;
470  unsigned int tag, tag1, handler;
471  int codec_type, stream_index, frame_period;
472  unsigned int size;
473  int i;
474  AVStream *st;
475  AVIStream *ast = NULL;
476  int avih_width = 0, avih_height = 0;
477  int amv_file_format = 0;
478  uint64_t list_end = 0;
479  int64_t pos;
480  int ret;
481  AVDictionaryEntry *dict_entry;
482 
483  avi->stream_index = -1;
484 
485  ret = get_riff(s, pb);
486  if (ret < 0)
487  return ret;
488 
489  av_log(avi, AV_LOG_DEBUG, "use odml:%d\n", avi->use_odml);
490 
491  avi->io_fsize = avi->fsize = avio_size(pb);
492  if (avi->fsize <= 0 || avi->fsize < avi->riff_end)
493  avi->fsize = avi->riff_end == 8 ? INT64_MAX : avi->riff_end;
494 
495  /* first list tag */
496  stream_index = -1;
497  codec_type = -1;
498  frame_period = 0;
499  for (;;) {
500  if (avio_feof(pb))
501  goto fail;
502  tag = avio_rl32(pb);
503  size = avio_rl32(pb);
504 
505  print_tag("tag", tag, size);
506 
507  switch (tag) {
508  case MKTAG('L', 'I', 'S', 'T'):
509  list_end = avio_tell(pb) + size;
510  /* Ignored, except at start of video packets. */
511  tag1 = avio_rl32(pb);
512 
513  print_tag("list", tag1, 0);
514 
515  if (tag1 == MKTAG('m', 'o', 'v', 'i')) {
516  avi->movi_list = avio_tell(pb) - 4;
517  if (size)
518  avi->movi_end = avi->movi_list + size + (size & 1);
519  else
520  avi->movi_end = avi->fsize;
521  av_log(NULL, AV_LOG_TRACE, "movi end=%"PRIx64"\n", avi->movi_end);
522  goto end_of_header;
523  } else if (tag1 == MKTAG('I', 'N', 'F', 'O'))
524  ff_read_riff_info(s, size - 4);
525  else if (tag1 == MKTAG('n', 'c', 'd', 't'))
526  avi_read_nikon(s, list_end);
527 
528  break;
529  case MKTAG('I', 'D', 'I', 'T'):
530  {
531  unsigned char date[64] = { 0 };
532  size += (size & 1);
533  size -= avio_read(pb, date, FFMIN(size, sizeof(date) - 1));
534  avio_skip(pb, size);
536  break;
537  }
538  case MKTAG('d', 'm', 'l', 'h'):
539  avi->is_odml = 1;
540  avio_skip(pb, size + (size & 1));
541  break;
542  case MKTAG('a', 'm', 'v', 'h'):
543  amv_file_format = 1;
544  case MKTAG('a', 'v', 'i', 'h'):
545  /* AVI header */
546  /* using frame_period is bad idea */
547  frame_period = avio_rl32(pb);
548  avio_rl32(pb); /* max. bytes per second */
549  avio_rl32(pb);
551 
552  avio_skip(pb, 2 * 4);
553  avio_rl32(pb);
554  avio_rl32(pb);
555  avih_width = avio_rl32(pb);
556  avih_height = avio_rl32(pb);
557 
558  avio_skip(pb, size - 10 * 4);
559  break;
560  case MKTAG('s', 't', 'r', 'h'):
561  /* stream header */
562 
563  tag1 = avio_rl32(pb);
564  handler = avio_rl32(pb); /* codec tag */
565 
566  if (tag1 == MKTAG('p', 'a', 'd', 's')) {
567  avio_skip(pb, size - 8);
568  break;
569  } else {
570  stream_index++;
571  st = avformat_new_stream(s, NULL);
572  if (!st)
573  goto fail;
574 
575  st->id = stream_index;
576  ast = av_mallocz(sizeof(AVIStream));
577  if (!ast)
578  goto fail;
579  st->priv_data = ast;
580  }
581  if (amv_file_format)
582  tag1 = stream_index ? MKTAG('a', 'u', 'd', 's')
583  : MKTAG('v', 'i', 'd', 's');
584 
585  print_tag("strh", tag1, -1);
586 
587  if (tag1 == MKTAG('i', 'a', 'v', 's') ||
588  tag1 == MKTAG('i', 'v', 'a', 's')) {
589  int64_t dv_dur;
590 
591  /* After some consideration -- I don't think we
592  * have to support anything but DV in type1 AVIs. */
593  if (s->nb_streams != 1)
594  goto fail;
595 
596  if (handler != MKTAG('d', 'v', 's', 'd') &&
597  handler != MKTAG('d', 'v', 'h', 'd') &&
598  handler != MKTAG('d', 'v', 's', 'l'))
599  goto fail;
600 
601  ast = s->streams[0]->priv_data;
603  av_freep(&s->streams[0]->codecpar);
604 #if FF_API_LAVF_AVCTX
606  av_freep(&s->streams[0]->codec);
608 #endif
609  if (s->streams[0]->info)
611  av_freep(&s->streams[0]->info);
612  if (s->streams[0]->internal)
613  av_freep(&s->streams[0]->internal->avctx);
614  av_freep(&s->streams[0]->internal);
615  av_freep(&s->streams[0]);
616  s->nb_streams = 0;
617  if (CONFIG_DV_DEMUXER) {
618  avi->dv_demux = avpriv_dv_init_demux(s);
619  if (!avi->dv_demux)
620  goto fail;
621  } else
622  goto fail;
623  s->streams[0]->priv_data = ast;
624  avio_skip(pb, 3 * 4);
625  ast->scale = avio_rl32(pb);
626  ast->rate = avio_rl32(pb);
627  avio_skip(pb, 4); /* start time */
628 
629  dv_dur = avio_rl32(pb);
630  if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) {
631  dv_dur *= AV_TIME_BASE;
632  s->duration = av_rescale(dv_dur, ast->scale, ast->rate);
633  }
634  /* else, leave duration alone; timing estimation in utils.c
635  * will make a guess based on bitrate. */
636 
637  stream_index = s->nb_streams - 1;
638  avio_skip(pb, size - 9 * 4);
639  break;
640  }
641 
642  av_assert0(stream_index < s->nb_streams);
643  ast->handler = handler;
644 
645  avio_rl32(pb); /* flags */
646  avio_rl16(pb); /* priority */
647  avio_rl16(pb); /* language */
648  avio_rl32(pb); /* initial frame */
649  ast->scale = avio_rl32(pb);
650  ast->rate = avio_rl32(pb);
651  if (!(ast->scale && ast->rate)) {
653  "scale/rate is %"PRIu32"/%"PRIu32" which is invalid. "
654  "(This file has been generated by broken software.)\n",
655  ast->scale,
656  ast->rate);
657  if (frame_period) {
658  ast->rate = 1000000;
659  ast->scale = frame_period;
660  } else {
661  ast->rate = 25;
662  ast->scale = 1;
663  }
664  }
665  avpriv_set_pts_info(st, 64, ast->scale, ast->rate);
666 
667  ast->cum_len = avio_rl32(pb); /* start */
668  st->nb_frames = avio_rl32(pb);
669 
670  st->start_time = 0;
671  avio_rl32(pb); /* buffer size */
672  avio_rl32(pb); /* quality */
673  if (ast->cum_len > 3600LL * ast->rate / ast->scale) {
674  av_log(s, AV_LOG_ERROR, "crazy start time, iam scared, giving up\n");
675  ast->cum_len = 0;
676  }
677  ast->sample_size = avio_rl32(pb);
678  ast->cum_len *= FFMAX(1, ast->sample_size);
679  av_log(s, AV_LOG_TRACE, "%"PRIu32" %"PRIu32" %d\n",
680  ast->rate, ast->scale, ast->sample_size);
681 
682  switch (tag1) {
683  case MKTAG('v', 'i', 'd', 's'):
684  codec_type = AVMEDIA_TYPE_VIDEO;
685 
686  ast->sample_size = 0;
687  st->avg_frame_rate = av_inv_q(st->time_base);
688  break;
689  case MKTAG('a', 'u', 'd', 's'):
690  codec_type = AVMEDIA_TYPE_AUDIO;
691  break;
692  case MKTAG('t', 'x', 't', 's'):
693  codec_type = AVMEDIA_TYPE_SUBTITLE;
694  break;
695  case MKTAG('d', 'a', 't', 's'):
696  codec_type = AVMEDIA_TYPE_DATA;
697  break;
698  default:
699  av_log(s, AV_LOG_INFO, "unknown stream type %X\n", tag1);
700  }
701 
702  if (ast->sample_size < 0) {
703  if (s->error_recognition & AV_EF_EXPLODE) {
704  av_log(s, AV_LOG_ERROR,
705  "Invalid sample_size %d at stream %d\n",
706  ast->sample_size,
707  stream_index);
708  goto fail;
709  }
711  "Invalid sample_size %d at stream %d "
712  "setting it to 0\n",
713  ast->sample_size,
714  stream_index);
715  ast->sample_size = 0;
716  }
717 
718  if (ast->sample_size == 0) {
719  st->duration = st->nb_frames;
720  if (st->duration > 0 && avi->io_fsize > 0 && avi->riff_end > avi->io_fsize) {
721  av_log(s, AV_LOG_DEBUG, "File is truncated adjusting duration\n");
722  st->duration = av_rescale(st->duration, avi->io_fsize, avi->riff_end);
723  }
724  }
725  ast->frame_offset = ast->cum_len;
726  avio_skip(pb, size - 12 * 4);
727  break;
728  case MKTAG('s', 't', 'r', 'f'):
729  /* stream header */
730  if (!size && (codec_type == AVMEDIA_TYPE_AUDIO ||
731  codec_type == AVMEDIA_TYPE_VIDEO))
732  break;
733  if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) {
734  avio_skip(pb, size);
735  } else {
736  uint64_t cur_pos = avio_tell(pb);
737  unsigned esize;
738  if (cur_pos < list_end)
739  size = FFMIN(size, list_end - cur_pos);
740  st = s->streams[stream_index];
742  avio_skip(pb, size);
743  break;
744  }
745  switch (codec_type) {
746  case AVMEDIA_TYPE_VIDEO:
747  if (amv_file_format) {
748  st->codecpar->width = avih_width;
749  st->codecpar->height = avih_height;
752  avio_skip(pb, size);
753  break;
754  }
755  tag1 = ff_get_bmp_header(pb, st, &esize);
756 
757  if (tag1 == MKTAG('D', 'X', 'S', 'B') ||
758  tag1 == MKTAG('D', 'X', 'S', 'A')) {
760  st->codecpar->codec_tag = tag1;
762  break;
763  }
764 
765  if (size > 10 * 4 && size < (1 << 30) && size < avi->fsize) {
766  if (esize == size-1 && (esize&1)) {
767  st->codecpar->extradata_size = esize - 10 * 4;
768  } else
769  st->codecpar->extradata_size = size - 10 * 4;
770  if (st->codecpar->extradata) {
771  av_log(s, AV_LOG_WARNING, "New extradata in strf chunk, freeing previous one.\n");
772  av_freep(&st->codecpar->extradata);
773  }
774  if (ff_get_extradata(s, st->codecpar, pb, st->codecpar->extradata_size) < 0)
775  return AVERROR(ENOMEM);
776  }
777 
778  // FIXME: check if the encoder really did this correctly
779  if (st->codecpar->extradata_size & 1)
780  avio_r8(pb);
781 
782  /* Extract palette from extradata if bpp <= 8.
783  * This code assumes that extradata contains only palette.
784  * This is true for all paletted codecs implemented in
785  * FFmpeg. */
786  if (st->codecpar->extradata_size &&
787  (st->codecpar->bits_per_coded_sample <= 8)) {
788  int pal_size = (1 << st->codecpar->bits_per_coded_sample) << 2;
789  const uint8_t *pal_src;
790 
791  pal_size = FFMIN(pal_size, st->codecpar->extradata_size);
792  pal_src = st->codecpar->extradata +
793  st->codecpar->extradata_size - pal_size;
794  /* Exclude the "BottomUp" field from the palette */
795  if (pal_src - st->codecpar->extradata >= 9 &&
796  !memcmp(st->codecpar->extradata + st->codecpar->extradata_size - 9, "BottomUp", 9))
797  pal_src -= 9;
798  for (i = 0; i < pal_size / 4; i++)
799  ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src + 4 * i);
800  ast->has_pal = 1;
801  }
802 
803  print_tag("video", tag1, 0);
804 
806  st->codecpar->codec_tag = tag1;
808  tag1);
809  /* If codec is not found yet, try with the mov tags. */
810  if (!st->codecpar->codec_id) {
811  st->codecpar->codec_id =
813  if (st->codecpar->codec_id)
815  "mov tag found in avi (fourcc %s)\n",
816  av_fourcc2str(tag1));
817  }
818  /* This is needed to get the pict type which is necessary
819  * for generating correct pts. */
821 
822  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4 &&
823  ast->handler == MKTAG('X', 'V', 'I', 'D'))
824  st->codecpar->codec_tag = MKTAG('X', 'V', 'I', 'D');
825 
826  if (st->codecpar->codec_tag == MKTAG('V', 'S', 'S', 'H'))
828  if (st->codecpar->codec_id == AV_CODEC_ID_RV40)
830 
831  if (st->codecpar->codec_tag == 0 && st->codecpar->height > 0 &&
832  st->codecpar->extradata_size < 1U << 30) {
833  st->codecpar->extradata_size += 9;
834  if ((ret = av_reallocp(&st->codecpar->extradata,
835  st->codecpar->extradata_size +
837  st->codecpar->extradata_size = 0;
838  return ret;
839  } else
840  memcpy(st->codecpar->extradata + st->codecpar->extradata_size - 9,
841  "BottomUp", 9);
842  }
843  st->codecpar->height = FFABS(st->codecpar->height);
844 
845 // avio_skip(pb, size - 5 * 4);
846  break;
847  case AVMEDIA_TYPE_AUDIO:
848  ret = ff_get_wav_header(s, pb, st->codecpar, size, 0);
849  if (ret < 0)
850  return ret;
852  if (ast->sample_size && st->codecpar->block_align &&
853  ast->sample_size != st->codecpar->block_align) {
854  av_log(s,
856  "sample size (%d) != block align (%d)\n",
857  ast->sample_size,
858  st->codecpar->block_align);
859  ast->sample_size = st->codecpar->block_align;
860  }
861  /* 2-aligned
862  * (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
863  if (size & 1)
864  avio_skip(pb, 1);
865  /* Force parsing as several audio frames can be in
866  * one packet and timestamps refer to packet start. */
868  /* ADTS header is in extradata, AAC without header must be
869  * stored as exact frames. Parser not needed and it will
870  * fail. */
871  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
874  // The flac parser does not work with AVSTREAM_PARSE_TIMESTAMPS
875  if (st->codecpar->codec_id == AV_CODEC_ID_FLAC)
877  /* AVI files with Xan DPCM audio (wrongly) declare PCM
878  * audio in the header but have Axan as stream_code_tag. */
879  if (ast->handler == AV_RL32("Axan")) {
881  st->codecpar->codec_tag = 0;
882  ast->dshow_block_align = 0;
883  }
884  if (amv_file_format) {
886  ast->dshow_block_align = 0;
887  }
888  if ((st->codecpar->codec_id == AV_CODEC_ID_AAC ||
890  st->codecpar->codec_id == AV_CODEC_ID_MP2 ) && ast->dshow_block_align <= 4 && ast->dshow_block_align) {
891  av_log(s, AV_LOG_DEBUG, "overriding invalid dshow_block_align of %d\n", ast->dshow_block_align);
892  ast->dshow_block_align = 0;
893  }
894  if (st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 1024 && ast->sample_size == 1024 ||
895  st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 4096 && ast->sample_size == 4096 ||
896  st->codecpar->codec_id == AV_CODEC_ID_MP3 && ast->dshow_block_align == 1152 && ast->sample_size == 1152) {
897  av_log(s, AV_LOG_DEBUG, "overriding sample_size\n");
898  ast->sample_size = 0;
899  }
900  break;
903  st->request_probe= 1;
904  avio_skip(pb, size);
905  break;
906  default:
909  st->codecpar->codec_tag = 0;
910  avio_skip(pb, size);
911  break;
912  }
913  }
914  break;
915  case MKTAG('s', 't', 'r', 'd'):
916  if (stream_index >= (unsigned)s->nb_streams
917  || s->streams[stream_index]->codecpar->extradata_size
918  || s->streams[stream_index]->codecpar->codec_tag == MKTAG('H','2','6','4')) {
919  avio_skip(pb, size);
920  } else {
921  uint64_t cur_pos = avio_tell(pb);
922  if (cur_pos < list_end)
923  size = FFMIN(size, list_end - cur_pos);
924  st = s->streams[stream_index];
925 
926  if (size<(1<<30)) {
927  if (st->codecpar->extradata) {
928  av_log(s, AV_LOG_WARNING, "New extradata in strd chunk, freeing previous one.\n");
929  av_freep(&st->codecpar->extradata);
930  }
931  if (ff_get_extradata(s, st->codecpar, pb, size) < 0)
932  return AVERROR(ENOMEM);
933  }
934 
935  if (st->codecpar->extradata_size & 1) //FIXME check if the encoder really did this correctly
936  avio_r8(pb);
937 
938  ret = avi_extract_stream_metadata(s, st);
939  if (ret < 0) {
940  av_log(s, AV_LOG_WARNING, "could not decoding EXIF data in stream header.\n");
941  }
942  }
943  break;
944  case MKTAG('i', 'n', 'd', 'x'):
945  pos = avio_tell(pb);
946  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !(s->flags & AVFMT_FLAG_IGNIDX) &&
947  avi->use_odml &&
948  read_odml_index(s, 0) < 0 &&
950  goto fail;
951  avio_seek(pb, pos + size, SEEK_SET);
952  break;
953  case MKTAG('v', 'p', 'r', 'p'):
954  if (stream_index < (unsigned)s->nb_streams && size > 9 * 4) {
955  AVRational active, active_aspect;
956 
957  st = s->streams[stream_index];
958  avio_rl32(pb);
959  avio_rl32(pb);
960  avio_rl32(pb);
961  avio_rl32(pb);
962  avio_rl32(pb);
963 
964  active_aspect.den = avio_rl16(pb);
965  active_aspect.num = avio_rl16(pb);
966  active.num = avio_rl32(pb);
967  active.den = avio_rl32(pb);
968  avio_rl32(pb); // nbFieldsPerFrame
969 
970  if (active_aspect.num && active_aspect.den &&
971  active.num && active.den) {
972  st->sample_aspect_ratio = av_div_q(active_aspect, active);
973  av_log(s, AV_LOG_TRACE, "vprp %d/%d %d/%d\n",
974  active_aspect.num, active_aspect.den,
975  active.num, active.den);
976  }
977  size -= 9 * 4;
978  }
979  avio_skip(pb, size);
980  break;
981  case MKTAG('s', 't', 'r', 'n'):
982  if (s->nb_streams) {
983  ret = avi_read_tag(s, s->streams[s->nb_streams - 1], tag, size);
984  if (ret < 0)
985  return ret;
986  break;
987  }
988  default:
989  if (size > 1000000) {
990  av_log(s, AV_LOG_ERROR,
991  "Something went wrong during header parsing, "
992  "tag %s has size %u, "
993  "I will ignore it and try to continue anyway.\n",
994  av_fourcc2str(tag), size);
996  goto fail;
997  avi->movi_list = avio_tell(pb) - 4;
998  avi->movi_end = avi->fsize;
999  goto end_of_header;
1000  }
1001  /* Do not fail for very large idx1 tags */
1002  case MKTAG('i', 'd', 'x', '1'):
1003  /* skip tag */
1004  size += (size & 1);
1005  avio_skip(pb, size);
1006  break;
1007  }
1008  }
1009 
1010 end_of_header:
1011  /* check stream number */
1012  if (stream_index != s->nb_streams - 1) {
1013 
1014 fail:
1015  return AVERROR_INVALIDDATA;
1016  }
1017 
1018  if (!avi->index_loaded && (pb->seekable & AVIO_SEEKABLE_NORMAL))
1019  avi_load_index(s);
1020  calculate_bitrate(s);
1021  avi->index_loaded |= 1;
1022 
1023  if ((ret = guess_ni_flag(s)) < 0)
1024  return ret;
1025 
1026  avi->non_interleaved |= ret | (s->flags & AVFMT_FLAG_SORT_DTS);
1027 
1028  dict_entry = av_dict_get(s->metadata, "ISFT", NULL, 0);
1029  if (dict_entry && !strcmp(dict_entry->value, "PotEncoder"))
1030  for (i = 0; i < s->nb_streams; i++) {
1031  AVStream *st = s->streams[i];
1035  }
1036 
1037  for (i = 0; i < s->nb_streams; i++) {
1038  AVStream *st = s->streams[i];
1039  if (st->nb_index_entries)
1040  break;
1041  }
1042  // DV-in-AVI cannot be non-interleaved, if set this must be
1043  // a mis-detection.
1044  if (avi->dv_demux)
1045  avi->non_interleaved = 0;
1046  if (i == s->nb_streams && avi->non_interleaved) {
1048  "Non-interleaved AVI without index, switching to interleaved\n");
1049  avi->non_interleaved = 0;
1050  }
1051 
1052  if (avi->non_interleaved) {
1053  av_log(s, AV_LOG_INFO, "non-interleaved AVI\n");
1054  clean_index(s);
1055  }
1056 
1057  ff_metadata_conv_ctx(s, NULL, avi_metadata_conv);
1059 
1060  return 0;
1061 }
1062 
1064 {
1065  if (pkt->size >= 7 &&
1066  pkt->size < INT_MAX - AVPROBE_PADDING_SIZE &&
1067  !strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data + 5) == 2) {
1068  uint8_t desc[256];
1069  int score = AVPROBE_SCORE_EXTENSION, ret;
1070  AVIStream *ast = st->priv_data;
1071  ff_const59 AVInputFormat *sub_demuxer;
1072  AVRational time_base;
1073  int size;
1074  AVIOContext *pb = avio_alloc_context(pkt->data + 7,
1075  pkt->size - 7,
1076  0, NULL, NULL, NULL, NULL);
1077  AVProbeData pd;
1078  unsigned int desc_len = avio_rl32(pb);
1079 
1080  if (desc_len > pb->buf_end - pb->buf_ptr)
1081  goto error;
1082 
1083  ret = avio_get_str16le(pb, desc_len, desc, sizeof(desc));
1084  avio_skip(pb, desc_len - ret);
1085  if (*desc)
1086  av_dict_set(&st->metadata, "title", desc, 0);
1087 
1088  avio_rl16(pb); /* flags? */
1089  avio_rl32(pb); /* data size */
1090 
1091  size = pb->buf_end - pb->buf_ptr;
1092  pd = (AVProbeData) { .buf = av_mallocz(size + AVPROBE_PADDING_SIZE),
1093  .buf_size = size };
1094  if (!pd.buf)
1095  goto error;
1096  memcpy(pd.buf, pb->buf_ptr, size);
1097  sub_demuxer = av_probe_input_format2(&pd, 1, &score);
1098  av_freep(&pd.buf);
1099  if (!sub_demuxer)
1100  goto error;
1101 
1102  if (strcmp(sub_demuxer->name, "srt") && strcmp(sub_demuxer->name, "ass"))
1103  goto error;
1104 
1105  if (!(ast->sub_ctx = avformat_alloc_context()))
1106  goto error;
1107 
1108  ast->sub_ctx->pb = pb;
1109 
1110  if (ff_copy_whiteblacklists(ast->sub_ctx, s) < 0)
1111  goto error;
1112 
1113  if (!avformat_open_input(&ast->sub_ctx, "", sub_demuxer, NULL)) {
1114  if (ast->sub_ctx->nb_streams != 1)
1115  goto error;
1116  ff_read_packet(ast->sub_ctx, &ast->sub_pkt);
1118  time_base = ast->sub_ctx->streams[0]->time_base;
1119  avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
1120  }
1121  ast->sub_buffer = pkt->data;
1122  memset(pkt, 0, sizeof(*pkt));
1123  return 1;
1124 
1125 error:
1126  av_freep(&ast->sub_ctx);
1127  avio_context_free(&pb);
1128  }
1129  return 0;
1130 }
1131 
1133  AVPacket *pkt)
1134 {
1135  AVIStream *ast, *next_ast = next_st->priv_data;
1136  int64_t ts, next_ts, ts_min = INT64_MAX;
1137  AVStream *st, *sub_st = NULL;
1138  int i;
1139 
1140  next_ts = av_rescale_q(next_ast->frame_offset, next_st->time_base,
1141  AV_TIME_BASE_Q);
1142 
1143  for (i = 0; i < s->nb_streams; i++) {
1144  st = s->streams[i];
1145  ast = st->priv_data;
1146  if (st->discard < AVDISCARD_ALL && ast && ast->sub_pkt.data) {
1147  ts = av_rescale_q(ast->sub_pkt.dts, st->time_base, AV_TIME_BASE_Q);
1148  if (ts <= next_ts && ts < ts_min) {
1149  ts_min = ts;
1150  sub_st = st;
1151  }
1152  }
1153  }
1154 
1155  if (sub_st) {
1156  ast = sub_st->priv_data;
1157  *pkt = ast->sub_pkt;
1158  pkt->stream_index = sub_st->index;
1159 
1160  if (ff_read_packet(ast->sub_ctx, &ast->sub_pkt) < 0)
1161  ast->sub_pkt.data = NULL;
1162  }
1163  return sub_st;
1164 }
1165 
1166 static int get_stream_idx(const unsigned *d)
1167 {
1168  if (d[0] >= '0' && d[0] <= '9' &&
1169  d[1] >= '0' && d[1] <= '9') {
1170  return (d[0] - '0') * 10 + (d[1] - '0');
1171  } else {
1172  return 100; // invalid stream ID
1173  }
1174 }
1175 
1176 /**
1177  *
1178  * @param exit_early set to 1 to just gather packet position without making the changes needed to actually read & return the packet
1179  */
1180 static int avi_sync(AVFormatContext *s, int exit_early)
1181 {
1182  AVIContext *avi = s->priv_data;
1183  AVIOContext *pb = s->pb;
1184  int n;
1185  unsigned int d[8];
1186  unsigned int size;
1187  int64_t i, sync;
1188 
1189 start_sync:
1190  memset(d, -1, sizeof(d));
1191  for (i = sync = avio_tell(pb); !avio_feof(pb); i++) {
1192  int j;
1193 
1194  for (j = 0; j < 7; j++)
1195  d[j] = d[j + 1];
1196  d[7] = avio_r8(pb);
1197 
1198  size = d[4] + (d[5] << 8) + (d[6] << 16) + (d[7] << 24);
1199 
1200  n = get_stream_idx(d + 2);
1201  ff_tlog(s, "%X %X %X %X %X %X %X %X %"PRId64" %u %d\n",
1202  d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n);
1203  if (i*(avi->io_fsize>0) + (uint64_t)size > avi->fsize || d[0] > 127)
1204  continue;
1205 
1206  // parse ix##
1207  if ((d[0] == 'i' && d[1] == 'x' && n < s->nb_streams) ||
1208  // parse JUNK
1209  (d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K') ||
1210  (d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1') ||
1211  (d[0] == 'i' && d[1] == 'n' && d[2] == 'd' && d[3] == 'x')) {
1212  avio_skip(pb, size);
1213  goto start_sync;
1214  }
1215 
1216  // parse stray LIST
1217  if (d[0] == 'L' && d[1] == 'I' && d[2] == 'S' && d[3] == 'T') {
1218  avio_skip(pb, 4);
1219  goto start_sync;
1220  }
1221 
1222  n = get_stream_idx(d);
1223 
1224  if (!((i - avi->last_pkt_pos) & 1) &&
1225  get_stream_idx(d + 1) < s->nb_streams)
1226  continue;
1227 
1228  // detect ##ix chunk and skip
1229  if (d[2] == 'i' && d[3] == 'x' && n < s->nb_streams) {
1230  avio_skip(pb, size);
1231  goto start_sync;
1232  }
1233 
1234  if (d[2] == 'w' && d[3] == 'c' && n < s->nb_streams) {
1235  avio_skip(pb, 16 * 3 + 8);
1236  goto start_sync;
1237  }
1238 
1239  if (avi->dv_demux && n != 0)
1240  continue;
1241 
1242  // parse ##dc/##wb
1243  if (n < s->nb_streams) {
1244  AVStream *st;
1245  AVIStream *ast;
1246  st = s->streams[n];
1247  ast = st->priv_data;
1248 
1249  if (!ast) {
1250  av_log(s, AV_LOG_WARNING, "Skipping foreign stream %d packet\n", n);
1251  continue;
1252  }
1253 
1254  if (s->nb_streams >= 2) {
1255  AVStream *st1 = s->streams[1];
1256  AVIStream *ast1 = st1->priv_data;
1257  // workaround for broken small-file-bug402.avi
1258  if ( d[2] == 'w' && d[3] == 'b'
1259  && n == 0
1260  && st ->codecpar->codec_type == AVMEDIA_TYPE_VIDEO
1262  && ast->prefix == 'd'*256+'c'
1263  && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count)
1264  ) {
1265  n = 1;
1266  st = st1;
1267  ast = ast1;
1269  "Invalid stream + prefix combination, assuming audio.\n");
1270  }
1271  }
1272 
1273  if (d[2] == 'p' && d[3] == 'c' && size <= 4 * 256 + 4) {
1274  int k = avio_r8(pb);
1275  int last = (k + avio_r8(pb) - 1) & 0xFF;
1276 
1277  avio_rl16(pb); // flags
1278 
1279  // b + (g << 8) + (r << 16);
1280  for (; k <= last; k++)
1281  ast->pal[k] = 0xFFU<<24 | avio_rb32(pb)>>8;
1282 
1283  ast->has_pal = 1;
1284  goto start_sync;
1285  } else if (((ast->prefix_count < 5 || sync + 9 > i) &&
1286  d[2] < 128 && d[3] < 128) ||
1287  d[2] * 256 + d[3] == ast->prefix /* ||
1288  (d[2] == 'd' && d[3] == 'c') ||
1289  (d[2] == 'w' && d[3] == 'b') */) {
1290  if (exit_early)
1291  return 0;
1292  if (d[2] * 256 + d[3] == ast->prefix)
1293  ast->prefix_count++;
1294  else {
1295  ast->prefix = d[2] * 256 + d[3];
1296  ast->prefix_count = 0;
1297  }
1298 
1299  if (!avi->dv_demux &&
1300  ((st->discard >= AVDISCARD_DEFAULT && size == 0) /* ||
1301  // FIXME: needs a little reordering
1302  (st->discard >= AVDISCARD_NONKEY &&
1303  !(pkt->flags & AV_PKT_FLAG_KEY)) */
1304  || st->discard >= AVDISCARD_ALL)) {
1305 
1306  ast->frame_offset += get_duration(ast, size);
1307  avio_skip(pb, size);
1308  goto start_sync;
1309  }
1310 
1311  avi->stream_index = n;
1312  ast->packet_size = size + 8;
1313  ast->remaining = size;
1314 
1315  if (size) {
1316  uint64_t pos = avio_tell(pb) - 8;
1317  if (!st->index_entries || !st->nb_index_entries ||
1318  st->index_entries[st->nb_index_entries - 1].pos < pos) {
1319  av_add_index_entry(st, pos, ast->frame_offset, size,
1320  0, AVINDEX_KEYFRAME);
1321  }
1322  }
1323  return 0;
1324  }
1325  }
1326  }
1327 
1328  if (pb->error)
1329  return pb->error;
1330  return AVERROR_EOF;
1331 }
1332 
1334 {
1335  AVIContext *avi = s->priv_data;
1336  int best_stream_index = 0;
1337  AVStream *best_st = NULL;
1338  AVIStream *best_ast;
1339  int64_t best_ts = INT64_MAX;
1340  int i;
1341 
1342  for (i = 0; i < s->nb_streams; i++) {
1343  AVStream *st = s->streams[i];
1344  AVIStream *ast = st->priv_data;
1345  int64_t ts = ast->frame_offset;
1346  int64_t last_ts;
1347 
1348  if (!st->nb_index_entries)
1349  continue;
1350 
1351  last_ts = st->index_entries[st->nb_index_entries - 1].timestamp;
1352  if (!ast->remaining && ts > last_ts)
1353  continue;
1354 
1355  ts = av_rescale_q(ts, st->time_base,
1356  (AVRational) { FFMAX(1, ast->sample_size),
1357  AV_TIME_BASE });
1358 
1359  av_log(s, AV_LOG_TRACE, "%"PRId64" %d/%d %"PRId64"\n", ts,
1360  st->time_base.num, st->time_base.den, ast->frame_offset);
1361  if (ts < best_ts) {
1362  best_ts = ts;
1363  best_st = st;
1364  best_stream_index = i;
1365  }
1366  }
1367  if (!best_st)
1368  return AVERROR_EOF;
1369 
1370  best_ast = best_st->priv_data;
1371  best_ts = best_ast->frame_offset;
1372  if (best_ast->remaining) {
1373  i = av_index_search_timestamp(best_st,
1374  best_ts,
1375  AVSEEK_FLAG_ANY |
1377  } else {
1378  i = av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY);
1379  if (i >= 0)
1380  best_ast->frame_offset = best_st->index_entries[i].timestamp;
1381  }
1382 
1383  if (i >= 0) {
1384  int64_t pos = best_st->index_entries[i].pos;
1385  pos += best_ast->packet_size - best_ast->remaining;
1386  if (avio_seek(s->pb, pos + 8, SEEK_SET) < 0)
1387  return AVERROR_EOF;
1388 
1389  av_assert0(best_ast->remaining <= best_ast->packet_size);
1390 
1391  avi->stream_index = best_stream_index;
1392  if (!best_ast->remaining)
1393  best_ast->packet_size =
1394  best_ast->remaining = best_st->index_entries[i].size;
1395  }
1396  else
1397  return AVERROR_EOF;
1398 
1399  return 0;
1400 }
1401 
1403 {
1404  AVIContext *avi = s->priv_data;
1405  AVIOContext *pb = s->pb;
1406  int err;
1407 
1408  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1409  int size = avpriv_dv_get_packet(avi->dv_demux, pkt);
1410  if (size >= 0)
1411  return size;
1412  else
1413  goto resync;
1414  }
1415 
1416  if (avi->non_interleaved) {
1417  err = ni_prepare_read(s);
1418  if (err < 0)
1419  return err;
1420  }
1421 
1422 resync:
1423  if (avi->stream_index >= 0) {
1424  AVStream *st = s->streams[avi->stream_index];
1425  AVIStream *ast = st->priv_data;
1426  int size, err;
1427 
1428  if (get_subtitle_pkt(s, st, pkt))
1429  return 0;
1430 
1431  // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM
1432  if (ast->sample_size <= 1)
1433  size = INT_MAX;
1434  else if (ast->sample_size < 32)
1435  // arbitrary multiplier to avoid tiny packets for raw PCM data
1436  size = 1024 * ast->sample_size;
1437  else
1438  size = ast->sample_size;
1439 
1440  if (size > ast->remaining)
1441  size = ast->remaining;
1442  avi->last_pkt_pos = avio_tell(pb);
1443  err = av_get_packet(pb, pkt, size);
1444  if (err < 0)
1445  return err;
1446  size = err;
1447 
1448  if (ast->has_pal && pkt->size < (unsigned)INT_MAX / 2) {
1449  uint8_t *pal;
1450  pal = av_packet_new_side_data(pkt,
1452  AVPALETTE_SIZE);
1453  if (!pal) {
1454  av_log(s, AV_LOG_ERROR,
1455  "Failed to allocate data for palette\n");
1456  } else {
1457  memcpy(pal, ast->pal, AVPALETTE_SIZE);
1458  ast->has_pal = 0;
1459  }
1460  }
1461 
1462  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1463  AVBufferRef *avbuf = pkt->buf;
1464  size = avpriv_dv_produce_packet(avi->dv_demux, pkt,
1465  pkt->data, pkt->size, pkt->pos);
1466  pkt->buf = avbuf;
1467  pkt->flags |= AV_PKT_FLAG_KEY;
1468  if (size < 0)
1469  av_packet_unref(pkt);
1470  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE &&
1471  !st->codecpar->codec_tag && read_gab2_sub(s, st, pkt)) {
1472  ast->frame_offset++;
1473  avi->stream_index = -1;
1474  ast->remaining = 0;
1475  goto resync;
1476  } else {
1477  /* XXX: How to handle B-frames in AVI? */
1478  pkt->dts = ast->frame_offset;
1479 // pkt->dts += ast->start;
1480  if (ast->sample_size)
1481  pkt->dts /= ast->sample_size;
1482  pkt->stream_index = avi->stream_index;
1483 
1484  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->index_entries) {
1485  AVIndexEntry *e;
1486  int index;
1487 
1489  e = &st->index_entries[index];
1490 
1491  if (index >= 0 && e->timestamp == ast->frame_offset) {
1492  if (index == st->nb_index_entries-1) {
1493  int key=1;
1494  uint32_t state=-1;
1495  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4) {
1496  const uint8_t *ptr = pkt->data, *end = ptr + FFMIN(size, 256);
1497  while (ptr < end) {
1498  ptr = avpriv_find_start_code(ptr, end, &state);
1499  if (state == 0x1B6 && ptr < end) {
1500  key = !(*ptr & 0xC0);
1501  break;
1502  }
1503  }
1504  }
1505  if (!key)
1506  e->flags &= ~AVINDEX_KEYFRAME;
1507  }
1508  if (e->flags & AVINDEX_KEYFRAME)
1509  pkt->flags |= AV_PKT_FLAG_KEY;
1510  }
1511  } else {
1512  pkt->flags |= AV_PKT_FLAG_KEY;
1513  }
1514  ast->frame_offset += get_duration(ast, pkt->size);
1515  }
1516  ast->remaining -= err;
1517  if (!ast->remaining) {
1518  avi->stream_index = -1;
1519  ast->packet_size = 0;
1520  }
1521 
1522  if (!avi->non_interleaved && pkt->pos >= 0 && ast->seek_pos > pkt->pos) {
1523  av_packet_unref(pkt);
1524  goto resync;
1525  }
1526  ast->seek_pos= 0;
1527 
1528  if (!avi->non_interleaved && st->nb_index_entries>1 && avi->index_loaded>1) {
1529  int64_t dts= av_rescale_q(pkt->dts, st->time_base, AV_TIME_BASE_Q);
1530 
1531  if (avi->dts_max - dts > 2*AV_TIME_BASE) {
1532  avi->non_interleaved= 1;
1533  av_log(s, AV_LOG_INFO, "Switching to NI mode, due to poor interleaving\n");
1534  }else if (avi->dts_max < dts)
1535  avi->dts_max = dts;
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_freep(&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:230
static AVStream * get_subtitle_pkt(AVFormatContext *s, AVStream *next_st, AVPacket *pkt)
Definition: avidec.c:1132
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2511
#define ff_tlog(ctx,...)
Definition: internal.h:75
#define NULL
Definition: coverity.c:32
full parsing and interpolation of timestamps for frames not starting on a packet boundary ...
Definition: avformat.h:802
uint32_t handler
Definition: avidec.c:48
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:339
uint32_t pal[256]
Definition: avidec.c:57
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:2039
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3131
AVFormatContext * sub_ctx
Definition: avidec.c:62
#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:84
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1497
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:4892
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:810
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2513
int64_t last_pkt_pos
Definition: avidec.c:76
uint32_t rate
Definition: avidec.c:50
#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:3957
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:943
int dshow_block_align
Definition: avidec.c:59
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:882
int size
Definition: avcodec.h:1478
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:460
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1110
int is_odml
Definition: avidec.c:78
enum AVMediaType codec_type
Definition: rtp.c:37
int64_t movi_end
Definition: avidec.c:72
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:49
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:124
void * priv_data
Definition: avformat.h:896
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:334
#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:811
static AVPacket pkt
static int ni_prepare_read(AVFormatContext *s)
Definition: avidec.c:1333
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:112
static struct @315 state
uint8_t base
Definition: vp3data.h:202
Format I/O context.
Definition: avformat.h:1358
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:1491
Public dictionary API.
int stream_index
Definition: avidec.c:80
uint8_t
static int nb_streams
Definition: ffprobe.c:280
#define av_malloc(s)
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: avcodec.h:4023
AVOptions.
static int avi_read_close(AVFormatContext *s)
Definition: avidec.c:1900
int64_t riff_end
Definition: avidec.c:71
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:803
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:83
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
enum AVStreamParseType need_parsing
Definition: avformat.h:1099
int id
Format-specific stream ID.
Definition: avformat.h:888
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int64_t movi_list
Definition: avidec.c:75
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4465
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
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:267
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:1489
DVDemuxContext * avpriv_dv_init_demux(AVFormatContext *s)
Definition: dv.c:324
uint8_t * data
Definition: avcodec.h:1477
static int read_gab2_sub(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: avidec.c:1063
uint32_t tag
Definition: movenc.c:1496
#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:310
#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:650
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:3986
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
int packet_size
Definition: avidec.c:46
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:549
#define AVIF_MUSTUSEINDEX
Definition: avi.h:25
#define AVINDEX_KEYFRAME
Definition: avformat.h:817
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:131
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:2021
#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:1598
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: avcodec.h:1190
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2154
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:772
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
int remaining
Definition: avidec.c:45
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:811
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#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:565
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1460
static int avi_read_tag(AVFormatContext *s, AVStream *st, uint32_t tag, uint32_t size)
Definition: avidec.c:295
simple assert() macros that are a bit more flexible than ISO C assert().
static int get_stream_idx(const unsigned *d)
Definition: avidec.c:1166
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:954
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:120
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3975
Only parse headers, do not repack.
Definition: avformat.h:801
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:641
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1414
int prefix_count
Definition: avidec.c:56
int non_interleaved
Definition: avidec.c:79
int block_align
Audio only.
Definition: avcodec.h:4074
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
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:54
static int avi_read_header(AVFormatContext *s)
Definition: avidec.c:466
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
static const char months[12][4]
Definition: avidec.c:319
#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:384
#define AVFMT_FLAG_SORT_DTS
try to interleave outputted packets by dts (using this flag can slow demuxing down) ...
Definition: avformat.h:1510
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2705
int n
Definition: avisynth_c.h:760
AVDictionary * metadata
Definition: avformat.h:945
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
static void error(const char *err)
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
Read a transport packet from a media file.
Definition: utils.c:831
static int calculate_bitrate(AVFormatContext *s)
Definition: avidec.c:422
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
if(ret)
Stream structure.
Definition: avformat.h:881
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:103
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:1402
int prefix
Definition: avidec.c:55
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:163
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1238
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:1400
static int resync(AVFormatContext *s)
Definition: flvdec.c:949
int index_loaded
Definition: avidec.c:77
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:599
double(* duration_error)[2][MAX_STD_TIMEBASES]
Definition: avformat.h:1049
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:1112
static const AVOption options[]
Definition: avidec.c:89
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:277
byte swapping routines
discard useless packets like 0 size packets in avi
Definition: avcodec.h:806
#define snprintf
Definition: snprintf.h:34
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:456
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:446
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:2535
const AVMetadataConv ff_riff_info_conv[]
Definition: riff.c:578
int64_t seek_pos
Definition: avidec.c:66
#define flags(name, subs,...)
Definition: cbs_av1.c:561
struct AVStream::@249 * info
Stream information used internally by avformat_find_stream_info()
static int avi_load_index(AVFormatContext *s)
Definition: avidec.c:1733
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVInputFormat ff_avi_demuxer
Definition: avidec.c:1936
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:930
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:458
int64_t io_fsize
Definition: avidec.c:74
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:94
full parsing and repack
Definition: avformat.h:800
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:756
Main libavformat public API header.
static void avi_read_nikon(AVFormatContext *s, uint64_t end)
Definition: avidec.c:341
static void avi_metadata_creation_time(AVDictionary **metadata, char *date)
Definition: avidec.c:322
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
AVPacket sub_pkt
Definition: avidec.c:63
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:920
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1625
static int get_riff(AVFormatContext *s, AVIOContext *pb)
Definition: avidec.c:134
void avio_context_free(AVIOContext **s)
Free the supplied IO context and everything associated with it.
Definition: aviobuf.c:148
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:3312
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:932
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:211
int sample_size
Definition: avidec.c:51
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4437
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:790
#define av_free(p)
char * value
Definition: dict.h:87
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int len
int has_pal
Definition: avidec.c:58
static int guess_ni_flag(AVFormatContext *s)
Definition: avidec.c:1691
void * priv_data
Format private data.
Definition: avformat.h:1386
#define print_tag(str, tag, size)
Definition: avidec.c:120
int64_t frame_offset
Definition: avidec.c:43
int64_t dts_max
Definition: avidec.c:85
int64_t fsize
Definition: avidec.c:73
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: avcodec.h:3999
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3971
AVCodecContext * avctx
The codec context used by avformat_find_stream_info, the parser, etc.
Definition: internal.h:172
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1476
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:1473
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:654
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:361
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3961
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:1479
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:910
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:159
#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:936
int odml_depth
Definition: avidec.c:82
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: avformat.h:1139
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1454
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:780
static int avi_sync(AVFormatContext *s, int exit_early)
Definition: avidec.c:1180
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:64
DVDemuxContext * dv_demux
Definition: avidec.c:81