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
32 typedef struct AVIStream
{
33 int64_t frame_offset
; /* current frame (video) or byte (audio) counter
34 (used to compute the pts) */
40 int sample_size
; /* size of one sample (or packet) (in the rate/scale sense) in bytes */
42 int64_t cum_len
; /* temporary storage (used during seek) */
44 int prefix
; ///< normally 'd'<<8 + 'c' or 'w'<<8 + 'b'
57 DVDemuxContext
* dv_demux
;
60 static const char avi_headers
[][8] = {
61 { 'R', 'I', 'F', 'F', 'A', 'V', 'I', ' ' },
62 { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 'X' },
63 { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 0x19},
64 { 'O', 'N', '2', ' ', 'O', 'N', '2', 'f' },
65 { 'R', 'I', 'F', 'F', 'A', 'M', 'V', ' ' },
69 static int avi_load_index(AVFormatContext
*s
);
70 static int guess_ni_flag(AVFormatContext
*s
);
73 static void print_tag(const char *str
, unsigned int tag
, int size
)
75 printf("%s: tag=%c%c%c%c size=0x%x\n",
84 static int get_riff(AVIContext
*avi
, ByteIOContext
*pb
)
89 /* check RIFF header */
90 get_buffer(pb
, header
, 4);
91 avi
->riff_end
= get_le32(pb
); /* RIFF chunk size */
92 avi
->riff_end
+= url_ftell(pb
); /* RIFF chunk end */
93 get_buffer(pb
, header
+4, 4);
95 for(i
=0; avi_headers
[i
][0]; i
++)
96 if(!memcmp(header
, avi_headers
[i
], 8))
98 if(!avi_headers
[i
][0])
101 if(header
[7] == 0x19)
102 av_log(NULL
, AV_LOG_INFO
, "file has been generated with a totally broken muxer\n");
107 static int read_braindead_odml_indx(AVFormatContext
*s
, int frame_num
){
108 AVIContext
*avi
= s
->priv_data
;
109 ByteIOContext
*pb
= s
->pb
;
110 int longs_pre_entry
= get_le16(pb
);
111 int index_sub_type
= get_byte(pb
);
112 int index_type
= get_byte(pb
);
113 int entries_in_use
= get_le32(pb
);
114 int chunk_id
= get_le32(pb
);
115 int64_t base
= get_le64(pb
);
116 int stream_id
= 10*((chunk_id
&0xFF) - '0') + (((chunk_id
>>8)&0xFF) - '0');
120 int64_t last_pos
= -1;
121 int64_t filesize
= url_fsize(s
->pb
);
124 av_log(s
, AV_LOG_ERROR
, "longs_pre_entry:%d index_type:%d entries_in_use:%d chunk_id:%X base:%16"PRIX64
"\n",
125 longs_pre_entry
,index_type
, entries_in_use
, chunk_id
, base
);
128 if(stream_id
> s
->nb_streams
|| stream_id
< 0)
130 st
= s
->streams
[stream_id
];
138 if(index_type
&& longs_pre_entry
!= 2)
143 if(filesize
> 0 && base
>= filesize
){
144 av_log(s
, AV_LOG_ERROR
, "ODML index invalid\n");
145 if(base
>>32 == (base
& 0xFFFFFFFF) && (base
& 0xFFFFFFFF) < filesize
&& filesize
<= 0xFFFFFFFF)
151 for(i
=0; i
<entries_in_use
; i
++){
153 int64_t pos
= get_le32(pb
) + base
- 8;
154 int len
= get_le32(pb
);
159 av_log(s
, AV_LOG_ERROR
, "pos:%"PRId64
", len:%X\n", pos
, len
);
161 if(last_pos
== pos
|| pos
== base
- 8)
162 avi
->non_interleaved
= 1;
164 av_add_index_entry(st
, pos
, ast
->cum_len
/ FFMAX(1, ast
->sample_size
), len
, 0, key
? AVINDEX_KEYFRAME
: 0);
174 offset
= get_le64(pb
);
175 get_le32(pb
); /* size */
176 duration
= get_le32(pb
);
179 url_fseek(pb
, offset
+8, SEEK_SET
);
180 read_braindead_odml_indx(s
, frame_num
);
181 frame_num
+= duration
;
183 url_fseek(pb
, pos
, SEEK_SET
);
190 static void clean_index(AVFormatContext
*s
){
194 for(i
=0; i
<s
->nb_streams
; i
++){
195 AVStream
*st
= s
->streams
[i
];
196 AVIStream
*ast
= st
->priv_data
;
197 int n
= st
->nb_index_entries
;
198 int max
= ast
->sample_size
;
199 int64_t pos
, size
, ts
;
201 if(n
!= 1 || ast
->sample_size
==0)
204 while(max
< 1024) max
+=max
;
206 pos
= st
->index_entries
[0].pos
;
207 size
= st
->index_entries
[0].size
;
208 ts
= st
->index_entries
[0].timestamp
;
210 for(j
=0; j
<size
; j
+=max
){
211 av_add_index_entry(st
, pos
+j
, ts
+ j
/ast
->sample_size
, FFMIN(max
, size
-j
), 0, AVINDEX_KEYFRAME
);
216 static int avi_read_tag(ByteIOContext
*pb
, char *buf
, int maxlen
, unsigned int size
)
218 offset_t i
= url_ftell(pb
);
220 get_strz(pb
, buf
, maxlen
);
221 url_fseek(pb
, i
+size
, SEEK_SET
);
225 static int avi_read_header(AVFormatContext
*s
, AVFormatParameters
*ap
)
227 AVIContext
*avi
= s
->priv_data
;
228 ByteIOContext
*pb
= s
->pb
;
229 uint32_t tag
, tag1
, handler
;
230 int codec_type
, stream_index
, frame_period
, bit_rate
;
231 unsigned int size
, nb_frames
;
234 AVIStream
*ast
= NULL
;
236 int avih_width
=0, avih_height
=0;
237 int amv_file_format
=0;
239 avi
->stream_index
= -1;
241 if (get_riff(avi
, pb
) < 0)
244 avi
->fsize
= url_fsize(pb
);
246 avi
->fsize
= avi
->riff_end
;
258 print_tag("tag", tag
, size
);
262 case MKTAG('L', 'I', 'S', 'T'):
263 /* ignored, except when start of video packets */
266 print_tag("list", tag1
, 0);
268 if (tag1
== MKTAG('m', 'o', 'v', 'i')) {
269 avi
->movi_list
= url_ftell(pb
) - 4;
270 if(size
) avi
->movi_end
= avi
->movi_list
+ size
+ (size
& 1);
271 else avi
->movi_end
= url_fsize(pb
);
273 printf("movi end=%"PRIx64
"\n", avi
->movi_end
);
278 case MKTAG('d', 'm', 'l', 'h'):
280 url_fskip(pb
, size
+ (size
& 1));
282 case MKTAG('a', 'm', 'v', 'h'):
284 case MKTAG('a', 'v', 'i', 'h'):
286 /* using frame_period is bad idea */
287 frame_period
= get_le32(pb
);
288 bit_rate
= get_le32(pb
) * 8;
290 avi
->non_interleaved
|= get_le32(pb
) & AVIF_MUSTUSEINDEX
;
292 url_fskip(pb
, 2 * 4);
295 avih_width
=get_le32(pb
);
296 avih_height
=get_le32(pb
);
298 url_fskip(pb
, size
- 10 * 4);
300 case MKTAG('s', 't', 'r', 'h'):
304 handler
= get_le32(pb
); /* codec tag */
306 if(tag1
== MKTAG('p', 'a', 'd', 's')){
307 url_fskip(pb
, size
- 8);
311 st
= av_new_stream(s
, stream_index
);
315 ast
= av_mallocz(sizeof(AVIStream
));
321 tag1
= stream_index
? MKTAG('a','u','d','s') : MKTAG('v','i','d','s');
324 print_tag("strh", tag1
, -1);
326 if(tag1
== MKTAG('i', 'a', 'v', 's') || tag1
== MKTAG('i', 'v', 'a', 's')){
330 * After some consideration -- I don't think we
331 * have to support anything but DV in a type1 AVIs.
333 if (s
->nb_streams
!= 1)
336 if (handler
!= MKTAG('d', 'v', 's', 'd') &&
337 handler
!= MKTAG('d', 'v', 'h', 'd') &&
338 handler
!= MKTAG('d', 'v', 's', 'l'))
341 ast
= s
->streams
[0]->priv_data
;
342 av_freep(&s
->streams
[0]->codec
->extradata
);
343 av_freep(&s
->streams
[0]);
345 if (ENABLE_DV_DEMUXER
) {
346 avi
->dv_demux
= dv_init_demux(s
);
350 s
->streams
[0]->priv_data
= ast
;
351 url_fskip(pb
, 3 * 4);
352 ast
->scale
= get_le32(pb
);
353 ast
->rate
= get_le32(pb
);
354 url_fskip(pb
, 4); /* start time */
356 dv_dur
= get_le32(pb
);
357 if (ast
->scale
> 0 && ast
->rate
> 0 && dv_dur
> 0) {
358 dv_dur
*= AV_TIME_BASE
;
359 s
->duration
= av_rescale(dv_dur
, ast
->scale
, ast
->rate
);
362 * else, leave duration alone; timing estimation in utils.c
363 * will make a guess based on bit rate.
366 stream_index
= s
->nb_streams
- 1;
367 url_fskip(pb
, size
- 9*4);
371 assert(stream_index
< s
->nb_streams
);
372 st
->codec
->stream_codec_tag
= handler
;
374 get_le32(pb
); /* flags */
375 get_le16(pb
); /* priority */
376 get_le16(pb
); /* language */
377 get_le32(pb
); /* initial frame */
378 ast
->scale
= get_le32(pb
);
379 ast
->rate
= get_le32(pb
);
380 if(ast
->scale
&& ast
->rate
){
381 }else if(frame_period
){
383 ast
->scale
= frame_period
;
388 av_set_pts_info(st
, 64, ast
->scale
, ast
->rate
);
390 ast
->cum_len
=get_le32(pb
); /* start */
391 nb_frames
= get_le32(pb
);
394 st
->duration
= nb_frames
;
395 get_le32(pb
); /* buffer size */
396 get_le32(pb
); /* quality */
397 ast
->sample_size
= get_le32(pb
); /* sample ssize */
398 ast
->cum_len
*= FFMAX(1, ast
->sample_size
);
399 // av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d\n", ast->rate, ast->scale, ast->start, ast->sample_size);
402 case MKTAG('v', 'i', 'd', 's'):
403 codec_type
= CODEC_TYPE_VIDEO
;
405 ast
->sample_size
= 0;
407 case MKTAG('a', 'u', 'd', 's'):
408 codec_type
= CODEC_TYPE_AUDIO
;
410 case MKTAG('t', 'x', 't', 's'):
412 codec_type
= CODEC_TYPE_DATA
; //CODEC_TYPE_SUB ? FIXME
415 av_log(s
, AV_LOG_ERROR
, "unknown stream type %X\n", tag1
);
418 ast
->frame_offset
= ast
->cum_len
;
419 url_fskip(pb
, size
- 12 * 4);
421 case MKTAG('s', 't', 'r', 'f'):
423 if (stream_index
>= (unsigned)s
->nb_streams
|| avi
->dv_demux
) {
426 st
= s
->streams
[stream_index
];
428 case CODEC_TYPE_VIDEO
:
430 st
->codec
->width
=avih_width
;
431 st
->codec
->height
=avih_height
;
432 st
->codec
->codec_type
= CODEC_TYPE_VIDEO
;
433 st
->codec
->codec_id
= CODEC_ID_AMV
;
437 get_le32(pb
); /* size */
438 st
->codec
->width
= get_le32(pb
);
439 st
->codec
->height
= get_le32(pb
);
440 get_le16(pb
); /* panes */
441 st
->codec
->bits_per_sample
= get_le16(pb
); /* depth */
443 get_le32(pb
); /* ImageSize */
444 get_le32(pb
); /* XPelsPerMeter */
445 get_le32(pb
); /* YPelsPerMeter */
446 get_le32(pb
); /* ClrUsed */
447 get_le32(pb
); /* ClrImportant */
449 if (tag1
== MKTAG('D', 'X', 'S', 'B')) {
450 st
->codec
->codec_type
= CODEC_TYPE_SUBTITLE
;
451 st
->codec
->codec_tag
= tag1
;
452 st
->codec
->codec_id
= CODEC_ID_XSUB
;
456 if(size
> 10*4 && size
<(1<<30)){
457 st
->codec
->extradata_size
= size
- 10*4;
458 st
->codec
->extradata
= av_malloc(st
->codec
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
459 get_buffer(pb
, st
->codec
->extradata
, st
->codec
->extradata_size
);
462 if(st
->codec
->extradata_size
& 1) //FIXME check if the encoder really did this correctly
465 /* Extract palette from extradata if bpp <= 8 */
466 /* This code assumes that extradata contains only palette */
467 /* This is true for all paletted codecs implemented in ffmpeg */
468 if (st
->codec
->extradata_size
&& (st
->codec
->bits_per_sample
<= 8)) {
469 st
->codec
->palctrl
= av_mallocz(sizeof(AVPaletteControl
));
470 #ifdef WORDS_BIGENDIAN
471 for (i
= 0; i
< FFMIN(st
->codec
->extradata_size
, AVPALETTE_SIZE
)/4; i
++)
472 st
->codec
->palctrl
->palette
[i
] = bswap_32(((uint32_t*)st
->codec
->extradata
)[i
]);
474 memcpy(st
->codec
->palctrl
->palette
, st
->codec
->extradata
,
475 FFMIN(st
->codec
->extradata_size
, AVPALETTE_SIZE
));
477 st
->codec
->palctrl
->palette_changed
= 1;
481 print_tag("video", tag1
, 0);
483 st
->codec
->codec_type
= CODEC_TYPE_VIDEO
;
484 st
->codec
->codec_tag
= tag1
;
485 st
->codec
->codec_id
= codec_get_id(codec_bmp_tags
, tag1
);
486 st
->need_parsing
= AVSTREAM_PARSE_HEADERS
; // this is needed to get the pict type which is needed for generating correct pts
487 // url_fskip(pb, size - 5 * 4);
489 case CODEC_TYPE_AUDIO
:
490 get_wav_header(pb
, st
->codec
, size
);
491 if(ast
->sample_size
&& st
->codec
->block_align
&& ast
->sample_size
% st
->codec
->block_align
)
492 av_log(s
, AV_LOG_DEBUG
, "invalid sample size or block align detected\n");
493 if (size
%2) /* 2-aligned (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
495 /* Force parsing as several audio frames can be in
496 * one packet and timestamps refer to packet start*/
497 st
->need_parsing
= AVSTREAM_PARSE_TIMESTAMPS
;
498 /* ADTS header is in extradata, AAC without header must be stored as exact frames, parser not needed and it will fail */
499 if (st
->codec
->codec_id
== CODEC_ID_AAC
&& st
->codec
->extradata_size
)
500 st
->need_parsing
= AVSTREAM_PARSE_NONE
;
501 /* AVI files with Xan DPCM audio (wrongly) declare PCM
502 * audio in the header but have Axan as stream_code_tag. */
503 if (st
->codec
->stream_codec_tag
== ff_get_fourcc("Axan")){
504 st
->codec
->codec_id
= CODEC_ID_XAN_DPCM
;
505 st
->codec
->codec_tag
= 0;
508 st
->codec
->codec_id
= CODEC_ID_ADPCM_IMA_AMV
;
511 st
->codec
->codec_type
= CODEC_TYPE_DATA
;
512 st
->codec
->codec_id
= CODEC_ID_NONE
;
513 st
->codec
->codec_tag
= 0;
519 case MKTAG('i', 'n', 'd', 'x'):
521 if(!url_is_streamed(pb
) && !(s
->flags
& AVFMT_FLAG_IGNIDX
)){
522 read_braindead_odml_indx(s
, 0);
524 url_fseek(pb
, i
+size
, SEEK_SET
);
526 case MKTAG('v', 'p', 'r', 'p'):
527 if(stream_index
< (unsigned)s
->nb_streams
&& size
> 9*4){
528 AVRational active
, active_aspect
;
530 st
= s
->streams
[stream_index
];
537 active_aspect
.num
= get_le16(pb
);
538 active_aspect
.den
= get_le16(pb
);
539 active
.num
= get_le32(pb
);
540 active
.den
= get_le32(pb
);
541 get_le32(pb
); //nbFieldsPerFrame
543 if(active_aspect
.num
&& active_aspect
.den
&& active
.num
&& active
.den
){
544 st
->codec
->sample_aspect_ratio
= av_div_q(active_aspect
, active
);
545 //av_log(s, AV_LOG_ERROR, "vprp %d/%d %d/%d\n", active_aspect.num, active_aspect.den, active.num, active.den);
549 url_fseek(pb
, size
, SEEK_CUR
);
551 case MKTAG('I', 'N', 'A', 'M'):
552 avi_read_tag(pb
, s
->title
, sizeof(s
->title
), size
);
554 case MKTAG('I', 'A', 'R', 'T'):
555 avi_read_tag(pb
, s
->author
, sizeof(s
->author
), size
);
557 case MKTAG('I', 'C', 'O', 'P'):
558 avi_read_tag(pb
, s
->copyright
, sizeof(s
->copyright
), size
);
560 case MKTAG('I', 'C', 'M', 'T'):
561 avi_read_tag(pb
, s
->comment
, sizeof(s
->comment
), size
);
563 case MKTAG('I', 'G', 'N', 'R'):
564 avi_read_tag(pb
, s
->genre
, sizeof(s
->genre
), size
);
566 case MKTAG('I', 'P', 'R', 'D'):
567 avi_read_tag(pb
, s
->album
, sizeof(s
->album
), size
);
569 case MKTAG('I', 'P', 'R', 'T'):
570 avi_read_tag(pb
, str_track
, sizeof(str_track
), size
);
571 sscanf(str_track
, "%d", &s
->track
);
575 av_log(s
, AV_LOG_ERROR
, "well something went wrong during header parsing, "
576 "ill ignore it and try to continue anyway\n");
577 avi
->movi_list
= url_ftell(pb
) - 4;
578 avi
->movi_end
= url_fsize(pb
);
588 /* check stream number */
589 if (stream_index
!= s
->nb_streams
- 1) {
591 for(i
=0;i
<s
->nb_streams
;i
++) {
592 av_freep(&s
->streams
[i
]->codec
->extradata
);
593 av_freep(&s
->streams
[i
]);
598 if(!avi
->index_loaded
&& !url_is_streamed(pb
))
600 avi
->index_loaded
= 1;
601 avi
->non_interleaved
|= guess_ni_flag(s
);
602 if(avi
->non_interleaved
)
608 static int avi_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
610 AVIContext
*avi
= s
->priv_data
;
611 ByteIOContext
*pb
= s
->pb
;
616 if (ENABLE_DV_DEMUXER
&& avi
->dv_demux
) {
617 size
= dv_get_packet(avi
->dv_demux
, pkt
);
622 if(avi
->non_interleaved
){
623 int best_stream_index
= 0;
624 AVStream
*best_st
= NULL
;
626 int64_t best_ts
= INT64_MAX
;
629 for(i
=0; i
<s
->nb_streams
; i
++){
630 AVStream
*st
= s
->streams
[i
];
631 AVIStream
*ast
= st
->priv_data
;
632 int64_t ts
= ast
->frame_offset
;
635 ts
/= ast
->sample_size
;
636 ts
= av_rescale(ts
, AV_TIME_BASE
* (int64_t)st
->time_base
.num
, st
->time_base
.den
);
638 // av_log(NULL, AV_LOG_DEBUG, "%"PRId64" %d/%d %"PRId64"\n", ts, st->time_base.num, st->time_base.den, ast->frame_offset);
642 best_stream_index
= i
;
645 best_ast
= best_st
->priv_data
;
646 best_ts
= av_rescale(best_ts
, best_st
->time_base
.den
, AV_TIME_BASE
* (int64_t)best_st
->time_base
.num
); //FIXME a little ugly
647 if(best_ast
->remaining
)
648 i
= av_index_search_timestamp(best_st
, best_ts
, AVSEEK_FLAG_ANY
| AVSEEK_FLAG_BACKWARD
);
650 i
= av_index_search_timestamp(best_st
, best_ts
, AVSEEK_FLAG_ANY
);
652 // av_log(NULL, AV_LOG_DEBUG, "%d\n", i);
654 int64_t pos
= best_st
->index_entries
[i
].pos
;
655 pos
+= best_ast
->packet_size
- best_ast
->remaining
;
656 url_fseek(s
->pb
, pos
+ 8, SEEK_SET
);
657 // av_log(NULL, AV_LOG_DEBUG, "pos=%"PRId64"\n", pos);
659 assert(best_ast
->remaining
<= best_ast
->packet_size
);
661 avi
->stream_index
= best_stream_index
;
662 if(!best_ast
->remaining
)
663 best_ast
->packet_size
=
664 best_ast
->remaining
= best_st
->index_entries
[i
].size
;
669 if(avi
->stream_index
>= 0){
670 AVStream
*st
= s
->streams
[ avi
->stream_index
];
671 AVIStream
*ast
= st
->priv_data
;
674 if(ast
->sample_size
<= 1) // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM
676 else if(ast
->sample_size
< 32)
677 size
= 64*ast
->sample_size
;
679 size
= ast
->sample_size
;
681 if(size
> ast
->remaining
)
682 size
= ast
->remaining
;
683 av_get_packet(pb
, pkt
, size
);
685 if (ENABLE_DV_DEMUXER
&& avi
->dv_demux
) {
686 dstr
= pkt
->destruct
;
687 size
= dv_produce_packet(avi
->dv_demux
, pkt
,
688 pkt
->data
, pkt
->size
);
689 pkt
->destruct
= dstr
;
690 pkt
->flags
|= PKT_FLAG_KEY
;
692 /* XXX: how to handle B frames in avi ? */
693 pkt
->dts
= ast
->frame_offset
;
694 // pkt->dts += ast->start;
696 pkt
->dts
/= ast
->sample_size
;
697 //av_log(NULL, AV_LOG_DEBUG, "dts:%"PRId64" offset:%"PRId64" %d/%d smpl_siz:%d base:%d st:%d size:%d\n", pkt->dts, ast->frame_offset, ast->scale, ast->rate, ast->sample_size, AV_TIME_BASE, avi->stream_index, size);
698 pkt
->stream_index
= avi
->stream_index
;
700 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
703 assert(st
->index_entries
);
705 index
= av_index_search_timestamp(st
, pkt
->dts
, 0);
706 e
= &st
->index_entries
[index
];
708 if(index
>= 0 && e
->timestamp
== ast
->frame_offset
){
709 if (e
->flags
& AVINDEX_KEYFRAME
)
710 pkt
->flags
|= PKT_FLAG_KEY
;
713 pkt
->flags
|= PKT_FLAG_KEY
;
716 ast
->frame_offset
+= pkt
->size
;
720 ast
->remaining
-= size
;
722 avi
->stream_index
= -1;
729 memset(d
, -1, sizeof(int)*8);
730 for(i
=sync
=url_ftell(pb
); !url_feof(pb
); i
++) {
737 size
= d
[4] + (d
[5]<<8) + (d
[6]<<16) + (d
[7]<<24);
739 if( d
[2] >= '0' && d
[2] <= '9'
740 && d
[3] >= '0' && d
[3] <= '9'){
741 n
= (d
[2] - '0') * 10 + (d
[3] - '0');
743 n
= 100; //invalid stream id
745 //av_log(NULL, AV_LOG_DEBUG, "%X %X %X %X %X %X %X %X %"PRId64" %d %d\n", d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n);
746 if(i
+ size
> avi
->fsize
|| d
[0]<0)
750 if( (d
[0] == 'i' && d
[1] == 'x' && n
< s
->nb_streams
)
752 ||(d
[0] == 'J' && d
[1] == 'U' && d
[2] == 'N' && d
[3] == 'K')
753 ||(d
[0] == 'i' && d
[1] == 'd' && d
[2] == 'x' && d
[3] == '1')){
755 //av_log(NULL, AV_LOG_DEBUG, "SKIP\n");
759 if( d
[0] >= '0' && d
[0] <= '9'
760 && d
[1] >= '0' && d
[1] <= '9'){
761 n
= (d
[0] - '0') * 10 + (d
[1] - '0');
763 n
= 100; //invalid stream id
767 if(n
< s
->nb_streams
){
773 if( (st
->discard
>= AVDISCARD_DEFAULT
&& size
==0)
774 /*|| (st->discard >= AVDISCARD_NONKEY && !(pkt->flags & PKT_FLAG_KEY))*/ //FIXME needs a little reordering
775 || st
->discard
>= AVDISCARD_ALL
){
776 if(ast
->sample_size
) ast
->frame_offset
+= pkt
->size
;
777 else ast
->frame_offset
++;
782 if( ((ast
->prefix_count
<5 || sync
+9 > i
) && d
[2]<128 && d
[3]<128) ||
783 d
[2]*256+d
[3] == ast
->prefix
/*||
784 (d[2] == 'd' && d[3] == 'c') ||
785 (d[2] == 'w' && d[3] == 'b')*/) {
787 //av_log(NULL, AV_LOG_DEBUG, "OK\n");
788 if(d
[2]*256+d
[3] == ast
->prefix
)
791 ast
->prefix
= d
[2]*256+d
[3];
792 ast
->prefix_count
= 0;
795 avi
->stream_index
= n
;
796 ast
->packet_size
= size
+ 8;
797 ast
->remaining
= size
;
800 uint64_t pos
= url_ftell(pb
) - 8;
801 if(!st
->index_entries
|| !st
->nb_index_entries
|| st
->index_entries
[st
->nb_index_entries
- 1].pos
< pos
){
802 av_add_index_entry(st
, pos
, ast
->frame_offset
/ FFMAX(1, ast
->sample_size
), size
, 0, AVINDEX_KEYFRAME
);
808 /* palette changed chunk */
809 if ( d
[0] >= '0' && d
[0] <= '9'
810 && d
[1] >= '0' && d
[1] <= '9'
811 && ((d
[2] == 'p' && d
[3] == 'c'))
812 && n
< s
->nb_streams
&& i
+ size
<= avi
->fsize
) {
815 int first
, clr
, flags
, k
, p
;
819 first
= get_byte(pb
);
821 if(!clr
) /* all 256 colors used */
823 flags
= get_le16(pb
);
825 for (k
= first
; k
< clr
+ first
; k
++) {
831 st
->codec
->palctrl
->palette
[k
] = b
+ (g
<< 8) + (r
<< 16);
833 st
->codec
->palctrl
->palette_changed
= 1;
842 /* XXX: we make the implicit supposition that the position are sorted
844 static int avi_read_idx1(AVFormatContext
*s
, int size
)
846 AVIContext
*avi
= s
->priv_data
;
847 ByteIOContext
*pb
= s
->pb
;
848 int nb_index_entries
, i
;
851 unsigned int index
, tag
, flags
, pos
, len
;
852 unsigned last_pos
= -1;
854 nb_index_entries
= size
/ 16;
855 if (nb_index_entries
<= 0)
858 /* read the entries and sort them in each stream component */
859 for(i
= 0; i
< nb_index_entries
; i
++) {
861 flags
= get_le32(pb
);
864 #if defined(DEBUG_SEEK)
865 av_log(NULL
, AV_LOG_DEBUG
, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/",
866 i
, tag
, flags
, pos
, len
);
868 if(i
==0 && pos
> avi
->movi_list
)
869 avi
->movi_list
= 0; //FIXME better check
870 pos
+= avi
->movi_list
;
872 index
= ((tag
& 0xff) - '0') * 10;
873 index
+= ((tag
>> 8) & 0xff) - '0';
874 if (index
>= s
->nb_streams
)
876 st
= s
->streams
[index
];
879 #if defined(DEBUG_SEEK)
880 av_log(NULL
, AV_LOG_DEBUG
, "%d cum_len=%"PRId64
"\n", len
, ast
->cum_len
);
883 avi
->non_interleaved
= 1;
885 av_add_index_entry(st
, pos
, ast
->cum_len
/ FFMAX(1, ast
->sample_size
), len
, 0, (flags
&AVIIF_INDEX
) ? AVINDEX_KEYFRAME
: 0);
895 static int guess_ni_flag(AVFormatContext
*s
){
897 int64_t last_start
=0;
898 int64_t first_end
= INT64_MAX
;
900 for(i
=0; i
<s
->nb_streams
; i
++){
901 AVStream
*st
= s
->streams
[i
];
902 int n
= st
->nb_index_entries
;
907 if(st
->index_entries
[0].pos
> last_start
)
908 last_start
= st
->index_entries
[0].pos
;
909 if(st
->index_entries
[n
-1].pos
< first_end
)
910 first_end
= st
->index_entries
[n
-1].pos
;
912 return last_start
> first_end
;
915 static int avi_load_index(AVFormatContext
*s
)
917 AVIContext
*avi
= s
->priv_data
;
918 ByteIOContext
*pb
= s
->pb
;
920 offset_t pos
= url_ftell(pb
);
922 url_fseek(pb
, avi
->movi_end
, SEEK_SET
);
924 printf("movi_end=0x%"PRIx64
"\n", avi
->movi_end
);
932 printf("tag=%c%c%c%c size=0x%x\n",
940 case MKTAG('i', 'd', 'x', '1'):
941 if (avi_read_idx1(s
, size
) < 0)
954 url_fseek(pb
, pos
, SEEK_SET
);
958 static int avi_read_seek(AVFormatContext
*s
, int stream_index
, int64_t timestamp
, int flags
)
960 AVIContext
*avi
= s
->priv_data
;
965 if (!avi
->index_loaded
) {
966 /* we only load the index on demand */
968 avi
->index_loaded
= 1;
970 assert(stream_index
>= 0);
972 st
= s
->streams
[stream_index
];
973 index
= av_index_search_timestamp(st
, timestamp
, flags
);
977 /* find the position */
978 pos
= st
->index_entries
[index
].pos
;
979 timestamp
= st
->index_entries
[index
].timestamp
;
981 // av_log(NULL, AV_LOG_DEBUG, "XX %"PRId64" %d %"PRId64"\n", timestamp, index, st->index_entries[index].timestamp);
983 if (ENABLE_DV_DEMUXER
&& avi
->dv_demux
) {
984 /* One and only one real stream for DV in AVI, and it has video */
985 /* offsets. Calling with other stream indices should have failed */
986 /* the av_index_search_timestamp call above. */
987 assert(stream_index
== 0);
989 /* Feed the DV video stream version of the timestamp to the */
990 /* DV demux so it can synth correct timestamps */
991 dv_offset_reset(avi
->dv_demux
, timestamp
);
993 url_fseek(s
->pb
, pos
, SEEK_SET
);
994 avi
->stream_index
= -1;
998 for(i
= 0; i
< s
->nb_streams
; i
++) {
999 AVStream
*st2
= s
->streams
[i
];
1000 AVIStream
*ast2
= st2
->priv_data
;
1005 if (st2
->nb_index_entries
<= 0)
1008 // assert(st2->codec->block_align);
1009 assert(st2
->time_base
.den
== ast2
->rate
);
1010 assert(st2
->time_base
.num
== ast2
->scale
);
1011 index
= av_index_search_timestamp(
1013 av_rescale(timestamp
, st2
->time_base
.den
*(int64_t)st
->time_base
.num
, st
->time_base
.den
* (int64_t)st2
->time_base
.num
),
1014 flags
| AVSEEK_FLAG_BACKWARD
);
1018 if(!avi
->non_interleaved
){
1019 while(index
>0 && st2
->index_entries
[index
].pos
> pos
)
1021 while(index
+1 < st2
->nb_index_entries
&& st2
->index_entries
[index
].pos
< pos
)
1025 // av_log(NULL, AV_LOG_DEBUG, "%"PRId64" %d %"PRId64"\n", timestamp, index, st2->index_entries[index].timestamp);
1026 /* extract the current frame number */
1027 ast2
->frame_offset
= st2
->index_entries
[index
].timestamp
;
1028 if(ast2
->sample_size
)
1029 ast2
->frame_offset
*=ast2
->sample_size
;
1033 url_fseek(s
->pb
, pos
, SEEK_SET
);
1034 avi
->stream_index
= -1;
1038 static int avi_read_close(AVFormatContext
*s
)
1041 AVIContext
*avi
= s
->priv_data
;
1043 for(i
=0;i
<s
->nb_streams
;i
++) {
1044 AVStream
*st
= s
->streams
[i
];
1045 AVIStream
*ast
= st
->priv_data
;
1047 av_free(st
->codec
->palctrl
);
1051 av_free(avi
->dv_demux
);
1056 static int avi_probe(AVProbeData
*p
)
1060 /* check file header */
1061 for(i
=0; avi_headers
[i
][0]; i
++)
1062 if(!memcmp(p
->buf
, avi_headers
[i
] , 4) &&
1063 !memcmp(p
->buf
+8, avi_headers
[i
]+4, 4))
1064 return AVPROBE_SCORE_MAX
;
1069 AVInputFormat avi_demuxer
= {