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