3 * Copyright (c) 2001 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
24 #include "libavutil/avassert.h"
25 #include "libavutil/avstring.h"
26 #include "libavutil/bswap.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/mathematics.h"
37 #include "libavcodec/bytestream.h"
38 #include "libavcodec/exif.h"
40 typedef struct AVIStream
{
41 int64_t frame_offset
; /* current frame (video) or byte (audio) counter
42 * (used to compute the pts) */
48 int sample_size
; /* size of one sample (or packet)
49 * (in the rate/scale sense) in bytes */
51 int64_t cum_len
; /* temporary storage (used during seek) */
52 int prefix
; /* normally 'd'<<8 + 'c' or 'w'<<8 + 'b' */
56 int dshow_block_align
; /* block align variable used to emulate bugs in
57 * the MS dshow demuxer */
59 AVFormatContext
*sub_ctx
;
78 DVDemuxContext
*dv_demux
;
81 #define MAX_ODML_DEPTH 1000
86 static const AVOption options
[] = {
87 { "use_odml", "use odml index", offsetof(AVIContext
, use_odml
), AV_OPT_TYPE_INT
, {.i64
= 1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM
},
91 static const AVClass demuxer_class
= {
93 .item_name
= av_default_item_name
,
95 .version
= LIBAVUTIL_VERSION_INT
,
96 .category
= AV_CLASS_CATEGORY_DEMUXER
,
100 static const char avi_headers
[][8] = {
101 { 'R', 'I', 'F', 'F', 'A', 'V', 'I', ' ' },
102 { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 'X' },
103 { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 0x19 },
104 { 'O', 'N', '2', ' ', 'O', 'N', '2', 'f' },
105 { 'R', 'I', 'F', 'F', 'A', 'M', 'V', ' ' },
109 static const AVMetadataConv avi_metadata_conv
[] = {
114 static int avi_load_index(AVFormatContext
*s
);
115 static int guess_ni_flag(AVFormatContext
*s
);
117 #define print_tag(str, tag, size) \
118 av_dlog(NULL, "pos:%"PRIX64" %s: tag=%c%c%c%c size=0x%x\n", \
119 avio_tell(pb), str, tag & 0xff, \
121 (tag >> 16) & 0xff, \
122 (tag >> 24) & 0xff, \
125 static inline int get_duration(AVIStream
*ast
, int len
)
127 if (ast
->sample_size
)
129 else if (ast
->dshow_block_align
)
130 return (len
+ ast
->dshow_block_align
- 1) / ast
->dshow_block_align
;
135 static int get_riff(AVFormatContext
*s
, AVIOContext
*pb
)
137 AVIContext
*avi
= s
->priv_data
;
141 /* check RIFF header */
142 avio_read(pb
, header
, 4);
143 avi
->riff_end
= avio_rl32(pb
); /* RIFF chunk size */
144 avi
->riff_end
+= avio_tell(pb
); /* RIFF chunk end */
145 avio_read(pb
, header
+ 4, 4);
147 for (i
= 0; avi_headers
[i
][0]; i
++)
148 if (!memcmp(header
, avi_headers
[i
], 8))
150 if (!avi_headers
[i
][0])
151 return AVERROR_INVALIDDATA
;
153 if (header
[7] == 0x19)
154 av_log(s
, AV_LOG_INFO
,
155 "This file has been generated by a totally broken muxer.\n");
160 static int read_braindead_odml_indx(AVFormatContext
*s
, int frame_num
)
162 AVIContext
*avi
= s
->priv_data
;
163 AVIOContext
*pb
= s
->pb
;
164 int longs_pre_entry
= avio_rl16(pb
);
165 int index_sub_type
= avio_r8(pb
);
166 int index_type
= avio_r8(pb
);
167 int entries_in_use
= avio_rl32(pb
);
168 int chunk_id
= avio_rl32(pb
);
169 int64_t base
= avio_rl64(pb
);
170 int stream_id
= ((chunk_id
& 0xFF) - '0') * 10 +
171 ((chunk_id
>> 8 & 0xFF) - '0');
175 int64_t last_pos
= -1;
176 int64_t filesize
= avi
->fsize
;
179 "longs_pre_entry:%d index_type:%d entries_in_use:%d "
180 "chunk_id:%X base:%16"PRIX64
"\n",
187 if (stream_id
>= s
->nb_streams
|| stream_id
< 0)
188 return AVERROR_INVALIDDATA
;
189 st
= s
->streams
[stream_id
];
193 return AVERROR_INVALIDDATA
;
197 if (index_type
&& longs_pre_entry
!= 2)
198 return AVERROR_INVALIDDATA
;
200 return AVERROR_INVALIDDATA
;
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)
209 return AVERROR_INVALIDDATA
;
212 for (i
= 0; i
< entries_in_use
; i
++) {
214 int64_t pos
= avio_rl32(pb
) + base
- 8;
215 int len
= avio_rl32(pb
);
220 av_log(s
, AV_LOG_ERROR
, "pos:%"PRId64
", len:%X\n", pos
, len
);
223 return AVERROR_INVALIDDATA
;
225 if (last_pos
== pos
|| pos
== base
- 8)
226 avi
->non_interleaved
= 1;
227 if (last_pos
!= pos
&& len
)
228 av_add_index_entry(st
, pos
, ast
->cum_len
, len
, 0,
229 key
? AVINDEX_KEYFRAME
: 0);
231 ast
->cum_len
+= get_duration(ast
, len
);
236 offset
= avio_rl64(pb
);
237 avio_rl32(pb
); /* size */
238 duration
= avio_rl32(pb
);
241 return AVERROR_INVALIDDATA
;
245 if (avi
->odml_depth
> MAX_ODML_DEPTH
) {
246 av_log(s
, AV_LOG_ERROR
, "Too deeply nested ODML indexes\n");
247 return AVERROR_INVALIDDATA
;
250 if (avio_seek(pb
, offset
+ 8, SEEK_SET
) < 0)
253 read_braindead_odml_indx(s
, frame_num
);
255 frame_num
+= duration
;
257 if (avio_seek(pb
, pos
, SEEK_SET
) < 0) {
258 av_log(s
, AV_LOG_ERROR
, "Failed to restore position after reading index\n");
264 avi
->index_loaded
= 2;
268 static void clean_index(AVFormatContext
*s
)
273 for (i
= 0; i
< s
->nb_streams
; i
++) {
274 AVStream
*st
= s
->streams
[i
];
275 AVIStream
*ast
= st
->priv_data
;
276 int n
= st
->nb_index_entries
;
277 int max
= ast
->sample_size
;
278 int64_t pos
, size
, ts
;
280 if (n
!= 1 || ast
->sample_size
== 0)
286 pos
= st
->index_entries
[0].pos
;
287 size
= st
->index_entries
[0].size
;
288 ts
= st
->index_entries
[0].timestamp
;
290 for (j
= 0; j
< size
; j
+= max
)
291 av_add_index_entry(st
, pos
+ j
, ts
+ j
, FFMIN(max
, size
- j
), 0,
296 static int avi_read_tag(AVFormatContext
*s
, AVStream
*st
, uint32_t tag
,
299 AVIOContext
*pb
= s
->pb
;
305 if (size
== UINT_MAX
)
306 return AVERROR(EINVAL
);
307 value
= av_malloc(size
+ 1);
309 return AVERROR(ENOMEM
);
310 avio_read(pb
, value
, size
);
315 return av_dict_set(st
? &st
->metadata
: &s
->metadata
, key
, value
,
316 AV_DICT_DONT_STRDUP_VAL
);
319 static const char months
[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
320 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
322 static void avi_metadata_creation_time(AVDictionary
**metadata
, char *date
)
324 char month
[4], time
[9], buffer
[64];
326 /* parse standard AVI date format (ie. "Mon Mar 10 15:04:43 2003") */
327 if (sscanf(date
, "%*3s%*[ ]%3s%*[ ]%2d%*[ ]%8s%*[ ]%4d",
328 month
, &day
, time
, &year
) == 4) {
329 for (i
= 0; i
< 12; i
++)
330 if (!av_strcasecmp(month
, months
[i
])) {
331 snprintf(buffer
, sizeof(buffer
), "%.4d-%.2d-%.2d %s",
332 year
, i
+ 1, day
, time
);
333 av_dict_set(metadata
, "creation_time", buffer
, 0);
335 } else if (date
[4] == '/' && date
[7] == '/') {
336 date
[4] = date
[7] = '-';
337 av_dict_set(metadata
, "creation_time", date
, 0);
341 static void avi_read_nikon(AVFormatContext
*s
, uint64_t end
)
343 while (avio_tell(s
->pb
) < end
) {
344 uint32_t tag
= avio_rl32(s
->pb
);
345 uint32_t size
= avio_rl32(s
->pb
);
347 case MKTAG('n', 'c', 't', 'g'): /* Nikon Tags */
349 uint64_t tag_end
= avio_tell(s
->pb
) + size
;
350 while (avio_tell(s
->pb
) < tag_end
) {
351 uint16_t tag
= avio_rl16(s
->pb
);
352 uint16_t size
= avio_rl16(s
->pb
);
353 const char *name
= NULL
;
354 char buffer
[64] = { 0 };
355 size
= FFMIN(size
, tag_end
- avio_tell(s
->pb
));
356 size
-= avio_read(s
->pb
, buffer
,
357 FFMIN(size
, sizeof(buffer
) - 1));
366 name
= "creation_time";
367 if (buffer
[4] == ':' && buffer
[7] == ':')
368 buffer
[4] = buffer
[7] = '-';
372 av_dict_set(&s
->metadata
, name
, buffer
, 0);
373 avio_skip(s
->pb
, size
);
378 avio_skip(s
->pb
, size
);
384 static int avi_extract_stream_metadata(AVStream
*st
)
387 uint8_t *data
= st
->codec
->extradata
;
388 int data_size
= st
->codec
->extradata_size
;
391 if (!data
|| data_size
< 8) {
392 return AVERROR_INVALIDDATA
;
395 bytestream2_init(&gb
, data
, data_size
);
397 tag
= bytestream2_get_le32(&gb
);
400 case MKTAG('A', 'V', 'I', 'F'):
401 // skip 4 byte padding
402 bytestream2_skip(&gb
, 4);
403 offset
= bytestream2_tell(&gb
);
404 bytestream2_init(&gb
, data
+ offset
, data_size
- offset
);
406 // decode EXIF tags from IFD, AVI is always little-endian
407 return avpriv_exif_decode_ifd(st
->codec
, &gb
, 1, 0, &st
->metadata
);
409 case MKTAG('C', 'A', 'S', 'I'):
410 avpriv_request_sample(st
->codec
, "RIFF stream data tag type CASI (%u)", tag
);
412 case MKTAG('Z', 'o', 'r', 'a'):
413 avpriv_request_sample(st
->codec
, "RIFF stream data tag type Zora (%u)", tag
);
422 static int calculate_bitrate(AVFormatContext
*s
)
424 AVIContext
*avi
= s
->priv_data
;
429 for (i
= 0; i
<s
->nb_streams
; i
++) {
431 AVStream
*st
= s
->streams
[i
];
433 if (!st
->nb_index_entries
)
436 for (j
= 0; j
< st
->nb_index_entries
; j
++)
437 len
+= st
->index_entries
[j
].size
;
438 maxpos
= FFMAX(maxpos
, st
->index_entries
[j
-1].pos
);
441 if (maxpos
< avi
->io_fsize
*9/10) // index does not cover the whole file
443 if (lensum
*9/10 > maxpos
|| lensum
< maxpos
*9/10) // frame sum and filesize mismatch
446 for (i
= 0; i
<s
->nb_streams
; i
++) {
448 AVStream
*st
= s
->streams
[i
];
451 for (j
= 0; j
< st
->nb_index_entries
; j
++)
452 len
+= st
->index_entries
[j
].size
;
454 if (st
->nb_index_entries
< 2 || st
->codec
->bit_rate
> 0)
456 duration
= st
->index_entries
[j
-1].timestamp
- st
->index_entries
[0].timestamp
;
457 st
->codec
->bit_rate
= av_rescale(8*len
, st
->time_base
.den
, duration
* st
->time_base
.num
);
462 static int avi_read_header(AVFormatContext
*s
)
464 AVIContext
*avi
= s
->priv_data
;
465 AVIOContext
*pb
= s
->pb
;
466 unsigned int tag
, tag1
, handler
;
467 int codec_type
, stream_index
, frame_period
;
471 AVIStream
*ast
= NULL
;
472 int avih_width
= 0, avih_height
= 0;
473 int amv_file_format
= 0;
474 uint64_t list_end
= 0;
476 AVDictionaryEntry
*dict_entry
;
478 avi
->stream_index
= -1;
480 ret
= get_riff(s
, pb
);
484 av_log(avi
, AV_LOG_DEBUG
, "use odml:%d\n", avi
->use_odml
);
486 avi
->io_fsize
= avi
->fsize
= avio_size(pb
);
487 if (avi
->fsize
<= 0 || avi
->fsize
< avi
->riff_end
)
488 avi
->fsize
= avi
->riff_end
== 8 ? INT64_MAX
: avi
->riff_end
;
498 size
= avio_rl32(pb
);
500 print_tag("tag", tag
, size
);
503 case MKTAG('L', 'I', 'S', 'T'):
504 list_end
= avio_tell(pb
) + size
;
505 /* Ignored, except at start of video packets. */
506 tag1
= avio_rl32(pb
);
508 print_tag("list", tag1
, 0);
510 if (tag1
== MKTAG('m', 'o', 'v', 'i')) {
511 avi
->movi_list
= avio_tell(pb
) - 4;
513 avi
->movi_end
= avi
->movi_list
+ size
+ (size
& 1);
515 avi
->movi_end
= avi
->fsize
;
516 av_dlog(NULL
, "movi end=%"PRIx64
"\n", avi
->movi_end
);
518 } else if (tag1
== MKTAG('I', 'N', 'F', 'O'))
519 ff_read_riff_info(s
, size
- 4);
520 else if (tag1
== MKTAG('n', 'c', 'd', 't'))
521 avi_read_nikon(s
, list_end
);
524 case MKTAG('I', 'D', 'I', 'T'):
526 unsigned char date
[64] = { 0 };
528 size
-= avio_read(pb
, date
, FFMIN(size
, sizeof(date
) - 1));
530 avi_metadata_creation_time(&s
->metadata
, date
);
533 case MKTAG('d', 'm', 'l', 'h'):
535 avio_skip(pb
, size
+ (size
& 1));
537 case MKTAG('a', 'm', 'v', 'h'):
539 case MKTAG('a', 'v', 'i', 'h'):
541 /* using frame_period is bad idea */
542 frame_period
= avio_rl32(pb
);
543 avio_rl32(pb
); /* max. bytes per second */
545 avi
->non_interleaved
|= avio_rl32(pb
) & AVIF_MUSTUSEINDEX
;
547 avio_skip(pb
, 2 * 4);
550 avih_width
= avio_rl32(pb
);
551 avih_height
= avio_rl32(pb
);
553 avio_skip(pb
, size
- 10 * 4);
555 case MKTAG('s', 't', 'r', 'h'):
558 tag1
= avio_rl32(pb
);
559 handler
= avio_rl32(pb
); /* codec tag */
561 if (tag1
== MKTAG('p', 'a', 'd', 's')) {
562 avio_skip(pb
, size
- 8);
566 st
= avformat_new_stream(s
, NULL
);
570 st
->id
= stream_index
;
571 ast
= av_mallocz(sizeof(AVIStream
));
577 tag1
= stream_index
? MKTAG('a', 'u', 'd', 's')
578 : MKTAG('v', 'i', 'd', 's');
580 print_tag("strh", tag1
, -1);
582 if (tag1
== MKTAG('i', 'a', 'v', 's') ||
583 tag1
== MKTAG('i', 'v', 'a', 's')) {
586 /* After some consideration -- I don't think we
587 * have to support anything but DV in type1 AVIs. */
588 if (s
->nb_streams
!= 1)
591 if (handler
!= MKTAG('d', 'v', 's', 'd') &&
592 handler
!= MKTAG('d', 'v', 'h', 'd') &&
593 handler
!= MKTAG('d', 'v', 's', 'l'))
596 ast
= s
->streams
[0]->priv_data
;
597 av_freep(&s
->streams
[0]->codec
->extradata
);
598 av_freep(&s
->streams
[0]->codec
);
599 if (s
->streams
[0]->info
)
600 av_freep(&s
->streams
[0]->info
->duration_error
);
601 av_freep(&s
->streams
[0]->info
);
602 av_freep(&s
->streams
[0]);
604 if (CONFIG_DV_DEMUXER
) {
605 avi
->dv_demux
= avpriv_dv_init_demux(s
);
610 s
->streams
[0]->priv_data
= ast
;
611 avio_skip(pb
, 3 * 4);
612 ast
->scale
= avio_rl32(pb
);
613 ast
->rate
= avio_rl32(pb
);
614 avio_skip(pb
, 4); /* start time */
616 dv_dur
= avio_rl32(pb
);
617 if (ast
->scale
> 0 && ast
->rate
> 0 && dv_dur
> 0) {
618 dv_dur
*= AV_TIME_BASE
;
619 s
->duration
= av_rescale(dv_dur
, ast
->scale
, ast
->rate
);
621 /* else, leave duration alone; timing estimation in utils.c
622 * will make a guess based on bitrate. */
624 stream_index
= s
->nb_streams
- 1;
625 avio_skip(pb
, size
- 9 * 4);
629 av_assert0(stream_index
< s
->nb_streams
);
630 st
->codec
->stream_codec_tag
= handler
;
632 avio_rl32(pb
); /* flags */
633 avio_rl16(pb
); /* priority */
634 avio_rl16(pb
); /* language */
635 avio_rl32(pb
); /* initial frame */
636 ast
->scale
= avio_rl32(pb
);
637 ast
->rate
= avio_rl32(pb
);
638 if (!(ast
->scale
&& ast
->rate
)) {
639 av_log(s
, AV_LOG_WARNING
,
640 "scale/rate is %"PRIu32
"/%"PRIu32
" which is invalid. "
641 "(This file has been generated by broken software.)\n",
646 ast
->scale
= frame_period
;
652 avpriv_set_pts_info(st
, 64, ast
->scale
, ast
->rate
);
654 ast
->cum_len
= avio_rl32(pb
); /* start */
655 st
->nb_frames
= avio_rl32(pb
);
658 avio_rl32(pb
); /* buffer size */
659 avio_rl32(pb
); /* quality */
660 if (ast
->cum_len
*ast
->scale
/ast
->rate
> 3600) {
661 av_log(s
, AV_LOG_ERROR
, "crazy start time, iam scared, giving up\n");
662 return AVERROR_INVALIDDATA
;
664 ast
->sample_size
= avio_rl32(pb
); /* sample ssize */
665 ast
->cum_len
*= FFMAX(1, ast
->sample_size
);
666 av_dlog(s
, "%"PRIu32
" %"PRIu32
" %d\n",
667 ast
->rate
, ast
->scale
, ast
->sample_size
);
670 case MKTAG('v', 'i', 'd', 's'):
671 codec_type
= AVMEDIA_TYPE_VIDEO
;
673 ast
->sample_size
= 0;
674 st
->avg_frame_rate
= av_inv_q(st
->time_base
);
676 case MKTAG('a', 'u', 'd', 's'):
677 codec_type
= AVMEDIA_TYPE_AUDIO
;
679 case MKTAG('t', 'x', 't', 's'):
680 codec_type
= AVMEDIA_TYPE_SUBTITLE
;
682 case MKTAG('d', 'a', 't', 's'):
683 codec_type
= AVMEDIA_TYPE_DATA
;
686 av_log(s
, AV_LOG_INFO
, "unknown stream type %X\n", tag1
);
688 if (ast
->sample_size
== 0) {
689 st
->duration
= st
->nb_frames
;
690 if (st
->duration
> 0 && avi
->io_fsize
> 0 && avi
->riff_end
> avi
->io_fsize
) {
691 av_log(s
, AV_LOG_DEBUG
, "File is truncated adjusting duration\n");
692 st
->duration
= av_rescale(st
->duration
, avi
->io_fsize
, avi
->riff_end
);
695 ast
->frame_offset
= ast
->cum_len
;
696 avio_skip(pb
, size
- 12 * 4);
698 case MKTAG('s', 't', 'r', 'f'):
702 if (stream_index
>= (unsigned)s
->nb_streams
|| avi
->dv_demux
) {
705 uint64_t cur_pos
= avio_tell(pb
);
707 if (cur_pos
< list_end
)
708 size
= FFMIN(size
, list_end
- cur_pos
);
709 st
= s
->streams
[stream_index
];
710 if (st
->codec
->codec_type
!= AVMEDIA_TYPE_UNKNOWN
) {
714 switch (codec_type
) {
715 case AVMEDIA_TYPE_VIDEO
:
716 if (amv_file_format
) {
717 st
->codec
->width
= avih_width
;
718 st
->codec
->height
= avih_height
;
719 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
720 st
->codec
->codec_id
= AV_CODEC_ID_AMV
;
724 tag1
= ff_get_bmp_header(pb
, st
, &esize
);
726 if (tag1
== MKTAG('D', 'X', 'S', 'B') ||
727 tag1
== MKTAG('D', 'X', 'S', 'A')) {
728 st
->codec
->codec_type
= AVMEDIA_TYPE_SUBTITLE
;
729 st
->codec
->codec_tag
= tag1
;
730 st
->codec
->codec_id
= AV_CODEC_ID_XSUB
;
734 if (size
> 10 * 4 && size
< (1 << 30) && size
< avi
->fsize
) {
735 if (esize
== size
-1 && (esize
&1)) {
736 st
->codec
->extradata_size
= esize
- 10 * 4;
738 st
->codec
->extradata_size
= size
- 10 * 4;
739 if (ff_get_extradata(st
->codec
, pb
, st
->codec
->extradata_size
) < 0)
740 return AVERROR(ENOMEM
);
743 // FIXME: check if the encoder really did this correctly
744 if (st
->codec
->extradata_size
& 1)
747 /* Extract palette from extradata if bpp <= 8.
748 * This code assumes that extradata contains only palette.
749 * This is true for all paletted codecs implemented in
751 if (st
->codec
->extradata_size
&&
752 (st
->codec
->bits_per_coded_sample
<= 8)) {
753 int pal_size
= (1 << st
->codec
->bits_per_coded_sample
) << 2;
754 const uint8_t *pal_src
;
756 pal_size
= FFMIN(pal_size
, st
->codec
->extradata_size
);
757 pal_src
= st
->codec
->extradata
+
758 st
->codec
->extradata_size
- pal_size
;
759 /* Exclude the "BottomUp" field from the palette */
760 if (pal_src
- st
->codec
->extradata
>= 9 &&
761 !memcmp(st
->codec
->extradata
+ st
->codec
->extradata_size
- 9, "BottomUp", 9))
763 for (i
= 0; i
< pal_size
/ 4; i
++)
764 ast
->pal
[i
] = 0xFFU
<<24 | AV_RL32(pal_src
+4*i
);
768 print_tag("video", tag1
, 0);
770 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
771 st
->codec
->codec_tag
= tag1
;
772 st
->codec
->codec_id
= ff_codec_get_id(ff_codec_bmp_tags
,
774 /* This is needed to get the pict type which is necessary
775 * for generating correct pts. */
776 st
->need_parsing
= AVSTREAM_PARSE_HEADERS
;
777 if (st
->codec
->codec_tag
== MKTAG('V', 'S', 'S', 'H'))
778 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
780 if (st
->codec
->codec_tag
== 0 && st
->codec
->height
> 0 &&
781 st
->codec
->extradata_size
< 1U << 30) {
782 st
->codec
->extradata_size
+= 9;
783 if ((ret
= av_reallocp(&st
->codec
->extradata
,
784 st
->codec
->extradata_size
+
785 FF_INPUT_BUFFER_PADDING_SIZE
)) < 0) {
786 st
->codec
->extradata_size
= 0;
789 memcpy(st
->codec
->extradata
+ st
->codec
->extradata_size
- 9,
792 st
->codec
->height
= FFABS(st
->codec
->height
);
794 // avio_skip(pb, size - 5 * 4);
796 case AVMEDIA_TYPE_AUDIO
:
797 ret
= ff_get_wav_header(pb
, st
->codec
, size
);
800 ast
->dshow_block_align
= st
->codec
->block_align
;
801 if (ast
->sample_size
&& st
->codec
->block_align
&&
802 ast
->sample_size
!= st
->codec
->block_align
) {
805 "sample size (%d) != block align (%d)\n",
807 st
->codec
->block_align
);
808 ast
->sample_size
= st
->codec
->block_align
;
811 * (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
814 /* Force parsing as several audio frames can be in
815 * one packet and timestamps refer to packet start. */
816 st
->need_parsing
= AVSTREAM_PARSE_TIMESTAMPS
;
817 /* ADTS header is in extradata, AAC without header must be
818 * stored as exact frames. Parser not needed and it will
820 if (st
->codec
->codec_id
== AV_CODEC_ID_AAC
&&
821 st
->codec
->extradata_size
)
822 st
->need_parsing
= AVSTREAM_PARSE_NONE
;
823 /* AVI files with Xan DPCM audio (wrongly) declare PCM
824 * audio in the header but have Axan as stream_code_tag. */
825 if (st
->codec
->stream_codec_tag
== AV_RL32("Axan")) {
826 st
->codec
->codec_id
= AV_CODEC_ID_XAN_DPCM
;
827 st
->codec
->codec_tag
= 0;
828 ast
->dshow_block_align
= 0;
830 if (amv_file_format
) {
831 st
->codec
->codec_id
= AV_CODEC_ID_ADPCM_IMA_AMV
;
832 ast
->dshow_block_align
= 0;
834 if (st
->codec
->codec_id
== AV_CODEC_ID_AAC
&& ast
->dshow_block_align
<= 4 && ast
->dshow_block_align
) {
835 av_log(s
, AV_LOG_DEBUG
, "overriding invalid dshow_block_align of %d\n", ast
->dshow_block_align
);
836 ast
->dshow_block_align
= 0;
838 if (st
->codec
->codec_id
== AV_CODEC_ID_AAC
&& ast
->dshow_block_align
== 1024 && ast
->sample_size
== 1024 ||
839 st
->codec
->codec_id
== AV_CODEC_ID_AAC
&& ast
->dshow_block_align
== 4096 && ast
->sample_size
== 4096 ||
840 st
->codec
->codec_id
== AV_CODEC_ID_MP3
&& ast
->dshow_block_align
== 1152 && ast
->sample_size
== 1152) {
841 av_log(s
, AV_LOG_DEBUG
, "overriding sample_size\n");
842 ast
->sample_size
= 0;
845 case AVMEDIA_TYPE_SUBTITLE
:
846 st
->codec
->codec_type
= AVMEDIA_TYPE_SUBTITLE
;
847 st
->request_probe
= 1;
851 st
->codec
->codec_type
= AVMEDIA_TYPE_DATA
;
852 st
->codec
->codec_id
= AV_CODEC_ID_NONE
;
853 st
->codec
->codec_tag
= 0;
859 case MKTAG('s', 't', 'r', 'd'):
860 if (stream_index
>= (unsigned)s
->nb_streams
861 || s
->streams
[stream_index
]->codec
->extradata_size
862 || s
->streams
[stream_index
]->codec
->codec_tag
== MKTAG('H','2','6','4')) {
865 uint64_t cur_pos
= avio_tell(pb
);
866 if (cur_pos
< list_end
)
867 size
= FFMIN(size
, list_end
- cur_pos
);
868 st
= s
->streams
[stream_index
];
871 if (ff_get_extradata(st
->codec
, pb
, size
) < 0)
872 return AVERROR(ENOMEM
);
875 if (st
->codec
->extradata_size
& 1) //FIXME check if the encoder really did this correctly
878 ret
= avi_extract_stream_metadata(st
);
880 av_log(s
, AV_LOG_WARNING
, "could not decoding EXIF data in stream header.\n");
884 case MKTAG('i', 'n', 'd', 'x'):
886 if (pb
->seekable
&& !(s
->flags
& AVFMT_FLAG_IGNIDX
) &&
888 read_braindead_odml_indx(s
, 0) < 0 &&
889 (s
->error_recognition
& AV_EF_EXPLODE
))
891 avio_seek(pb
, i
+ size
, SEEK_SET
);
893 case MKTAG('v', 'p', 'r', 'p'):
894 if (stream_index
< (unsigned)s
->nb_streams
&& size
> 9 * 4) {
895 AVRational active
, active_aspect
;
897 st
= s
->streams
[stream_index
];
904 active_aspect
.den
= avio_rl16(pb
);
905 active_aspect
.num
= avio_rl16(pb
);
906 active
.num
= avio_rl32(pb
);
907 active
.den
= avio_rl32(pb
);
908 avio_rl32(pb
); // nbFieldsPerFrame
910 if (active_aspect
.num
&& active_aspect
.den
&&
911 active
.num
&& active
.den
) {
912 st
->sample_aspect_ratio
= av_div_q(active_aspect
, active
);
913 av_dlog(s
, "vprp %d/%d %d/%d\n",
914 active_aspect
.num
, active_aspect
.den
,
915 active
.num
, active
.den
);
921 case MKTAG('s', 't', 'r', 'n'):
923 ret
= avi_read_tag(s
, s
->streams
[s
->nb_streams
- 1], tag
, size
);
929 if (size
> 1000000) {
930 av_log(s
, AV_LOG_ERROR
,
931 "Something went wrong during header parsing, "
932 "I will ignore it and try to continue anyway.\n");
933 if (s
->error_recognition
& AV_EF_EXPLODE
)
935 avi
->movi_list
= avio_tell(pb
) - 4;
936 avi
->movi_end
= avi
->fsize
;
947 /* check stream number */
948 if (stream_index
!= s
->nb_streams
- 1) {
951 return AVERROR_INVALIDDATA
;
954 if (!avi
->index_loaded
&& pb
->seekable
)
956 calculate_bitrate(s
);
957 avi
->index_loaded
|= 1;
959 if ((ret
= guess_ni_flag(s
)) < 0)
962 avi
->non_interleaved
|= ret
| (s
->flags
& AVFMT_FLAG_SORT_DTS
);
964 dict_entry
= av_dict_get(s
->metadata
, "ISFT", NULL
, 0);
965 if (dict_entry
&& !strcmp(dict_entry
->value
, "PotEncoder"))
966 for (i
= 0; i
< s
->nb_streams
; i
++) {
967 AVStream
*st
= s
->streams
[i
];
968 if ( st
->codec
->codec_id
== AV_CODEC_ID_MPEG1VIDEO
969 || st
->codec
->codec_id
== AV_CODEC_ID_MPEG2VIDEO
)
970 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
973 for (i
= 0; i
< s
->nb_streams
; i
++) {
974 AVStream
*st
= s
->streams
[i
];
975 if (st
->nb_index_entries
)
978 // DV-in-AVI cannot be non-interleaved, if set this must be
981 avi
->non_interleaved
= 0;
982 if (i
== s
->nb_streams
&& avi
->non_interleaved
) {
983 av_log(s
, AV_LOG_WARNING
,
984 "Non-interleaved AVI without index, switching to interleaved\n");
985 avi
->non_interleaved
= 0;
988 if (avi
->non_interleaved
) {
989 av_log(s
, AV_LOG_INFO
, "non-interleaved AVI\n");
993 ff_metadata_conv_ctx(s
, NULL
, avi_metadata_conv
);
994 ff_metadata_conv_ctx(s
, NULL
, ff_riff_info_conv
);
999 static int read_gab2_sub(AVFormatContext
*s
, AVStream
*st
, AVPacket
*pkt
)
1001 if (pkt
->size
>= 7 &&
1002 pkt
->size
< INT_MAX
- AVPROBE_PADDING_SIZE
&&
1003 !strcmp(pkt
->data
, "GAB2") && AV_RL16(pkt
->data
+ 5) == 2) {
1005 int score
= AVPROBE_SCORE_EXTENSION
, ret
;
1006 AVIStream
*ast
= st
->priv_data
;
1007 AVInputFormat
*sub_demuxer
;
1008 AVRational time_base
;
1010 AVIOContext
*pb
= avio_alloc_context(pkt
->data
+ 7,
1012 0, NULL
, NULL
, NULL
, NULL
);
1014 unsigned int desc_len
= avio_rl32(pb
);
1016 if (desc_len
> pb
->buf_end
- pb
->buf_ptr
)
1019 ret
= avio_get_str16le(pb
, desc_len
, desc
, sizeof(desc
));
1020 avio_skip(pb
, desc_len
- ret
);
1022 av_dict_set(&st
->metadata
, "title", desc
, 0);
1024 avio_rl16(pb
); /* flags? */
1025 avio_rl32(pb
); /* data size */
1027 size
= pb
->buf_end
- pb
->buf_ptr
;
1028 pd
= (AVProbeData
) { .buf
= av_mallocz(size
+ AVPROBE_PADDING_SIZE
),
1032 memcpy(pd
.buf
, pb
->buf_ptr
, size
);
1033 sub_demuxer
= av_probe_input_format2(&pd
, 1, &score
);
1038 if (!(ast
->sub_ctx
= avformat_alloc_context()))
1041 ast
->sub_ctx
->pb
= pb
;
1043 if (ff_copy_whitelists(ast
->sub_ctx
, s
) < 0)
1046 if (!avformat_open_input(&ast
->sub_ctx
, "", sub_demuxer
, NULL
)) {
1047 ff_read_packet(ast
->sub_ctx
, &ast
->sub_pkt
);
1048 *st
->codec
= *ast
->sub_ctx
->streams
[0]->codec
;
1049 ast
->sub_ctx
->streams
[0]->codec
->extradata
= NULL
;
1050 time_base
= ast
->sub_ctx
->streams
[0]->time_base
;
1051 avpriv_set_pts_info(st
, 64, time_base
.num
, time_base
.den
);
1053 ast
->sub_buffer
= pkt
->data
;
1054 memset(pkt
, 0, sizeof(*pkt
));
1058 av_freep(&ast
->sub_ctx
);
1064 static AVStream
*get_subtitle_pkt(AVFormatContext
*s
, AVStream
*next_st
,
1067 AVIStream
*ast
, *next_ast
= next_st
->priv_data
;
1068 int64_t ts
, next_ts
, ts_min
= INT64_MAX
;
1069 AVStream
*st
, *sub_st
= NULL
;
1072 next_ts
= av_rescale_q(next_ast
->frame_offset
, next_st
->time_base
,
1075 for (i
= 0; i
< s
->nb_streams
; i
++) {
1077 ast
= st
->priv_data
;
1078 if (st
->discard
< AVDISCARD_ALL
&& ast
&& ast
->sub_pkt
.data
) {
1079 ts
= av_rescale_q(ast
->sub_pkt
.dts
, st
->time_base
, AV_TIME_BASE_Q
);
1080 if (ts
<= next_ts
&& ts
< ts_min
) {
1088 ast
= sub_st
->priv_data
;
1089 *pkt
= ast
->sub_pkt
;
1090 pkt
->stream_index
= sub_st
->index
;
1092 if (ff_read_packet(ast
->sub_ctx
, &ast
->sub_pkt
) < 0)
1093 ast
->sub_pkt
.data
= NULL
;
1098 static int get_stream_idx(const unsigned *d
)
1100 if (d
[0] >= '0' && d
[0] <= '9' &&
1101 d
[1] >= '0' && d
[1] <= '9') {
1102 return (d
[0] - '0') * 10 + (d
[1] - '0');
1104 return 100; // invalid stream ID
1110 * @param exit_early set to 1 to just gather packet position without making the changes needed to actually read & return the packet
1112 static int avi_sync(AVFormatContext
*s
, int exit_early
)
1114 AVIContext
*avi
= s
->priv_data
;
1115 AVIOContext
*pb
= s
->pb
;
1122 memset(d
, -1, sizeof(d
));
1123 for (i
= sync
= avio_tell(pb
); !avio_feof(pb
); i
++) {
1126 for (j
= 0; j
< 7; j
++)
1130 size
= d
[4] + (d
[5] << 8) + (d
[6] << 16) + (d
[7] << 24);
1132 n
= get_stream_idx(d
+ 2);
1133 av_dlog(s
, "%X %X %X %X %X %X %X %X %"PRId64
" %u %d\n",
1134 d
[0], d
[1], d
[2], d
[3], d
[4], d
[5], d
[6], d
[7], i
, size
, n
);
1135 if (i
*(avi
->io_fsize
>0) + (uint64_t)size
> avi
->fsize
|| d
[0] > 127)
1139 if ((d
[0] == 'i' && d
[1] == 'x' && n
< s
->nb_streams
) ||
1141 (d
[0] == 'J' && d
[1] == 'U' && d
[2] == 'N' && d
[3] == 'K') ||
1142 (d
[0] == 'i' && d
[1] == 'd' && d
[2] == 'x' && d
[3] == '1')) {
1143 avio_skip(pb
, size
);
1148 if (d
[0] == 'L' && d
[1] == 'I' && d
[2] == 'S' && d
[3] == 'T') {
1153 n
= get_stream_idx(d
);
1155 if (!((i
- avi
->last_pkt_pos
) & 1) &&
1156 get_stream_idx(d
+ 1) < s
->nb_streams
)
1159 // detect ##ix chunk and skip
1160 if (d
[2] == 'i' && d
[3] == 'x' && n
< s
->nb_streams
) {
1161 avio_skip(pb
, size
);
1165 if (avi
->dv_demux
&& n
!= 0)
1169 if (n
< s
->nb_streams
) {
1173 ast
= st
->priv_data
;
1176 av_log(s
, AV_LOG_WARNING
, "Skipping foreign stream %d packet\n", n
);
1180 if (s
->nb_streams
>= 2) {
1181 AVStream
*st1
= s
->streams
[1];
1182 AVIStream
*ast1
= st1
->priv_data
;
1183 // workaround for broken small-file-bug402.avi
1184 if ( d
[2] == 'w' && d
[3] == 'b'
1186 && st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
1187 && st1
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
1188 && ast
->prefix
== 'd'*256+'c'
1189 && (d
[2]*256+d
[3] == ast1
->prefix
|| !ast1
->prefix_count
)
1194 av_log(s
, AV_LOG_WARNING
,
1195 "Invalid stream + prefix combination, assuming audio.\n");
1199 if (!avi
->dv_demux
&&
1200 ((st
->discard
>= AVDISCARD_DEFAULT
&& size
== 0) /* ||
1201 // FIXME: needs a little reordering
1202 (st->discard >= AVDISCARD_NONKEY &&
1203 !(pkt->flags & AV_PKT_FLAG_KEY)) */
1204 || st
->discard
>= AVDISCARD_ALL
)) {
1206 ast
->frame_offset
+= get_duration(ast
, size
);
1207 avio_skip(pb
, size
);
1212 if (d
[2] == 'p' && d
[3] == 'c' && size
<= 4 * 256 + 4) {
1213 int k
= avio_r8(pb
);
1214 int last
= (k
+ avio_r8(pb
) - 1) & 0xFF;
1216 avio_rl16(pb
); // flags
1218 // b + (g << 8) + (r << 16);
1219 for (; k
<= last
; k
++)
1220 ast
->pal
[k
] = 0xFFU
<<24 | avio_rb32(pb
)>>8;
1224 } else if (((ast
->prefix_count
< 5 || sync
+ 9 > i
) &&
1225 d
[2] < 128 && d
[3] < 128) ||
1226 d
[2] * 256 + d
[3] == ast
->prefix
/* ||
1227 (d[2] == 'd' && d[3] == 'c') ||
1228 (d[2] == 'w' && d[3] == 'b') */) {
1231 if (d
[2] * 256 + d
[3] == ast
->prefix
)
1232 ast
->prefix_count
++;
1234 ast
->prefix
= d
[2] * 256 + d
[3];
1235 ast
->prefix_count
= 0;
1238 avi
->stream_index
= n
;
1239 ast
->packet_size
= size
+ 8;
1240 ast
->remaining
= size
;
1243 uint64_t pos
= avio_tell(pb
) - 8;
1244 if (!st
->index_entries
|| !st
->nb_index_entries
||
1245 st
->index_entries
[st
->nb_index_entries
- 1].pos
< pos
) {
1246 av_add_index_entry(st
, pos
, ast
->frame_offset
, size
,
1247 0, AVINDEX_KEYFRAME
);
1260 static int avi_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
1262 AVIContext
*avi
= s
->priv_data
;
1263 AVIOContext
*pb
= s
->pb
;
1265 #if FF_API_DESTRUCT_PACKET
1269 if (CONFIG_DV_DEMUXER
&& avi
->dv_demux
) {
1270 int size
= avpriv_dv_get_packet(avi
->dv_demux
, pkt
);
1277 if (avi
->non_interleaved
) {
1278 int best_stream_index
= 0;
1279 AVStream
*best_st
= NULL
;
1280 AVIStream
*best_ast
;
1281 int64_t best_ts
= INT64_MAX
;
1284 for (i
= 0; i
< s
->nb_streams
; i
++) {
1285 AVStream
*st
= s
->streams
[i
];
1286 AVIStream
*ast
= st
->priv_data
;
1287 int64_t ts
= ast
->frame_offset
;
1290 if (!st
->nb_index_entries
)
1293 last_ts
= st
->index_entries
[st
->nb_index_entries
- 1].timestamp
;
1294 if (!ast
->remaining
&& ts
> last_ts
)
1297 ts
= av_rescale_q(ts
, st
->time_base
,
1298 (AVRational
) { FFMAX(1, ast
->sample_size
),
1301 av_dlog(s
, "%"PRId64
" %d/%d %"PRId64
"\n", ts
,
1302 st
->time_base
.num
, st
->time_base
.den
, ast
->frame_offset
);
1306 best_stream_index
= i
;
1312 best_ast
= best_st
->priv_data
;
1313 best_ts
= best_ast
->frame_offset
;
1314 if (best_ast
->remaining
) {
1315 i
= av_index_search_timestamp(best_st
,
1318 AVSEEK_FLAG_BACKWARD
);
1320 i
= av_index_search_timestamp(best_st
, best_ts
, AVSEEK_FLAG_ANY
);
1322 best_ast
->frame_offset
= best_st
->index_entries
[i
].timestamp
;
1326 int64_t pos
= best_st
->index_entries
[i
].pos
;
1327 pos
+= best_ast
->packet_size
- best_ast
->remaining
;
1328 if (avio_seek(s
->pb
, pos
+ 8, SEEK_SET
) < 0)
1331 av_assert0(best_ast
->remaining
<= best_ast
->packet_size
);
1333 avi
->stream_index
= best_stream_index
;
1334 if (!best_ast
->remaining
)
1335 best_ast
->packet_size
=
1336 best_ast
->remaining
= best_st
->index_entries
[i
].size
;
1343 if (avi
->stream_index
>= 0) {
1344 AVStream
*st
= s
->streams
[avi
->stream_index
];
1345 AVIStream
*ast
= st
->priv_data
;
1348 if (get_subtitle_pkt(s
, st
, pkt
))
1351 // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM
1352 if (ast
->sample_size
<= 1)
1354 else if (ast
->sample_size
< 32)
1355 // arbitrary multiplier to avoid tiny packets for raw PCM data
1356 size
= 1024 * ast
->sample_size
;
1358 size
= ast
->sample_size
;
1360 if (size
> ast
->remaining
)
1361 size
= ast
->remaining
;
1362 avi
->last_pkt_pos
= avio_tell(pb
);
1363 err
= av_get_packet(pb
, pkt
, size
);
1368 if (ast
->has_pal
&& pkt
->size
< (unsigned)INT_MAX
/ 2) {
1370 pal
= av_packet_new_side_data(pkt
,
1371 AV_PKT_DATA_PALETTE
,
1374 av_log(s
, AV_LOG_ERROR
,
1375 "Failed to allocate data for palette\n");
1377 memcpy(pal
, ast
->pal
, AVPALETTE_SIZE
);
1382 if (CONFIG_DV_DEMUXER
&& avi
->dv_demux
) {
1383 AVBufferRef
*avbuf
= pkt
->buf
;
1384 #if FF_API_DESTRUCT_PACKET
1385 FF_DISABLE_DEPRECATION_WARNINGS
1386 dstr
= pkt
->destruct
;
1387 FF_ENABLE_DEPRECATION_WARNINGS
1389 size
= avpriv_dv_produce_packet(avi
->dv_demux
, pkt
,
1390 pkt
->data
, pkt
->size
, pkt
->pos
);
1391 #if FF_API_DESTRUCT_PACKET
1392 FF_DISABLE_DEPRECATION_WARNINGS
1393 pkt
->destruct
= dstr
;
1394 FF_ENABLE_DEPRECATION_WARNINGS
1397 pkt
->flags
|= AV_PKT_FLAG_KEY
;
1399 av_free_packet(pkt
);
1400 } else if (st
->codec
->codec_type
== AVMEDIA_TYPE_SUBTITLE
&&
1401 !st
->codec
->codec_tag
&& read_gab2_sub(s
, st
, pkt
)) {
1402 ast
->frame_offset
++;
1403 avi
->stream_index
= -1;
1407 /* XXX: How to handle B-frames in AVI? */
1408 pkt
->dts
= ast
->frame_offset
;
1409 // pkt->dts += ast->start;
1410 if (ast
->sample_size
)
1411 pkt
->dts
/= ast
->sample_size
;
1413 "dts:%"PRId64
" offset:%"PRId64
" %d/%d smpl_siz:%d "
1414 "base:%d st:%d size:%d\n",
1423 pkt
->stream_index
= avi
->stream_index
;
1425 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
&& st
->index_entries
) {
1429 index
= av_index_search_timestamp(st
, ast
->frame_offset
, AVSEEK_FLAG_ANY
);
1430 e
= &st
->index_entries
[index
];
1432 if (index
>= 0 && e
->timestamp
== ast
->frame_offset
) {
1433 if (index
== st
->nb_index_entries
-1) {
1437 for (i
=0; i
<FFMIN(size
,256); i
++) {
1438 if (st
->codec
->codec_id
== AV_CODEC_ID_MPEG4
) {
1439 if (state
== 0x1B6) {
1440 key
= !(pkt
->data
[i
]&0xC0);
1445 state
= (state
<<8) + pkt
->data
[i
];
1448 e
->flags
&= ~AVINDEX_KEYFRAME
;
1450 if (e
->flags
& AVINDEX_KEYFRAME
)
1451 pkt
->flags
|= AV_PKT_FLAG_KEY
;
1454 pkt
->flags
|= AV_PKT_FLAG_KEY
;
1456 ast
->frame_offset
+= get_duration(ast
, pkt
->size
);
1458 ast
->remaining
-= err
;
1459 if (!ast
->remaining
) {
1460 avi
->stream_index
= -1;
1461 ast
->packet_size
= 0;
1464 if (!avi
->non_interleaved
&& pkt
->pos
>= 0 && ast
->seek_pos
> pkt
->pos
) {
1465 av_free_packet(pkt
);
1470 if (!avi
->non_interleaved
&& st
->nb_index_entries
>1 && avi
->index_loaded
>1) {
1471 int64_t dts
= av_rescale_q(pkt
->dts
, st
->time_base
, AV_TIME_BASE_Q
);
1473 if (avi
->dts_max
- dts
> 2*AV_TIME_BASE
) {
1474 avi
->non_interleaved
= 1;
1475 av_log(s
, AV_LOG_INFO
, "Switching to NI mode, due to poor interleaving\n");
1476 }else if (avi
->dts_max
< dts
)
1483 if ((err
= avi_sync(s
, 0)) < 0)
1488 /* XXX: We make the implicit supposition that the positions are sorted
1489 * for each stream. */
1490 static int avi_read_idx1(AVFormatContext
*s
, int size
)
1492 AVIContext
*avi
= s
->priv_data
;
1493 AVIOContext
*pb
= s
->pb
;
1494 int nb_index_entries
, i
;
1497 unsigned int index
, tag
, flags
, pos
, len
, first_packet
= 1;
1498 unsigned last_pos
= -1;
1499 unsigned last_idx
= -1;
1500 int64_t idx1_pos
, first_packet_pos
= 0, data_offset
= 0;
1503 nb_index_entries
= size
/ 16;
1504 if (nb_index_entries
<= 0)
1505 return AVERROR_INVALIDDATA
;
1507 idx1_pos
= avio_tell(pb
);
1508 avio_seek(pb
, avi
->movi_list
+ 4, SEEK_SET
);
1509 if (avi_sync(s
, 1) == 0)
1510 first_packet_pos
= avio_tell(pb
) - 8;
1511 avi
->stream_index
= -1;
1512 avio_seek(pb
, idx1_pos
, SEEK_SET
);
1514 if (s
->nb_streams
== 1 && s
->streams
[0]->codec
->codec_tag
== AV_RL32("MMES")) {
1515 first_packet_pos
= 0;
1516 data_offset
= avi
->movi_list
;
1519 /* Read the entries and sort them in each stream component. */
1520 for (i
= 0; i
< nb_index_entries
; i
++) {
1524 tag
= avio_rl32(pb
);
1525 flags
= avio_rl32(pb
);
1526 pos
= avio_rl32(pb
);
1527 len
= avio_rl32(pb
);
1528 av_dlog(s
, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/",
1529 i
, tag
, flags
, pos
, len
);
1531 index
= ((tag
& 0xff) - '0') * 10;
1532 index
+= (tag
>> 8 & 0xff) - '0';
1533 if (index
>= s
->nb_streams
)
1535 st
= s
->streams
[index
];
1536 ast
= st
->priv_data
;
1538 if (first_packet
&& first_packet_pos
) {
1539 data_offset
= first_packet_pos
- pos
;
1544 av_dlog(s
, "%d cum_len=%"PRId64
"\n", len
, ast
->cum_len
);
1546 // even if we have only a single stream, we should
1547 // switch to non-interleaved to get correct timestamps
1548 if (last_pos
== pos
)
1549 avi
->non_interleaved
= 1;
1550 if (last_idx
!= pos
&& len
) {
1551 av_add_index_entry(st
, pos
, ast
->cum_len
, len
, 0,
1552 (flags
& AVIIF_INDEX
) ? AVINDEX_KEYFRAME
: 0);
1555 ast
->cum_len
+= get_duration(ast
, len
);
1557 anykey
|= flags
&AVIIF_INDEX
;
1560 for (index
= 0; index
< s
->nb_streams
; index
++) {
1561 st
= s
->streams
[index
];
1562 if (st
->nb_index_entries
)
1563 st
->index_entries
[0].flags
|= AVINDEX_KEYFRAME
;
1569 /* Scan the index and consider any file with streams more than
1570 * 2 seconds or 64MB apart non-interleaved. */
1571 static int check_stream_max_drift(AVFormatContext
*s
)
1573 int64_t min_pos
, pos
;
1575 int *idx
= av_mallocz_array(s
->nb_streams
, sizeof(*idx
));
1577 return AVERROR(ENOMEM
);
1578 for (min_pos
= pos
= 0; min_pos
!= INT64_MAX
; pos
= min_pos
+ 1LU) {
1579 int64_t max_dts
= INT64_MIN
/ 2;
1580 int64_t min_dts
= INT64_MAX
/ 2;
1581 int64_t max_buffer
= 0;
1583 min_pos
= INT64_MAX
;
1585 for (i
= 0; i
< s
->nb_streams
; i
++) {
1586 AVStream
*st
= s
->streams
[i
];
1587 AVIStream
*ast
= st
->priv_data
;
1588 int n
= st
->nb_index_entries
;
1589 while (idx
[i
] < n
&& st
->index_entries
[idx
[i
]].pos
< pos
)
1593 dts
= av_rescale_q(st
->index_entries
[idx
[i
]].timestamp
/
1594 FFMAX(ast
->sample_size
, 1),
1595 st
->time_base
, AV_TIME_BASE_Q
);
1596 min_dts
= FFMIN(min_dts
, dts
);
1597 min_pos
= FFMIN(min_pos
, st
->index_entries
[idx
[i
]].pos
);
1600 for (i
= 0; i
< s
->nb_streams
; i
++) {
1601 AVStream
*st
= s
->streams
[i
];
1602 AVIStream
*ast
= st
->priv_data
;
1604 if (idx
[i
] && min_dts
!= INT64_MAX
/ 2) {
1606 dts
= av_rescale_q(st
->index_entries
[idx
[i
] - 1].timestamp
/
1607 FFMAX(ast
->sample_size
, 1),
1608 st
->time_base
, AV_TIME_BASE_Q
);
1609 max_dts
= FFMAX(max_dts
, dts
);
1610 max_buffer
= FFMAX(max_buffer
,
1611 av_rescale(dts
- min_dts
,
1612 st
->codec
->bit_rate
,
1616 if (max_dts
- min_dts
> 2 * AV_TIME_BASE
||
1617 max_buffer
> 1024 * 1024 * 8 * 8) {
1626 static int guess_ni_flag(AVFormatContext
*s
)
1629 int64_t last_start
= 0;
1630 int64_t first_end
= INT64_MAX
;
1631 int64_t oldpos
= avio_tell(s
->pb
);
1633 for (i
= 0; i
< s
->nb_streams
; i
++) {
1634 AVStream
*st
= s
->streams
[i
];
1635 int n
= st
->nb_index_entries
;
1642 int64_t pos
= st
->index_entries
[0].pos
;
1643 avio_seek(s
->pb
, pos
+ 4, SEEK_SET
);
1644 size
= avio_rl32(s
->pb
);
1645 if (pos
+ size
> st
->index_entries
[1].pos
)
1646 last_start
= INT64_MAX
;
1649 if (st
->index_entries
[0].pos
> last_start
)
1650 last_start
= st
->index_entries
[0].pos
;
1651 if (st
->index_entries
[n
- 1].pos
< first_end
)
1652 first_end
= st
->index_entries
[n
- 1].pos
;
1654 avio_seek(s
->pb
, oldpos
, SEEK_SET
);
1656 if (last_start
> first_end
)
1659 return check_stream_max_drift(s
);
1662 static int avi_load_index(AVFormatContext
*s
)
1664 AVIContext
*avi
= s
->priv_data
;
1665 AVIOContext
*pb
= s
->pb
;
1667 int64_t pos
= avio_tell(pb
);
1671 if (avio_seek(pb
, avi
->movi_end
, SEEK_SET
) < 0)
1672 goto the_end
; // maybe truncated file
1673 av_dlog(s
, "movi_end=0x%"PRIx64
"\n", avi
->movi_end
);
1675 tag
= avio_rl32(pb
);
1676 size
= avio_rl32(pb
);
1679 next
= avio_tell(pb
) + size
+ (size
& 1);
1681 av_dlog(s
, "tag=%c%c%c%c size=0x%x\n",
1688 if (tag
== MKTAG('i', 'd', 'x', '1') &&
1689 avi_read_idx1(s
, size
) >= 0) {
1690 avi
->index_loaded
=2;
1692 }else if (tag
== MKTAG('L', 'I', 'S', 'T')) {
1693 uint32_t tag1
= avio_rl32(pb
);
1695 if (tag1
== MKTAG('I', 'N', 'F', 'O'))
1696 ff_read_riff_info(s
, size
- 4);
1700 if (avio_seek(pb
, next
, SEEK_SET
) < 0)
1701 break; // something is wrong here
1705 avio_seek(pb
, pos
, SEEK_SET
);
1709 static void seek_subtitle(AVStream
*st
, AVStream
*st2
, int64_t timestamp
)
1711 AVIStream
*ast2
= st2
->priv_data
;
1712 int64_t ts2
= av_rescale_q(timestamp
, st
->time_base
, st2
->time_base
);
1713 av_free_packet(&ast2
->sub_pkt
);
1714 if (avformat_seek_file(ast2
->sub_ctx
, 0, INT64_MIN
, ts2
, ts2
, 0) >= 0 ||
1715 avformat_seek_file(ast2
->sub_ctx
, 0, ts2
, ts2
, INT64_MAX
, 0) >= 0)
1716 ff_read_packet(ast2
->sub_ctx
, &ast2
->sub_pkt
);
1719 static int avi_read_seek(AVFormatContext
*s
, int stream_index
,
1720 int64_t timestamp
, int flags
)
1722 AVIContext
*avi
= s
->priv_data
;
1725 int64_t pos
, pos_min
;
1728 /* Does not matter which stream is requested dv in avi has the
1729 * stream information in the first video stream.
1734 if (!avi
->index_loaded
) {
1735 /* we only load the index on demand */
1737 avi
->index_loaded
|= 1;
1739 av_assert0(stream_index
>= 0);
1741 st
= s
->streams
[stream_index
];
1742 ast
= st
->priv_data
;
1743 index
= av_index_search_timestamp(st
,
1744 timestamp
* FFMAX(ast
->sample_size
, 1),
1747 if (st
->nb_index_entries
> 0)
1748 av_log(s
, AV_LOG_DEBUG
, "Failed to find timestamp %"PRId64
" in index %"PRId64
" .. %"PRId64
"\n",
1749 timestamp
* FFMAX(ast
->sample_size
, 1),
1750 st
->index_entries
[0].timestamp
,
1751 st
->index_entries
[st
->nb_index_entries
- 1].timestamp
);
1752 return AVERROR_INVALIDDATA
;
1755 /* find the position */
1756 pos
= st
->index_entries
[index
].pos
;
1757 timestamp
= st
->index_entries
[index
].timestamp
/ FFMAX(ast
->sample_size
, 1);
1759 av_dlog(s
, "XX %"PRId64
" %d %"PRId64
"\n",
1760 timestamp
, index
, st
->index_entries
[index
].timestamp
);
1762 if (CONFIG_DV_DEMUXER
&& avi
->dv_demux
) {
1763 /* One and only one real stream for DV in AVI, and it has video */
1764 /* offsets. Calling with other stream indexes should have failed */
1765 /* the av_index_search_timestamp call above. */
1767 if (avio_seek(s
->pb
, pos
, SEEK_SET
) < 0)
1770 /* Feed the DV video stream version of the timestamp to the */
1771 /* DV demux so it can synthesize correct timestamps. */
1772 ff_dv_offset_reset(avi
->dv_demux
, timestamp
);
1774 avi
->stream_index
= -1;
1779 for (i
= 0; i
< s
->nb_streams
; i
++) {
1780 AVStream
*st2
= s
->streams
[i
];
1781 AVIStream
*ast2
= st2
->priv_data
;
1784 ast2
->remaining
= 0;
1786 if (ast2
->sub_ctx
) {
1787 seek_subtitle(st
, st2
, timestamp
);
1791 if (st2
->nb_index_entries
<= 0)
1794 // av_assert1(st2->codec->block_align);
1795 av_assert0(fabs(av_q2d(st2
->time_base
) - ast2
->scale
/ (double)ast2
->rate
) < av_q2d(st2
->time_base
) * 0.00000001);
1796 index
= av_index_search_timestamp(st2
,
1797 av_rescale_q(timestamp
,
1800 FFMAX(ast2
->sample_size
, 1),
1802 AVSEEK_FLAG_BACKWARD
|
1803 (st2
->codec
->codec_type
!= AVMEDIA_TYPE_VIDEO
? AVSEEK_FLAG_ANY
: 0));
1806 ast2
->seek_pos
= st2
->index_entries
[index
].pos
;
1807 pos_min
= FFMIN(pos_min
,ast2
->seek_pos
);
1809 for (i
= 0; i
< s
->nb_streams
; i
++) {
1810 AVStream
*st2
= s
->streams
[i
];
1811 AVIStream
*ast2
= st2
->priv_data
;
1813 if (ast2
->sub_ctx
|| st2
->nb_index_entries
<= 0)
1816 index
= av_index_search_timestamp(
1818 av_rescale_q(timestamp
, st
->time_base
, st2
->time_base
) * FFMAX(ast2
->sample_size
, 1),
1819 flags
| AVSEEK_FLAG_BACKWARD
| (st2
->codec
->codec_type
!= AVMEDIA_TYPE_VIDEO
? AVSEEK_FLAG_ANY
: 0));
1822 while (!avi
->non_interleaved
&& index
>0 && st2
->index_entries
[index
-1].pos
>= pos_min
)
1824 ast2
->frame_offset
= st2
->index_entries
[index
].timestamp
;
1828 if (avio_seek(s
->pb
, pos_min
, SEEK_SET
) < 0) {
1829 av_log(s
, AV_LOG_ERROR
, "Seek failed\n");
1832 avi
->stream_index
= -1;
1833 avi
->dts_max
= INT_MIN
;
1837 static int avi_read_close(AVFormatContext
*s
)
1840 AVIContext
*avi
= s
->priv_data
;
1842 for (i
= 0; i
< s
->nb_streams
; i
++) {
1843 AVStream
*st
= s
->streams
[i
];
1844 AVIStream
*ast
= st
->priv_data
;
1847 av_freep(&ast
->sub_ctx
->pb
);
1848 avformat_close_input(&ast
->sub_ctx
);
1850 av_free(ast
->sub_buffer
);
1851 av_free_packet(&ast
->sub_pkt
);
1855 av_free(avi
->dv_demux
);
1860 static int avi_probe(AVProbeData
*p
)
1864 /* check file header */
1865 for (i
= 0; avi_headers
[i
][0]; i
++)
1866 if (!memcmp(p
->buf
, avi_headers
[i
], 4) &&
1867 !memcmp(p
->buf
+ 8, avi_headers
[i
] + 4, 4))
1868 return AVPROBE_SCORE_MAX
;
1873 AVInputFormat ff_avi_demuxer
= {
1875 .long_name
= NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"),
1876 .priv_data_size
= sizeof(AVIContext
),
1877 .extensions
= "avi",
1878 .read_probe
= avi_probe
,
1879 .read_header
= avi_read_header
,
1880 .read_packet
= avi_read_packet
,
1881 .read_close
= avi_read_close
,
1882 .read_seek
= avi_read_seek
,
1883 .priv_class
= &demuxer_class
,