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