avidec.c 46.9 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1
/*
2
 * AVI demuxer
Diego Biurrun's avatar
Diego Biurrun committed
3
 * Copyright (c) 2001 Fabrice Bellard
Fabrice Bellard's avatar
Fabrice Bellard committed
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
Fabrice Bellard's avatar
Fabrice Bellard committed
11
 *
12
 * Libav is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
Fabrice Bellard's avatar
Fabrice Bellard committed
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with Libav; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Fabrice Bellard's avatar
Fabrice Bellard committed
20
 */
21

22
#include "libavutil/intreadwrite.h"
23
#include "libavutil/mathematics.h"
24
#include "libavutil/bswap.h"
25
#include "libavutil/dict.h"
26
#include "libavutil/avstring.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
27
#include "avformat.h"
28
#include "internal.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
29
#include "avi.h"
30
#include "dv.h"
31
#include "riff.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
32

33 34 35
#undef NDEBUG
#include <assert.h>

Fabrice Bellard's avatar
Fabrice Bellard committed
36
typedef struct AVIStream {
37
    int64_t frame_offset; /* current frame (video) or byte (audio) counter
Fabrice Bellard's avatar
Fabrice Bellard committed
38
                         (used to compute the pts) */
39 40 41
    int remaining;
    int packet_size;

42 43
    uint32_t scale;
    uint32_t rate;
44
    int sample_size; /* size of one sample (or packet) (in the rate/scale sense) in bytes */
45

46
    int64_t cum_len; /* temporary storage (used during seek) */
47

48 49
    int prefix;                       ///< normally 'd'<<8 + 'c' or 'w'<<8 + 'b'
    int prefix_count;
50 51
    uint32_t pal[256];
    int has_pal;
52
    int dshow_block_align;            ///< block align variable used to emulate bugs in the MS dshow demuxer
53 54 55 56

    AVFormatContext *sub_ctx;
    AVPacket sub_pkt;
    uint8_t *sub_buffer;
Fabrice Bellard's avatar
Fabrice Bellard committed
57
} AVIStream;
Fabrice Bellard's avatar
Fabrice Bellard committed
58 59

typedef struct {
60 61
    int64_t  riff_end;
    int64_t  movi_end;
62
    int64_t  fsize;
63
    int64_t movi_list;
64
    int64_t last_pkt_pos;
Fabrice Bellard's avatar
Fabrice Bellard committed
65
    int index_loaded;
66
    int is_odml;
67 68
    int non_interleaved;
    int stream_index;
69
    DVDemuxContext* dv_demux;
70 71
    int odml_depth;
#define MAX_ODML_DEPTH 1000
Fabrice Bellard's avatar
Fabrice Bellard committed
72 73
} AVIContext;

74 75 76 77
static const char avi_headers[][8] = {
    { 'R', 'I', 'F', 'F',    'A', 'V', 'I', ' ' },
    { 'R', 'I', 'F', 'F',    'A', 'V', 'I', 'X' },
    { 'R', 'I', 'F', 'F',    'A', 'V', 'I', 0x19},
78
    { 'O', 'N', '2', ' ',    'O', 'N', '2', 'f' },
79
    { 'R', 'I', 'F', 'F',    'A', 'M', 'V', ' ' },
80 81 82
    { 0 }
};

83 84 85 86 87
static const AVMetadataConv avi_metadata_conv[] = {
    { "strn", "title" },
    { 0 },
};

88
static int avi_load_index(AVFormatContext *s);
89
static int guess_ni_flag(AVFormatContext *s);
90

91
#define print_tag(str, tag, size)                       \
92
    av_dlog(NULL, "%s: tag=%c%c%c%c size=0x%x\n",       \
93 94 95 96 97
           str, tag & 0xff,                             \
           (tag >> 8) & 0xff,                           \
           (tag >> 16) & 0xff,                          \
           (tag >> 24) & 0xff,                          \
           size)
Fabrice Bellard's avatar
Fabrice Bellard committed
98

99 100 101
static inline int get_duration(AVIStream *ast, int len){
    if(ast->sample_size){
        return len;
102 103
    }else if (ast->dshow_block_align){
        return (len + ast->dshow_block_align - 1)/ast->dshow_block_align;
104 105 106 107
    }else
        return 1;
}

108
static int get_riff(AVFormatContext *s, AVIOContext *pb)
109
{
110
    AVIContext *avi = s->priv_data;
111 112
    char header[8];
    int i;
113

114
    /* check RIFF header */
115 116
    avio_read(pb, header, 4);
    avi->riff_end = avio_rl32(pb);  /* RIFF chunk size */
117
    avi->riff_end += avio_tell(pb); /* RIFF chunk end */
118
    avio_read(pb, header+4, 4);
119 120 121 122 123

    for(i=0; avi_headers[i][0]; i++)
        if(!memcmp(header, avi_headers[i], 8))
            break;
    if(!avi_headers[i][0])
124
        return -1;
125

126
    if(header[7] == 0x19)
127
        av_log(s, AV_LOG_INFO, "This file has been generated by a totally broken muxer.\n");
128

129 130 131
    return 0;
}

132
static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){
133
    AVIContext *avi = s->priv_data;
134
    AVIOContext *pb = s->pb;
135 136 137 138 139 140
    int longs_pre_entry= avio_rl16(pb);
    int index_sub_type = avio_r8(pb);
    int index_type     = avio_r8(pb);
    int entries_in_use = avio_rl32(pb);
    int chunk_id       = avio_rl32(pb);
    int64_t base       = avio_rl64(pb);
141 142 143 144
    int stream_id= 10*((chunk_id&0xFF) - '0') + (((chunk_id>>8)&0xFF) - '0');
    AVStream *st;
    AVIStream *ast;
    int i;
145
    int64_t last_pos= -1;
146
    int64_t filesize= avio_size(s->pb);
147

148 149
    av_dlog(s, "longs_pre_entry:%d index_type:%d entries_in_use:%d chunk_id:%X base:%16"PRIX64"\n",
            longs_pre_entry,index_type, entries_in_use, chunk_id, base);
150

151
    if(stream_id >= s->nb_streams || stream_id < 0)
152 153 154 155 156 157 158
        return -1;
    st= s->streams[stream_id];
    ast = st->priv_data;

    if(index_sub_type)
        return -1;

159
    avio_rl32(pb);
160 161 162 163 164 165

    if(index_type && longs_pre_entry != 2)
        return -1;
    if(index_type>1)
        return -1;

166 167 168 169 170 171 172 173
    if(filesize > 0 && base >= filesize){
        av_log(s, AV_LOG_ERROR, "ODML index invalid\n");
        if(base>>32 == (base & 0xFFFFFFFF) && (base & 0xFFFFFFFF) < filesize && filesize <= 0xFFFFFFFF)
            base &= 0xFFFFFFFF;
        else
            return -1;
    }

174 175
    for(i=0; i<entries_in_use; i++){
        if(index_type){
176 177
            int64_t pos= avio_rl32(pb) + base - 8;
            int len    = avio_rl32(pb);
178
            int key= len >= 0;
179 180
            len &= 0x7FFFFFFF;

181 182
            av_dlog(s, "pos:%"PRId64", len:%X\n", pos, len);

Anton Khirnov's avatar
Anton Khirnov committed
183
            if(pb->eof_reached)
184 185
                return -1;

186 187
            if(last_pos == pos || pos == base - 8)
                avi->non_interleaved= 1;
188
            if(last_pos != pos && (len || !ast->sample_size))
189
                av_add_index_entry(st, pos, ast->cum_len, len, 0, key ? AVINDEX_KEYFRAME : 0);
190

191
            ast->cum_len += get_duration(ast, len);
192
            last_pos= pos;
193
        }else{
Måns Rullgård's avatar
Måns Rullgård committed
194 195
            int64_t offset, pos;
            int duration;
196 197 198
            offset = avio_rl64(pb);
            avio_rl32(pb);       /* size */
            duration = avio_rl32(pb);
199

Anton Khirnov's avatar
Anton Khirnov committed
200
            if(pb->eof_reached)
201 202
                return -1;

203
            pos = avio_tell(pb);
204

205 206 207 208 209
            if(avi->odml_depth > MAX_ODML_DEPTH){
                av_log(s, AV_LOG_ERROR, "Too deeply nested ODML indexes\n");
                return -1;
            }

210
            avio_seek(pb, offset+8, SEEK_SET);
211
            avi->odml_depth++;
212
            read_braindead_odml_indx(s, frame_num);
213
            avi->odml_depth--;
214 215
            frame_num += duration;

216
            avio_seek(pb, pos, SEEK_SET);
217 218
        }
    }
219
    avi->index_loaded=1;
220 221 222
    return 0;
}

223
static void clean_index(AVFormatContext *s){
224 225
    int i;
    int64_t j;
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243

    for(i=0; i<s->nb_streams; i++){
        AVStream *st = s->streams[i];
        AVIStream *ast = st->priv_data;
        int n= st->nb_index_entries;
        int max= ast->sample_size;
        int64_t pos, size, ts;

        if(n != 1 || ast->sample_size==0)
            continue;

        while(max < 1024) max+=max;

        pos= st->index_entries[0].pos;
        size= st->index_entries[0].size;
        ts= st->index_entries[0].timestamp;

        for(j=0; j<size; j+=max){
244
            av_add_index_entry(st, pos+j, ts+j, FFMIN(max, size-j), 0, AVINDEX_KEYFRAME);
245 246 247 248
        }
    }
}

249
static int avi_read_tag(AVFormatContext *s, AVStream *st, uint32_t tag, uint32_t size)
250
{
251
    AVIOContext *pb = s->pb;
252
    char key[5] = {0}, *value;
253

254
    size += (size & 1);
255

256 257 258 259 260
    if (size == UINT_MAX)
        return -1;
    value = av_malloc(size+1);
    if (!value)
        return -1;
261
    avio_read(pb, value, size);
262
    value[size]=0;
263

264 265
    AV_WL32(key, tag);

266 267
    return av_dict_set(st ? &st->metadata : &s->metadata, key, value,
                            AV_DICT_DONT_STRDUP_VAL);
268 269
}

270 271 272
static const char months[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
                                    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };

273
static void avi_metadata_creation_time(AVDictionary **metadata, char *date)
274 275 276 277 278
{
    char month[4], time[9], buffer[64];
    int i, day, year;
    /* parse standard AVI date format (ie. "Mon Mar 10 15:04:43 2003") */
    if (sscanf(date, "%*3s%*[ ]%3s%*[ ]%2d%*[ ]%8s%*[ ]%4d",
279
               month, &day, time, &year) == 4) {
280
        for (i=0; i<12; i++)
281
            if (!av_strcasecmp(month, months[i])) {
282 283
                snprintf(buffer, sizeof(buffer), "%.4d-%.2d-%.2d %s",
                         year, i+1, day, time);
284
                av_dict_set(metadata, "creation_time", buffer, 0);
285
            }
286 287
    } else if (date[4] == '/' && date[7] == '/') {
        date[4] = date[7] = '-';
288
        av_dict_set(metadata, "creation_time", date, 0);
289
    }
290 291
}

292 293
static void avi_read_nikon(AVFormatContext *s, uint64_t end)
{
294
    while (avio_tell(s->pb) < end) {
295 296
        uint32_t tag  = avio_rl32(s->pb);
        uint32_t size = avio_rl32(s->pb);
297 298
        switch (tag) {
        case MKTAG('n', 'c', 't', 'g'): {  /* Nikon Tags */
299 300
            uint64_t tag_end = avio_tell(s->pb) + size;
            while (avio_tell(s->pb) < tag_end) {
301 302
                uint16_t tag  = avio_rl16(s->pb);
                uint16_t size = avio_rl16(s->pb);
303 304
                const char *name = NULL;
                char buffer[64] = {0};
305
                size -= avio_read(s->pb, buffer,
306 307 308 309 310 311 312 313 314 315
                                   FFMIN(size, sizeof(buffer)-1));
                switch (tag) {
                case 0x03:  name = "maker";  break;
                case 0x04:  name = "model";  break;
                case 0x13:  name = "creation_time";
                    if (buffer[4] == ':' && buffer[7] == ':')
                        buffer[4] = buffer[7] = '-';
                    break;
                }
                if (name)
316
                    av_dict_set(&s->metadata, name, buffer, 0);
317
                avio_skip(s->pb, size);
318 319 320 321
            }
            break;
        }
        default:
322
            avio_skip(s->pb, size);
323 324 325 326 327
            break;
        }
    }
}

328
static int avi_read_header(AVFormatContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
329
{
Fabrice Bellard's avatar
Fabrice Bellard committed
330
    AVIContext *avi = s->priv_data;
331
    AVIOContext *pb = s->pb;
332
    unsigned int tag, tag1, handler;
Mans Rullgard's avatar
Mans Rullgard committed
333
    int codec_type, stream_index, frame_period;
Michael Niedermayer's avatar
Michael Niedermayer committed
334
    unsigned int size;
335
    int i;
Fabrice Bellard's avatar
Fabrice Bellard committed
336
    AVStream *st;
Måns Rullgård's avatar
Måns Rullgård committed
337
    AVIStream *ast = NULL;
338 339
    int avih_width=0, avih_height=0;
    int amv_file_format=0;
340
    uint64_t list_end = 0;
341
    int ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
342

343
    avi->stream_index= -1;
344

345
    if (get_riff(s, pb) < 0)
Fabrice Bellard's avatar
Fabrice Bellard committed
346
        return -1;
347

348
    avi->fsize = avio_size(pb);
349
    if(avi->fsize<=0)
350
        avi->fsize= avi->riff_end == 8 ? INT64_MAX : avi->riff_end;
351

Fabrice Bellard's avatar
Fabrice Bellard committed
352 353 354 355 356
    /* first list tag */
    stream_index = -1;
    codec_type = -1;
    frame_period = 0;
    for(;;) {
Anton Khirnov's avatar
Anton Khirnov committed
357
        if (pb->eof_reached)
Fabrice Bellard's avatar
Fabrice Bellard committed
358
            goto fail;
359 360
        tag = avio_rl32(pb);
        size = avio_rl32(pb);
361

Fabrice Bellard's avatar
Fabrice Bellard committed
362 363 364 365
        print_tag("tag", tag, size);

        switch(tag) {
        case MKTAG('L', 'I', 'S', 'T'):
366
            list_end = avio_tell(pb) + size;
Diego Biurrun's avatar
Diego Biurrun committed
367
            /* Ignored, except at start of video packets. */
368
            tag1 = avio_rl32(pb);
369

Fabrice Bellard's avatar
Fabrice Bellard committed
370
            print_tag("list", tag1, 0);
371

Fabrice Bellard's avatar
Fabrice Bellard committed
372
            if (tag1 == MKTAG('m', 'o', 'v', 'i')) {
373
                avi->movi_list = avio_tell(pb) - 4;
374
                if(size) avi->movi_end = avi->movi_list + size + (size & 1);
375
                else     avi->movi_end = avio_size(pb);
376
                av_dlog(NULL, "movi end=%"PRIx64"\n", avi->movi_end);
Fabrice Bellard's avatar
Fabrice Bellard committed
377 378
                goto end_of_header;
            }
379
            else if (tag1 == MKTAG('I', 'N', 'F', 'O'))
380
                ff_read_riff_info(s, size - 4);
381 382
            else if (tag1 == MKTAG('n', 'c', 'd', 't'))
                avi_read_nikon(s, list_end);
383

Fabrice Bellard's avatar
Fabrice Bellard committed
384
            break;
385 386 387
        case MKTAG('I', 'D', 'I', 'T'): {
            unsigned char date[64] = {0};
            size += (size & 1);
388
            size -= avio_read(pb, date, FFMIN(size, sizeof(date)-1));
389
            avio_skip(pb, size);
390 391 392
            avi_metadata_creation_time(&s->metadata, date);
            break;
        }
393
        case MKTAG('d', 'm', 'l', 'h'):
394
            avi->is_odml = 1;
395
            avio_skip(pb, size + (size & 1));
396
            break;
397 398
        case MKTAG('a', 'm', 'v', 'h'):
            amv_file_format=1;
Fabrice Bellard's avatar
Fabrice Bellard committed
399
        case MKTAG('a', 'v', 'i', 'h'):
Diego Biurrun's avatar
Diego Biurrun committed
400
            /* AVI header */
401
            /* using frame_period is bad idea */
402
            frame_period = avio_rl32(pb);
Mans Rullgard's avatar
Mans Rullgard committed
403
            avio_skip(pb, 4);
404 405
            avio_rl32(pb);
            avi->non_interleaved |= avio_rl32(pb) & AVIF_MUSTUSEINDEX;
406

407
            avio_skip(pb, 2 * 4);
408 409 410 411
            avio_rl32(pb);
            avio_rl32(pb);
            avih_width=avio_rl32(pb);
            avih_height=avio_rl32(pb);
412

413
            avio_skip(pb, size - 10 * 4);
414 415 416 417
            break;
        case MKTAG('s', 't', 'r', 'h'):
            /* stream header */

418 419
            tag1 = avio_rl32(pb);
            handler = avio_rl32(pb); /* codec tag */
420 421

            if(tag1 == MKTAG('p', 'a', 'd', 's')){
422
                avio_skip(pb, size - 8);
423 424 425
                break;
            }else{
                stream_index++;
426
                st = avformat_new_stream(s, NULL);
Fabrice Bellard's avatar
Fabrice Bellard committed
427 428
                if (!st)
                    goto fail;
429

430
                st->id = stream_index;
Fabrice Bellard's avatar
Fabrice Bellard committed
431 432 433 434
                ast = av_mallocz(sizeof(AVIStream));
                if (!ast)
                    goto fail;
                st->priv_data = ast;
435
            }
436 437
            if(amv_file_format)
                tag1 = stream_index ? MKTAG('a','u','d','s') : MKTAG('v','i','d','s');
438

439
            print_tag("strh", tag1, -1);
440

441
            if(tag1 == MKTAG('i', 'a', 'v', 's') || tag1 == MKTAG('i', 'v', 'a', 's')){
442 443
                int64_t dv_dur;

444
                /*
445
                 * After some consideration -- I don't think we
Diego Biurrun's avatar
Diego Biurrun committed
446
                 * have to support anything but DV in type1 AVIs.
447 448 449 450 451 452 453 454 455 456 457
                 */
                if (s->nb_streams != 1)
                    goto fail;

                if (handler != MKTAG('d', 'v', 's', 'd') &&
                    handler != MKTAG('d', 'v', 'h', 'd') &&
                    handler != MKTAG('d', 'v', 's', 'l'))
                   goto fail;

                ast = s->streams[0]->priv_data;
                av_freep(&s->streams[0]->codec->extradata);
458
                av_freep(&s->streams[0]->codec);
459 460
                av_freep(&s->streams[0]);
                s->nb_streams = 0;
461
                if (CONFIG_DV_DEMUXER) {
462
                    avi->dv_demux = avpriv_dv_init_demux(s);
463 464
                    if (!avi->dv_demux)
                        goto fail;
465
                }
466
                s->streams[0]->priv_data = ast;
467
                avio_skip(pb, 3 * 4);
468 469
                ast->scale = avio_rl32(pb);
                ast->rate = avio_rl32(pb);
470
                avio_skip(pb, 4);  /* start time */
471

472
                dv_dur = avio_rl32(pb);
473 474 475 476 477 478
                if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) {
                    dv_dur *= AV_TIME_BASE;
                    s->duration = av_rescale(dv_dur, ast->scale, ast->rate);
                }
                /*
                 * else, leave duration alone; timing estimation in utils.c
Diego Biurrun's avatar
Diego Biurrun committed
479
                 *      will make a guess based on bitrate.
480 481
                 */

482
                stream_index = s->nb_streams - 1;
483
                avio_skip(pb, size - 9*4);
484 485
                break;
            }
486

487
            assert(stream_index < s->nb_streams);
488
            st->codec->stream_codec_tag= handler;
489

490 491 492 493 494 495
            avio_rl32(pb); /* flags */
            avio_rl16(pb); /* priority */
            avio_rl16(pb); /* language */
            avio_rl32(pb); /* initial frame */
            ast->scale = avio_rl32(pb);
            ast->rate = avio_rl32(pb);
496
            if(!(ast->scale && ast->rate)){
Diego Biurrun's avatar
Diego Biurrun committed
497
                av_log(s, AV_LOG_WARNING, "scale/rate is %u/%u which is invalid. (This file has been generated by broken software.)\n", ast->scale, ast->rate);
Michael Niedermayer's avatar
Michael Niedermayer committed
498 499 500 501 502 503 504
                if(frame_period){
                    ast->rate = 1000000;
                    ast->scale = frame_period;
                }else{
                    ast->rate = 25;
                    ast->scale = 1;
                }
505
            }
506
            avpriv_set_pts_info(st, 64, ast->scale, ast->rate);
507

508 509
            ast->cum_len=avio_rl32(pb); /* start */
            st->nb_frames = avio_rl32(pb);
510

511
            st->start_time = 0;
512 513 514
            avio_rl32(pb); /* buffer size */
            avio_rl32(pb); /* quality */
            ast->sample_size = avio_rl32(pb); /* sample ssize */
515
            ast->cum_len *= FFMAX(1, ast->sample_size);
516 517
            av_dlog(s, "%"PRIu32" %"PRIu32" %d\n",
                    ast->rate, ast->scale, ast->sample_size);
518

519
            switch(tag1) {
520
            case MKTAG('v', 'i', 'd', 's'):
521
                codec_type = AVMEDIA_TYPE_VIDEO;
522

523 524 525
                ast->sample_size = 0;
                break;
            case MKTAG('a', 'u', 'd', 's'):
526
                codec_type = AVMEDIA_TYPE_AUDIO;
527
                break;
528
            case MKTAG('t', 'x', 't', 's'):
529
                codec_type = AVMEDIA_TYPE_SUBTITLE;
530
                break;
Florian Echtler's avatar
Florian Echtler committed
531
            case MKTAG('d', 'a', 't', 's'):
532
                codec_type = AVMEDIA_TYPE_DATA;
Florian Echtler's avatar
Florian Echtler committed
533
                break;
534
            default:
Michael Niedermayer's avatar
Michael Niedermayer committed
535
                av_log(s, AV_LOG_ERROR, "unknown stream type %X\n", tag1);
536
                goto fail;
Fabrice Bellard's avatar
Fabrice Bellard committed
537
            }
538 539
            if(ast->sample_size == 0)
                st->duration = st->nb_frames;
540
            ast->frame_offset= ast->cum_len;
541
            avio_skip(pb, size - 12 * 4);
Fabrice Bellard's avatar
Fabrice Bellard committed
542 543 544
            break;
        case MKTAG('s', 't', 'r', 'f'):
            /* stream header */
545
            if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) {
546
                avio_skip(pb, size);
Fabrice Bellard's avatar
Fabrice Bellard committed
547
            } else {
548
                uint64_t cur_pos = avio_tell(pb);
549 550
                if (cur_pos < list_end)
                    size = FFMIN(size, list_end - cur_pos);
Fabrice Bellard's avatar
Fabrice Bellard committed
551 552
                st = s->streams[stream_index];
                switch(codec_type) {
553
                case AVMEDIA_TYPE_VIDEO:
554 555 556
                    if(amv_file_format){
                        st->codec->width=avih_width;
                        st->codec->height=avih_height;
557
                        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
558
                        st->codec->codec_id = AV_CODEC_ID_AMV;
559
                        avio_skip(pb, size);
560 561
                        break;
                    }
Peter Ross's avatar
Peter Ross committed
562
                    tag1 = ff_get_bmp_header(pb, st);
563

Michael Niedermayer's avatar
Michael Niedermayer committed
564
                    if (tag1 == MKTAG('D', 'X', 'S', 'B') || tag1 == MKTAG('D','X','S','A')) {
565
                        st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
566
                        st->codec->codec_tag = tag1;
567
                        st->codec->codec_id = AV_CODEC_ID_XSUB;
568 569 570
                        break;
                    }

571 572 573
                    if(size > 10*4 && size<(1<<30)){
                        st->codec->extradata_size= size - 10*4;
                        st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
574 575 576 577
                        if (!st->codec->extradata) {
                            st->codec->extradata_size= 0;
                            return AVERROR(ENOMEM);
                        }
578
                        avio_read(pb, st->codec->extradata, st->codec->extradata_size);
579
                    }
580

581
                    if(st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly
582
                        avio_r8(pb);
583

Diego Biurrun's avatar
Diego Biurrun committed
584 585
                    /* Extract palette from extradata if bpp <= 8. */
                    /* This code assumes that extradata contains only palette. */
586
                    /* This is true for all paletted codecs implemented in Libav. */
587
                    if (st->codec->extradata_size && (st->codec->bits_per_coded_sample <= 8)) {
588 589 590 591 592
                        int pal_size = (1 << st->codec->bits_per_coded_sample) << 2;
                        const uint8_t *pal_src;

                        pal_size = FFMIN(pal_size, st->codec->extradata_size);
                        pal_src = st->codec->extradata + st->codec->extradata_size - pal_size;
593
#if HAVE_BIGENDIAN
594 595
                        for (i = 0; i < pal_size/4; i++)
                            ast->pal[i] = av_bswap32(((uint32_t*)pal_src)[i]);
596
#else
597
                        memcpy(ast->pal, pal_src, pal_size);
598
#endif
599
                        ast->has_pal = 1;
600 601
                    }

Fabrice Bellard's avatar
Fabrice Bellard committed
602
                    print_tag("video", tag1, 0);
603

604
                    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
605
                    st->codec->codec_tag = tag1;
606
                    st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag1);
Diego Biurrun's avatar
Diego Biurrun committed
607
                    st->need_parsing = AVSTREAM_PARSE_HEADERS; // This is needed to get the pict type which is necessary for generating correct pts.
608 609 610 611
                    // Support "Resolution 1:1" for Avid AVI Codec
                    if(tag1 == MKTAG('A', 'V', 'R', 'n') &&
                       st->codec->extradata_size >= 31 &&
                       !memcmp(&st->codec->extradata[28], "1:1", 3))
612
                        st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
613 614 615 616 617 618 619 620 621

                    if(st->codec->codec_tag==0 && st->codec->height > 0 && st->codec->extradata_size < 1U<<30){
                        st->codec->extradata_size+= 9;
                        st->codec->extradata= av_realloc(st->codec->extradata, st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
                        if(st->codec->extradata)
                            memcpy(st->codec->extradata + st->codec->extradata_size - 9, "BottomUp", 9);
                    }
                    st->codec->height= FFABS(st->codec->height);

622
//                    avio_skip(pb, size - 5 * 4);
Fabrice Bellard's avatar
Fabrice Bellard committed
623
                    break;
624
                case AVMEDIA_TYPE_AUDIO:
625 626 627
                    ret = ff_get_wav_header(pb, st->codec, size);
                    if (ret < 0)
                        return ret;
628
                    ast->dshow_block_align= st->codec->block_align;
629
                    if(ast->sample_size && st->codec->block_align && ast->sample_size != st->codec->block_align){
630
                        av_log(s, AV_LOG_WARNING, "sample size (%d) != block align (%d)\n", ast->sample_size, st->codec->block_align);
631 632
                        ast->sample_size= st->codec->block_align;
                    }
633
                    if (size&1) /* 2-aligned (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
634
                        avio_skip(pb, 1);
Diego Biurrun's avatar
Diego Biurrun committed
635
                    /* Force parsing as several audio frames can be in
Diego Biurrun's avatar
Diego Biurrun committed
636
                     * one packet and timestamps refer to packet start. */
637
                    st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
Diego Biurrun's avatar
Diego Biurrun committed
638 639 640
                    /* ADTS header is in extradata, AAC without header must be
                     * stored as exact frames. Parser not needed and it will
                     * fail. */
641
                    if (st->codec->codec_id == AV_CODEC_ID_AAC && st->codec->extradata_size)
642
                        st->need_parsing = AVSTREAM_PARSE_NONE;
643 644
                    /* AVI files with Xan DPCM audio (wrongly) declare PCM
                     * audio in the header but have Axan as stream_code_tag. */
645
                    if (st->codec->stream_codec_tag == AV_RL32("Axan")){
646
                        st->codec->codec_id  = AV_CODEC_ID_XAN_DPCM;
647 648
                        st->codec->codec_tag = 0;
                    }
649
                    if (amv_file_format){
650
                        st->codec->codec_id  = AV_CODEC_ID_ADPCM_IMA_AMV;
651 652
                        ast->dshow_block_align = 0;
                    }
Fabrice Bellard's avatar
Fabrice Bellard committed
653
                    break;
654 655
                case AVMEDIA_TYPE_SUBTITLE:
                    st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
656
                    st->codec->codec_id   = AV_CODEC_ID_PROBE;
657
                    break;
Fabrice Bellard's avatar
Fabrice Bellard committed
658
                default:
659
                    st->codec->codec_type = AVMEDIA_TYPE_DATA;
660
                    st->codec->codec_id= AV_CODEC_ID_NONE;
661
                    st->codec->codec_tag= 0;
662
                    avio_skip(pb, size);
Fabrice Bellard's avatar
Fabrice Bellard committed
663 664 665 666
                    break;
                }
            }
            break;
667
        case MKTAG('i', 'n', 'd', 'x'):
668
            i= avio_tell(pb);
669
            if(pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX) &&
670 671
               read_braindead_odml_indx(s, 0) < 0 &&
               (s->error_recognition & AV_EF_EXPLODE))
672
                goto fail;
673
            avio_seek(pb, i+size, SEEK_SET);
674
            break;
675 676 677 678 679
        case MKTAG('v', 'p', 'r', 'p'):
            if(stream_index < (unsigned)s->nb_streams && size > 9*4){
                AVRational active, active_aspect;

                st = s->streams[stream_index];
680 681 682 683 684 685 686 687 688 689 690
                avio_rl32(pb);
                avio_rl32(pb);
                avio_rl32(pb);
                avio_rl32(pb);
                avio_rl32(pb);

                active_aspect.den= avio_rl16(pb);
                active_aspect.num= avio_rl16(pb);
                active.num       = avio_rl32(pb);
                active.den       = avio_rl32(pb);
                avio_rl32(pb); //nbFieldsPerFrame
691 692

                if(active_aspect.num && active_aspect.den && active.num && active.den){
693
                    st->sample_aspect_ratio= av_div_q(active_aspect, active);
694 695 696
                    av_dlog(s, "vprp %d/%d %d/%d\n",
                            active_aspect.num, active_aspect.den,
                            active.num, active.den);
697 698 699
                }
                size -= 9*4;
            }
700
            avio_skip(pb, size);
701
            break;
702 703
        case MKTAG('s', 't', 'r', 'n'):
            if(s->nb_streams){
704
                avi_read_tag(s, s->streams[s->nb_streams-1], tag, size);
705 706
                break;
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
707
        default:
708
            if(size > 1000000){
Diego Biurrun's avatar
Diego Biurrun committed
709 710
                av_log(s, AV_LOG_ERROR, "Something went wrong during header parsing, "
                                        "I will ignore it and try to continue anyway.\n");
711 712
                if (s->error_recognition & AV_EF_EXPLODE)
                    goto fail;
713
                avi->movi_list = avio_tell(pb) - 4;
714
                avi->movi_end  = avio_size(pb);
715 716
                goto end_of_header;
            }
Fabrice Bellard's avatar
Fabrice Bellard committed
717 718
            /* skip tag */
            size += (size & 1);
719
            avio_skip(pb, size);
Fabrice Bellard's avatar
Fabrice Bellard committed
720 721 722 723 724 725 726 727 728
            break;
        }
    }
 end_of_header:
    /* check stream number */
    if (stream_index != s->nb_streams - 1) {
    fail:
        return -1;
    }
729

730
    if(!avi->index_loaded && pb->seekable)
731
        avi_load_index(s);
732
    avi->index_loaded = 1;
733
    avi->non_interleaved |= guess_ni_flag(s);
734 735 736 737 738 739 740 741 742 743
    for(i=0; i<s->nb_streams; i++){
        AVStream *st = s->streams[i];
        if(st->nb_index_entries)
            break;
    }
    if(i==s->nb_streams && avi->non_interleaved) {
        av_log(s, AV_LOG_WARNING, "non-interleaved AVI without index, switching to interleaved\n");
        avi->non_interleaved=0;
    }

744
    if(avi->non_interleaved) {
Diego Biurrun's avatar
Diego Biurrun committed
745
        av_log(s, AV_LOG_INFO, "non-interleaved AVI\n");
746
        clean_index(s);
747
    }
748

749 750
    ff_metadata_conv_ctx(s, NULL, avi_metadata_conv);
    ff_metadata_conv_ctx(s, NULL, ff_riff_info_conv);
751

Fabrice Bellard's avatar
Fabrice Bellard committed
752 753 754
    return 0;
}

755 756
static int read_gab2_sub(AVStream *st, AVPacket *pkt) {
    if (!strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data+5) == 2) {
757 758
        uint8_t desc[256];
        int score = AVPROBE_SCORE_MAX / 2, ret;
759 760 761
        AVIStream *ast = st->priv_data;
        AVInputFormat *sub_demuxer;
        AVRational time_base;
762
        AVIOContext *pb = avio_alloc_context( pkt->data + 7,
763 764
                                              pkt->size - 7,
                                              0, NULL, NULL, NULL, NULL);
765
        AVProbeData pd;
766
        unsigned int desc_len = avio_rl32(pb);
767

768 769
        if (desc_len > pb->buf_end - pb->buf_ptr)
            goto error;
770

771
        ret = avio_get_str16le(pb, desc_len, desc, sizeof(desc));
772
        avio_skip(pb, desc_len - ret);
773
        if (*desc)
774
            av_dict_set(&st->metadata, "title", desc, 0);
775

776 777
        avio_rl16(pb);   /* flags? */
        avio_rl32(pb);   /* data size */
778

779
        pd = (AVProbeData) { .buf = pb->buf_ptr, .buf_size = pb->buf_end - pb->buf_ptr };
780
        if (!(sub_demuxer = av_probe_input_format2(&pd, 1, &score)))
781
            goto error;
782

783 784 785 786 787
        if (!(ast->sub_ctx = avformat_alloc_context()))
            goto error;

        ast->sub_ctx->pb      = pb;
        if (!avformat_open_input(&ast->sub_ctx, "", sub_demuxer, NULL)) {
788
            ff_read_packet(ast->sub_ctx, &ast->sub_pkt);
789 790 791
            *st->codec = *ast->sub_ctx->streams[0]->codec;
            ast->sub_ctx->streams[0]->codec->extradata = NULL;
            time_base = ast->sub_ctx->streams[0]->time_base;
792
            avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
793 794 795 796
        }
        ast->sub_buffer = pkt->data;
        memset(pkt, 0, sizeof(*pkt));
        return 1;
797 798
error:
        av_freep(&pb);
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816
    }
    return 0;
}

static AVStream *get_subtitle_pkt(AVFormatContext *s, AVStream *next_st,
                                  AVPacket *pkt)
{
    AVIStream *ast, *next_ast = next_st->priv_data;
    int64_t ts, next_ts, ts_min = INT64_MAX;
    AVStream *st, *sub_st = NULL;
    int i;

    next_ts = av_rescale_q(next_ast->frame_offset, next_st->time_base,
                           AV_TIME_BASE_Q);

    for (i=0; i<s->nb_streams; i++) {
        st  = s->streams[i];
        ast = st->priv_data;
817
        if (st->discard < AVDISCARD_ALL && ast && ast->sub_pkt.data) {
818 819 820 821 822 823 824 825 826 827 828 829
            ts = av_rescale_q(ast->sub_pkt.dts, st->time_base, AV_TIME_BASE_Q);
            if (ts <= next_ts && ts < ts_min) {
                ts_min = ts;
                sub_st = st;
            }
        }
    }

    if (sub_st) {
        ast = sub_st->priv_data;
        *pkt = ast->sub_pkt;
        pkt->stream_index = sub_st->index;
830
        if (ff_read_packet(ast->sub_ctx, &ast->sub_pkt) < 0)
831 832 833 834 835
            ast->sub_pkt.data = NULL;
    }
    return sub_st;
}

836 837 838 839 840 841 842 843 844
static int get_stream_idx(int *d){
    if(    d[0] >= '0' && d[0] <= '9'
        && d[1] >= '0' && d[1] <= '9'){
        return (d[0] - '0') * 10 + (d[1] - '0');
    }else{
        return 100; //invalid stream ID
    }
}

845
static int avi_sync(AVFormatContext *s, int exit_early)
Fabrice Bellard's avatar
Fabrice Bellard committed
846 847
{
    AVIContext *avi = s->priv_data;
848
    AVIOContext *pb = s->pb;
849 850
    int n;
    unsigned int d[8];
851
    unsigned int size;
852
    int64_t i, sync;
853 854

start_sync:
855
    memset(d, -1, sizeof(d));
856 857 858 859 860 861 862 863 864 865
    for(i=sync=avio_tell(pb); !pb->eof_reached; i++) {
        int j;

        for(j=0; j<7; j++)
            d[j]= d[j+1];
        d[7]= avio_r8(pb);

        size= d[4] + (d[5]<<8) + (d[6]<<16) + (d[7]<<24);

        n= get_stream_idx(d+2);
866 867
        av_dlog(s, "%X %X %X %X %X %X %X %X %"PRId64" %u %d\n",
                d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n);
868
        if(i + (uint64_t)size > avi->fsize || d[0] > 127)
869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925
            continue;

        //parse ix##
        if(  (d[0] == 'i' && d[1] == 'x' && n < s->nb_streams)
        //parse JUNK
           ||(d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K')
           ||(d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1')){
            avio_skip(pb, size);
            goto start_sync;
        }

        //parse stray LIST
        if(d[0] == 'L' && d[1] == 'I' && d[2] == 'S' && d[3] == 'T'){
            avio_skip(pb, 4);
            goto start_sync;
        }

        n= get_stream_idx(d);

        if(!((i-avi->last_pkt_pos)&1) && get_stream_idx(d+1) < s->nb_streams)
            continue;

        //detect ##ix chunk and skip
        if(d[2] == 'i' && d[3] == 'x' && n < s->nb_streams){
            avio_skip(pb, size);
            goto start_sync;
        }

        //parse ##dc/##wb
        if(n < s->nb_streams){
            AVStream *st;
            AVIStream *ast;
            st = s->streams[n];
            ast = st->priv_data;

            if(s->nb_streams>=2){
                AVStream *st1  = s->streams[1];
                AVIStream *ast1= st1->priv_data;
                //workaround for broken small-file-bug402.avi
                if(   d[2] == 'w' && d[3] == 'b'
                   && n==0
                   && st ->codec->codec_type == AVMEDIA_TYPE_VIDEO
                   && st1->codec->codec_type == AVMEDIA_TYPE_AUDIO
                   && ast->prefix == 'd'*256+'c'
                   && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count)
                  ){
                    n=1;
                    st = st1;
                    ast = ast1;
                    av_log(s, AV_LOG_WARNING, "Invalid stream + prefix combination, assuming audio.\n");
                }
            }


            if(   (st->discard >= AVDISCARD_DEFAULT && size==0)
               /*|| (st->discard >= AVDISCARD_NONKEY && !(pkt->flags & AV_PKT_FLAG_KEY))*/ //FIXME needs a little reordering
               || st->discard >= AVDISCARD_ALL){
926 927 928
                if (!exit_early) {
                    ast->frame_offset += get_duration(ast, size);
                }
929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947
                avio_skip(pb, size);
                goto start_sync;
            }

            if (d[2] == 'p' && d[3] == 'c' && size<=4*256+4) {
                int k = avio_r8(pb);
                int last = (k + avio_r8(pb) - 1) & 0xFF;

                avio_rl16(pb); //flags

                for (; k <= last; k++)
                    ast->pal[k] = avio_rb32(pb)>>8;// b + (g << 8) + (r << 16);
                ast->has_pal= 1;
                goto start_sync;
            } else if(   ((ast->prefix_count<5 || sync+9 > i) && d[2]<128 && d[3]<128) ||
                         d[2]*256+d[3] == ast->prefix /*||
                         (d[2] == 'd' && d[3] == 'c') ||
                         (d[2] == 'w' && d[3] == 'b')*/) {

948 949
                if (exit_early)
                    return 0;
950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979
                if(d[2]*256+d[3] == ast->prefix)
                    ast->prefix_count++;
                else{
                    ast->prefix= d[2]*256+d[3];
                    ast->prefix_count= 0;
                }

                avi->stream_index= n;
                ast->packet_size= size + 8;
                ast->remaining= size;

                if(size || !ast->sample_size){
                    uint64_t pos= avio_tell(pb) - 8;
                    if(!st->index_entries || !st->nb_index_entries || st->index_entries[st->nb_index_entries - 1].pos < pos){
                        av_add_index_entry(st, pos, ast->frame_offset, size, 0, AVINDEX_KEYFRAME);
                    }
                }
                return 0;
            }
        }
    }

    return AVERROR_EOF;
}

static int avi_read_packet(AVFormatContext *s, AVPacket *pkt)
{
    AVIContext *avi = s->priv_data;
    AVIOContext *pb = s->pb;
    int err;
980
    void* dstr;
981

982
    if (CONFIG_DV_DEMUXER && avi->dv_demux) {
983
        int size = avpriv_dv_get_packet(avi->dv_demux, pkt);
984 985
        if (size >= 0)
            return size;
986
    }
987

988
    if(avi->non_interleaved){
989
        int best_stream_index = 0;
990 991 992 993
        AVStream *best_st= NULL;
        AVIStream *best_ast;
        int64_t best_ts= INT64_MAX;
        int i;
994

995 996 997 998
        for(i=0; i<s->nb_streams; i++){
            AVStream *st = s->streams[i];
            AVIStream *ast = st->priv_data;
            int64_t ts= ast->frame_offset;
999
            int64_t last_ts;
1000

1001 1002 1003
            if(!st->nb_index_entries)
                continue;

1004 1005 1006 1007
            last_ts = st->index_entries[st->nb_index_entries - 1].timestamp;
            if(!ast->remaining && ts > last_ts)
                continue;

1008
            ts = av_rescale_q(ts, st->time_base, (AVRational){FFMAX(1, ast->sample_size), AV_TIME_BASE});
1009

1010 1011
            av_dlog(s, "%"PRId64" %d/%d %"PRId64"\n", ts,
                    st->time_base.num, st->time_base.den, ast->frame_offset);
1012
            if(ts < best_ts){
1013 1014 1015 1016 1017
                best_ts= ts;
                best_st= st;
                best_stream_index= i;
            }
        }
1018 1019 1020
        if(!best_st)
            return -1;

1021
        best_ast = best_st->priv_data;
1022
        best_ts = av_rescale_q(best_ts, (AVRational){FFMAX(1, best_ast->sample_size), AV_TIME_BASE}, best_st->time_base);
1023 1024
        if(best_ast->remaining)
            i= av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD);
1025
        else{
1026
            i= av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY);
1027
            if(i>=0)
1028
                best_ast->frame_offset= best_st->index_entries[i].timestamp;
1029
        }
1030 1031 1032

        if(i>=0){
            int64_t pos= best_st->index_entries[i].pos;
1033
            pos += best_ast->packet_size - best_ast->remaining;
1034
            avio_seek(s->pb, pos + 8, SEEK_SET);
1035

1036 1037
            assert(best_ast->remaining <= best_ast->packet_size);

1038 1039
            avi->stream_index= best_stream_index;
            if(!best_ast->remaining)
1040
                best_ast->packet_size=
1041
                best_ast->remaining= best_st->index_entries[i].size;
1042 1043
        }
    }
1044

1045
resync:
1046 1047 1048
    if(avi->stream_index >= 0){
        AVStream *st= s->streams[ avi->stream_index ];
        AVIStream *ast= st->priv_data;
1049
        int size, err;
1050

1051 1052 1053
        if(get_subtitle_pkt(s, st, pkt))
            return 0;

1054
        if(ast->sample_size <= 1) // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM
1055
            size= INT_MAX;
1056
        else if(ast->sample_size < 32)
1057 1058
            // arbitrary multiplier to avoid tiny packets for raw PCM data
            size= 1024*ast->sample_size;
1059 1060 1061 1062 1063
        else
            size= ast->sample_size;

        if(size > ast->remaining)
            size= ast->remaining;
1064
        avi->last_pkt_pos= avio_tell(pb);
1065 1066 1067
        err= av_get_packet(pb, pkt, size);
        if(err<0)
            return err;
1068

1069
        if(ast->has_pal && pkt->data && pkt->size<(unsigned)INT_MAX/2){
1070 1071 1072 1073 1074 1075 1076 1077
            uint8_t *pal;
            pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);
            if(!pal){
                av_log(s, AV_LOG_ERROR, "Failed to allocate data for palette\n");
            }else{
                memcpy(pal, ast->pal, AVPALETTE_SIZE);
                ast->has_pal = 0;
            }
1078 1079
        }

1080
        if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1081
            dstr = pkt->destruct;
1082
            size = avpriv_dv_produce_packet(avi->dv_demux, pkt,
1083 1084
                                    pkt->data, pkt->size);
            pkt->destruct = dstr;
1085
            pkt->flags |= AV_PKT_FLAG_KEY;
1086 1087
            if (size < 0)
                av_free_packet(pkt);
1088 1089 1090 1091 1092 1093
        } else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
                   && !st->codec->codec_tag && read_gab2_sub(st, pkt)) {
            ast->frame_offset++;
            avi->stream_index = -1;
            ast->remaining = 0;
            goto resync;
1094
        } else {
Diego Biurrun's avatar
Diego Biurrun committed
1095
            /* XXX: How to handle B-frames in AVI? */
1096 1097 1098 1099
            pkt->dts = ast->frame_offset;
//                pkt->dts += ast->start;
            if(ast->sample_size)
                pkt->dts /= ast->sample_size;
1100 1101 1102
            av_dlog(s, "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);
1103 1104
            pkt->stream_index = avi->stream_index;

1105
            if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
Michael Niedermayer's avatar
Michael Niedermayer committed
1106 1107
                AVIndexEntry *e;
                int index;
1108
                assert(st->index_entries);
1109

1110
                index= av_index_search_timestamp(st, ast->frame_offset, 0);
Michael Niedermayer's avatar
Michael Niedermayer committed
1111
                e= &st->index_entries[index];
1112

Michael Niedermayer's avatar
Michael Niedermayer committed
1113 1114
                if(index >= 0 && e->timestamp == ast->frame_offset){
                    if (e->flags & AVINDEX_KEYFRAME)
1115
                        pkt->flags |= AV_PKT_FLAG_KEY;
Michael Niedermayer's avatar
Michael Niedermayer committed
1116
                }
1117
            } else {
1118
                pkt->flags |= AV_PKT_FLAG_KEY;
1119
            }
1120
            ast->frame_offset += get_duration(ast, pkt->size);
1121
        }
1122
        ast->remaining -= err;
1123 1124 1125 1126 1127
        if(!ast->remaining){
            avi->stream_index= -1;
            ast->packet_size= 0;
        }

1128
        return 0;
1129 1130
    }

1131
    if ((err = avi_sync(s, 0)) < 0)
1132 1133
        return err;
    goto resync;
Fabrice Bellard's avatar
Fabrice Bellard committed
1134 1135
}

Diego Biurrun's avatar
Diego Biurrun committed
1136 1137
/* XXX: We make the implicit supposition that the positions are sorted
   for each stream. */
Fabrice Bellard's avatar
Fabrice Bellard committed
1138 1139
static int avi_read_idx1(AVFormatContext *s, int size)
{
1140
    AVIContext *avi = s->priv_data;
1141
    AVIOContext *pb = s->pb;
Fabrice Bellard's avatar
Fabrice Bellard committed
1142 1143 1144
    int nb_index_entries, i;
    AVStream *st;
    AVIStream *ast;
1145
    unsigned int index, tag, flags, pos, len, first_packet = 1;
1146
    unsigned last_pos= -1;
1147
    int64_t idx1_pos, first_packet_pos = 0, data_offset = 0;
1148

Fabrice Bellard's avatar
Fabrice Bellard committed
1149 1150 1151 1152
    nb_index_entries = size / 16;
    if (nb_index_entries <= 0)
        return -1;

1153 1154 1155 1156 1157 1158 1159 1160
    idx1_pos = avio_tell(pb);
    avio_seek(pb, avi->movi_list+4, SEEK_SET);
    if (avi_sync(s, 1) == 0) {
        first_packet_pos = avio_tell(pb) - 8;
    }
    avi->stream_index = -1;
    avio_seek(pb, idx1_pos, SEEK_SET);

Diego Biurrun's avatar
Diego Biurrun committed
1161
    /* Read the entries and sort them in each stream component. */
Fabrice Bellard's avatar
Fabrice Bellard committed
1162
    for(i = 0; i < nb_index_entries; i++) {
1163 1164 1165 1166
        tag = avio_rl32(pb);
        flags = avio_rl32(pb);
        pos = avio_rl32(pb);
        len = avio_rl32(pb);
1167 1168
        av_dlog(s, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/",
                i, tag, flags, pos, len);
1169

Fabrice Bellard's avatar
Fabrice Bellard committed
1170 1171 1172 1173 1174 1175
        index = ((tag & 0xff) - '0') * 10;
        index += ((tag >> 8) & 0xff) - '0';
        if (index >= s->nb_streams)
            continue;
        st = s->streams[index];
        ast = st->priv_data;
1176

1177 1178 1179 1180 1181 1182
        if(first_packet && first_packet_pos && len) {
            data_offset = first_packet_pos - pos;
            first_packet = 0;
        }
        pos += data_offset;

1183 1184
        av_dlog(s, "%d cum_len=%"PRId64"\n", len, ast->cum_len);

Anton Khirnov's avatar
Anton Khirnov committed
1185
        if(pb->eof_reached)
1186 1187
            return -1;

1188 1189
        if(last_pos == pos)
            avi->non_interleaved= 1;
1190
        else if(len || !ast->sample_size)
1191
            av_add_index_entry(st, pos, ast->cum_len, len, 0, (flags&AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);
1192
        ast->cum_len += get_duration(ast, len);
1193
        last_pos= pos;
Fabrice Bellard's avatar
Fabrice Bellard committed
1194 1195 1196 1197
    }
    return 0;
}

1198 1199 1200 1201
static int guess_ni_flag(AVFormatContext *s){
    int i;
    int64_t last_start=0;
    int64_t first_end= INT64_MAX;
1202
    int64_t oldpos= avio_tell(s->pb);
1203

1204 1205 1206
    for(i=0; i<s->nb_streams; i++){
        AVStream *st = s->streams[i];
        int n= st->nb_index_entries;
1207
        unsigned int size;
1208 1209 1210 1211

        if(n <= 0)
            continue;

1212 1213
        if(n >= 2){
            int64_t pos= st->index_entries[0].pos;
1214
            avio_seek(s->pb, pos + 4, SEEK_SET);
1215
            size= avio_rl32(s->pb);
1216 1217 1218 1219
            if(pos + size > st->index_entries[1].pos)
                last_start= INT64_MAX;
        }

1220 1221 1222 1223 1224
        if(st->index_entries[0].pos > last_start)
            last_start= st->index_entries[0].pos;
        if(st->index_entries[n-1].pos < first_end)
            first_end= st->index_entries[n-1].pos;
    }
1225
    avio_seek(s->pb, oldpos, SEEK_SET);
1226 1227 1228
    return last_start > first_end;
}

Fabrice Bellard's avatar
Fabrice Bellard committed
1229 1230 1231
static int avi_load_index(AVFormatContext *s)
{
    AVIContext *avi = s->priv_data;
1232
    AVIOContext *pb = s->pb;
Fabrice Bellard's avatar
Fabrice Bellard committed
1233
    uint32_t tag, size;
1234
    int64_t pos= avio_tell(pb);
1235
    int ret = -1;
1236

1237
    if (avio_seek(pb, avi->movi_end, SEEK_SET) < 0)
1238
        goto the_end; // maybe truncated file
1239
    av_dlog(s, "movi_end=0x%"PRIx64"\n", avi->movi_end);
Fabrice Bellard's avatar
Fabrice Bellard committed
1240
    for(;;) {
Anton Khirnov's avatar
Anton Khirnov committed
1241
        if (pb->eof_reached)
Fabrice Bellard's avatar
Fabrice Bellard committed
1242
            break;
1243 1244
        tag = avio_rl32(pb);
        size = avio_rl32(pb);
1245 1246 1247 1248 1249 1250
        av_dlog(s, "tag=%c%c%c%c size=0x%x\n",
                 tag        & 0xff,
                (tag >>  8) & 0xff,
                (tag >> 16) & 0xff,
                (tag >> 24) & 0xff,
                size);
1251 1252 1253

        if (tag == MKTAG('i', 'd', 'x', '1') &&
            avi_read_idx1(s, size) >= 0) {
1254
            ret = 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1255 1256
            break;
        }
1257 1258 1259 1260

        size += (size & 1);
        if (avio_skip(pb, size) < 0)
            break; // something is wrong here
Fabrice Bellard's avatar
Fabrice Bellard committed
1261 1262
    }
 the_end:
1263
    avio_seek(pb, pos, SEEK_SET);
1264
    return ret;
Fabrice Bellard's avatar
Fabrice Bellard committed
1265 1266
}

1267 1268 1269 1270 1271 1272 1273
static void seek_subtitle(AVStream *st, AVStream *st2, int64_t timestamp)
{
    AVIStream *ast2 = st2->priv_data;
    int64_t ts2 = av_rescale_q(timestamp, st->time_base, st2->time_base);
    av_free_packet(&ast2->sub_pkt);
    if (avformat_seek_file(ast2->sub_ctx, 0, INT64_MIN, ts2, ts2, 0) >= 0 ||
        avformat_seek_file(ast2->sub_ctx, 0, ts2, ts2, INT64_MAX, 0) >= 0)
1274
        ff_read_packet(ast2->sub_ctx, &ast2->sub_pkt);
1275 1276
}

1277
static int avi_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Fabrice Bellard's avatar
Fabrice Bellard committed
1278 1279 1280
{
    AVIContext *avi = s->priv_data;
    AVStream *st;
1281
    int i, index;
Fabrice Bellard's avatar
Fabrice Bellard committed
1282
    int64_t pos;
1283
    AVIStream *ast;
Fabrice Bellard's avatar
Fabrice Bellard committed
1284 1285 1286 1287 1288 1289

    if (!avi->index_loaded) {
        /* we only load the index on demand */
        avi_load_index(s);
        avi->index_loaded = 1;
    }
1290
    assert(stream_index>= 0);
Fabrice Bellard's avatar
Fabrice Bellard committed
1291 1292

    st = s->streams[stream_index];
1293 1294
    ast= st->priv_data;
    index= av_index_search_timestamp(st, timestamp * FFMAX(ast->sample_size, 1), flags);
1295
    if(index<0)
Fabrice Bellard's avatar
Fabrice Bellard committed
1296
        return -1;
1297

Fabrice Bellard's avatar
Fabrice Bellard committed
1298
    /* find the position */
1299
    pos = st->index_entries[index].pos;
1300
    timestamp = st->index_entries[index].timestamp / FFMAX(ast->sample_size, 1);
1301

1302 1303
    av_dlog(s, "XX %"PRId64" %d %"PRId64"\n",
            timestamp, index, st->index_entries[index].timestamp);
Fabrice Bellard's avatar
Fabrice Bellard committed
1304

1305
    if (CONFIG_DV_DEMUXER && avi->dv_demux) {
1306
        /* One and only one real stream for DV in AVI, and it has video  */
1307
        /* offsets. Calling with other stream indexes should have failed */
1308 1309 1310 1311
        /* the av_index_search_timestamp call above.                     */
        assert(stream_index == 0);

        /* Feed the DV video stream version of the timestamp to the */
Diego Biurrun's avatar
Diego Biurrun committed
1312
        /* DV demux so it can synthesize correct timestamps.        */
1313
        ff_dv_offset_reset(avi->dv_demux, timestamp);
1314

1315
        avio_seek(s->pb, pos, SEEK_SET);
1316 1317 1318 1319
        avi->stream_index= -1;
        return 0;
    }

Fabrice Bellard's avatar
Fabrice Bellard committed
1320
    for(i = 0; i < s->nb_streams; i++) {
1321 1322
        AVStream *st2 = s->streams[i];
        AVIStream *ast2 = st2->priv_data;
1323 1324 1325 1326

        ast2->packet_size=
        ast2->remaining= 0;

1327 1328 1329 1330 1331
        if (ast2->sub_ctx) {
            seek_subtitle(st, st2, timestamp);
            continue;
        }

1332 1333
        if (st2->nb_index_entries <= 0)
            continue;
1334

1335
//        assert(st2->codec->block_align);
1336
        assert((int64_t)st2->time_base.num*ast2->rate == (int64_t)st2->time_base.den*ast2->scale);
1337
        index = av_index_search_timestamp(
1338
                st2,
1339
                av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1),
1340 1341 1342
                flags | AVSEEK_FLAG_BACKWARD);
        if(index<0)
            index=0;
1343

1344 1345 1346 1347 1348 1349 1350
        if(!avi->non_interleaved){
            while(index>0 && st2->index_entries[index].pos > pos)
                index--;
            while(index+1 < st2->nb_index_entries && st2->index_entries[index].pos < pos)
                index++;
        }

1351 1352
        av_dlog(s, "%"PRId64" %d %"PRId64"\n",
                timestamp, index, st2->index_entries[index].timestamp);
1353 1354
        /* extract the current frame number */
        ast2->frame_offset = st2->index_entries[index].timestamp;
Fabrice Bellard's avatar
Fabrice Bellard committed
1355
    }
1356

Fabrice Bellard's avatar
Fabrice Bellard committed
1357
    /* do the seek */
1358
    avio_seek(s->pb, pos, SEEK_SET);
1359
    avi->stream_index= -1;
Fabrice Bellard's avatar
Fabrice Bellard committed
1360 1361 1362
    return 0;
}

1363
static int avi_read_close(AVFormatContext *s)
Fabrice Bellard's avatar
Fabrice Bellard committed
1364
{
Michael Niedermayer's avatar
Michael Niedermayer committed
1365 1366 1367 1368 1369
    int i;
    AVIContext *avi = s->priv_data;

    for(i=0;i<s->nb_streams;i++) {
        AVStream *st = s->streams[i];
1370
        AVIStream *ast = st->priv_data;
1371
        if (ast) {
1372 1373
            if (ast->sub_ctx) {
                av_freep(&ast->sub_ctx->pb);
1374
                avformat_close_input(&ast->sub_ctx);
1375 1376 1377
            }
            av_free(ast->sub_buffer);
            av_free_packet(&ast->sub_pkt);
1378
        }
Michael Niedermayer's avatar
Michael Niedermayer committed
1379 1380
    }

1381
    av_free(avi->dv_demux);
1382

Fabrice Bellard's avatar
Fabrice Bellard committed
1383 1384 1385 1386 1387
    return 0;
}

static int avi_probe(AVProbeData *p)
{
1388 1389
    int i;

Fabrice Bellard's avatar
Fabrice Bellard committed
1390
    /* check file header */
1391 1392 1393 1394 1395 1396
    for(i=0; avi_headers[i][0]; i++)
        if(!memcmp(p->buf  , avi_headers[i]  , 4) &&
           !memcmp(p->buf+8, avi_headers[i]+4, 4))
            return AVPROBE_SCORE_MAX;

    return 0;
Fabrice Bellard's avatar
Fabrice Bellard committed
1397 1398
}

1399
AVInputFormat ff_avi_demuxer = {
1400
    .name           = "avi",
1401
    .long_name      = NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"),
1402 1403 1404 1405 1406 1407
    .priv_data_size = sizeof(AVIContext),
    .read_probe     = avi_probe,
    .read_header    = avi_read_header,
    .read_packet    = avi_read_packet,
    .read_close     = avi_read_close,
    .read_seek      = avi_read_seek,
Fabrice Bellard's avatar
Fabrice Bellard committed
1408
};