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_read_close(AVFormatContext *s);
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 < av_rescale(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 
468 #define RETURN_ERROR(code) do { ret = (code); goto fail; } while (0)
470 {
471  AVIContext *avi = s->priv_data;
472  AVIOContext *pb = s->pb;
473  unsigned int tag, tag1, handler;
474  int codec_type, stream_index, frame_period;
475  unsigned int size;
476  int i;
477  AVStream *st;
478  AVIStream *ast = NULL;
479  int avih_width = 0, avih_height = 0;
480  int amv_file_format = 0;
481  uint64_t list_end = 0;
482  int64_t pos;
483  int ret;
484  AVDictionaryEntry *dict_entry;
485 
486  avi->stream_index = -1;
487 
488  ret = get_riff(s, pb);
489  if (ret < 0)
490  return ret;
491 
492  av_log(avi, AV_LOG_DEBUG, "use odml:%d\n", avi->use_odml);
493 
494  avi->io_fsize = avi->fsize = avio_size(pb);
495  if (avi->fsize <= 0 || avi->fsize < avi->riff_end)
496  avi->fsize = avi->riff_end == 8 ? INT64_MAX : avi->riff_end;
497 
498  /* first list tag */
499  stream_index = -1;
500  codec_type = -1;
501  frame_period = 0;
502  for (;;) {
503  if (avio_feof(pb))
505  tag = avio_rl32(pb);
506  size = avio_rl32(pb);
507 
508  print_tag(s, "tag", tag, size);
509 
510  switch (tag) {
511  case MKTAG('L', 'I', 'S', 'T'):
512  list_end = avio_tell(pb) + size;
513  /* Ignored, except at start of video packets. */
514  tag1 = avio_rl32(pb);
515 
516  print_tag(s, "list", tag1, 0);
517 
518  if (tag1 == MKTAG('m', 'o', 'v', 'i')) {
519  avi->movi_list = avio_tell(pb) - 4;
520  if (size)
521  avi->movi_end = avi->movi_list + size + (size & 1);
522  else
523  avi->movi_end = avi->fsize;
524  av_log(s, AV_LOG_TRACE, "movi end=%"PRIx64"\n", avi->movi_end);
525  goto end_of_header;
526  } else if (tag1 == MKTAG('I', 'N', 'F', 'O'))
527  ff_read_riff_info(s, size - 4);
528  else if (tag1 == MKTAG('n', 'c', 'd', 't'))
529  avi_read_nikon(s, list_end);
530 
531  break;
532  case MKTAG('I', 'D', 'I', 'T'):
533  {
534  unsigned char date[64] = { 0 };
535  size += (size & 1);
536  size -= avio_read(pb, date, FFMIN(size, sizeof(date) - 1));
537  avio_skip(pb, size);
539  break;
540  }
541  case MKTAG('d', 'm', 'l', 'h'):
542  avi->is_odml = 1;
543  avio_skip(pb, size + (size & 1));
544  break;
545  case MKTAG('a', 'm', 'v', 'h'):
546  amv_file_format = 1;
547  case MKTAG('a', 'v', 'i', 'h'):
548  /* AVI header */
549  /* using frame_period is bad idea */
550  frame_period = avio_rl32(pb);
551  avio_rl32(pb); /* max. bytes per second */
552  avio_rl32(pb);
554 
555  avio_skip(pb, 2 * 4);
556  avio_rl32(pb);
557  avio_rl32(pb);
558  avih_width = avio_rl32(pb);
559  avih_height = avio_rl32(pb);
560 
561  avio_skip(pb, size - 10 * 4);
562  break;
563  case MKTAG('s', 't', 'r', 'h'):
564  /* stream header */
565 
566  tag1 = avio_rl32(pb);
567  handler = avio_rl32(pb); /* codec tag */
568 
569  if (tag1 == MKTAG('p', 'a', 'd', 's')) {
570  avio_skip(pb, size - 8);
571  break;
572  } else {
573  stream_index++;
574  st = avformat_new_stream(s, NULL);
575  if (!st)
576  RETURN_ERROR(AVERROR(ENOMEM));
577 
578  st->id = stream_index;
579  ast = av_mallocz(sizeof(AVIStream));
580  if (!ast)
581  RETURN_ERROR(AVERROR(ENOMEM));
582  st->priv_data = ast;
583  }
584  if (amv_file_format)
585  tag1 = stream_index ? MKTAG('a', 'u', 'd', 's')
586  : MKTAG('v', 'i', 'd', 's');
587 
588  print_tag(s, "strh", tag1, -1);
589 
590  if (tag1 == MKTAG('i', 'a', 'v', 's') ||
591  tag1 == MKTAG('i', 'v', 'a', 's')) {
592  int64_t dv_dur;
593 
594  /* After some consideration -- I don't think we
595  * have to support anything but DV in type1 AVIs. */
596  if (s->nb_streams != 1)
598 
599  if (handler != MKTAG('d', 'v', 's', 'd') &&
600  handler != MKTAG('d', 'v', 'h', 'd') &&
601  handler != MKTAG('d', 'v', 's', 'l'))
602  return AVERROR_INVALIDDATA;
603 
604  if (!CONFIG_DV_DEMUXER)
606 
607  ast = s->streams[0]->priv_data;
608  st->priv_data = NULL;
609  ff_free_stream(s, st);
610 
611  avi->dv_demux = avpriv_dv_init_demux(s);
612  if (!avi->dv_demux) {
613  av_free(ast);
614  return AVERROR(ENOMEM);
615  }
616 
617  s->streams[0]->priv_data = ast;
618  avio_skip(pb, 3 * 4);
619  ast->scale = avio_rl32(pb);
620  ast->rate = avio_rl32(pb);
621  avio_skip(pb, 4); /* start time */
622 
623  dv_dur = avio_rl32(pb);
624  if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) {
625  dv_dur *= AV_TIME_BASE;
626  s->duration = av_rescale(dv_dur, ast->scale, ast->rate);
627  }
628  /* else, leave duration alone; timing estimation in utils.c
629  * will make a guess based on bitrate. */
630 
631  stream_index = s->nb_streams - 1;
632  avio_skip(pb, size - 9 * 4);
633  break;
634  }
635 
636  av_assert0(stream_index < s->nb_streams);
637  ast->handler = handler;
638 
639  avio_rl32(pb); /* flags */
640  avio_rl16(pb); /* priority */
641  avio_rl16(pb); /* language */
642  avio_rl32(pb); /* initial frame */
643  ast->scale = avio_rl32(pb);
644  ast->rate = avio_rl32(pb);
645  if (!(ast->scale && ast->rate)) {
647  "scale/rate is %"PRIu32"/%"PRIu32" which is invalid. "
648  "(This file has been generated by broken software.)\n",
649  ast->scale,
650  ast->rate);
651  if (frame_period) {
652  ast->rate = 1000000;
653  ast->scale = frame_period;
654  } else {
655  ast->rate = 25;
656  ast->scale = 1;
657  }
658  }
659  avpriv_set_pts_info(st, 64, ast->scale, ast->rate);
660 
661  ast->cum_len = avio_rl32(pb); /* start */
662  st->nb_frames = avio_rl32(pb);
663 
664  st->start_time = 0;
665  avio_rl32(pb); /* buffer size */
666  avio_rl32(pb); /* quality */
667  if (ast->cum_len > 3600LL * ast->rate / ast->scale) {
668  av_log(s, AV_LOG_ERROR, "crazy start time, iam scared, giving up\n");
669  ast->cum_len = 0;
670  }
671  ast->sample_size = avio_rl32(pb);
672  ast->cum_len *= FFMAX(1, ast->sample_size);
673  av_log(s, AV_LOG_TRACE, "%"PRIu32" %"PRIu32" %d\n",
674  ast->rate, ast->scale, ast->sample_size);
675 
676  switch (tag1) {
677  case MKTAG('v', 'i', 'd', 's'):
678  codec_type = AVMEDIA_TYPE_VIDEO;
679 
680  ast->sample_size = 0;
681  st->avg_frame_rate = av_inv_q(st->time_base);
682  break;
683  case MKTAG('a', 'u', 'd', 's'):
684  codec_type = AVMEDIA_TYPE_AUDIO;
685  break;
686  case MKTAG('t', 'x', 't', 's'):
687  codec_type = AVMEDIA_TYPE_SUBTITLE;
688  break;
689  case MKTAG('d', 'a', 't', 's'):
690  codec_type = AVMEDIA_TYPE_DATA;
691  break;
692  default:
693  av_log(s, AV_LOG_INFO, "unknown stream type %X\n", tag1);
694  }
695 
696  if (ast->sample_size < 0) {
697  if (s->error_recognition & AV_EF_EXPLODE) {
698  av_log(s, AV_LOG_ERROR,
699  "Invalid sample_size %d at stream %d\n",
700  ast->sample_size,
701  stream_index);
703  }
705  "Invalid sample_size %d at stream %d "
706  "setting it to 0\n",
707  ast->sample_size,
708  stream_index);
709  ast->sample_size = 0;
710  }
711 
712  if (ast->sample_size == 0) {
713  st->duration = st->nb_frames;
714  if (st->duration > 0 && avi->io_fsize > 0 && avi->riff_end > avi->io_fsize) {
715  av_log(s, AV_LOG_DEBUG, "File is truncated adjusting duration\n");
716  st->duration = av_rescale(st->duration, avi->io_fsize, avi->riff_end);
717  }
718  }
719  ast->frame_offset = ast->cum_len;
720  avio_skip(pb, size - 12 * 4);
721  break;
722  case MKTAG('s', 't', 'r', 'f'):
723  /* stream header */
724  if (!size && (codec_type == AVMEDIA_TYPE_AUDIO ||
725  codec_type == AVMEDIA_TYPE_VIDEO))
726  break;
727  if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) {
728  avio_skip(pb, size);
729  } else {
730  uint64_t cur_pos = avio_tell(pb);
731  unsigned esize;
732  if (cur_pos < list_end)
733  size = FFMIN(size, list_end - cur_pos);
734  st = s->streams[stream_index];
736  avio_skip(pb, size);
737  break;
738  }
739  switch (codec_type) {
740  case AVMEDIA_TYPE_VIDEO:
741  if (amv_file_format) {
742  st->codecpar->width = avih_width;
743  st->codecpar->height = avih_height;
746  avio_skip(pb, size);
747  break;
748  }
749  tag1 = ff_get_bmp_header(pb, st, &esize);
750 
751  if (tag1 == MKTAG('D', 'X', 'S', 'B') ||
752  tag1 == MKTAG('D', 'X', 'S', 'A')) {
754  st->codecpar->codec_tag = tag1;
756  break;
757  }
758 
759  if (size > 10 * 4 && size < (1 << 30) && size < avi->fsize) {
760  if (esize == size-1 && (esize&1)) {
761  st->codecpar->extradata_size = esize - 10 * 4;
762  } else
763  st->codecpar->extradata_size = size - 10 * 4;
764  if (st->codecpar->extradata) {
765  av_log(s, AV_LOG_WARNING, "New extradata in strf chunk, freeing previous one.\n");
766  }
767  ret = ff_get_extradata(s, st->codecpar, pb,
768  st->codecpar->extradata_size);
769  if (ret < 0)
770  return ret;
771  }
772 
773  // FIXME: check if the encoder really did this correctly
774  if (st->codecpar->extradata_size & 1)
775  avio_r8(pb);
776 
777  /* Extract palette from extradata if bpp <= 8.
778  * This code assumes that extradata contains only palette.
779  * This is true for all paletted codecs implemented in
780  * FFmpeg. */
781  if (st->codecpar->extradata_size &&
782  (st->codecpar->bits_per_coded_sample <= 8)) {
783  int pal_size = (1 << st->codecpar->bits_per_coded_sample) << 2;
784  const uint8_t *pal_src;
785 
786  pal_size = FFMIN(pal_size, st->codecpar->extradata_size);
787  pal_src = st->codecpar->extradata +
788  st->codecpar->extradata_size - pal_size;
789  /* Exclude the "BottomUp" field from the palette */
790  if (pal_src - st->codecpar->extradata >= 9 &&
791  !memcmp(st->codecpar->extradata + st->codecpar->extradata_size - 9, "BottomUp", 9))
792  pal_src -= 9;
793  for (i = 0; i < pal_size / 4; i++)
794  ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src + 4 * i);
795  ast->has_pal = 1;
796  }
797 
798  print_tag(s, "video", tag1, 0);
799 
801  st->codecpar->codec_tag = tag1;
803  tag1);
804  /* If codec is not found yet, try with the mov tags. */
805  if (!st->codecpar->codec_id) {
806  st->codecpar->codec_id =
808  if (st->codecpar->codec_id)
810  "mov tag found in avi (fourcc %s)\n",
811  av_fourcc2str(tag1));
812  }
813  if (!st->codecpar->codec_id)
815 
816  /* This is needed to get the pict type which is necessary
817  * for generating correct pts. */
819 
820  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4 &&
821  ast->handler == MKTAG('X', 'V', 'I', 'D'))
822  st->codecpar->codec_tag = MKTAG('X', 'V', 'I', 'D');
823 
824  if (st->codecpar->codec_tag == MKTAG('V', 'S', 'S', 'H'))
826  if (st->codecpar->codec_id == AV_CODEC_ID_RV40)
828  if (st->codecpar->codec_id == AV_CODEC_ID_HEVC &&
829  st->codecpar->codec_tag == MKTAG('H', '2', '6', '5'))
831 
832  if (st->codecpar->codec_tag == 0 && st->codecpar->height > 0 &&
833  st->codecpar->extradata_size < 1U << 30) {
834  st->codecpar->extradata_size += 9;
835  if ((ret = av_reallocp(&st->codecpar->extradata,
836  st->codecpar->extradata_size +
838  st->codecpar->extradata_size = 0;
839  return ret;
840  } else
841  memcpy(st->codecpar->extradata + st->codecpar->extradata_size - 9,
842  "BottomUp", 9);
843  }
844  st->codecpar->height = FFABS(st->codecpar->height);
845 
846 // avio_skip(pb, size - 5 * 4);
847  break;
848  case AVMEDIA_TYPE_AUDIO:
849  ret = ff_get_wav_header(s, pb, st->codecpar, size, 0);
850  if (ret < 0)
851  return ret;
853  if (ast->sample_size && st->codecpar->block_align &&
854  ast->sample_size != st->codecpar->block_align) {
855  av_log(s,
857  "sample size (%d) != block align (%d)\n",
858  ast->sample_size,
859  st->codecpar->block_align);
860  ast->sample_size = st->codecpar->block_align;
861  }
862  /* 2-aligned
863  * (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
864  if (size & 1)
865  avio_skip(pb, 1);
866  /* Force parsing as several audio frames can be in
867  * one packet and timestamps refer to packet start. */
869  /* ADTS header is in extradata, AAC without header must be
870  * stored as exact frames. Parser not needed and it will
871  * fail. */
872  if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&
875  // The flac parser does not work with AVSTREAM_PARSE_TIMESTAMPS
876  if (st->codecpar->codec_id == AV_CODEC_ID_FLAC)
878  /* AVI files with Xan DPCM audio (wrongly) declare PCM
879  * audio in the header but have Axan as stream_code_tag. */
880  if (ast->handler == AV_RL32("Axan")) {
882  st->codecpar->codec_tag = 0;
883  ast->dshow_block_align = 0;
884  }
885  if (amv_file_format) {
887  ast->dshow_block_align = 0;
888  }
889  if ((st->codecpar->codec_id == AV_CODEC_ID_AAC ||
891  st->codecpar->codec_id == AV_CODEC_ID_MP2 ) && ast->dshow_block_align <= 4 && ast->dshow_block_align) {
892  av_log(s, AV_LOG_DEBUG, "overriding invalid dshow_block_align of %d\n", ast->dshow_block_align);
893  ast->dshow_block_align = 0;
894  }
895  if (st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 1024 && ast->sample_size == 1024 ||
896  st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 4096 && ast->sample_size == 4096 ||
897  st->codecpar->codec_id == AV_CODEC_ID_MP3 && ast->dshow_block_align == 1152 && ast->sample_size == 1152) {
898  av_log(s, AV_LOG_DEBUG, "overriding sample_size\n");
899  ast->sample_size = 0;
900  }
901  break;
904  st->request_probe= 1;
905  avio_skip(pb, size);
906  break;
907  default:
910  st->codecpar->codec_tag = 0;
911  avio_skip(pb, size);
912  break;
913  }
914  }
915  break;
916  case MKTAG('s', 't', 'r', 'd'):
917  if (stream_index >= (unsigned)s->nb_streams
918  || s->streams[stream_index]->codecpar->extradata_size
919  || s->streams[stream_index]->codecpar->codec_tag == MKTAG('H','2','6','4')) {
920  avio_skip(pb, size);
921  } else {
922  uint64_t cur_pos = avio_tell(pb);
923  if (cur_pos < list_end)
924  size = FFMIN(size, list_end - cur_pos);
925  st = s->streams[stream_index];
926 
927  if (size<(1<<30)) {
928  if (st->codecpar->extradata) {
929  av_log(s, AV_LOG_WARNING, "New extradata in strd chunk, freeing previous one.\n");
930  }
931  if ((ret = ff_get_extradata(s, st->codecpar, pb, size)) < 0)
932  goto fail;
933  }
934 
935  if (st->codecpar->extradata_size & 1) //FIXME check if the encoder really did this correctly
936  avio_r8(pb);
937 
938  ret = avi_extract_stream_metadata(s, st);
939  if (ret < 0) {
940  av_log(s, AV_LOG_WARNING, "could not decoding EXIF data in stream header.\n");
941  }
942  }
943  break;
944  case MKTAG('i', 'n', 'd', 'x'):
945  pos = avio_tell(pb);
946  if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !(s->flags & AVFMT_FLAG_IGNIDX) &&
947  avi->use_odml &&
948  read_odml_index(s, 0) < 0 &&
951  avio_seek(pb, pos + size, SEEK_SET);
952  break;
953  case MKTAG('v', 'p', 'r', 'p'):
954  if (stream_index < (unsigned)s->nb_streams && size > 9 * 4) {
955  AVRational active, active_aspect;
956 
957  st = s->streams[stream_index];
958  avio_rl32(pb);
959  avio_rl32(pb);
960  avio_rl32(pb);
961  avio_rl32(pb);
962  avio_rl32(pb);
963 
964  active_aspect.den = avio_rl16(pb);
965  active_aspect.num = avio_rl16(pb);
966  active.num = avio_rl32(pb);
967  active.den = avio_rl32(pb);
968  avio_rl32(pb); // nbFieldsPerFrame
969 
970  if (active_aspect.num && active_aspect.den &&
971  active.num && active.den) {
972  st->sample_aspect_ratio = av_div_q(active_aspect, active);
973  av_log(s, AV_LOG_TRACE, "vprp %d/%d %d/%d\n",
974  active_aspect.num, active_aspect.den,
975  active.num, active.den);
976  }
977  size -= 9 * 4;
978  }
979  avio_skip(pb, size);
980  break;
981  case MKTAG('s', 't', 'r', 'n'):
982  if (s->nb_streams) {
983  ret = avi_read_tag(s, s->streams[s->nb_streams - 1], tag, size);
984  if (ret < 0)
985  goto fail;
986  break;
987  }
988  default:
989  if (size > 1000000) {
990  av_log(s, AV_LOG_ERROR,
991  "Something went wrong during header parsing, "
992  "tag %s has size %u, "
993  "I will ignore it and try to continue anyway.\n",
994  av_fourcc2str(tag), size);
997  avi->movi_list = avio_tell(pb) - 4;
998  avi->movi_end = avi->fsize;
999  goto end_of_header;
1000  }
1001  /* Do not fail for very large idx1 tags */
1002  case MKTAG('i', 'd', 'x', '1'):
1003  /* skip tag */
1004  size += (size & 1);
1005  avio_skip(pb, size);
1006  break;
1007  }
1008  }
1009 
1010 end_of_header:
1011  /* check stream number */
1012  if (stream_index != s->nb_streams - 1) {
1014  }
1015 
1016  if (!avi->index_loaded && (pb->seekable & AVIO_SEEKABLE_NORMAL))
1017  avi_load_index(s);
1018  calculate_bitrate(s);
1019  avi->index_loaded |= 1;
1020 
1021  if ((ret = guess_ni_flag(s)) < 0)
1022  goto fail;
1023 
1024  avi->non_interleaved |= ret | (s->flags & AVFMT_FLAG_SORT_DTS);
1025 
1026  dict_entry = av_dict_get(s->metadata, "ISFT", NULL, 0);
1027  if (dict_entry && !strcmp(dict_entry->value, "PotEncoder"))
1028  for (i = 0; i < s->nb_streams; i++) {
1029  AVStream *st = s->streams[i];
1033  }
1034 
1035  for (i = 0; i < s->nb_streams; i++) {
1036  AVStream *st = s->streams[i];
1037  if (st->nb_index_entries)
1038  break;
1039  }
1040  // DV-in-AVI cannot be non-interleaved, if set this must be
1041  // a mis-detection.
1042  if (avi->dv_demux)
1043  avi->non_interleaved = 0;
1044  if (i == s->nb_streams && avi->non_interleaved) {
1046  "Non-interleaved AVI without index, switching to interleaved\n");
1047  avi->non_interleaved = 0;
1048  }
1049 
1050  if (avi->non_interleaved) {
1051  av_log(s, AV_LOG_INFO, "non-interleaved AVI\n");
1052  clean_index(s);
1053  }
1054 
1055  ff_metadata_conv_ctx(s, NULL, avi_metadata_conv);
1057 
1058  return 0;
1059 fail:
1060  avi_read_close(s);
1061  return ret;
1062 }
1063 
1065 {
1066  if (pkt->size >= 7 &&
1067  pkt->size < INT_MAX - AVPROBE_PADDING_SIZE &&
1068  !strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data + 5) == 2) {
1069  uint8_t desc[256];
1070  int score = AVPROBE_SCORE_EXTENSION, ret;
1071  AVIStream *ast = st->priv_data;
1072  ff_const59 AVInputFormat *sub_demuxer;
1073  AVRational time_base;
1074  int size;
1075  AVIOContext *pb = avio_alloc_context(pkt->data + 7,
1076  pkt->size - 7,
1077  0, NULL, NULL, NULL, NULL);
1078  AVProbeData pd;
1079  unsigned int desc_len = avio_rl32(pb);
1080 
1081  if (desc_len > pb->buf_end - pb->buf_ptr)
1082  goto error;
1083 
1084  ret = avio_get_str16le(pb, desc_len, desc, sizeof(desc));
1085  avio_skip(pb, desc_len - ret);
1086  if (*desc)
1087  av_dict_set(&st->metadata, "title", desc, 0);
1088 
1089  avio_rl16(pb); /* flags? */
1090  avio_rl32(pb); /* data size */
1091 
1092  size = pb->buf_end - pb->buf_ptr;
1093  pd = (AVProbeData) { .buf = av_mallocz(size + AVPROBE_PADDING_SIZE),
1094  .buf_size = size };
1095  if (!pd.buf)
1096  goto error;
1097  memcpy(pd.buf, pb->buf_ptr, size);
1098  sub_demuxer = av_probe_input_format2(&pd, 1, &score);
1099  av_freep(&pd.buf);
1100  if (!sub_demuxer)
1101  goto error;
1102 
1103  if (strcmp(sub_demuxer->name, "srt") && strcmp(sub_demuxer->name, "ass"))
1104  goto error;
1105 
1106  if (!(ast->sub_ctx = avformat_alloc_context()))
1107  goto error;
1108 
1109  ast->sub_ctx->pb = pb;
1110 
1111  if (ff_copy_whiteblacklists(ast->sub_ctx, s) < 0)
1112  goto error;
1113 
1114  if (!avformat_open_input(&ast->sub_ctx, "", sub_demuxer, NULL)) {
1115  if (ast->sub_ctx->nb_streams != 1)
1116  goto error;
1117  ff_read_packet(ast->sub_ctx, &ast->sub_pkt);
1119  time_base = ast->sub_ctx->streams[0]->time_base;
1120  avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
1121  }
1122  ast->sub_buffer = pkt->buf;
1123  pkt->buf = NULL;
1124  av_packet_unref(pkt);
1125  return 1;
1126 
1127 error:
1128  av_freep(&ast->sub_ctx);
1129  avio_context_free(&pb);
1130  }
1131  return 0;
1132 }
1133 
1135  AVPacket *pkt)
1136 {
1137  AVIStream *ast, *next_ast = next_st->priv_data;
1138  int64_t ts, next_ts, ts_min = INT64_MAX;
1139  AVStream *st, *sub_st = NULL;
1140  int i;
1141 
1142  next_ts = av_rescale_q(next_ast->frame_offset, next_st->time_base,
1143  AV_TIME_BASE_Q);
1144 
1145  for (i = 0; i < s->nb_streams; i++) {
1146  st = s->streams[i];
1147  ast = st->priv_data;
1148  if (st->discard < AVDISCARD_ALL && ast && ast->sub_pkt.data) {
1149  ts = av_rescale_q(ast->sub_pkt.dts, st->time_base, AV_TIME_BASE_Q);
1150  if (ts <= next_ts && ts < ts_min) {
1151  ts_min = ts;
1152  sub_st = st;
1153  }
1154  }
1155  }
1156 
1157  if (sub_st) {
1158  ast = sub_st->priv_data;
1159  *pkt = ast->sub_pkt;
1160  pkt->stream_index = sub_st->index;
1161 
1162  if (ff_read_packet(ast->sub_ctx, &ast->sub_pkt) < 0)
1163  ast->sub_pkt.data = NULL;
1164  }
1165  return sub_st;
1166 }
1167 
1168 static int get_stream_idx(const unsigned *d)
1169 {
1170  if (d[0] >= '0' && d[0] <= '9' &&
1171  d[1] >= '0' && d[1] <= '9') {
1172  return (d[0] - '0') * 10 + (d[1] - '0');
1173  } else {
1174  return 100; // invalid stream ID
1175  }
1176 }
1177 
1178 /**
1179  *
1180  * @param exit_early set to 1 to just gather packet position without making the changes needed to actually read & return the packet
1181  */
1182 static int avi_sync(AVFormatContext *s, int exit_early)
1183 {
1184  AVIContext *avi = s->priv_data;
1185  AVIOContext *pb = s->pb;
1186  int n;
1187  unsigned int d[8];
1188  unsigned int size;
1189  int64_t i, sync;
1190 
1191 start_sync:
1192  memset(d, -1, sizeof(d));
1193  for (i = sync = avio_tell(pb); !avio_feof(pb); i++) {
1194  int j;
1195 
1196  for (j = 0; j < 7; j++)
1197  d[j] = d[j + 1];
1198  d[7] = avio_r8(pb);
1199 
1200  size = d[4] + (d[5] << 8) + (d[6] << 16) + (d[7] << 24);
1201 
1202  n = get_stream_idx(d + 2);
1203  ff_tlog(s, "%X %X %X %X %X %X %X %X %"PRId64" %u %d\n",
1204  d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n);
1205  if (i*(avi->io_fsize>0) + (uint64_t)size > avi->fsize || d[0] > 127)
1206  continue;
1207 
1208  // parse ix##
1209  if ((d[0] == 'i' && d[1] == 'x' && n < s->nb_streams) ||
1210  // parse JUNK
1211  (d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K') ||
1212  (d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1') ||
1213  (d[0] == 'i' && d[1] == 'n' && d[2] == 'd' && d[3] == 'x')) {
1214  avio_skip(pb, size);
1215  goto start_sync;
1216  }
1217 
1218  // parse stray LIST
1219  if (d[0] == 'L' && d[1] == 'I' && d[2] == 'S' && d[3] == 'T') {
1220  avio_skip(pb, 4);
1221  goto start_sync;
1222  }
1223 
1224  n = get_stream_idx(d);
1225 
1226  if (!((i - avi->last_pkt_pos) & 1) &&
1227  get_stream_idx(d + 1) < s->nb_streams)
1228  continue;
1229 
1230  // detect ##ix chunk and skip
1231  if (d[2] == 'i' && d[3] == 'x' && n < s->nb_streams) {
1232  avio_skip(pb, size);
1233  goto start_sync;
1234  }
1235 
1236  if (d[2] == 'w' && d[3] == 'c' && n < s->nb_streams) {
1237  avio_skip(pb, 16 * 3 + 8);
1238  goto start_sync;
1239  }
1240 
1241  if (avi->dv_demux && n != 0)
1242  continue;
1243 
1244  // parse ##dc/##wb
1245  if (n < s->nb_streams) {
1246  AVStream *st;
1247  AVIStream *ast;
1248  st = s->streams[n];
1249  ast = st->priv_data;
1250 
1251  if (!ast) {
1252  av_log(s, AV_LOG_WARNING, "Skipping foreign stream %d packet\n", n);
1253  continue;
1254  }
1255 
1256  if (s->nb_streams >= 2) {
1257  AVStream *st1 = s->streams[1];
1258  AVIStream *ast1 = st1->priv_data;
1259  // workaround for broken small-file-bug402.avi
1260  if ( d[2] == 'w' && d[3] == 'b'
1261  && n == 0
1262  && st ->codecpar->codec_type == AVMEDIA_TYPE_VIDEO
1264  && ast->prefix == 'd'*256+'c'
1265  && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count)
1266  ) {
1267  n = 1;
1268  st = st1;
1269  ast = ast1;
1271  "Invalid stream + prefix combination, assuming audio.\n");
1272  }
1273  }
1274 
1275  if (d[2] == 'p' && d[3] == 'c' && size <= 4 * 256 + 4) {
1276  int k = avio_r8(pb);
1277  int last = (k + avio_r8(pb) - 1) & 0xFF;
1278 
1279  avio_rl16(pb); // flags
1280 
1281  // b + (g << 8) + (r << 16);
1282  for (; k <= last; k++)
1283  ast->pal[k] = 0xFFU<<24 | avio_rb32(pb)>>8;
1284 
1285  ast->has_pal = 1;
1286  goto start_sync;
1287  } else if (((ast->prefix_count < 5 || sync + 9 > i) &&
1288  d[2] < 128 && d[3] < 128) ||
1289  d[2] * 256 + d[3] == ast->prefix /* ||
1290  (d[2] == 'd' && d[3] == 'c') ||
1291  (d[2] == 'w' && d[3] == 'b') */) {
1292  if (exit_early)
1293  return 0;
1294  if (d[2] * 256 + d[3] == ast->prefix)
1295  ast->prefix_count++;
1296  else {
1297  ast->prefix = d[2] * 256 + d[3];
1298  ast->prefix_count = 0;
1299  }
1300 
1301  if (!avi->dv_demux &&
1302  ((st->discard >= AVDISCARD_DEFAULT && size == 0) /* ||
1303  // FIXME: needs a little reordering
1304  (st->discard >= AVDISCARD_NONKEY &&
1305  !(pkt->flags & AV_PKT_FLAG_KEY)) */
1306  || st->discard >= AVDISCARD_ALL)) {
1307 
1308  ast->frame_offset += get_duration(ast, size);
1309  avio_skip(pb, size);
1310  goto start_sync;
1311  }
1312 
1313  avi->stream_index = n;
1314  ast->packet_size = size + 8;
1315  ast->remaining = size;
1316 
1317  if (size) {
1318  uint64_t pos = avio_tell(pb) - 8;
1319  if (!st->index_entries || !st->nb_index_entries ||
1320  st->index_entries[st->nb_index_entries - 1].pos < pos) {
1321  av_add_index_entry(st, pos, ast->frame_offset, size,
1322  0, AVINDEX_KEYFRAME);
1323  }
1324  }
1325  return 0;
1326  }
1327  }
1328  }
1329 
1330  if (pb->error)
1331  return pb->error;
1332  return AVERROR_EOF;
1333 }
1334 
1336 {
1337  AVIContext *avi = s->priv_data;
1338  int best_stream_index = 0;
1339  AVStream *best_st = NULL;
1340  AVIStream *best_ast;
1341  int64_t best_ts = INT64_MAX;
1342  int i;
1343 
1344  for (i = 0; i < s->nb_streams; i++) {
1345  AVStream *st = s->streams[i];
1346  AVIStream *ast = st->priv_data;
1347  int64_t ts = ast->frame_offset;
1348  int64_t last_ts;
1349 
1350  if (!st->nb_index_entries)
1351  continue;
1352 
1353  last_ts = st->index_entries[st->nb_index_entries - 1].timestamp;
1354  if (!ast->remaining && ts > last_ts)
1355  continue;
1356 
1357  ts = av_rescale_q(ts, st->time_base,
1358  (AVRational) { FFMAX(1, ast->sample_size),
1359  AV_TIME_BASE });
1360 
1361  av_log(s, AV_LOG_TRACE, "%"PRId64" %d/%d %"PRId64"\n", ts,
1362  st->time_base.num, st->time_base.den, ast->frame_offset);
1363  if (ts < best_ts) {
1364  best_ts = ts;
1365  best_st = st;
1366  best_stream_index = i;
1367  }
1368  }
1369  if (!best_st)
1370  return AVERROR_EOF;
1371 
1372  best_ast = best_st->priv_data;
1373  best_ts = best_ast->frame_offset;
1374  if (best_ast->remaining) {
1375  i = av_index_search_timestamp(best_st,
1376  best_ts,
1377  AVSEEK_FLAG_ANY |
1379  } else {
1380  i = av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY);
1381  if (i >= 0)
1382  best_ast->frame_offset = best_st->index_entries[i].timestamp;
1383  }
1384 
1385  if (i >= 0) {
1386  int64_t pos = best_st->index_entries[i].pos;
1387  pos += best_ast->packet_size - best_ast->remaining;
1388  if (avio_seek(s->pb, pos + 8, SEEK_SET) < 0)
1389  return AVERROR_EOF;
1390 
1391  av_assert0(best_ast->remaining <= best_ast->packet_size);
1392 
1393  avi->stream_index = best_stream_index;
1394  if (!best_ast->remaining)
1395  best_ast->packet_size =
1396  best_ast->remaining = best_st->index_entries[i].size;
1397  }
1398  else
1399  return AVERROR_EOF;
1400 
1401  return 0;
1402 }
1403 
1405 {
1406  AVIContext *avi = s->priv_data;
1407  AVIOContext *pb = s->pb;
1408  int err;
1409 
1410  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1411  int size = avpriv_dv_get_packet(avi->dv_demux, pkt);
1412  if (size >= 0)
1413  return size;
1414  else
1415  goto resync;
1416  }
1417 
1418  if (avi->non_interleaved) {
1419  err = ni_prepare_read(s);
1420  if (err < 0)
1421  return err;
1422  }
1423 
1424 resync:
1425  if (avi->stream_index >= 0) {
1426  AVStream *st = s->streams[avi->stream_index];
1427  AVIStream *ast = st->priv_data;
1428  int size, err;
1429 
1430  if (get_subtitle_pkt(s, st, pkt))
1431  return 0;
1432 
1433  // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM
1434  if (ast->sample_size <= 1)
1435  size = INT_MAX;
1436  else if (ast->sample_size < 32)
1437  // arbitrary multiplier to avoid tiny packets for raw PCM data
1438  size = 1024 * ast->sample_size;
1439  else
1440  size = ast->sample_size;
1441 
1442  if (size > ast->remaining)
1443  size = ast->remaining;
1444  avi->last_pkt_pos = avio_tell(pb);
1445  err = av_get_packet(pb, pkt, size);
1446  if (err < 0)
1447  return err;
1448  size = err;
1449 
1450  if (ast->has_pal && pkt->size < (unsigned)INT_MAX / 2) {
1451  uint8_t *pal;
1452  pal = av_packet_new_side_data(pkt,
1454  AVPALETTE_SIZE);
1455  if (!pal) {
1456  av_log(s, AV_LOG_ERROR,
1457  "Failed to allocate data for palette\n");
1458  } else {
1459  memcpy(pal, ast->pal, AVPALETTE_SIZE);
1460  ast->has_pal = 0;
1461  }
1462  }
1463 
1464  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1465  AVBufferRef *avbuf = pkt->buf;
1466  size = avpriv_dv_produce_packet(avi->dv_demux, pkt,
1467  pkt->data, pkt->size, pkt->pos);
1468  pkt->buf = avbuf;
1469  pkt->flags |= AV_PKT_FLAG_KEY;
1470  if (size < 0)
1471  av_packet_unref(pkt);
1472  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE &&
1473  !st->codecpar->codec_tag && read_gab2_sub(s, st, pkt)) {
1474  ast->frame_offset++;
1475  avi->stream_index = -1;
1476  ast->remaining = 0;
1477  goto resync;
1478  } else {
1479  /* XXX: How to handle B-frames in AVI? */
1480  pkt->dts = ast->frame_offset;
1481 // pkt->dts += ast->start;
1482  if (ast->sample_size)
1483  pkt->dts /= ast->sample_size;
1484  pkt->stream_index = avi->stream_index;
1485 
1486  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && st->index_entries) {
1487  AVIndexEntry *e;
1488  int index;
1489 
1491  e = &st->index_entries[index];
1492 
1493  if (index >= 0 && e->timestamp == ast->frame_offset) {
1494  if (index == st->nb_index_entries-1) {
1495  int key=1;
1496  uint32_t state=-1;
1497  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4) {
1498  const uint8_t *ptr = pkt->data, *end = ptr + FFMIN(size, 256);
1499  while (ptr < end) {
1500  ptr = avpriv_find_start_code(ptr, end, &state);
1501  if (state == 0x1B6 && ptr < end) {
1502  key = !(*ptr & 0xC0);
1503  break;
1504  }
1505  }
1506  }
1507  if (!key)
1508  e->flags &= ~AVINDEX_KEYFRAME;
1509  }
1510  if (e->flags & AVINDEX_KEYFRAME)
1511  pkt->flags |= AV_PKT_FLAG_KEY;
1512  }
1513  } else {
1514  pkt->flags |= AV_PKT_FLAG_KEY;
1515  }
1516  ast->frame_offset += get_duration(ast, pkt->size);
1517  }
1518  ast->remaining -= err;
1519  if (!ast->remaining) {
1520  avi->stream_index = -1;
1521  ast->packet_size = 0;
1522  }
1523 
1524  if (!avi->non_interleaved && pkt->pos >= 0 && ast->seek_pos > pkt->pos) {
1525  av_packet_unref(pkt);
1526  goto resync;
1527  }
1528  ast->seek_pos= 0;
1529 
1530  if (!avi->non_interleaved && st->nb_index_entries>1 && avi->index_loaded>1) {
1531  int64_t dts= av_rescale_q(pkt->dts, st->time_base, AV_TIME_BASE_Q);
1532 
1533  if (avi->dts_max < dts) {
1534  avi->dts_max = dts;
1535  } else if (avi->dts_max - (uint64_t)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  }
1539  }
1540 
1541  return 0;
1542  }
1543 
1544  if ((err = avi_sync(s, 0)) < 0)
1545  return err;
1546  goto resync;
1547 }
1548 
1549 /* XXX: We make the implicit supposition that the positions are sorted
1550  * for each stream. */
1552 {
1553  AVIContext *avi = s->priv_data;
1554  AVIOContext *pb = s->pb;
1555  int nb_index_entries, i;
1556  AVStream *st;
1557  AVIStream *ast;
1558  int64_t pos;
1559  unsigned int index, tag, flags, len, first_packet = 1;
1560  int64_t last_pos = -1;
1561  unsigned last_idx = -1;
1562  int64_t idx1_pos, first_packet_pos = 0, data_offset = 0;
1563  int anykey = 0;
1564 
1565  nb_index_entries = size / 16;
1566  if (nb_index_entries <= 0)
1567  return AVERROR_INVALIDDATA;
1568 
1569  idx1_pos = avio_tell(pb);
1570  avio_seek(pb, avi->movi_list + 4, SEEK_SET);
1571  if (avi_sync(s, 1) == 0)
1572  first_packet_pos = avio_tell(pb) - 8;
1573  avi->stream_index = -1;
1574  avio_seek(pb, idx1_pos, SEEK_SET);
1575 
1576  if (s->nb_streams == 1 && s->streams[0]->codecpar->codec_tag == AV_RL32("MMES")) {
1577  first_packet_pos = 0;
1578  data_offset = avi->movi_list;
1579  }
1580 
1581  /* Read the entries and sort them in each stream component. */
1582  for (i = 0; i < nb_index_entries; i++) {
1583  if (avio_feof(pb))
1584  return -1;
1585 
1586  tag = avio_rl32(pb);
1587  flags = avio_rl32(pb);
1588  pos = avio_rl32(pb);
1589  len = avio_rl32(pb);
1590  av_log(s, AV_LOG_TRACE, "%d: tag=0x%x flags=0x%x pos=0x%"PRIx64" len=%d/",
1591  i, tag, flags, pos, len);
1592 
1593  index = ((tag & 0xff) - '0') * 10;
1594  index += (tag >> 8 & 0xff) - '0';
1595  if (index >= s->nb_streams)
1596  continue;
1597  st = s->streams[index];
1598  ast = st->priv_data;
1599 
1600  /* Skip 'xxpc' palette change entries in the index until a logic
1601  * to process these is properly implemented. */
1602  if ((tag >> 16 & 0xff) == 'p' && (tag >> 24 & 0xff) == 'c')
1603  continue;
1604 
1605  if (first_packet && first_packet_pos) {
1606  if (avi->movi_list + 4 != pos || pos + 500 > first_packet_pos)
1607  data_offset = first_packet_pos - pos;
1608  first_packet = 0;
1609  }
1610  pos += data_offset;
1611 
1612  av_log(s, AV_LOG_TRACE, "%d cum_len=%"PRId64"\n", len, ast->cum_len);
1613 
1614  // even if we have only a single stream, we should
1615  // switch to non-interleaved to get correct timestamps
1616  if (last_pos == pos)
1617  avi->non_interleaved = 1;
1618  if (last_idx != pos && len) {
1619  av_add_index_entry(st, pos, ast->cum_len, len, 0,
1620  (flags & AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);
1621  last_idx= pos;
1622  }
1623  ast->cum_len += get_duration(ast, len);
1624  last_pos = pos;
1625  anykey |= flags&AVIIF_INDEX;
1626  }
1627  if (!anykey) {
1628  for (index = 0; index < s->nb_streams; index++) {
1629  st = s->streams[index];
1630  if (st->nb_index_entries)
1632  }
1633  }
1634  return 0;
1635 }
1636 
1637 /* Scan the index and consider any file with streams more than
1638  * 2 seconds or 64MB apart non-interleaved. */
1640 {
1641  int64_t min_pos, pos;
1642  int i;
1643  int *idx = av_mallocz_array(s->nb_streams, sizeof(*idx));
1644  if (!idx)
1645  return AVERROR(ENOMEM);
1646  for (min_pos = pos = 0; min_pos != INT64_MAX; pos = min_pos + 1LU) {
1647  int64_t max_dts = INT64_MIN / 2;
1648  int64_t min_dts = INT64_MAX / 2;
1649  int64_t max_buffer = 0;
1650 
1651  min_pos = INT64_MAX;
1652 
1653  for (i = 0; i < s->nb_streams; i++) {
1654  AVStream *st = s->streams[i];
1655  AVIStream *ast = st->priv_data;
1656  int n = st->nb_index_entries;
1657  while (idx[i] < n && st->index_entries[idx[i]].pos < pos)
1658  idx[i]++;
1659  if (idx[i] < n) {
1660  int64_t dts;
1661  dts = av_rescale_q(st->index_entries[idx[i]].timestamp /
1662  FFMAX(ast->sample_size, 1),
1663  st->time_base, AV_TIME_BASE_Q);
1664  min_dts = FFMIN(min_dts, dts);
1665  min_pos = FFMIN(min_pos, st->index_entries[idx[i]].pos);
1666  }
1667  }
1668  for (i = 0; i < s->nb_streams; i++) {
1669  AVStream *st = s->streams[i];
1670  AVIStream *ast = st->priv_data;
1671 
1672  if (idx[i] && min_dts != INT64_MAX / 2) {
1673  int64_t dts;
1674  dts = av_rescale_q(st->index_entries[idx[i] - 1].timestamp /
1675  FFMAX(ast->sample_size, 1),
1676  st->time_base, AV_TIME_BASE_Q);
1677  max_dts = FFMAX(max_dts, dts);
1678  max_buffer = FFMAX(max_buffer,
1679  av_rescale(dts - min_dts,
1680  st->codecpar->bit_rate,
1681  AV_TIME_BASE));
1682  }
1683  }
1684  if (max_dts - min_dts > 2 * AV_TIME_BASE ||
1685  max_buffer > 1024 * 1024 * 8 * 8) {
1686  av_free(idx);
1687  return 1;
1688  }
1689  }
1690  av_free(idx);
1691  return 0;
1692 }
1693 
1695 {
1696  int i;
1697  int64_t last_start = 0;
1698  int64_t first_end = INT64_MAX;
1699  int64_t oldpos = avio_tell(s->pb);
1700 
1701  for (i = 0; i < s->nb_streams; i++) {
1702  AVStream *st = s->streams[i];
1703  int n = st->nb_index_entries;
1704  unsigned int size;
1705 
1706  if (n <= 0)
1707  continue;
1708 
1709  if (n >= 2) {
1710  int64_t pos = st->index_entries[0].pos;
1711  unsigned tag[2];
1712  avio_seek(s->pb, pos, SEEK_SET);
1713  tag[0] = avio_r8(s->pb);
1714  tag[1] = avio_r8(s->pb);
1715  avio_rl16(s->pb);
1716  size = avio_rl32(s->pb);
1717  if (get_stream_idx(tag) == i && pos + size > st->index_entries[1].pos)
1718  last_start = INT64_MAX;
1719  if (get_stream_idx(tag) == i && size == st->index_entries[0].size + 8)
1720  last_start = INT64_MAX;
1721  }
1722 
1723  if (st->index_entries[0].pos > last_start)
1724  last_start = st->index_entries[0].pos;
1725  if (st->index_entries[n - 1].pos < first_end)
1726  first_end = st->index_entries[n - 1].pos;
1727  }
1728  avio_seek(s->pb, oldpos, SEEK_SET);
1729 
1730  if (last_start > first_end)
1731  return 1;
1732 
1733  return check_stream_max_drift(s);
1734 }
1735 
1737 {
1738  AVIContext *avi = s->priv_data;
1739  AVIOContext *pb = s->pb;
1740  uint32_t tag, size;
1741  int64_t pos = avio_tell(pb);
1742  int64_t next;
1743  int ret = -1;
1744 
1745  if (avio_seek(pb, avi->movi_end, SEEK_SET) < 0)
1746  goto the_end; // maybe truncated file
1747  av_log(s, AV_LOG_TRACE, "movi_end=0x%"PRIx64"\n", avi->movi_end);
1748  for (;;) {
1749  tag = avio_rl32(pb);
1750  size = avio_rl32(pb);
1751  if (avio_feof(pb))
1752  break;
1753  next = avio_tell(pb) + size + (size & 1);
1754 
1755  if (tag == MKTAG('i', 'd', 'x', '1') &&
1756  avi_read_idx1(s, size) >= 0) {
1757  avi->index_loaded=2;
1758  ret = 0;
1759  }else if (tag == MKTAG('L', 'I', 'S', 'T')) {
1760  uint32_t tag1 = avio_rl32(pb);
1761 
1762  if (tag1 == MKTAG('I', 'N', 'F', 'O'))
1763  ff_read_riff_info(s, size - 4);
1764  }else if (!ret)
1765  break;
1766 
1767  if (avio_seek(pb, next, SEEK_SET) < 0)
1768  break; // something is wrong here
1769  }
1770 
1771 the_end:
1772  avio_seek(pb, pos, SEEK_SET);
1773  return ret;
1774 }
1775 
1776 static void seek_subtitle(AVStream *st, AVStream *st2, int64_t timestamp)
1777 {
1778  AVIStream *ast2 = st2->priv_data;
1779  int64_t ts2 = av_rescale_q(timestamp, st->time_base, st2->time_base);
1780  av_packet_unref(&ast2->sub_pkt);
1781  if (avformat_seek_file(ast2->sub_ctx, 0, INT64_MIN, ts2, ts2, 0) >= 0 ||
1782  avformat_seek_file(ast2->sub_ctx, 0, ts2, ts2, INT64_MAX, 0) >= 0)
1783  ff_read_packet(ast2->sub_ctx, &ast2->sub_pkt);
1784 }
1785 
1786 static int avi_read_seek(AVFormatContext *s, int stream_index,
1787  int64_t timestamp, int flags)
1788 {
1789  AVIContext *avi = s->priv_data;
1790  AVStream *st;
1791  int i, index;
1792  int64_t pos, pos_min;
1793  AVIStream *ast;
1794 
1795  /* Does not matter which stream is requested dv in avi has the
1796  * stream information in the first video stream.
1797  */
1798  if (avi->dv_demux)
1799  stream_index = 0;
1800 
1801  if (!avi->index_loaded) {
1802  /* we only load the index on demand */
1803  avi_load_index(s);
1804  avi->index_loaded |= 1;
1805  }
1806  av_assert0(stream_index >= 0);
1807 
1808  st = s->streams[stream_index];
1809  ast = st->priv_data;
1810  index = av_index_search_timestamp(st,
1811  timestamp * FFMAX(ast->sample_size, 1),
1812  flags);
1813  if (index < 0) {
1814  if (st->nb_index_entries > 0)
1815  av_log(s, AV_LOG_DEBUG, "Failed to find timestamp %"PRId64 " in index %"PRId64 " .. %"PRId64 "\n",
1816  timestamp * FFMAX(ast->sample_size, 1),
1817  st->index_entries[0].timestamp,
1819  return AVERROR_INVALIDDATA;
1820  }
1821 
1822  /* find the position */
1823  pos = st->index_entries[index].pos;
1824  timestamp = st->index_entries[index].timestamp / FFMAX(ast->sample_size, 1);
1825 
1826  av_log(s, AV_LOG_TRACE, "XX %"PRId64" %d %"PRId64"\n",
1827  timestamp, index, st->index_entries[index].timestamp);
1828 
1829  if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1830  /* One and only one real stream for DV in AVI, and it has video */
1831  /* offsets. Calling with other stream indexes should have failed */
1832  /* the av_index_search_timestamp call above. */
1833 
1834  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
1835  return -1;
1836 
1837  /* Feed the DV video stream version of the timestamp to the */
1838  /* DV demux so it can synthesize correct timestamps. */
1839  ff_dv_offset_reset(avi->dv_demux, timestamp);
1840 
1841  avi->stream_index = -1;
1842  return 0;
1843  }
1844 
1845  pos_min = pos;
1846  for (i = 0; i < s->nb_streams; i++) {
1847  AVStream *st2 = s->streams[i];
1848  AVIStream *ast2 = st2->priv_data;
1849 
1850  ast2->packet_size =
1851  ast2->remaining = 0;
1852 
1853  if (ast2->sub_ctx) {
1854  seek_subtitle(st, st2, timestamp);
1855  continue;
1856  }
1857 
1858  if (st2->nb_index_entries <= 0)
1859  continue;
1860 
1861 // av_assert1(st2->codecpar->block_align);
1862  index = av_index_search_timestamp(st2,
1863  av_rescale_q(timestamp,
1864  st->time_base,
1865  st2->time_base) *
1866  FFMAX(ast2->sample_size, 1),
1867  flags |
1870  if (index < 0)
1871  index = 0;
1872  ast2->seek_pos = st2->index_entries[index].pos;
1873  pos_min = FFMIN(pos_min,ast2->seek_pos);
1874  }
1875  for (i = 0; i < s->nb_streams; i++) {
1876  AVStream *st2 = s->streams[i];
1877  AVIStream *ast2 = st2->priv_data;
1878 
1879  if (ast2->sub_ctx || st2->nb_index_entries <= 0)
1880  continue;
1881 
1882  index = av_index_search_timestamp(
1883  st2,
1884  av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1),
1886  if (index < 0)
1887  index = 0;
1888  while (!avi->non_interleaved && index>0 && st2->index_entries[index-1].pos >= pos_min)
1889  index--;
1890  ast2->frame_offset = st2->index_entries[index].timestamp;
1891  }
1892 
1893  /* do the seek */
1894  if (avio_seek(s->pb, pos_min, SEEK_SET) < 0) {
1895  av_log(s, AV_LOG_ERROR, "Seek failed\n");
1896  return -1;
1897  }
1898  avi->stream_index = -1;
1899  avi->dts_max = INT_MIN;
1900  return 0;
1901 }
1902 
1904 {
1905  int i;
1906  AVIContext *avi = s->priv_data;
1907 
1908  for (i = 0; i < s->nb_streams; i++) {
1909  AVStream *st = s->streams[i];
1910  AVIStream *ast = st->priv_data;
1911  if (ast) {
1912  if (ast->sub_ctx) {
1913  av_freep(&ast->sub_ctx->pb);
1915  }
1916  av_buffer_unref(&ast->sub_buffer);
1917  av_packet_unref(&ast->sub_pkt);
1918  }
1919  }
1920 
1921  av_freep(&avi->dv_demux);
1922 
1923  return 0;
1924 }
1925 
1926 static int avi_probe(const AVProbeData *p)
1927 {
1928  int i;
1929 
1930  /* check file header */
1931  for (i = 0; avi_headers[i][0]; i++)
1932  if (AV_RL32(p->buf ) == AV_RL32(avi_headers[i] ) &&
1933  AV_RL32(p->buf + 8) == AV_RL32(avi_headers[i] + 4))
1934  return AVPROBE_SCORE_MAX;
1935 
1936  return 0;
1937 }
1938 
1940  .name = "avi",
1941  .long_name = NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"),
1942  .priv_data_size = sizeof(AVIContext),
1943  .extensions = "avi",
1944  .read_probe = avi_probe,
1949  .priv_class = &demuxer_class,
1950 };
int ff_read_riff_info(AVFormatContext *s, int64_t size)
Definition: riffdec.c:228
static AVStream * get_subtitle_pkt(AVFormatContext *s, AVStream *next_st, AVPacket *pkt)
Definition: avidec.c:1134
#define AVSEEK_FLAG_BACKWARD
Definition: avformat.h:2507
#define ff_tlog(ctx,...)
Definition: internal.h:86
#define NULL
Definition: coverity.c:32
full parsing and interpolation of timestamps for frames not starting on a packet boundary ...
Definition: avformat.h:797
uint32_t handler
Definition: avidec.c:47
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void ff_metadata_conv_ctx(AVFormatContext *ctx, const AVMetadataConv *d_conv, const AVMetadataConv *s_conv)
Definition: metadata.c:59
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:346
uint32_t pal[256]
Definition: avidec.c:56
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
AVOption.
Definition: opt.h:248
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: utils.c:1983
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3096
AVFormatContext * sub_ctx
Definition: avidec.c:61
const char * desc
Definition: libsvtav1.c:79
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
unsigned char * buf_ptr
Current position in the buffer.
Definition: avio.h:228
unsigned char * buf_end
End of the data, may be less than buffer+buffer_size if the read function returned less data than req...
Definition: avio.h:229
#define MAX_ODML_DEPTH
Definition: avidec.c:83
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:383
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4869
#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:160
int64_t pos
Definition: avformat.h:805
#define AVSEEK_FLAG_ANY
seek to any frame, even non-keyframes
Definition: avformat.h:2509
int64_t last_pkt_pos
Definition: avidec.c:75
uint32_t rate
Definition: avidec.c:49
#define avpriv_request_sample(...)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:938
int dshow_block_align
Definition: avidec.c:58
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:877
int size
Definition: packet.h:364
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
#define AVPROBE_PADDING_SIZE
extra allocated bytes at the end of the probe buffer
Definition: avformat.h:455
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1105
int is_odml
Definition: avidec.c:77
enum AVMediaType codec_type
Definition: rtp.c:37
int64_t movi_end
Definition: avidec.c:71
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
uint32_t scale
Definition: avidec.c:48
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:500
static int get_duration(AVIStream *ast, int len)
Definition: avidec.c:124
void * priv_data
Definition: avformat.h:891
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:341
#define AVIIF_INDEX
Definition: avi.h:38
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
discard all
Definition: avcodec.h:236
static AVPacket pkt
static void error(const char *err)
static int ni_prepare_read(AVFormatContext *s)
Definition: avidec.c:1335
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:1639
static const AVMetadataConv avi_metadata_conv[]
Definition: avidec.c:111
uint8_t base
Definition: vp3data.h:202
Format I/O context.
Definition: avformat.h:1351
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1484
Public dictionary API.
int stream_index
Definition: avidec.c:79
uint8_t
static int nb_streams
Definition: ffprobe.c:282
#define av_malloc(s)
Opaque data information usually continuous.
Definition: avutil.h:203
int width
Video only.
Definition: codec_par.h:126
AVOptions.
static int avi_read_close(AVFormatContext *s)
Definition: avidec.c:1903
int64_t riff_end
Definition: avidec.c:70
const AVCodecTag ff_codec_movvideo_tags[]
Definition: isom.c:75
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:790
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
int use_odml
Definition: avidec.c:82
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
enum AVStreamParseType need_parsing
Definition: avformat.h:1094
int id
Format-specific stream ID.
Definition: avformat.h:883
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int64_t movi_list
Definition: avidec.c:74
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4450
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
int64_t duration
Definition: movenc.c:63
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:208
static void clean_index(AVFormatContext *s)
Definition: avidec.c: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:1482
DVDemuxContext * avpriv_dv_init_demux(AVFormatContext *s)
Definition: dv.c:339
uint8_t * data
Definition: packet.h:363
static int read_gab2_sub(AVFormatContext *s, AVStream *st, AVPacket *pkt)
Definition: avidec.c:1064
uint32_t tag
Definition: movenc.c:1596
#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:305
const AVCodecTag ff_codec_bmp_tags_unofficial[]
Definition: riff.c:501
#define max(a, b)
Definition: cuda_runtime.h:33
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
static const uint8_t header[24]
Definition: sdr2.c:67
#define av_log(a,...)
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
int ff_get_wav_header(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
Definition: riffdec.c:91
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
int packet_size
Definition: avidec.c:45
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
#define U(x)
Definition: vp56_arith.h:37
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning...
Definition: avformat.h:544
#define AVIF_MUSTUSEINDEX
Definition: avi.h:25
#define AVINDEX_KEYFRAME
Definition: avformat.h:812
AVIOContext * avio_alloc_context(unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Allocate and initialize an AVIOContext for buffered I/O.
Definition: aviobuf.c:138
ff_const59 AVInputFormat * av_probe_input_format2(ff_const59 AVProbeData *pd, int is_opened, int *score_max)
Guess the file format.
Definition: format.c:205
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1591
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: packet.h:46
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2100
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:759
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
int remaining
Definition: avidec.c:44
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:806
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:416
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:346
static int avi_read_tag(AVFormatContext *s, AVStream *st, uint32_t tag, uint32_t size)
Definition: avidec.c: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:1168
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:949
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:123
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
Only parse headers, do not repack.
Definition: avformat.h:796
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:628
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1407
int prefix_count
Definition: avidec.c:55
AVBufferRef * sub_buffer
Definition: avidec.c:63
int non_interleaved
Definition: avidec.c:78
int block_align
Audio only.
Definition: codec_par.h:177
static int avi_probe(const AVProbeData *p)
Definition: avidec.c:1926
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
static struct @322 state
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:444
const AVCodecTag ff_codec_bmp_tags[]
Definition: riff.c:32
void ff_free_stream(AVFormatContext *s, AVStream *st)
Definition: utils.c:4371
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:215
#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:469
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:1776
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:1503
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1666
AVDictionary * metadata
Definition: avformat.h:940
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
Read a transport packet from a media file.
Definition: utils.c:792
static int calculate_bitrate(AVFormatContext *s)
Definition: avidec.c:424
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
if(ret)
Stream structure.
Definition: avformat.h:876
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
static const char avi_headers[][8]
Definition: avidec.c:102
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
static int avi_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: avidec.c:1404
int prefix
Definition: avidec.c:54
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:161
int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, uint8_t *buf, int buf_size, int64_t pos)
Definition: dv.c:372
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
AVIOContext * pb
I/O context.
Definition: avformat.h:1393
static int resync(AVFormatContext *s)
Definition: flvdec.c:946
int index_loaded
Definition: avidec.c:76
int avpriv_exif_decode_ifd(void *logctx, const uint8_t *buf, int size, int le, int depth, AVDictionary **metadata)
Recursively decodes all IFD&#39;s and adds included TAGS into the metadata dictionary.
Definition: exif.c:144
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
int nb_index_entries
Definition: avformat.h:1107
static const AVOption options[]
Definition: avidec.c:88
Describe the class of an AVClass context structure.
Definition: log.h:67
static int avi_read_idx1(AVFormatContext *s, int size)
Definition: avidec.c:1551
int index
Definition: gxfenc.c:89
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:279
discard useless packets like 0 size packets in avi
Definition: avcodec.h:231
#define snprintf
Definition: snprintf.h:34
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
int error
contains the error code or 0 if no error happened
Definition: avio.h:245
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Seek to timestamp ts.
Definition: utils.c:2481
const AVMetadataConv ff_riff_info_conv[]
Definition: riff.c:592
int64_t seek_pos
Definition: avidec.c:65
#define flags(name, subs,...)
Definition: cbs_av1.c:560
static int avi_load_index(AVFormatContext *s)
Definition: avidec.c:1736
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
#define AVERROR_DEMUXER_NOT_FOUND
Demuxer not found.
Definition: error.h:53
AVInputFormat ff_avi_demuxer
Definition: avidec.c:1939
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:925
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
int64_t io_fsize
Definition: avidec.c:73
int64_t bitrate
Definition: h264_levels.c:131
A reference to a data buffer.
Definition: buffer.h:81
static const AVClass demuxer_class
Definition: avidec.c:93
full parsing and repack
Definition: avformat.h:795
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:743
Main libavformat public API header.
static void avi_read_nikon(AVFormatContext *s, uint64_t end)
Definition: avidec.c:343
static void avi_metadata_creation_time(AVDictionary **metadata, char *date)
Definition: avidec.c:324
common internal api header.
AVPacket sub_pkt
Definition: avidec.c:62
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:915
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1618
static int get_riff(AVFormatContext *s, AVIOContext *pb)
Definition: avidec.c:134
void avio_context_free(AVIOContext **s)
Free the supplied IO context and everything associated with it.
Definition: aviobuf.c:155
int ff_get_extradata(AVFormatContext *s, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: utils.c:3277
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:927
int den
Denominator.
Definition: rational.h:60
int avpriv_dv_get_packet(DVDemuxContext *c, AVPacket *pkt)
Definition: dv.c:355
int ff_get_bmp_header(AVIOContext *pb, AVStream *st, uint32_t *size)
Read BITMAPINFOHEADER structure and set AVStream codec width, height and bits_per_encoded_sample fiel...
Definition: riffdec.c:209
int sample_size
Definition: avidec.c:50
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4422
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
#define av_free(p)
char * value
Definition: dict.h:87
int len
int has_pal
Definition: avidec.c:57
static int guess_ni_flag(AVFormatContext *s)
Definition: avidec.c:1694
void * priv_data
Format private data.
Definition: avformat.h:1379
int64_t frame_offset
Definition: avidec.c:42
int64_t dts_max
Definition: avidec.c:84
int64_t fsize
Definition: avidec.c:72
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:362
static int avi_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: avidec.c:1786
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1466
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:368
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
static int64_t fsize(FILE *f)
Definition: audiomatch.c:28
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:332
int stream_index
Definition: packet.h:365
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:905
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static int read_odml_index(AVFormatContext *s, int frame_num)
Definition: avidec.c:159
#define MKTAG(a, b, c, d)
Definition: common.h:406
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2082
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:931
int odml_depth
Definition: avidec.c:81
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: avformat.h:1133
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: packet.h:340
uint64_t avio_rl64(AVIOContext *s)
Definition: aviobuf.c:767
static int avi_sync(AVFormatContext *s, int exit_early)
Definition: avidec.c:1182
int i
Definition: input.c:407
#define RETURN_ERROR(code)
Definition: avidec.c:468
GLuint buffer
Definition: opengl_enc.c:101
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
const char * name
Definition: opengl_enc.c:102
DVDemuxContext * dv_demux
Definition: avidec.c:80