always use audio spread (instead of "video no spread" for audio ...)
[libav.git] / libavformat / avidec.c
CommitLineData
de6d9b64 1/*
7fbde343 2 * AVI demuxer
19720f15 3 * Copyright (c) 2001 Fabrice Bellard.
de6d9b64 4 *
b78e7197
DB
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
19720f15
FB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
de6d9b64 11 *
b78e7197 12 * FFmpeg is distributed in the hope that it will be useful,
de6d9b64 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19720f15
FB
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
de6d9b64 16 *
19720f15 17 * You should have received a copy of the GNU Lesser General Public
b78e7197 18 * License along with FFmpeg; if not, write to the Free Software
5509bffa 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
de6d9b64 20 */
de6d9b64
FB
21#include "avformat.h"
22#include "avi.h"
7458ccbb 23#include "dv.h"
9d9f4119 24#include "riff.h"
de6d9b64 25
52a0bbff
MN
26#undef NDEBUG
27#include <assert.h>
28
de6d9b64 29//#define DEBUG
155e9ee9
FB
30//#define DEBUG_SEEK
31
155e9ee9 32typedef struct AVIStream {
7c7f3866 33 int64_t frame_offset; /* current frame (video) or byte (audio) counter
155e9ee9 34 (used to compute the pts) */
7c7f3866
MN
35 int remaining;
36 int packet_size;
37
155e9ee9 38 int scale;
115329f1 39 int rate;
8223bca5 40 int sample_size; /* size of one sample (or packet) (in the rate/scale sense) in bytes */
115329f1 41
94d1d6c0 42 int64_t cum_len; /* temporary storage (used during seek) */
115329f1 43
d2c5f0a4
MN
44 int prefix; ///< normally 'd'<<8 + 'c' or 'w'<<8 + 'b'
45 int prefix_count;
155e9ee9 46} AVIStream;
de6d9b64
FB
47
48typedef struct {
7458ccbb
RS
49 int64_t riff_end;
50 int64_t movi_end;
de6d9b64 51 offset_t movi_list;
155e9ee9 52 int index_loaded;
8f9298f8 53 int is_odml;
7c7f3866
MN
54 int non_interleaved;
55 int stream_index;
ddaae6a9 56 DVDemuxContext* dv_demux;
de6d9b64
FB
57} AVIContext;
58
42feef6b 59static int avi_load_index(AVFormatContext *s);
30a43f2d 60static int guess_ni_flag(AVFormatContext *s);
42feef6b 61
de6d9b64 62#ifdef DEBUG
1101abfe 63static void print_tag(const char *str, unsigned int tag, int size)
de6d9b64
FB
64{
65 printf("%s: tag=%c%c%c%c size=0x%x\n",
66 str, tag & 0xff,
67 (tag >> 8) & 0xff,
68 (tag >> 16) & 0xff,
69 (tag >> 24) & 0xff,
70 size);
71}
72#endif
73
06219cb1
RS
74static int get_riff(AVIContext *avi, ByteIOContext *pb)
75{
115329f1 76 uint32_t tag;
06219cb1
RS
77 /* check RIFF header */
78 tag = get_le32(pb);
79
80 if (tag != MKTAG('R', 'I', 'F', 'F'))
81 return -1;
82 avi->riff_end = get_le32(pb); /* RIFF chunk size */
83 avi->riff_end += url_ftell(pb); /* RIFF chunk end */
84 tag = get_le32(pb);
d09ea618
MN
85 if(tag == MKTAG('A', 'V', 'I', 0x19))
86 av_log(NULL, AV_LOG_INFO, "file has been generated with a totally broken muxer\n");
87 else
06219cb1
RS
88 if (tag != MKTAG('A', 'V', 'I', ' ') && tag != MKTAG('A', 'V', 'I', 'X'))
89 return -1;
115329f1 90
06219cb1
RS
91 return 0;
92}
93
94d1d6c0 94static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){
8945ebb9 95 AVIContext *avi = s->priv_data;
94d1d6c0
MN
96 ByteIOContext *pb = &s->pb;
97 int longs_pre_entry= get_le16(pb);
98 int index_sub_type = get_byte(pb);
99 int index_type = get_byte(pb);
100 int entries_in_use = get_le32(pb);
101 int chunk_id = get_le32(pb);
102 int64_t base = get_le64(pb);
103 int stream_id= 10*((chunk_id&0xFF) - '0') + (((chunk_id>>8)&0xFF) - '0');
104 AVStream *st;
105 AVIStream *ast;
106 int i;
8945ebb9 107 int64_t last_pos= -1;
965a63af 108 int64_t filesize= url_fsize(&s->pb);
94d1d6c0 109
965a63af 110#ifdef DEBUG_SEEK
949b1a13 111 av_log(s, AV_LOG_ERROR, "longs_pre_entry:%d index_type:%d entries_in_use:%d chunk_id:%X base:%16"PRIX64"\n",
965a63af
MN
112 longs_pre_entry,index_type, entries_in_use, chunk_id, base);
113#endif
94d1d6c0
MN
114
115 if(stream_id > s->nb_streams || stream_id < 0)
116 return -1;
117 st= s->streams[stream_id];
118 ast = st->priv_data;
119
120 if(index_sub_type)
121 return -1;
122
123 get_le32(pb);
124
125 if(index_type && longs_pre_entry != 2)
126 return -1;
127 if(index_type>1)
128 return -1;
129
965a63af
MN
130 if(filesize > 0 && base >= filesize){
131 av_log(s, AV_LOG_ERROR, "ODML index invalid\n");
132 if(base>>32 == (base & 0xFFFFFFFF) && (base & 0xFFFFFFFF) < filesize && filesize <= 0xFFFFFFFF)
133 base &= 0xFFFFFFFF;
134 else
135 return -1;
136 }
137
94d1d6c0
MN
138 for(i=0; i<entries_in_use; i++){
139 if(index_type){
30a43f2d 140 int64_t pos= get_le32(pb) + base - 8;
94d1d6c0 141 int len = get_le32(pb);
30a43f2d 142 int key= len >= 0;
94d1d6c0
MN
143 len &= 0x7FFFFFFF;
144
965a63af 145#ifdef DEBUG_SEEK
949b1a13 146 av_log(s, AV_LOG_ERROR, "pos:%"PRId64", len:%X\n", pos, len);
965a63af 147#endif
8945ebb9
MN
148 if(last_pos == pos || pos == base - 8)
149 avi->non_interleaved= 1;
150 else
2b70eb2b 151 av_add_index_entry(st, pos, ast->cum_len / FFMAX(1, ast->sample_size), len, 0, key ? AVINDEX_KEYFRAME : 0);
30a43f2d 152
94d1d6c0 153 if(ast->sample_size)
2b70eb2b 154 ast->cum_len += len;
94d1d6c0
MN
155 else
156 ast->cum_len ++;
8945ebb9 157 last_pos= pos;
94d1d6c0 158 }else{
26b89135
MR
159 int64_t offset, pos;
160 int duration;
161 offset = get_le64(pb);
162 get_le32(pb); /* size */
163 duration = get_le32(pb);
164 pos = url_ftell(pb);
94d1d6c0
MN
165
166 url_fseek(pb, offset+8, SEEK_SET);
167 read_braindead_odml_indx(s, frame_num);
168 frame_num += duration;
169
170 url_fseek(pb, pos, SEEK_SET);
171 }
172 }
965a63af 173 avi->index_loaded=1;
94d1d6c0
MN
174 return 0;
175}
176
115e8ae5 177static void clean_index(AVFormatContext *s){
965a63af
MN
178 int i;
179 int64_t j;
115e8ae5
MN
180
181 for(i=0; i<s->nb_streams; i++){
182 AVStream *st = s->streams[i];
183 AVIStream *ast = st->priv_data;
184 int n= st->nb_index_entries;
185 int max= ast->sample_size;
186 int64_t pos, size, ts;
187
188 if(n != 1 || ast->sample_size==0)
189 continue;
190
191 while(max < 1024) max+=max;
192
193 pos= st->index_entries[0].pos;
194 size= st->index_entries[0].size;
195 ts= st->index_entries[0].timestamp;
196
197 for(j=0; j<size; j+=max){
198 av_add_index_entry(st, pos+j, ts + j/ast->sample_size, FFMIN(max, size-j), 0, AVINDEX_KEYFRAME);
199 }
200 }
201}
202
57060f89
DC
203static int avi_read_tag(ByteIOContext *pb, char *buf, int maxlen, unsigned int size)
204{
205 offset_t i = url_ftell(pb);
206 size += (size & 1);
207 get_strz(pb, buf, maxlen);
208 url_fseek(pb, i+size, SEEK_SET);
209 return 0;
210}
211
1101abfe 212static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
de6d9b64 213{
c9a65ca8 214 AVIContext *avi = s->priv_data;
de6d9b64 215 ByteIOContext *pb = &s->pb;
deb0a292 216 uint32_t tag, tag1, handler;
b53f1064 217 int codec_type, stream_index, frame_period, bit_rate;
247eadca
FB
218 unsigned int size, nb_frames;
219 int i, n;
de6d9b64 220 AVStream *st;
26b89135 221 AVIStream *ast = NULL;
2ad4648f 222 char str_track[4];
de6d9b64 223
7c7f3866 224 avi->stream_index= -1;
115329f1 225
06219cb1 226 if (get_riff(avi, pb) < 0)
de6d9b64 227 return -1;
1101abfe 228
de6d9b64
FB
229 /* first list tag */
230 stream_index = -1;
231 codec_type = -1;
232 frame_period = 0;
233 for(;;) {
234 if (url_feof(pb))
235 goto fail;
236 tag = get_le32(pb);
237 size = get_le32(pb);
238#ifdef DEBUG
239 print_tag("tag", tag, size);
240#endif
241
242 switch(tag) {
243 case MKTAG('L', 'I', 'S', 'T'):
244 /* ignored, except when start of video packets */
245 tag1 = get_le32(pb);
246#ifdef DEBUG
247 print_tag("list", tag1, 0);
248#endif
249 if (tag1 == MKTAG('m', 'o', 'v', 'i')) {
155e9ee9 250 avi->movi_list = url_ftell(pb) - 4;
2064c77a 251 if(size) avi->movi_end = avi->movi_list + size + (size & 1);
a965c478 252 else avi->movi_end = url_fsize(pb);
de6d9b64 253#ifdef DEBUG
949b1a13 254 printf("movi end=%"PRIx64"\n", avi->movi_end);
de6d9b64
FB
255#endif
256 goto end_of_header;
257 }
258 break;
8f9298f8 259 case MKTAG('d', 'm', 'l', 'h'):
bb270c08
DB
260 avi->is_odml = 1;
261 url_fskip(pb, size + (size & 1));
262 break;
de6d9b64 263 case MKTAG('a', 'v', 'i', 'h'):
bb270c08 264 /* avi header */
1101abfe 265 /* using frame_period is bad idea */
de6d9b64
FB
266 frame_period = get_le32(pb);
267 bit_rate = get_le32(pb) * 8;
1894edeb
MN
268 get_le32(pb);
269 avi->non_interleaved |= get_le32(pb) & AVIF_MUSTUSEINDEX;
270
271 url_fskip(pb, 2 * 4);
247eadca
FB
272 n = get_le32(pb);
273 for(i=0;i<n;i++) {
155e9ee9 274 AVIStream *ast;
7458ccbb 275 st = av_new_stream(s, i);
de6d9b64
FB
276 if (!st)
277 goto fail;
9ee91c2f 278
155e9ee9
FB
279 ast = av_mallocz(sizeof(AVIStream));
280 if (!ast)
281 goto fail;
282 st->priv_data = ast;
bb270c08 283 }
de6d9b64
FB
284 url_fskip(pb, size - 7 * 4);
285 break;
286 case MKTAG('s', 't', 'r', 'h'):
287 /* stream header */
288 stream_index++;
289 tag1 = get_le32(pb);
7458ccbb 290 handler = get_le32(pb); /* codec tag */
cc11e2b3 291#ifdef DEBUG
e344c1ea 292 print_tag("strh", tag1, -1);
cc11e2b3 293#endif
b53f1064 294 if(tag1 == MKTAG('i', 'a', 'v', 's') || tag1 == MKTAG('i', 'v', 'a', 's')){
6eb2de74
RS
295 int64_t dv_dur;
296
115329f1 297 /*
bb270c08
DB
298 * After some consideration -- I don't think we
299 * have to support anything but DV in a type1 AVIs.
300 */
301 if (s->nb_streams != 1)
302 goto fail;
303
304 if (handler != MKTAG('d', 'v', 's', 'd') &&
305 handler != MKTAG('d', 'v', 'h', 'd') &&
306 handler != MKTAG('d', 'v', 's', 'l'))
307 goto fail;
308
309 ast = s->streams[0]->priv_data;
310 av_freep(&s->streams[0]->codec->extradata);
311 av_freep(&s->streams[0]);
312 s->nb_streams = 0;
a2a6332b 313 if (ENABLE_DV_DEMUXER) {
38ca53da
AJ
314 avi->dv_demux = dv_init_demux(s);
315 if (!avi->dv_demux)
316 goto fail;
a2a6332b 317 }
bb270c08
DB
318 s->streams[0]->priv_data = ast;
319 url_fskip(pb, 3 * 4);
320 ast->scale = get_le32(pb);
321 ast->rate = get_le32(pb);
6eb2de74
RS
322 url_fskip(pb, 4); /* start time */
323
324 dv_dur = get_le32(pb);
325 if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) {
326 dv_dur *= AV_TIME_BASE;
327 s->duration = av_rescale(dv_dur, ast->scale, ast->rate);
328 }
329 /*
330 * else, leave duration alone; timing estimation in utils.c
331 * will make a guess based on bit rate.
332 */
333
bb270c08 334 stream_index = s->nb_streams - 1;
6eb2de74 335 url_fskip(pb, size - 9*4);
b53f1064
MN
336 break;
337 }
b559b29b 338
b53f1064
MN
339 if (stream_index >= s->nb_streams) {
340 url_fskip(pb, size - 8);
1c6606e2
KS
341 /* ignore padding stream */
342 if (tag1 == MKTAG('p', 'a', 'd', 's'))
343 stream_index--;
b53f1064 344 break;
115329f1 345 }
b53f1064
MN
346 st = s->streams[stream_index];
347 ast = st->priv_data;
01f4895c 348 st->codec->stream_codec_tag= handler;
b559b29b 349
b53f1064
MN
350 get_le32(pb); /* flags */
351 get_le16(pb); /* priority */
352 get_le16(pb); /* language */
353 get_le32(pb); /* initial frame */
354 ast->scale = get_le32(pb);
355 ast->rate = get_le32(pb);
356 if(ast->scale && ast->rate){
357 }else if(frame_period){
358 ast->rate = 1000000;
359 ast->scale = frame_period;
360 }else{
361 ast->rate = 25;
362 ast->scale = 1;
363 }
364 av_set_pts_info(st, 64, ast->scale, ast->rate);
115329f1 365
b72a2bc8 366 ast->cum_len=get_le32(pb); /* start */
b53f1064 367 nb_frames = get_le32(pb);
b559b29b 368
b53f1064 369 st->start_time = 0;
c0df9d75 370 st->duration = nb_frames;
b53f1064
MN
371 get_le32(pb); /* buffer size */
372 get_le32(pb); /* quality */
373 ast->sample_size = get_le32(pb); /* sample ssize */
2b70eb2b 374 ast->cum_len *= FFMAX(1, ast->sample_size);
b53f1064 375// av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d\n", ast->rate, ast->scale, ast->start, ast->sample_size);
247eadca 376
b53f1064 377 switch(tag1) {
bb270c08 378 case MKTAG('v', 'i', 'd', 's'):
b53f1064 379 codec_type = CODEC_TYPE_VIDEO;
247eadca 380
b53f1064 381 ast->sample_size = 0;
b53f1064
MN
382 break;
383 case MKTAG('a', 'u', 'd', 's'):
384 codec_type = CODEC_TYPE_AUDIO;
9bf9a5fc 385 break;
cc11e2b3 386 case MKTAG('t', 'x', 't', 's'):
115329f1 387 //FIXME
cc11e2b3 388 codec_type = CODEC_TYPE_DATA; //CODEC_TYPE_SUB ? FIXME
cc11e2b3 389 break;
30667f42
MN
390 case MKTAG('p', 'a', 'd', 's'):
391 codec_type = CODEC_TYPE_UNKNOWN;
30667f42
MN
392 stream_index--;
393 break;
9bf9a5fc 394 default:
30667f42 395 av_log(s, AV_LOG_ERROR, "unknown stream type %X\n", tag1);
9bf9a5fc 396 goto fail;
de6d9b64 397 }
2b70eb2b 398 ast->frame_offset= ast->cum_len;
b53f1064 399 url_fskip(pb, size - 12 * 4);
de6d9b64
FB
400 break;
401 case MKTAG('s', 't', 'r', 'f'):
402 /* stream header */
db69c2e5 403 if (stream_index >= s->nb_streams || avi->dv_demux) {
de6d9b64
FB
404 url_fskip(pb, size);
405 } else {
406 st = s->streams[stream_index];
407 switch(codec_type) {
408 case CODEC_TYPE_VIDEO:
409 get_le32(pb); /* size */
01f4895c
MN
410 st->codec->width = get_le32(pb);
411 st->codec->height = get_le32(pb);
de6d9b64 412 get_le16(pb); /* panes */
01f4895c 413 st->codec->bits_per_sample= get_le16(pb); /* depth */
de6d9b64 414 tag1 = get_le32(pb);
b559b29b
MN
415 get_le32(pb); /* ImageSize */
416 get_le32(pb); /* XPelsPerMeter */
417 get_le32(pb); /* YPelsPerMeter */
418 get_le32(pb); /* ClrUsed */
419 get_le32(pb); /* ClrImportant */
420
e344c1ea
SH
421 if(size > 10*4 && size<(1<<30)){
422 st->codec->extradata_size= size - 10*4;
423 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
424 get_buffer(pb, st->codec->extradata, st->codec->extradata_size);
425 }
115329f1 426
01f4895c 427 if(st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly
952c69c4 428 get_byte(pb);
b559b29b 429
5e29abf8
RT
430 /* Extract palette from extradata if bpp <= 8 */
431 /* This code assumes that extradata contains only palette */
432 /* This is true for all paletted codecs implemented in ffmpeg */
01f4895c
MN
433 if (st->codec->extradata_size && (st->codec->bits_per_sample <= 8)) {
434 st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));
5e29abf8 435#ifdef WORDS_BIGENDIAN
01f4895c
MN
436 for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)
437 st->codec->palctrl->palette[i] = bswap_32(((uint32_t*)st->codec->extradata)[i]);
5e29abf8 438#else
01f4895c
MN
439 memcpy(st->codec->palctrl->palette, st->codec->extradata,
440 FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));
5e29abf8 441#endif
01f4895c 442 st->codec->palctrl->palette_changed = 1;
5e29abf8
RT
443 }
444
de6d9b64
FB
445#ifdef DEBUG
446 print_tag("video", tag1, 0);
447#endif
01f4895c
MN
448 st->codec->codec_type = CODEC_TYPE_VIDEO;
449 st->codec->codec_tag = tag1;
450 st->codec->codec_id = codec_get_id(codec_bmp_tags, tag1);
7cbaa7ba 451 st->need_parsing = 2; //only parse headers dont do slower repacketization, this is needed to get the pict type which is needed for generating correct pts
b559b29b 452// url_fskip(pb, size - 5 * 4);
de6d9b64 453 break;
9bf9a5fc 454 case CODEC_TYPE_AUDIO:
01f4895c 455 get_wav_header(pb, st->codec, size);
e84dab5f
MN
456 if(ast->sample_size && st->codec->block_align && ast->sample_size % st->codec->block_align)
457 av_log(s, AV_LOG_DEBUG, "invalid sample size or block align detected\n");
1cef9527
FR
458 if (size%2) /* 2-aligned (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
459 url_fskip(pb, 1);
5836d158
DB
460 /* Force parsing as several audio frames can be in
461 * one packet. */
155e9ee9 462 st->need_parsing = 1;
cbee7a69
BC
463 /* ADTS header is in extradata, AAC without header must be stored as exact frames, parser not needed and it will fail */
464 if (st->codec->codec_id == CODEC_ID_AAC && st->codec->extradata_size)
465 st->need_parsing = 0;
8662900b
DB
466 /* AVI files with Xan DPCM audio (wrongly) declare PCM
467 * audio in the header but have Axan as stream_code_tag. */
468 if (st->codec->stream_codec_tag == ff_get_fourcc("Axan")){
469 st->codec->codec_id = CODEC_ID_XAN_DPCM;
470 st->codec->codec_tag = 0;
471 }
de6d9b64
FB
472 break;
473 default:
01f4895c
MN
474 st->codec->codec_type = CODEC_TYPE_DATA;
475 st->codec->codec_id= CODEC_ID_NONE;
476 st->codec->codec_tag= 0;
de6d9b64
FB
477 url_fskip(pb, size);
478 break;
479 }
480 }
481 break;
94d1d6c0
MN
482 case MKTAG('i', 'n', 'd', 'x'):
483 i= url_ftell(pb);
2c00106c 484 if(!url_is_streamed(pb) && !(s->flags & AVFMT_FLAG_IGNIDX)){
b7b22558 485 read_braindead_odml_indx(s, 0);
b7b22558 486 }
94d1d6c0
MN
487 url_fseek(pb, i+size, SEEK_SET);
488 break;
57060f89
DC
489 case MKTAG('I', 'N', 'A', 'M'):
490 avi_read_tag(pb, s->title, sizeof(s->title), size);
491 break;
492 case MKTAG('I', 'A', 'R', 'T'):
493 avi_read_tag(pb, s->author, sizeof(s->author), size);
494 break;
495 case MKTAG('I', 'C', 'O', 'P'):
496 avi_read_tag(pb, s->copyright, sizeof(s->copyright), size);
497 break;
498 case MKTAG('I', 'C', 'M', 'T'):
499 avi_read_tag(pb, s->comment, sizeof(s->comment), size);
500 break;
501 case MKTAG('I', 'G', 'N', 'R'):
502 avi_read_tag(pb, s->genre, sizeof(s->genre), size);
503 break;
f0861f46
PI
504 case MKTAG('I', 'P', 'R', 'D'):
505 avi_read_tag(pb, s->album, sizeof(s->album), size);
506 break;
2ad4648f
PI
507 case MKTAG('I', 'P', 'R', 'T'):
508 avi_read_tag(pb, str_track, sizeof(str_track), size);
509 sscanf(str_track, "%d", &s->track);
510 break;
de6d9b64
FB
511 default:
512 /* skip tag */
513 size += (size & 1);
514 url_fskip(pb, size);
515 break;
516 }
517 }
518 end_of_header:
519 /* check stream number */
520 if (stream_index != s->nb_streams - 1) {
521 fail:
522 for(i=0;i<s->nb_streams;i++) {
01f4895c 523 av_freep(&s->streams[i]->codec->extradata);
9145f8b3 524 av_freep(&s->streams[i]);
de6d9b64
FB
525 }
526 return -1;
527 }
1101abfe 528
b7b22558 529 if(!avi->index_loaded && !url_is_streamed(pb))
94d1d6c0 530 avi_load_index(s);
42feef6b 531 avi->index_loaded = 1;
30a43f2d 532 avi->non_interleaved |= guess_ni_flag(s);
115e8ae5
MN
533 if(avi->non_interleaved)
534 clean_index(s);
115329f1 535
de6d9b64
FB
536 return 0;
537}
538
1101abfe 539static int avi_read_packet(AVFormatContext *s, AVPacket *pkt)
de6d9b64
FB
540{
541 AVIContext *avi = s->priv_data;
542 ByteIOContext *pb = &s->pb;
8f9298f8 543 int n, d[8], size;
4a8d5135 544 offset_t i, sync;
7458ccbb 545 void* dstr;
115329f1 546
a2a6332b 547 if (ENABLE_DV_DEMUXER && avi->dv_demux) {
7458ccbb 548 size = dv_get_packet(avi->dv_demux, pkt);
bb270c08
DB
549 if (size >= 0)
550 return size;
2af7e610 551 }
115329f1 552
7c7f3866 553 if(avi->non_interleaved){
79396ac6 554 int best_stream_index = 0;
7c7f3866
MN
555 AVStream *best_st= NULL;
556 AVIStream *best_ast;
557 int64_t best_ts= INT64_MAX;
558 int i;
115329f1 559
7c7f3866
MN
560 for(i=0; i<s->nb_streams; i++){
561 AVStream *st = s->streams[i];
562 AVIStream *ast = st->priv_data;
563 int64_t ts= ast->frame_offset;
564
565 if(ast->sample_size)
566 ts /= ast->sample_size;
567 ts= av_rescale(ts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
568
949b1a13 569// av_log(NULL, AV_LOG_DEBUG, "%"PRId64" %d/%d %"PRId64"\n", ts, st->time_base.num, st->time_base.den, ast->frame_offset);
7c7f3866
MN
570 if(ts < best_ts){
571 best_ts= ts;
572 best_st= st;
573 best_stream_index= i;
574 }
575 }
576 best_ast = best_st->priv_data;
577 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
578 if(best_ast->remaining)
579 i= av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD);
580 else
581 i= av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY);
582
583// av_log(NULL, AV_LOG_DEBUG, "%d\n", i);
584 if(i>=0){
585 int64_t pos= best_st->index_entries[i].pos;
5c89153e 586 pos += best_ast->packet_size - best_ast->remaining;
1894edeb 587 url_fseek(&s->pb, pos + 8, SEEK_SET);
949b1a13 588// av_log(NULL, AV_LOG_DEBUG, "pos=%"PRId64"\n", pos);
115329f1 589
8223bca5
MN
590 assert(best_ast->remaining <= best_ast->packet_size);
591
1894edeb
MN
592 avi->stream_index= best_stream_index;
593 if(!best_ast->remaining)
8223bca5 594 best_ast->packet_size=
1894edeb 595 best_ast->remaining= best_st->index_entries[i].size;
7c7f3866
MN
596 }
597 }
115329f1 598
4a8d5135 599resync:
7c7f3866
MN
600 if(avi->stream_index >= 0){
601 AVStream *st= s->streams[ avi->stream_index ];
602 AVIStream *ast= st->priv_data;
603 int size;
115329f1 604
e84dab5f 605 if(ast->sample_size <= 1) // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM
7c7f3866 606 size= INT_MAX;
115329f1 607 else if(ast->sample_size < 32)
7c7f3866
MN
608 size= 64*ast->sample_size;
609 else
610 size= ast->sample_size;
611
612 if(size > ast->remaining)
613 size= ast->remaining;
2692067a 614 av_get_packet(pb, pkt, size);
115329f1 615
a2a6332b 616 if (ENABLE_DV_DEMUXER && avi->dv_demux) {
7c7f3866
MN
617 dstr = pkt->destruct;
618 size = dv_produce_packet(avi->dv_demux, pkt,
619 pkt->data, pkt->size);
620 pkt->destruct = dstr;
621 pkt->flags |= PKT_FLAG_KEY;
622 } else {
623 /* XXX: how to handle B frames in avi ? */
624 pkt->dts = ast->frame_offset;
625// pkt->dts += ast->start;
626 if(ast->sample_size)
627 pkt->dts /= ast->sample_size;
949b1a13 628//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);
7c7f3866
MN
629 pkt->stream_index = avi->stream_index;
630
01f4895c 631 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
4323b09d
MN
632 AVIndexEntry *e;
633 int index;
ded3c7da 634 assert(st->index_entries);
7c7f3866 635
4323b09d
MN
636 index= av_index_search_timestamp(st, pkt->dts, 0);
637 e= &st->index_entries[index];
115329f1 638
4323b09d
MN
639 if(index >= 0 && e->timestamp == ast->frame_offset){
640 if (e->flags & AVINDEX_KEYFRAME)
641 pkt->flags |= PKT_FLAG_KEY;
642 }
7c7f3866 643 } else {
115329f1 644 pkt->flags |= PKT_FLAG_KEY;
7c7f3866
MN
645 }
646 if(ast->sample_size)
647 ast->frame_offset += pkt->size;
648 else
649 ast->frame_offset++;
650 }
651 ast->remaining -= size;
652 if(!ast->remaining){
653 avi->stream_index= -1;
654 ast->packet_size= 0;
7c7f3866
MN
655 }
656
657 return size;
658 }
659
4a8d5135
MN
660 memset(d, -1, sizeof(int)*8);
661 for(i=sync=url_ftell(pb); !url_feof(pb); i++) {
df99755b 662 int j;
1101abfe 663
bb270c08
DB
664 if (i >= avi->movi_end) {
665 if (avi->is_odml) {
666 url_fskip(pb, avi->riff_end - i);
667 avi->riff_end = avi->movi_end = url_fsize(pb);
668 } else
669 break;
670 }
06219cb1 671
df99755b
MN
672 for(j=0; j<7; j++)
673 d[j]= d[j+1];
674 d[7]= get_byte(pb);
115329f1 675
df99755b 676 size= d[4] + (d[5]<<8) + (d[6]<<16) + (d[7]<<24);
115329f1 677
df99755b 678 if( d[2] >= '0' && d[2] <= '9'
d2c5f0a4
MN
679 && d[3] >= '0' && d[3] <= '9'){
680 n= (d[2] - '0') * 10 + (d[3] - '0');
681 }else{
682 n= 100; //invalid stream id
df99755b 683 }
949b1a13 684//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);
d2c5f0a4
MN
685 if(i + size > avi->movi_end || d[0]<0)
686 continue;
115329f1 687
d2c5f0a4
MN
688 //parse ix##
689 if( (d[0] == 'i' && d[1] == 'x' && n < s->nb_streams)
bb270c08 690 //parse JUNK
d2c5f0a4 691 ||(d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K')){
8f9298f8 692 url_fskip(pb, size);
d2c5f0a4 693//av_log(NULL, AV_LOG_DEBUG, "SKIP\n");
4a8d5135 694 goto resync;
8f9298f8 695 }
d2c5f0a4 696
df99755b 697 if( d[0] >= '0' && d[0] <= '9'
d2c5f0a4
MN
698 && d[1] >= '0' && d[1] <= '9'){
699 n= (d[0] - '0') * 10 + (d[1] - '0');
700 }else{
701 n= 100; //invalid stream id
702 }
115329f1 703
d2c5f0a4 704 //parse ##dc/##wb
80e3a08c 705 if(n < s->nb_streams){
d2c5f0a4
MN
706 AVStream *st;
707 AVIStream *ast;
708 st = s->streams[n];
709 ast = st->priv_data;
115329f1 710
f3356e9c
MN
711 if( (st->discard >= AVDISCARD_DEFAULT && size==0)
712 /*|| (st->discard >= AVDISCARD_NONKEY && !(pkt->flags & PKT_FLAG_KEY))*/ //FIXME needs a little reordering
713 || st->discard >= AVDISCARD_ALL){
714 if(ast->sample_size) ast->frame_offset += pkt->size;
715 else ast->frame_offset++;
b4aea108
MN
716 url_fskip(pb, size);
717 goto resync;
718 }
d2c5f0a4 719
115329f1 720 if( ((ast->prefix_count<5 || sync+9 > i) && d[2]<128 && d[3]<128) ||
d2c5f0a4 721 d[2]*256+d[3] == ast->prefix /*||
115329f1 722 (d[2] == 'd' && d[3] == 'c') ||
bb270c08 723 (d[2] == 'w' && d[3] == 'b')*/) {
d2c5f0a4
MN
724
725//av_log(NULL, AV_LOG_DEBUG, "OK\n");
726 if(d[2]*256+d[3] == ast->prefix)
727 ast->prefix_count++;
728 else{
729 ast->prefix= d[2]*256+d[3];
730 ast->prefix_count= 0;
731 }
732
7c7f3866
MN
733 avi->stream_index= n;
734 ast->packet_size= size + 8;
735 ast->remaining= size;
ded3c7da
MN
736
737 {
738 uint64_t pos= url_ftell(pb) - 8;
739 if(!st->index_entries || !st->nb_index_entries || st->index_entries[st->nb_index_entries - 1].pos < pos){
740 av_add_index_entry(st, pos, ast->frame_offset / FFMAX(1, ast->sample_size), size, 0, AVINDEX_KEYFRAME);
741 }
742 }
7c7f3866 743 goto resync;
d2c5f0a4 744 }
df99755b 745 }
69bde0b2
MM
746 /* palette changed chunk */
747 if ( d[0] >= '0' && d[0] <= '9'
748 && d[1] >= '0' && d[1] <= '9'
749 && ((d[2] == 'p' && d[3] == 'c'))
750 && n < s->nb_streams && i + size <= avi->movi_end) {
751
752 AVStream *st;
753 int first, clr, flags, k, p;
754
755 st = s->streams[n];
756
757 first = get_byte(pb);
758 clr = get_byte(pb);
bb270c08
DB
759 if(!clr) /* all 256 colors used */
760 clr = 256;
69bde0b2
MM
761 flags = get_le16(pb);
762 p = 4;
763 for (k = first; k < clr + first; k++) {
764 int r, g, b;
765 r = get_byte(pb);
766 g = get_byte(pb);
767 b = get_byte(pb);
768 get_byte(pb);
01f4895c 769 st->codec->palctrl->palette[k] = b + (g << 8) + (r << 16);
69bde0b2 770 }
01f4895c 771 st->codec->palctrl->palette_changed = 1;
4a8d5135 772 goto resync;
69bde0b2
MM
773 }
774
df99755b 775 }
d2c5f0a4 776
df99755b 777 return -1;
de6d9b64
FB
778}
779
155e9ee9
FB
780/* XXX: we make the implicit supposition that the position are sorted
781 for each stream */
782static int avi_read_idx1(AVFormatContext *s, int size)
783{
7c7f3866 784 AVIContext *avi = s->priv_data;
155e9ee9
FB
785 ByteIOContext *pb = &s->pb;
786 int nb_index_entries, i;
787 AVStream *st;
788 AVIStream *ast;
155e9ee9 789 unsigned int index, tag, flags, pos, len;
7c7f3866 790 unsigned last_pos= -1;
115329f1 791
155e9ee9
FB
792 nb_index_entries = size / 16;
793 if (nb_index_entries <= 0)
794 return -1;
795
796 /* read the entries and sort them in each stream component */
797 for(i = 0; i < nb_index_entries; i++) {
798 tag = get_le32(pb);
799 flags = get_le32(pb);
800 pos = get_le32(pb);
801 len = get_le32(pb);
52a0bbff 802#if defined(DEBUG_SEEK)
115329f1 803 av_log(NULL, AV_LOG_DEBUG, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/",
155e9ee9
FB
804 i, tag, flags, pos, len);
805#endif
7c7f3866
MN
806 if(i==0 && pos > avi->movi_list)
807 avi->movi_list= 0; //FIXME better check
5c89153e 808 pos += avi->movi_list;
7c7f3866 809
155e9ee9
FB
810 index = ((tag & 0xff) - '0') * 10;
811 index += ((tag >> 8) & 0xff) - '0';
812 if (index >= s->nb_streams)
813 continue;
814 st = s->streams[index];
815 ast = st->priv_data;
115329f1 816
52a0bbff 817#if defined(DEBUG_SEEK)
949b1a13 818 av_log(NULL, AV_LOG_DEBUG, "%d cum_len=%"PRId64"\n", len, ast->cum_len);
52a0bbff 819#endif
80e3a08c
MN
820 if(last_pos == pos)
821 avi->non_interleaved= 1;
822 else
2b70eb2b 823 av_add_index_entry(st, pos, ast->cum_len / FFMAX(1, ast->sample_size), len, 0, (flags&AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);
7c7f3866 824 if(ast->sample_size)
2b70eb2b 825 ast->cum_len += len;
7c7f3866
MN
826 else
827 ast->cum_len ++;
7c7f3866 828 last_pos= pos;
155e9ee9
FB
829 }
830 return 0;
831}
832
7c7f3866 833static int guess_ni_flag(AVFormatContext *s){
7c7f3866
MN
834 int i;
835 int64_t last_start=0;
836 int64_t first_end= INT64_MAX;
115329f1 837
7c7f3866
MN
838 for(i=0; i<s->nb_streams; i++){
839 AVStream *st = s->streams[i];
7c7f3866
MN
840 int n= st->nb_index_entries;
841
842 if(n <= 0)
843 continue;
844
845 if(st->index_entries[0].pos > last_start)
846 last_start= st->index_entries[0].pos;
847 if(st->index_entries[n-1].pos < first_end)
848 first_end= st->index_entries[n-1].pos;
849 }
850 return last_start > first_end;
851}
852
155e9ee9
FB
853static int avi_load_index(AVFormatContext *s)
854{
855 AVIContext *avi = s->priv_data;
856 ByteIOContext *pb = &s->pb;
857 uint32_t tag, size;
e6c0297f 858 offset_t pos= url_ftell(pb);
115329f1 859
155e9ee9
FB
860 url_fseek(pb, avi->movi_end, SEEK_SET);
861#ifdef DEBUG_SEEK
949b1a13 862 printf("movi_end=0x%"PRIx64"\n", avi->movi_end);
155e9ee9
FB
863#endif
864 for(;;) {
865 if (url_feof(pb))
866 break;
867 tag = get_le32(pb);
868 size = get_le32(pb);
869#ifdef DEBUG_SEEK
870 printf("tag=%c%c%c%c size=0x%x\n",
871 tag & 0xff,
872 (tag >> 8) & 0xff,
873 (tag >> 16) & 0xff,
874 (tag >> 24) & 0xff,
875 size);
876#endif
877 switch(tag) {
878 case MKTAG('i', 'd', 'x', '1'):
879 if (avi_read_idx1(s, size) < 0)
880 goto skip;
881 else
882 goto the_end;
883 break;
884 default:
885 skip:
886 size += (size & 1);
887 url_fskip(pb, size);
888 break;
889 }
890 }
891 the_end:
e6c0297f 892 url_fseek(pb, pos, SEEK_SET);
155e9ee9
FB
893 return 0;
894}
895
7b3c1382 896static int avi_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
155e9ee9
FB
897{
898 AVIContext *avi = s->priv_data;
899 AVStream *st;
52a0bbff 900 int i, index;
155e9ee9
FB
901 int64_t pos;
902
903 if (!avi->index_loaded) {
904 /* we only load the index on demand */
905 avi_load_index(s);
906 avi->index_loaded = 1;
907 }
52a0bbff 908 assert(stream_index>= 0);
155e9ee9
FB
909
910 st = s->streams[stream_index];
52a0bbff
MN
911 index= av_index_search_timestamp(st, timestamp, flags);
912 if(index<0)
155e9ee9 913 return -1;
115329f1 914
155e9ee9 915 /* find the position */
52a0bbff
MN
916 pos = st->index_entries[index].pos;
917 timestamp = st->index_entries[index].timestamp;
918
949b1a13 919// av_log(NULL, AV_LOG_DEBUG, "XX %"PRId64" %d %"PRId64"\n", timestamp, index, st->index_entries[index].timestamp);
155e9ee9 920
6eb2de74
RS
921 if (ENABLE_DV_DEMUXER && avi->dv_demux) {
922 /* One and only one real stream for DV in AVI, and it has video */
923 /* offsets. Calling with other stream indices should have failed */
924 /* the av_index_search_timestamp call above. */
925 assert(stream_index == 0);
926
927 /* Feed the DV video stream version of the timestamp to the */
928 /* DV demux so it can synth correct timestamps */
929 dv_offset_reset(avi->dv_demux, timestamp);
930
931 url_fseek(&s->pb, pos, SEEK_SET);
932 avi->stream_index= -1;
933 return 0;
934 }
935
155e9ee9 936 for(i = 0; i < s->nb_streams; i++) {
52a0bbff
MN
937 AVStream *st2 = s->streams[i];
938 AVIStream *ast2 = st2->priv_data;
7c7f3866
MN
939
940 ast2->packet_size=
941 ast2->remaining= 0;
942
52a0bbff
MN
943 if (st2->nb_index_entries <= 0)
944 continue;
115329f1 945
e84dab5f 946// assert(st2->codec->block_align);
52a0bbff
MN
947 assert(st2->time_base.den == ast2->rate);
948 assert(st2->time_base.num == ast2->scale);
949 index = av_index_search_timestamp(
115329f1 950 st2,
52a0bbff
MN
951 av_rescale(timestamp, st2->time_base.den*(int64_t)st->time_base.num, st->time_base.den * (int64_t)st2->time_base.num),
952 flags | AVSEEK_FLAG_BACKWARD);
953 if(index<0)
954 index=0;
115329f1 955
7c7f3866
MN
956 if(!avi->non_interleaved){
957 while(index>0 && st2->index_entries[index].pos > pos)
958 index--;
959 while(index+1 < st2->nb_index_entries && st2->index_entries[index].pos < pos)
960 index++;
961 }
962
949b1a13 963// av_log(NULL, AV_LOG_DEBUG, "%"PRId64" %d %"PRId64"\n", timestamp, index, st2->index_entries[index].timestamp);
52a0bbff
MN
964 /* extract the current frame number */
965 ast2->frame_offset = st2->index_entries[index].timestamp;
966 if(ast2->sample_size)
967 ast2->frame_offset *=ast2->sample_size;
155e9ee9 968 }
52a0bbff 969
155e9ee9 970 /* do the seek */
155e9ee9 971 url_fseek(&s->pb, pos, SEEK_SET);
7c7f3866 972 avi->stream_index= -1;
155e9ee9
FB
973 return 0;
974}
975
1101abfe 976static int avi_read_close(AVFormatContext *s)
de6d9b64 977{
5ae2c73e
MN
978 int i;
979 AVIContext *avi = s->priv_data;
5ae2c73e
MN
980
981 for(i=0;i<s->nb_streams;i++) {
982 AVStream *st = s->streams[i];
155e9ee9 983 AVIStream *ast = st->priv_data;
52a0bbff 984 av_free(ast);
01f4895c 985 av_free(st->codec->palctrl);
5ae2c73e
MN
986 }
987
7458ccbb
RS
988 if (avi->dv_demux)
989 av_free(avi->dv_demux);
990
c9a65ca8
FB
991 return 0;
992}
993
994static int avi_probe(AVProbeData *p)
995{
996 /* check file header */
997 if (p->buf_size <= 32)
998 return 0;
999 if (p->buf[0] == 'R' && p->buf[1] == 'I' &&
1000 p->buf[2] == 'F' && p->buf[3] == 'F' &&
1001 p->buf[8] == 'A' && p->buf[9] == 'V' &&
d09ea618 1002 p->buf[10] == 'I' && (p->buf[11] == ' ' || p->buf[11] == 0x19))
c9a65ca8
FB
1003 return AVPROBE_SCORE_MAX;
1004 else
1005 return 0;
1006}
1007
ff70e601 1008AVInputFormat avi_demuxer = {
c9a65ca8
FB
1009 "avi",
1010 "avi format",
1011 sizeof(AVIContext),
1012 avi_probe,
1013 avi_read_header,
1014 avi_read_packet,
1015 avi_read_close,
155e9ee9 1016 avi_read_seek,
c9a65ca8 1017};