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(s, str, tag, size) \
121  av_log(s, 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  av_freep(&value);
311  return AVERROR_INVALIDDATA;
312  }
313  value[size] = 0;
314 
315  AV_WL32(key, tag);
316 
317  return av_dict_set(st ? &st->metadata : &s->metadata, key, value,
319 }
320 
321 static const char months[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
322  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
323 
324 static void avi_metadata_creation_time(AVDictionary **metadata, char *date)
325 {
326  char month[4], time[9], buffer[64];
327  int i, day, year;
328  /* parse standard AVI date format (ie. "Mon Mar 10 15:04:43 2003") */
329  if (sscanf(date, "%*3s%*[ ]%3s%*[ ]%2d%*[ ]%8s%*[ ]%4d",
330  month, &day, time, &year) == 4) {
331  for (i = 0; i < 12; i++)
332  if (!av_strcasecmp(month, months[i])) {
333  snprintf(buffer, sizeof(buffer), "%.4d-%.2d-%.2d %s",
334  year, i + 1, day, time);
335  av_dict_set(metadata, "creation_time", buffer, 0);
336  }
337  } else if (date[4] == '/' && date[7] == '/') {
338  date[4] = date[7] = '-';
339  av_dict_set(metadata, "creation_time", date, 0);
340  }
341 }
342 
343 static void avi_read_nikon(AVFormatContext *s, uint64_t end)
344 {
345  while (avio_tell(s->pb) < end && !avio_feof(s->pb)) {
346  uint32_t tag = avio_rl32(s->pb);
347  uint32_t size = avio_rl32(s->pb);
348  switch (tag) {
349  case MKTAG('n', 'c', 't', 'g'): /* Nikon Tags */
350  {
351  uint64_t tag_end = avio_tell(s->pb) + size;
352  while (avio_tell(s->pb) < tag_end && !avio_feof(s->pb)) {
353  uint16_t tag = avio_rl16(s->pb);
354  uint16_t size = avio_rl16(s->pb);
355  const char *name = NULL;
356  char buffer[64] = { 0 };
357  size = FFMIN(size, tag_end - avio_tell(s->pb));
358  size -= avio_read(s->pb, buffer,
359  FFMIN(size, sizeof(buffer) - 1));
360  switch (tag) {
361  case 0x03:
362  name = "maker";
363  break;
364  case 0x04:
365  name = "model";
366  break;
367  case 0x13:
368  name = "creation_time";
369  if (buffer[4] == ':' && buffer[7] == ':')
370  buffer[4] = buffer[7] = '-';
371  break;
372  }
373  if (name)
374  av_dict_set(&s->metadata, name, buffer, 0);
375  avio_skip(s->pb, size);
376  }
377  break;
378  }
379  default:
380  avio_skip(s->pb, size);
381  break;
382  }
383  }
384 }
385 
387 {
388  GetByteContext gb;
389  uint8_t *data = st->codecpar->extradata;
390  int data_size = st->codecpar->extradata_size;
391  int tag, offset;
392 
393  if (!data || data_size < 8) {
394  return AVERROR_INVALIDDATA;
395  }
396 
397  bytestream2_init(&gb, data, data_size);
398 
399  tag = bytestream2_get_le32(&gb);
400 
401  switch (tag) {
402  case MKTAG('A', 'V', 'I', 'F'):
403  // skip 4 byte padding
404  bytestream2_skip(&gb, 4);
405  offset = bytestream2_tell(&gb);
406 
407  // decode EXIF tags from IFD, AVI is always little-endian
408  return avpriv_exif_decode_ifd(s, data + offset, data_size - offset,
409  1, 0, &st->metadata);
410  break;
411  case MKTAG('C', 'A', 'S', 'I'):
412  avpriv_request_sample(s, "RIFF stream data tag type CASI (%u)", tag);
413  break;
414  case MKTAG('Z', 'o', 'r', 'a'):
415  avpriv_request_sample(s, "RIFF stream data tag type Zora (%u)", tag);
416  break;
417  default:
418  break;
419  }
420 
421  return 0;
422 }
423 
425 {
426  AVIContext *avi = s->priv_data;
427  int i, j;
428  int64_t lensum = 0;
429  int64_t maxpos = 0;
430 
431  for (i = 0; i<s->nb_streams; i++) {
432  int64_t len = 0;
433  AVStream *st = s->streams[i];
434 
435  if (!st->nb_index_entries)
436  continue;
437 
438  for (j = 0; j < st->nb_index_entries; j++)
439  len += st->index_entries[j].size;
440  maxpos = FFMAX(maxpos, st->index_entries[j-1].pos);
441  lensum += len;
442  }
443  if (maxpos < avi->io_fsize*9/10) // index does not cover the whole file
444  return 0;
445  if (lensum*9/10 > maxpos || lensum < maxpos*9/10) // frame sum and filesize mismatch
446  return 0;
447 
448  for (i = 0; i<s->nb_streams; i++) {
449  int64_t len = 0;
450  AVStream *st = s->streams[i];
451  int64_t duration;
452  int64_t bitrate;
453 
454  for (j = 0; j < st->nb_index_entries; j++)
455  len += st->index_entries[j].size;
456 
457  if (st->nb_index_entries < 2 || st->codecpar->bit_rate > 0)
458  continue;
459  duration = st->index_entries[j-1].timestamp - st->index_entries[0].timestamp;
460  bitrate = av_rescale(8*len, st->time_base.den, duration * st->time_base.num);
461  if (bitrate > 0) {
462  st->codecpar->bit_rate = bitrate;
463  }
464  }
465  return 1;
466 }
467 
469 {
470  AVIContext *avi = s->priv_data;
471  AVIOContext *pb = s->pb;
472  unsigned int tag, tag1, handler;
473  int codec_type, stream_index, frame_period;
474  unsigned int size;
475  int i;
476  AVStream *st;
477  AVIStream *ast = NULL;
478  int avih_width = 0, avih_height = 0;
479  int amv_file_format = 0;
480  uint64_t list_end = 0;
481  int64_t pos;
482  int ret;
483  AVDictionaryEntry *dict_entry;
484 
485  avi->stream_index = -1;
486 
487  ret = get_riff(s, pb);
488  if (ret < 0)
489  return ret;
490 
491  av_log(avi, AV_LOG_DEBUG, "use odml:%d\n", avi->use_odml);
492 
493  avi->io_fsize = avi->fsize = avio_size(pb);
494  if (avi->fsize <= 0 || avi->fsize < avi->riff_end)
495  avi->fsize = avi->riff_end == 8 ? INT64_MAX : avi->riff_end;
496 
497  /* first list tag */
498  stream_index = -1;
499  codec_type = -1;
500  frame_period = 0;
501  for (;;) {
502  if (avio_feof(pb))
503  goto fail;
504  tag = avio_rl32(pb);
505  size = avio_rl32(pb);
506 
507  print_tag(s, "tag", tag, size);
508 
509  switch (tag) {
510  case MKTAG('L', 'I', 'S', 'T'):
511  list_end = avio_tell(pb) + size;
512  /* Ignored, except at start of video packets. */
513  tag1 = avio_rl32(pb);
514 
515  print_tag(s, "list", tag1, 0);
516 
517  if (tag1 == MKTAG('m', 'o', 'v', 'i')) {
518  avi->movi_list = avio_tell(pb) - 4;
519  if (size)
520  avi->movi_end = avi->movi_list + size + (size & 1);
521  else
522  avi->movi_end = avi->fsize;
523  av_log(s, AV_LOG_TRACE, "movi end=%"PRIx64"\n", avi->movi_end);
524  goto end_of_header;
525  } else if (tag1 == MKTAG('I', 'N', 'F', 'O'))
526  ff_read_riff_info(s, size - 4);
527  else if (tag1 == MKTAG('n', 'c', 'd', 't'))
528  avi_read_nikon(s, list_end);
529 
530  break;
531  case MKTAG('I', 'D', 'I', 'T'):
532  {
533  unsigned char date[64] = { 0 };
534  size += (size & 1);
535  size -= avio_read(pb, date, FFMIN(size, sizeof(date) - 1));
536  avio_skip(pb, size);
538  break;
539  }
540  case MKTAG('d', 'm', 'l', 'h'):
541  avi->is_odml = 1;
542  avio_skip(pb, size + (size & 1));
543  break;
544  case MKTAG('a', 'm', 'v', 'h'):
545  amv_file_format = 1;
546  case MKTAG('a', 'v', 'i', 'h'):
547  /* AVI header */
548  /* using frame_period is bad idea */
549  frame_period = avio_rl32(pb);
550  avio_rl32(pb); /* max. bytes per second */
551  avio_rl32(pb);
553 
554  avio_skip(pb, 2 * 4);
555  avio_rl32(pb);
556  avio_rl32(pb);
557  avih_width = avio_rl32(pb);
558  avih_height = avio_rl32(pb);
559 
560  avio_skip(pb, size - 10 * 4);
561  break;
562  case MKTAG('s', 't', 'r', 'h'):
563  /* stream header */
564 
565  tag1 = avio_rl32(pb);
566  handler = avio_rl32(pb); /* codec tag */
567 
568  if (tag1 == MKTAG('p', 'a', 'd', 's')) {
569  avio_skip(pb, size - 8);
570  break;
571  } else {
572  stream_index++;
573  st = avformat_new_stream(s, NULL);
574  if (!st)
575  goto fail;
576 
577  st->id = stream_index;
578  ast = av_mallocz(sizeof(AVIStream));
579  if (!ast)
580  goto fail;
581  st->priv_data = ast;
582  }
583  if (amv_file_format)
584  tag1 = stream_index ? MKTAG('a', 'u', 'd', 's')
585  : MKTAG('v', 'i', 'd', 's');
586 
587  print_tag(s, "strh", tag1, -1);
588 
589  if (tag1 == MKTAG('i', 'a', 'v', 's') ||
590  tag1 == MKTAG('i', 'v', 'a', 's')) {
591  int64_t dv_dur;
592 
593  /* After some consideration -- I don't think we
594  * have to support anything but DV in type1 AVIs. */
595  if (s->nb_streams != 1)
596  goto fail;
597 
598  if (handler != MKTAG('d', 'v', 's', 'd') &&
599  handler != MKTAG('d', 'v', 'h', 'd') &&
600  handler != MKTAG('d', 'v', 's', 'l'))
601  goto fail;
602 
603  ast = s->streams[0]->priv_data;
605  av_freep(&s->streams[0]->codecpar);
606 #if FF_API_LAVF_AVCTX
608  av_freep(&s->streams[0]->codec);
610 #endif
611  if (s->streams[0]->info)
613  av_freep(&s->streams[0]->info);
614  if (s->streams[0]->internal)
615  av_freep(&s->streams[0]->internal->avctx);
616  av_freep(&s->streams[0]->internal);
617  av_freep(&s->streams[0]);
618  s->nb_streams = 0;
619  if (CONFIG_DV_DEMUXER) {
620  avi->dv_demux = avpriv_dv_init_demux(s);
621  if (!avi->dv_demux)
622  goto fail;
623  } else
624  goto fail;
625  s->streams[0]->priv_data = ast;
626  avio_skip(pb, 3 * 4);
627  ast->scale = avio_rl32(pb);
628  ast->rate = avio_rl32(pb);
629  avio_skip(pb, 4); /* start time */
630 
631  dv_dur = avio_rl32(pb);
632  if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) {
633  dv_dur *= AV_TIME_BASE;
634  s->duration = av_rescale(dv_dur, ast->scale, ast->rate);
635  }
636  /* else, leave duration alone; timing estimation in utils.c
637  * will make a guess based on bitrate. */
638 
639  stream_index = s->nb_streams - 1;
640  avio_skip(pb, size - 9 * 4);
641  break;
642  }
643 
644  av_assert0(stream_index < s->nb_streams);
645  ast->handler = handler;
646 
647  avio_rl32(pb); /* flags */
648  avio_rl16(pb); /* priority */
649  avio_rl16(pb); /* language */
650  avio_rl32(pb); /* initial frame */
651  ast->scale = avio_rl32(pb);
652  ast->rate = avio_rl32(pb);
653  if (!(ast->scale && ast->rate)) {
655  "scale/rate is %"PRIu32"/%"PRIu32" which is invalid. "
656  "(This file has been generated by broken software.)\n",
657  ast->scale,
658  ast->rate);
659  if (frame_period) {
660  ast->rate = 1000000;
661  ast->scale = frame_period;
662  } else {
663  ast->rate = 25;
664  ast->scale = 1;
665  }
666  }
667  avpriv_set_pts_info(st, 64, ast->scale, ast->rate);
668 
669  ast->cum_len = avio_rl32(pb); /* start */
670  st->nb_frames = avio_rl32(pb);
671 
672  st->start_time = 0;
673  avio_rl32(pb); /* buffer size */
674  avio_rl32(pb); /* quality */
675  if (ast->cum_len > 3600LL * ast->rate / ast->scale) {
676  av_log(s, AV_LOG_ERROR, "crazy start time, iam scared, giving up\n");
677  ast->cum_len = 0;
678  }
679  ast->sample_size = avio_rl32(pb);
680  ast->cum_len *= FFMAX(1, ast->sample_size);
681  av_log(s, AV_LOG_TRACE, "%"PRIu32" %"PRIu32" %d\n",
682  ast->rate, ast->scale, ast->sample_size);
683 
684  switch (tag1) {
685  case MKTAG('v', 'i', 'd', 's'):
686  codec_type = AVMEDIA_TYPE_VIDEO;
687 
688  ast->sample_size = 0;
689  st->avg_frame_rate = av_inv_q(st->time_base);
690  break;
691  case MKTAG('a', 'u', 'd', 's'):
692  codec_type = AVMEDIA_TYPE_AUDIO;
693  break;
694  case MKTAG('t', 'x', 't', 's'):
695  codec_type = AVMEDIA_TYPE_SUBTITLE;
696  break;
697  case MKTAG('d', 'a', 't', 's'):
698  codec_type = AVMEDIA_TYPE_DATA;
699  break;
700  default:
701  av_log(s, AV_LOG_INFO, "unknown stream type %X\n", tag1);
702  }
703 
704  if (ast->sample_size < 0) {
705  if (s->error_recognition & AV_EF_EXPLODE) {
706  av_log(s, AV_LOG_ERROR,
707  "Invalid sample_size %d at stream %d\n",
708  ast->sample_size,
709  stream_index);
710  goto fail;
711  }
713  "Invalid sample_size %d at stream %d "
714  "setting it to 0\n",
715  ast->sample_size,
716  stream_index);
717  ast->sample_size = 0;
718  }
719 
720  if (ast->sample_size == 0) {
721  st->duration = st->nb_frames;
722  if (st->duration > 0 && avi->io_fsize > 0 && avi->riff_end > avi->io_fsize) {
723  av_log(s, AV_LOG_DEBUG, "File is truncated adjusting duration\n");
724  st->duration = av_rescale(st->duration, avi->io_fsize, avi->riff_end);
725  }
726  }
727  ast->frame_offset = ast->cum_len;
728  avio_skip(pb, size - 12 * 4);
729  break;
730  case MKTAG('s', 't', 'r', 'f'):
731  /* stream header */
732  if (!size && (codec_type == AVMEDIA_TYPE_AUDIO ||
733  codec_type == AVMEDIA_TYPE_VIDEO))
734  break;
735  if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) {
736  avio_skip(pb, size);
737  } else {
738  uint64_t cur_pos = avio_tell(pb);
739  unsigned esize;
740  if (cur_pos < list_end)
741  size = FFMIN(size, list_end - cur_pos);
742  st = s->streams[stream_index];
744  avio_skip(pb, size);
745  break;
746  }
747  switch (codec_type) {
748  case AVMEDIA_TYPE_VIDEO:
749  if (amv_file_format) {
750  st->codecpar->width = avih_width;
751  st->codecpar->height = avih_height;
754  avio_skip(pb, size);
755  break;
756  }
757  tag1 = ff_get_bmp_header(pb, st, &esize);
758 
759  if (tag1 == MKTAG('D', 'X', 'S', 'B') ||
760  tag1 == MKTAG('D', 'X', 'S', 'A')) {
762  st->codecpar->codec_tag = tag1;
764  break;
765  }
766 
767  if (size > 10 * 4 && size < (1 << 30) && size < avi->fsize) {
768  if (esize == size-1 && (esize&1)) {
769  st->codecpar->extradata_size = esize - 10 * 4;
770  } else
771  st->codecpar->extradata_size = size - 10 * 4;
772  if (st->codecpar->extradata) {
773  av_log(s, AV_LOG_WARNING, "New extradata in strf chunk, freeing previous one.\n");
774  av_freep(&st->codecpar->extradata);
775  }
776  if (ff_get_extradata(s, st->codecpar, pb, st->codecpar->extradata_size) < 0)
777  return AVERROR(ENOMEM);
778  }
779 
780  // FIXME: check if the encoder really did this correctly
781  if (st->codecpar->extradata_size & 1)
782  avio_r8(pb);
783 
784  /* Extract palette from extradata if bpp <= 8.
785  * This code assumes that extradata contains only palette.
786  * This is true for all paletted codecs implemented in
787  * FFmpeg. */
788  if (st->codecpar->extradata_size &&
789  (st->codecpar->bits_per_coded_sample <= 8)) {
790  int pal_size = (1 << st->codecpar->bits_per_coded_sample) << 2;
791  const uint8_t *pal_src;
792 
793  pal_size = FFMIN(pal_size, st->codecpar->extradata_size);
794  pal_src = st->codecpar->extradata +
795  st->codecpar->extradata_size - pal_size;
796  /* Exclude the "BottomUp" field from the palette */
797  if (pal_src - st->codecpar->extradata >= 9 &&
798  !memcmp(st->codecpar->extradata + st->codecpar->extradata_size - 9, "BottomUp", 9))
799  pal_src -= 9;
800  for (i = 0; i < pal_size / 4; i++)
801  ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src + 4 * i);
802  ast->has_pal = 1;
803  }
804 
805  print_tag(s, "video", tag1, 0);
806 
808  st->codecpar->codec_tag = tag1;
810  tag1);
811  /* If codec is not found yet, try with the mov tags. */
812  if (!st->codecpar->codec_id) {
813  st->codecpar->codec_id =
815  if (st->codecpar->codec_id)
817  "mov tag found in avi (fourcc %s)\n",
818  av_fourcc2str(tag1));
819  }
820  if (!st->codecpar->codec_id)
822 
823  /* This is needed to get the pict type which is necessary
824  * for generating correct pts. */
826 
827  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4 &&
828  ast->handler == MKTAG('X', 'V', 'I', 'D'))
829  st->codecpar->codec_tag = MKTAG('X', 'V', 'I', 'D');
830 
831  if (st->codecpar->codec_tag == MKTAG('V', 'S', 'S', 'H'))
833  if (st->codecpar->codec_id == AV_CODEC_ID_RV40)
835 
836  if (st->codecpar->codec_tag == 0 && st->codecpar->height > 0 &&
837  st->codecpar->extradata_size < 1U << 30) {
838  st->codecpar->extradata_size += 9;
839  if ((ret = av_reallocp(&st->codecpar->extradata,
840  st->codecpar->extradata_size +
842  st->codecpar->extradata_size = 0;
843  return ret;
844  } else
845  memcpy(st->codecpar->extradata + st->codecpar->extradata_size - 9,
846  "BottomUp", 9);
847  }
848  st->codecpar->height = FFABS(st->codecpar->height);
849 
850 // avio_skip(pb, size - 5 * 4);
851  break;
852  case AVMEDIA_TYPE_AUDIO:
853  ret = ff_get_wav_header(s, pb, st->codecpar, size, 0);
854  if (ret < 0)
855  return ret;
857  if (ast->sample_size && st->codecpar->block_align &&
858  ast->sample_size != st->codecpar->block_align) {
859  av_log(s,
861  "sample size (%d) != block align (%d)\n",
862  ast->sample_size,
863  st->codecpar->block_align);
864  ast->sample_size = st->codecpar->block_align;
865  }
866  /* 2-aligned
867  * (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
868  if (size & 1)
869  avio_skip(pb, 1);
870  /* Force parsing as several audio frames can be in
871  * one packet and timestamps refer to packet start. */
873  /* ADTS header is in extradata, AAC without header must be
874  * stored as exact frames. Parser not needed and it will
875  * fail. */
876  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
879  // The flac parser does not work with AVSTREAM_PARSE_TIMESTAMPS
880  if (st->codecpar->codec_id == AV_CODEC_ID_FLAC)
882  /* AVI files with Xan DPCM audio (wrongly) declare PCM
883  * audio in the header but have Axan as stream_code_tag. */
884  if (ast->handler == AV_RL32("Axan")) {
886  st->codecpar->codec_tag = 0;
887  ast->dshow_block_align = 0;
888  }
889  if (amv_file_format) {
891  ast->dshow_block_align = 0;
892  }
893  if ((st->codecpar->codec_id == AV_CODEC_ID_AAC ||
895  st->codecpar->codec_id == AV_CODEC_ID_MP2 ) && ast->dshow_block_align <= 4 && ast->dshow_block_align) {
896  av_log(s, AV_LOG_DEBUG, "overriding invalid dshow_block_align of %d\n", ast->dshow_block_align);
897  ast->dshow_block_align = 0;
898  }
899  if (st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 1024 && ast->sample_size == 1024 ||
900  st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 4096 && ast->sample_size == 4096 ||
901  st->codecpar->codec_id == AV_CODEC_ID_MP3 && ast->dshow_block_align == 1152 && ast->sample_size == 1152) {
902  av_log(s, AV_LOG_DEBUG, "overriding sample_size\n");
903  ast->sample_size = 0;
904  }
905  break;
908  st->request_probe= 1;
909  avio_skip(pb, size);
910  break;
911  default:
914  st->codecpar->codec_tag = 0;
915  avio_skip(pb, size);
916  break;
917  }
918  }
919  break;
920  case MKTAG('s', 't', 'r', 'd'):
921  if (stream_index >= (unsigned)s->nb_streams
922  || s->streams[stream_index]->codecpar->extradata_size
923  || s->streams[stream_index]->codecpar->codec_tag == MKTAG('H','2','6','4')) {
924  avio_skip(pb, size);
925  } else {
926  uint64_t cur_pos = avio_tell(pb);
927  if (cur_pos < list_end)
928  size = FFMIN(size, list_end - cur_pos);
929  st = s->streams[stream_index];
930 
931  if (size<(1<<30)) {
932  if (st->codecpar->extradata) {
933  av_log(s, AV_LOG_WARNING, "New extradata in strd chunk, freeing previous one.\n");
934  av_freep(&st->codecpar->extradata);
935  }
936  if (ff_get_extradata(s, st->codecpar, pb, size) < 0)
937  return AVERROR(ENOMEM);
938  }
939 
940  if (st->codecpar->extradata_size & 1) //FIXME check if the encoder really did this correctly
941  avio_r8(pb);
942 
943  ret = avi_extract_stream_metadata(s, st);
944  if (ret < 0) {
945  av_log(s, AV_LOG_WARNING, "could not decoding EXIF data in stream header.\n");
946  }
947  }
948  break;
949  case MKTAG('i', 'n', 'd', 'x'):
950  pos = avio_tell(pb);
951  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !(s->flags & AVFMT_FLAG_IGNIDX) &&
952  avi->use_odml &&
953  read_odml_index(s, 0) < 0 &&
955  goto fail;
956  avio_seek(pb, pos + size, SEEK_SET);
957  break;
958  case MKTAG('v', 'p', 'r', 'p'):
959  if (stream_index < (unsigned)s->nb_streams && size > 9 * 4) {
960  AVRational active, active_aspect;
961 
962  st = s->streams[stream_index];
963  avio_rl32(pb);
964  avio_rl32(pb);
965  avio_rl32(pb);
966  avio_rl32(pb);
967  avio_rl32(pb);
968 
969  active_aspect.den = avio_rl16(pb);
970  active_aspect.num = avio_rl16(pb);
971  active.num = avio_rl32(pb);
972  active.den = avio_rl32(pb);
973  avio_rl32(pb); // nbFieldsPerFrame
974 
975  if (active_aspect.num && active_aspect.den &&
976  active.num && active.den) {
977  st->sample_aspect_ratio = av_div_q(active_aspect, active);
978  av_log(s, AV_LOG_TRACE, "vprp %d/%d %d/%d\n",
979  active_aspect.num, active_aspect.den,
980  active.num, active.den);
981  }
982  size -= 9 * 4;
983  }
984  avio_skip(pb, size);
985  break;
986  case MKTAG('s', 't', 'r', 'n'):
987  if (s->nb_streams) {
988  ret = avi_read_tag(s, s->streams[s->nb_streams - 1], tag, size);
989  if (ret < 0)
990  return ret;
991  break;
992  }
993  default:
994  if (size > 1000000) {
995  av_log(s, AV_LOG_ERROR,
996  "Something went wrong during header parsing, "
997  "tag %s has size %u, "
998  "I will ignore it and try to continue anyway.\n",
999  av_fourcc2str(tag), size);
1001  goto fail;
1002  avi->movi_list = avio_tell(pb) - 4;
1003  avi->movi_end = avi->fsize;
1004  goto end_of_header;
1005  }
1006  /* Do not fail for very large idx1 tags */
1007  case MKTAG('i', 'd', 'x', '1'):
1008  /* skip tag */
1009  size += (size & 1);
1010  avio_skip(pb, size);
1011  break;
1012  }
1013  }
1014 
1015 end_of_header:
1016  /* check stream number */
1017  if (stream_index != s->nb_streams - 1) {
1018 
1019 fail:
1020  return AVERROR_INVALIDDATA;
1021  }
1022 
1023  if (!avi->index_loaded && (pb->seekable & AVIO_SEEKABLE_NORMAL))
1024  avi_load_index(s);
1025  calculate_bitrate(s);
1026  avi->index_loaded |= 1;
1027 
1028  if ((ret = guess_ni_flag(s)) < 0)
1029  return ret;
1030 
1031  avi->non_interleaved |= ret | (s->flags & AVFMT_FLAG_SORT_DTS);
1032 
1033  dict_entry = av_dict_get(s->metadata, "ISFT", NULL, 0);
1034  if (dict_entry && !strcmp(dict_entry->value, "PotEncoder"))
1035  for (i = 0; i < s->nb_streams; i++) {
1036  AVStream *st = s->streams[i];
1040  }
1041 
1042  for (i = 0; i < s->nb_streams; i++) {
1043  AVStream *st = s->streams[i];
1044  if (st->nb_index_entries)
1045  break;
1046  }
1047  // DV-in-AVI cannot be non-interleaved, if set this must be
1048  // a mis-detection.
1049  if (avi->dv_demux)
1050  avi->non_interleaved = 0;
1051  if (i == s->nb_streams && avi->non_interleaved) {
1053  "Non-interleaved AVI without index, switching to interleaved\n");
1054  avi->non_interleaved = 0;
1055  }
1056 
1057  if (avi->non_interleaved) {
1058  av_log(s, AV_LOG_INFO, "non-interleaved AVI\n");
1059  clean_index(s);
1060  }
1061 
1062  ff_metadata_conv_ctx(s, NULL, avi_metadata_conv);
1064 
1065  return 0;
1066 }
1067 
1069 {
1070  if (pkt->size >= 7 &&
1071  pkt->size < INT_MAX - AVPROBE_PADDING_SIZE &&
1072  !strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data + 5) == 2) {
1073  uint8_t desc[256];
1074  int score = AVPROBE_SCORE_EXTENSION, ret;
1075  AVIStream *ast = st->priv_data;
1076  ff_const59 AVInputFormat *sub_demuxer;
1077  AVRational time_base;
1078  int size;
1079  AVIOContext *pb = avio_alloc_context(pkt->data + 7,
1080  pkt->size - 7,
1081  0, NULL, NULL, NULL, NULL);
1082  AVProbeData pd;
1083  unsigned int desc_len = avio_rl32(pb);
1084 
1085  if (desc_len > pb->buf_end - pb->buf_ptr)
1086  goto error;
1087 
1088  ret = avio_get_str16le(pb, desc_len, desc, sizeof(desc));
1089  avio_skip(pb, desc_len - ret);
1090  if (*desc)
1091  av_dict_set(&st->metadata, "title", desc, 0);
1092 
1093  avio_rl16(pb); /* flags? */
1094  avio_rl32(pb); /* data size */
1095 
1096  size = pb->buf_end - pb->buf_ptr;
1097  pd = (AVProbeData) { .buf = av_mallocz(size + AVPROBE_PADDING_SIZE),
1098  .buf_size = size };
1099  if (!pd.buf)
1100  goto error;
1101  memcpy(pd.buf, pb->buf_ptr, size);
1102  sub_demuxer = av_probe_input_format2(&pd, 1, &score);
1103  av_freep(&pd.buf);
1104  if (!sub_demuxer)
1105  goto error;
1106 
1107  if (strcmp(sub_demuxer->name, "srt") && strcmp(sub_demuxer->name, "ass"))
1108  goto error;
1109 
1110  if (!(ast->sub_ctx = avformat_alloc_context()))
1111  goto error;
1112 
1113  ast->sub_ctx->pb = pb;
1114 
1115  if (ff_copy_whiteblacklists(ast->sub_ctx, s) < 0)
1116  goto error;
1117 
1118  if (!avformat_open_input(&ast->sub_ctx, "", sub_demuxer, NULL)) {
1119  if (ast->sub_ctx->nb_streams != 1)
1120  goto error;
1121  ff_read_packet(ast->sub_ctx, &ast->sub_pkt);
1123  time_base = ast->sub_ctx->streams[0]->time_base;
1124  avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
1125  }
1126  ast->sub_buffer = pkt->data;
1127  memset(pkt, 0, sizeof(*pkt));
1128  return 1;
1129 
1130 error:
1131  av_freep(&ast->sub_ctx);
1132  avio_context_free(&pb);
1133  }
1134  return 0;
1135 }
1136 
1138  AVPacket *pkt)
1139 {
1140  AVIStream *ast, *next_ast = next_st->priv_data;
1141  int64_t ts, next_ts, ts_min = INT64_MAX;
1142  AVStream *st, *sub_st = NULL;
1143  int i;
1144 
1145  next_ts = av_rescale_q(next_ast->frame_offset, next_st->time_base,
1146  AV_TIME_BASE_Q);
1147 
1148  for (i = 0; i < s->nb_streams; i++) {
1149  st = s->streams[i];
1150  ast = st->priv_data;
1151  if (st->discard < AVDISCARD_ALL && ast && ast->sub_pkt.data) {
1152  ts = av_rescale_q(ast->sub_pkt.dts, st->time_base, AV_TIME_BASE_Q);
1153  if (ts <= next_ts && ts < ts_min) {
1154  ts_min = ts;
1155  sub_st = st;
1156  }
1157  }
1158  }
1159 
1160  if (sub_st) {
1161  ast = sub_st->priv_data;
1162  *pkt = ast->sub_pkt;
1163  pkt->stream_index = sub_st->index;
1164 
1165  if (ff_read_packet(ast->sub_ctx, &ast->sub_pkt) < 0)
1166  ast->sub_pkt.data = NULL;
1167  }
1168  return sub_st;
1169 }
1170 
1171 static int get_stream_idx(const unsigned *d)
1172 {
1173  if (d[0] >= '0' && d[0] <= '9' &&
1174  d[1] >= '0' && d[1] <= '9') {
1175  return (d[0] - '0') * 10 + (d[1] - '0');
1176  } else {
1177  return 100; // invalid stream ID
1178  }
1179 }
1180 
1181 /**
1182  *
1183  * @param exit_early set to 1 to just gather packet position without making the changes needed to actually read & return the packet
1184  */
1185 static int avi_sync(AVFormatContext *s, int exit_early)
1186 {
1187  AVIContext *avi = s->priv_data;
1188  AVIOContext *pb = s->pb;
1189  int n;
1190  unsigned int d[8];
1191  unsigned int size;
1192  int64_t i, sync;
1193 
1194 start_sync:
1195  memset(d, -1, sizeof(d));
1196  for (i = sync = avio_tell(pb); !avio_feof(pb); i++) {
1197  int j;
1198 
1199  for (j = 0; j < 7; j++)
1200  d[j] = d[j + 1];
1201  d[7] = avio_r8(pb);
1202 
1203  size = d[4] + (d[5] << 8) + (d[6] << 16) + (d[7] << 24);
1204 
1205  n = get_stream_idx(d + 2);
1206  ff_tlog(s, "%X %X %X %X %X %X %X %X %"PRId64" %u %d\n",
1207  d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n);
1208  if (i*(avi->io_fsize>0) + (uint64_t)size > avi->fsize || d[0] > 127)
1209  continue;
1210 
1211  // parse ix##
1212  if ((d[0] == 'i' && d[1] == 'x' && n < s->nb_streams) ||
1213  // parse JUNK
1214  (d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K') ||
1215  (d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1') ||
1216  (d[0] == 'i' && d[1] == 'n' && d[2] == 'd' && d[3] == 'x')) {
1217  avio_skip(pb, size);
1218  goto start_sync;
1219  }
1220 
1221  // parse stray LIST
1222  if (d[0] == 'L' && d[1] == 'I' && d[2] == 'S' && d[3] == 'T') {
1223  avio_skip(pb, 4);
1224  goto start_sync;
1225  }
1226 
1227  n = get_stream_idx(d);
1228 
1229  if (!((i - avi->last_pkt_pos) & 1) &&
1230  get_stream_idx(d + 1) < s->nb_streams)
1231  continue;
1232 
1233  // detect ##ix chunk and skip
1234  if (d[2] == 'i' && d[3] == 'x' && n < s->nb_streams) {
1235  avio_skip(pb, size);
1236  goto start_sync;
1237  }
1238 
1239  if (d[2] == 'w' && d[3] == 'c' && n < s->nb_streams) {
1240  avio_skip(pb, 16 * 3 + 8);
1241  goto start_sync;
1242  }
1243 
1244  if (avi->dv_demux && n != 0)
1245  continue;
1246 
1247  // parse ##dc/##wb
1248  if (n < s->nb_streams) {
1249  AVStream *st;
1250  AVIStream *ast;
1251  st = s->streams[n];
1252  ast = st->priv_data;
1253 
1254  if (!ast) {
1255  av_log(s, AV_LOG_WARNING, "Skipping foreign stream %d packet\n", n);
1256  continue;
1257  }
1258 
1259  if (s->nb_streams >= 2) {
1260  AVStream *st1 = s->streams[1];
1261  AVIStream *ast1 = st1->priv_data;
1262  // workaround for broken small-file-bug402.avi
1263  if ( d[2] == 'w' && d[3] == 'b'
1264  && n == 0
1265  && st ->codecpar->codec_type == AVMEDIA_TYPE_VIDEO
1267  && ast->prefix == 'd'*256+'c'
1268  && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count)
1269  ) {
1270  n = 1;
1271  st = st1;
1272  ast = ast1;
1274  "Invalid stream + prefix combination, assuming audio.\n");
1275  }
1276  }
1277 
1278  if (d[2] == 'p' && d[3] == 'c' && size <= 4 * 256 + 4) {
1279  int k = avio_r8(pb);
1280  int last = (k + avio_r8(pb) - 1) & 0xFF;
1281 
1282  avio_rl16(pb); // flags
1283 
1284  // b + (g << 8) + (r << 16);
1285  for (; k <= last; k++)
1286  ast->pal[k] = 0xFFU<<24 | avio_rb32(pb)>>8;
1287 
1288  ast->has_pal = 1;
1289  goto start_sync;
1290  } else if (((ast->prefix_count < 5 || sync + 9 > i) &&
1291  d[2] < 128 && d[3] < 128) ||
1292  d[2] * 256 + d[3] == ast->prefix /* ||
1293  (d[2] == 'd' && d[3] == 'c') ||
1294  (d[2] == 'w' && d[3] == 'b') */) {
1295  if (exit_early)
1296  return 0;
1297  if (d[2] * 256 + d[3] == ast->prefix)
1298  ast->prefix_count++;
1299  else {
1300  ast->prefix = d[2] * 256 + d[3];
1301  ast->prefix_count = 0;
1302  }
1303 
1304  if (!avi->dv_demux &&
1305  ((st->discard >= AVDISCARD_DEFAULT && size == 0) /* ||
1306  // FIXME: needs a little reordering
1307  (st->discard >= AVDISCARD_NONKEY &&
1308  !(pkt->flags & AV_PKT_FLAG_KEY)) */
1309  || st->discard >= AVDISCARD_ALL)) {
1310 
1311  ast->frame_offset += get_duration(ast, size);
1312  avio_skip(pb, size);
1313  goto start_sync;
1314  }
1315 
1316  avi->stream_index = n;
1317  ast->packet_size = size + 8;
1318  ast->remaining = size;
1319 
1320  if (size) {
1321  uint64_t pos = avio_tell(pb) - 8;
1322  if (!st->index_entries || !st->nb_index_entries ||
1323  st->index_entries[st->nb_index_entries - 1].pos < pos) {
1324  av_add_index_entry(st, pos, ast->frame_offset, size,
1325  0, AVINDEX_KEYFRAME);
1326  }
1327  }
1328  return 0;
1329  }
1330  }
1331  }
1332 
1333  if (pb->error)
1334  return pb->error;
1335  return AVERROR_EOF;
1336 }
1337 
1339 {
1340  AVIContext *avi = s->priv_data;
1341  int best_stream_index = 0;
1342  AVStream *best_st = NULL;
1343  AVIStream *best_ast;
1344  int64_t best_ts = INT64_MAX;
1345  int i;
1346 
1347  for (i = 0; i < s->nb_streams; i++) {
1348  AVStream *st = s->streams[i];
1349  AVIStream *ast = st->priv_data;
1350  int64_t ts = ast->frame_offset;
1351  int64_t last_ts;
1352 
1353  if (!st->nb_index_entries)
1354  continue;
1355 
1356  last_ts = st->index_entries[st->nb_index_entries - 1].timestamp;
1357  if (!ast->remaining && ts > last_ts)
1358  continue;
1359 
1360  ts = av_rescale_q(ts, st->time_base,
1361  (AVRational) { FFMAX(1, ast->sample_size),
1362  AV_TIME_BASE });
1363 
1364  av_log(s, AV_LOG_TRACE, "%"PRId64" %d/%d %"PRId64"\n", ts,
1365  st->time_base.num, st->time_base.den, ast->frame_offset);
1366  if (ts < best_ts) {
1367  best_ts = ts;
1368  best_st = st;
1369  best_stream_index = i;
1370  }
1371  }
1372  if (!best_st)
1373  return AVERROR_EOF;
1374 
1375  best_ast = best_st->priv_data;
1376  best_ts = best_ast->frame_offset;
1377  if (best_ast->remaining) {
1378  i = av_index_search_timestamp(best_st,
1379  best_ts,
1380  AVSEEK_FLAG_ANY |
1382  } else {
1383  i = av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY);
1384  if (i >= 0)
1385  best_ast->frame_offset = best_st->index_entries[i].timestamp;
1386  }
1387 
1388  if (i >= 0) {
1389  int64_t pos = best_st->index_entries[i].pos;
1390  pos += best_ast->packet_size - best_ast->remaining;
1391  if (avio_seek(s->pb, pos + 8, SEEK_SET) < 0)
1392  return AVERROR_EOF;
1393 
1394  av_assert0(best_ast->remaining <= best_ast->packet_size);
1395 
1396  avi->stream_index = best_stream_index;
1397  if (!best_ast->remaining)
1398  best_ast->packet_size =
1399  best_ast->remaining = best_st->index_entries[i].size;
1400  }
1401  else
1402  return AVERROR_EOF;
1403 
1404  return 0;
1405 }
1406 
1408 {
1409  AVIContext *avi = s->priv_data;
1410  AVIOContext *pb = s->pb;
1411  int err;
1412 
1413  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1414  int size = avpriv_dv_get_packet(avi->dv_demux, pkt);
1415  if (size >= 0)
1416  return size;
1417  else
1418  goto resync;
1419  }
1420 
1421  if (avi->non_interleaved) {
1422  err = ni_prepare_read(s);
1423  if (err < 0)
1424  return err;
1425  }
1426 
1427 resync:
1428  if (avi->stream_index >= 0) {
1429  AVStream *st = s->streams[avi->stream_index];
1430  AVIStream *ast = st->priv_data;
1431  int size, err;
1432 
1433  if (get_subtitle_pkt(s, st, pkt))
1434  return 0;
1435 
1436  // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM
1437  if (ast->sample_size <= 1)
1438  size = INT_MAX;
1439  else if (ast->sample_size < 32)
1440  // arbitrary multiplier to avoid tiny packets for raw PCM data
1441  size = 1024 * ast->sample_size;
1442  else
1443  size = ast->sample_size;
1444 
1445  if (size > ast->remaining)
1446  size = ast->remaining;
1447  avi->last_pkt_pos = avio_tell(pb);
1448  err = av_get_packet(pb, pkt, size);
1449  if (err < 0)
1450  return err;
1451  size = err;
1452 
1453  if (ast->has_pal && pkt->size < (unsigned)INT_MAX / 2) {
1454  uint8_t *pal;
1455  pal = av_packet_new_side_data(pkt,
1457  AVPALETTE_SIZE);
1458  if (!pal) {
1459  av_log(s, AV_LOG_ERROR,
1460  "Failed to allocate data for palette\n");
1461  } else {
1462  memcpy(pal, ast->pal, AVPALETTE_SIZE);
1463  ast->has_pal = 0;
1464  }
1465  }
1466 
1467  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1468  AVBufferRef *avbuf = pkt->buf;
1469  size = avpriv_dv_produce_packet(avi->dv_demux, pkt,
1470  pkt->data, pkt->size, pkt->pos);
1471  pkt->buf = avbuf;
1472  pkt->flags |= AV_PKT_FLAG_KEY;
1473  if (size < 0)
1474  av_packet_unref(pkt);
1475  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE &&
1476  !st->codecpar->codec_tag && read_gab2_sub(s, st, pkt)) {
1477  ast->frame_offset++;
1478  avi->stream_index = -1;
1479  ast->remaining = 0;
1480  goto resync;
1481  } else {
1482  /* XXX: How to handle B-frames in AVI? */
1483  pkt->dts = ast->frame_offset;
1484 // pkt->dts += ast->start;
1485  if (ast->sample_size)
1486  pkt->dts /= ast->sample_size;
1487  pkt->stream_index = avi->stream_index;
1488 
1489  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->index_entries) {
1490  AVIndexEntry *e;
1491  int index;
1492 
1494  e = &st->index_entries[index];
1495 
1496  if (index >= 0 && e->timestamp == ast->frame_offset) {
1497  if (index == st->nb_index_entries-1) {
1498  int key=1;
1499  uint32_t state=-1;
1500  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4) {
1501  const uint8_t *ptr = pkt->data, *end = ptr + FFMIN(size, 256);
1502  while (ptr < end) {
1503  ptr = avpriv_find_start_code(ptr, end, &state);
1504  if (state == 0x1B6 && ptr < end) {
1505  key = !(*ptr & 0xC0);
1506  break;
1507  }
1508  }
1509  }
1510  if (!key)
1511  e->flags &= ~AVINDEX_KEYFRAME;
1512  }
1513  if (e->flags & AVINDEX_KEYFRAME)
1514  pkt->flags |= AV_PKT_FLAG_KEY;
1515  }
1516  } else {
1517  pkt->flags |= AV_PKT_FLAG_KEY;
1518  }
1519  ast->frame_offset += get_duration(ast, pkt->size);
1520  }
1521  ast->remaining -= err;
1522  if (!ast->remaining) {
1523  avi->stream_index = -1;
1524  ast->packet_size = 0;
1525  }
1526 
1527  if (!avi->non_interleaved && pkt->pos >= 0 && ast->seek_pos > pkt->pos) {
1528  av_packet_unref(pkt);
1529  goto resync;
1530  }
1531  ast->seek_pos= 0;
1532 
1533  if (!avi->non_interleaved && st->nb_index_entries>1 && avi->index_loaded>1) {
1534  int64_t dts= av_rescale_q(pkt->dts, st->time_base, AV_TIME_BASE_Q);
1535 
1536  if (avi->dts_max - dts > 2*AV_TIME_BASE) {
1537  avi->non_interleaved= 1;
1538  av_log(s, AV_LOG_INFO, "Switching to NI mode, due to poor interleaving\n");
1539  }else if (avi->dts_max < dts)
1540  avi->dts_max = dts;
1541  }
1542 
1543  return 0;
1544  }
1545 
1546  if ((err = avi_sync(s, 0)) < 0)
1547  return err;
1548  goto resync;
1549 }
1550 
1551 /* XXX: We make the implicit supposition that the positions are sorted
1552  * for each stream. */
1554 {
1555  AVIContext *avi = s->priv_data;
1556  AVIOContext *pb = s->pb;
1557  int nb_index_entries, i;
1558  AVStream *st;
1559  AVIStream *ast;
1560  int64_t pos;
1561  unsigned int index, tag, flags, len, first_packet = 1;
1562  int64_t last_pos = -1;
1563  unsigned last_idx = -1;
1564  int64_t idx1_pos, first_packet_pos = 0, data_offset = 0;
1565  int anykey = 0;
1566 
1567  nb_index_entries = size / 16;
1568  if (nb_index_entries <= 0)
1569  return AVERROR_INVALIDDATA;
1570 
1571  idx1_pos = avio_tell(pb);
1572  avio_seek(pb, avi->movi_list + 4, SEEK_SET);
1573  if (avi_sync(s, 1) == 0)
1574  first_packet_pos = avio_tell(pb) - 8;
1575  avi->stream_index = -1;
1576  avio_seek(pb, idx1_pos, SEEK_SET);
1577 
1578  if (s->nb_streams == 1 && s->streams[0]->codecpar->codec_tag == AV_RL32("MMES")) {
1579  first_packet_pos = 0;
1580  data_offset = avi->movi_list;
1581  }
1582 
1583  /* Read the entries and sort them in each stream component. */
1584  for (i = 0; i < nb_index_entries; i++) {
1585  if (avio_feof(pb))
1586  return -1;
1587 
1588  tag = avio_rl32(pb);
1589  flags = avio_rl32(pb);
1590  pos = avio_rl32(pb);
1591  len = avio_rl32(pb);
1592  av_log(s, AV_LOG_TRACE, "%d: tag=0x%x flags=0x%x pos=0x%"PRIx64" len=%d/",
1593  i, tag, flags, pos, len);
1594 
1595  index = ((tag & 0xff) - '0') * 10;
1596  index += (tag >> 8 & 0xff) - '0';
1597  if (index >= s->nb_streams)
1598  continue;
1599  st = s->streams[index];
1600  ast = st->priv_data;
1601 
1602  /* Skip 'xxpc' palette change entries in the index until a logic
1603  * to process these is properly implemented. */
1604  if ((tag >> 16 & 0xff) == 'p' && (tag >> 24 & 0xff) == 'c')
1605  continue;
1606 
1607  if (first_packet && first_packet_pos) {
1608  if (avi->movi_list + 4 != pos || pos + 500 > first_packet_pos)
1609  data_offset = first_packet_pos - pos;
1610  first_packet = 0;
1611  }
1612  pos += data_offset;
1613 
1614  av_log(s, AV_LOG_TRACE, "%d cum_len=%"PRId64"\n", len, ast->cum_len);
1615 
1616  // even if we have only a single stream, we should
1617  // switch to non-interleaved to get correct timestamps
1618  if (last_pos == pos)
1619  avi->non_interleaved = 1;
1620  if (last_idx != pos && len) {
1621  av_add_index_entry(st, pos, ast->cum_len, len, 0,
1622  (flags & AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);
1623  last_idx= pos;
1624  }
1625  ast->cum_len += get_duration(ast, len);
1626  last_pos = pos;
1627  anykey |= flags&AVIIF_INDEX;
1628  }
1629  if (!anykey) {
1630  for (index = 0; index < s->nb_streams; index++) {
1631  st = s->streams[index];
1632  if (st->nb_index_entries)
1634  }
1635  }
1636  return 0;
1637 }
1638 
1639 /* Scan the index and consider any file with streams more than
1640  * 2 seconds or 64MB apart non-interleaved. */
1642 {
1643  int64_t min_pos, pos;
1644  int i;
1645  int *idx = av_mallocz_array(s->nb_streams, sizeof(*idx));
1646  if (!idx)
1647  return AVERROR(ENOMEM);
1648  for (min_pos = pos = 0; min_pos != INT64_MAX; pos = min_pos + 1LU) {
1649  int64_t max_dts = INT64_MIN / 2;
1650  int64_t min_dts = INT64_MAX / 2;
1651  int64_t max_buffer = 0;
1652 
1653  min_pos = INT64_MAX;
1654 
1655  for (i = 0; i < s->nb_streams; i++) {
1656  AVStream *st = s->streams[i];
1657  AVIStream *ast = st->priv_data;
1658  int n = st->nb_index_entries;
1659  while (idx[i] < n && st->index_entries[idx[i]].pos < pos)
1660  idx[i]++;
1661  if (idx[i] < n) {
1662  int64_t dts;
1663  dts = av_rescale_q(st->index_entries[idx[i]].timestamp /
1664  FFMAX(ast->sample_size, 1),
1665  st->time_base, AV_TIME_BASE_Q);
1666  min_dts = FFMIN(min_dts, dts);
1667  min_pos = FFMIN(min_pos, st->index_entries[idx[i]].pos);
1668  }
1669  }
1670  for (i = 0; i < s->nb_streams; i++) {
1671  AVStream *st = s->streams[i];
1672  AVIStream *ast = st->priv_data;
1673 
1674  if (idx[i] && min_dts != INT64_MAX / 2) {
1675  int64_t dts;
1676  dts = av_rescale_q(st->index_entries[idx[i] - 1].timestamp /
1677  FFMAX(ast->sample_size, 1),
1678  st->time_base, AV_TIME_BASE_Q);
1679  max_dts = FFMAX(max_dts, dts);
1680  max_buffer = FFMAX(max_buffer,
1681  av_rescale(dts - min_dts,
1682  st->codecpar->bit_rate,
1683  AV_TIME_BASE));
1684  }
1685  }
1686  if (max_dts - min_dts > 2 * AV_TIME_BASE ||
1687  max_buffer > 1024 * 1024 * 8 * 8) {
1688  av_free(idx);
1689  return 1;
1690  }
1691  }
1692  av_free(idx);
1693  return 0;
1694 }
1695 
1697 {
1698  int i;
1699  int64_t last_start = 0;
1700  int64_t first_end = INT64_MAX;
1701  int64_t oldpos = avio_tell(s->pb);
1702 
1703  for (i = 0; i < s->nb_streams; i++) {
1704  AVStream *st = s->streams[i];
1705  int n = st->nb_index_entries;
1706  unsigned int size;
1707 
1708  if (n <= 0)
1709  continue;
1710 
1711  if (n >= 2) {
1712  int64_t pos = st->index_entries[0].pos;
1713  unsigned tag[2];
1714  avio_seek(s->pb, pos, SEEK_SET);
1715  tag[0] = avio_r8(s->pb);
1716  tag[1] = avio_r8(s->pb);
1717  avio_rl16(s->pb);
1718  size = avio_rl32(s->pb);
1719  if (get_stream_idx(tag) == i && pos + size > st->index_entries[1].pos)
1720  last_start = INT64_MAX;
1721  if (get_stream_idx(tag) == i && size == st->index_entries[0].size + 8)
1722  last_start = INT64_MAX;
1723  }
1724 
1725  if (st->index_entries[0].pos > last_start)
1726  last_start = st->index_entries[0].pos;
1727  if (st->index_entries[n - 1].pos < first_end)
1728  first_end = st->index_entries[n - 1].pos;
1729  }
1730  avio_seek(s->pb, oldpos, SEEK_SET);
1731 
1732  if (last_start > first_end)
1733  return 1;
1734 
1735  return check_stream_max_drift(s);
1736 }
1737 
1739 {
1740  AVIContext *avi = s->priv_data;
1741  AVIOContext *pb = s->pb;
1742  uint32_t tag, size;
1743  int64_t pos = avio_tell(pb);
1744  int64_t next;
1745  int ret = -1;
1746 
1747  if (avio_seek(pb, avi->movi_end, SEEK_SET) < 0)
1748  goto the_end; // maybe truncated file
1749  av_log(s, AV_LOG_TRACE, "movi_end=0x%"PRIx64"\n", avi->movi_end);
1750  for (;;) {
1751  tag = avio_rl32(pb);
1752  size = avio_rl32(pb);
1753  if (avio_feof(pb))
1754  break;
1755  next = avio_tell(pb) + size + (size & 1);
1756 
1757  if (tag == MKTAG('i', 'd', 'x', '1') &&
1758  avi_read_idx1(s, size) >= 0) {
1759  avi->index_loaded=2;
1760  ret = 0;
1761  }else if (tag == MKTAG('L', 'I', 'S', 'T')) {
1762  uint32_t tag1 = avio_rl32(pb);
1763 
1764  if (tag1 == MKTAG('I', 'N', 'F', 'O'))
1765  ff_read_riff_info(s, size - 4);
1766  }else if (!ret)
1767  break;
1768 
1769  if (avio_seek(pb, next, SEEK_SET) < 0)
1770  break; // something is wrong here
1771  }
1772 
1773 the_end:
1774  avio_seek(pb, pos, SEEK_SET);
1775  return ret;
1776 }
1777 
1778 static void seek_subtitle(AVStream *st, AVStream *st2, int64_t timestamp)
1779 {
1780  AVIStream *ast2 = st2->priv_data;
1781  int64_t ts2 = av_rescale_q(timestamp, st->time_base, st2->time_base);
1782  av_packet_unref(&ast2->sub_pkt);
1783  if (avformat_seek_file(ast2->sub_ctx, 0, INT64_MIN, ts2, ts2, 0) >= 0 ||
1784  avformat_seek_file(ast2->sub_ctx, 0, ts2, ts2, INT64_MAX, 0) >= 0)
1785  ff_read_packet(ast2->sub_ctx, &ast2->sub_pkt);
1786 }
1787 
1788 static int avi_read_seek(AVFormatContext *s, int stream_index,
1789  int64_t timestamp, int flags)
1790 {
1791  AVIContext *avi = s->priv_data;
1792  AVStream *st;
1793  int i, index;
1794  int64_t pos, pos_min;
1795  AVIStream *ast;
1796 
1797  /* Does not matter which stream is requested dv in avi has the
1798  * stream information in the first video stream.
1799  */
1800  if (avi->dv_demux)
1801  stream_index = 0;
1802 
1803  if (!avi->index_loaded) {
1804  /* we only load the index on demand */
1805  avi_load_index(s);
1806  avi->index_loaded |= 1;
1807  }
1808  av_assert0(stream_index >= 0);
1809 
1810  st = s->streams[stream_index];
1811  ast = st->priv_data;
1812  index = av_index_search_timestamp(st,
1813  timestamp * FFMAX(ast->sample_size, 1),
1814  flags);
1815  if (index < 0) {
1816  if (st->nb_index_entries > 0)
1817  av_log(s, AV_LOG_DEBUG, "Failed to find timestamp %"PRId64 " in index %"PRId64 " .. %"PRId64 "\n",
1818  timestamp * FFMAX(ast->sample_size, 1),
1819  st->index_entries[0].timestamp,
1821  return AVERROR_INVALIDDATA;
1822  }
1823 
1824  /* find the position */
1825  pos = st->index_entries[index].pos;
1826  timestamp = st->index_entries[index].timestamp / FFMAX(ast->sample_size, 1);
1827 
1828  av_log(s, AV_LOG_TRACE, "XX %"PRId64" %d %"PRId64"\n",
1829  timestamp, index, st->index_entries[index].timestamp);
1830 
1831  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1832  /* One and only one real stream for DV in AVI, and it has video */
1833  /* offsets. Calling with other stream indexes should have failed */
1834  /* the av_index_search_timestamp call above. */
1835 
1836  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
1837  return -1;
1838 
1839  /* Feed the DV video stream version of the timestamp to the */
1840  /* DV demux so it can synthesize correct timestamps. */
1841  ff_dv_offset_reset(avi->dv_demux, timestamp);
1842 
1843  avi->stream_index = -1;
1844  return 0;
1845  }
1846 
1847  pos_min = pos;
1848  for (i = 0; i < s->nb_streams; i++) {
1849  AVStream *st2 = s->streams[i];
1850  AVIStream *ast2 = st2->priv_data;
1851 
1852  ast2->packet_size =
1853  ast2->remaining = 0;
1854 
1855  if (ast2->sub_ctx) {
1856  seek_subtitle(st, st2, timestamp);
1857  continue;
1858  }
1859 
1860  if (st2->nb_index_entries <= 0)
1861  continue;
1862 
1863 // av_assert1(st2->codecpar->block_align);
1864  index = av_index_search_timestamp(st2,
1865  av_rescale_q(timestamp,
1866  st->time_base,
1867  st2->time_base) *
1868  FFMAX(ast2->sample_size, 1),
1869  flags |
1872  if (index < 0)
1873  index = 0;
1874  ast2->seek_pos = st2->index_entries[index].pos;
1875  pos_min = FFMIN(pos_min,ast2->seek_pos);
1876  }
1877  for (i = 0; i < s->nb_streams; i++) {
1878  AVStream *st2 = s->streams[i];
1879  AVIStream *ast2 = st2->priv_data;
1880 
1881  if (ast2->sub_ctx || st2->nb_index_entries <= 0)
1882  continue;
1883 
1884  index = av_index_search_timestamp(
1885  st2,
1886  av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1),
1888  if (index < 0)
1889  index = 0;
1890  while (!avi->non_interleaved && index>0 && st2->index_entries[index-1].pos >= pos_min)
1891  index--;
1892  ast2->frame_offset = st2->index_entries[index].timestamp;
1893  }
1894 
1895  /* do the seek */
1896  if (avio_seek(s->pb, pos_min, SEEK_SET) < 0) {
1897  av_log(s, AV_LOG_ERROR, "Seek failed\n");
1898  return -1;
1899  }
1900  avi->stream_index = -1;
1901  avi->dts_max = INT_MIN;
1902  return 0;
1903 }
1904 
1906 {
1907  int i;
1908  AVIContext *avi = s->priv_data;
1909 
1910  for (i = 0; i < s->nb_streams; i++) {
1911  AVStream *st = s->streams[i];
1912  AVIStream *ast = st->priv_data;
1913  if (ast) {
1914  if (ast->sub_ctx) {
1915  av_freep(&ast->sub_ctx->pb);
1917  }
1918  av_freep(&ast->sub_buffer);
1919  av_packet_unref(&ast->sub_pkt);
1920  }
1921  }
1922 
1923  av_freep(&avi->dv_demux);
1924 
1925  return 0;
1926 }
1927 
1928 static int avi_probe(const AVProbeData *p)
1929 {
1930  int i;
1931 
1932  /* check file header */
1933  for (i = 0; avi_headers[i][0]; i++)
1934  if (AV_RL32(p->buf ) == AV_RL32(avi_headers[i] ) &&
1935  AV_RL32(p->buf + 8) == AV_RL32(avi_headers[i] + 4))
1936  return AVPROBE_SCORE_MAX;
1937 
1938  return 0;
1939 }
1940 
1942  .name = "avi",
1943  .long_name = NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"),
1944  .priv_data_size = sizeof(AVIContext),
1945  .extensions = "avi",
1946  .read_probe = avi_probe,
1951  .priv_class = &demuxer_class,
1952 };
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:1137
#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:2049
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3158
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:1500
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:4926
#define print_tag(s, str, tag, size)
Definition: avidec.c:120
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:3968
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:1481
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:539
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:814
static AVPacket pkt
static int ni_prepare_read(AVFormatContext *s)
Definition: avidec.c:1338
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:1641
static const AVMetadataConv avi_metadata_conv[]
Definition: avidec.c:112
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:4034
AVOptions.
static int avi_read_close(AVFormatContext *s)
Definition: avidec.c:1905
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:4499
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:1480
static int read_gab2_sub(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: avidec.c:1068
uint32_t tag
Definition: movenc.c:1531
#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
const AVCodecTag ff_codec_bmp_tags_unofficial[]
Definition: riff.c:495
#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:3997
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1512
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:2035
#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:1193
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2164
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:566
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3964
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1463
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:1171
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:954
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:122
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1486
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3986
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:4085
static int avi_probe(const AVProbeData *p)
Definition: avidec.c:1928
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:468
internal header for RIFF based (de)muxers do NOT include this in end user applications ...
static const char months[12][4]
Definition: avidec.c:321
#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:1778
static int avi_extract_stream_metadata(AVFormatContext *s, AVStream *st)
Definition: avidec.c:386
#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:2708
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:833
static int calculate_bitrate(AVFormatContext *s)
Definition: avidec.c:424
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:1407
struct AVStream::@250 * info
Stream information used internally by avformat_find_stream_info()
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:948
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:1553
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:809
#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:2545
const AVMetadataConv ff_riff_info_conv[]
Definition: riff.c:585
int64_t seek_pos
Definition: avidec.c:66
#define flags(name, subs,...)
Definition: cbs_av1.c:561
static int avi_load_index(AVFormatContext *s)
Definition: avidec.c:1738
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVInputFormat ff_avi_demuxer
Definition: avidec.c:1941
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:343
static void avi_metadata_creation_time(AVDictionary **metadata, char *date)
Definition: avidec.c:324
#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:3339
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:4471
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:793
#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:1696
void * priv_data
Format private data.
Definition: avformat.h:1386
int64_t frame_offset
Definition: avidec.c:43
static struct @316 state
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:4010
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3982
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:1479
static int avi_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: avidec.c:1788
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:3972
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:1482
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:1457
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:780
static int avi_sync(AVFormatContext *s, int exit_early)
Definition: avidec.c:1185
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