/*

 * AVI demuxer

 * Copyright (c) 2001 Fabrice Bellard

 *

 * This file is part of FFmpeg.

 *

 * FFmpeg is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * FFmpeg is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with FFmpeg; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

#include "config_components.h"

#include <inttypes.h>

#include "libavutil/attributes.h"

#include "libavutil/avassert.h"

#include "libavutil/avstring.h"

#include "libavutil/mem.h"

#include "libavutil/opt.h"

#include "libavutil/dict.h"

#include "libavutil/integer.h"

#include "libavutil/internal.h"

#include "libavutil/intreadwrite.h"

#include "libavutil/mathematics.h"

#include "avformat.h"

#include "avi.h"

#include "demux.h"

#include "dv.h"

#include "internal.h"

#include "isom.h"

#include "riff.h"

#include "libavcodec/bytestream.h"

#include "libavcodec/exif.h"

#include "libavcodec/startcode.h"

typedef struct AVIStream {

    int64_t frame_offset;   /* current frame (video) or byte (audio) counter

                             * (used to compute the pts) */

    int remaining;

    int packet_size;

    uint32_t handler;

    uint32_t scale;

    uint32_t rate;

    int sample_size;        /* size of one sample (or packet)

                             * (in the rate/scale sense) in bytes */

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

    int prefix;             /* normally 'd'<<8 + 'c' or 'w'<<8 + 'b' */

    int prefix_count;

    uint32_t pal[256];

    int has_pal;

    int dshow_block_align;  /* block align variable used to emulate bugs in

                             * the MS dshow demuxer */

    AVFormatContext *sub_ctx;

    AVPacket *sub_pkt;

    AVBufferRef *sub_buffer;

    int64_t seek_pos;

} AVIStream;

typedef struct AVIContext {

    const AVClass *class;

    int64_t riff_end;

    int64_t movi_end;

    int64_t fsize;

    int64_t io_fsize;

    int64_t movi_list;

    int64_t last_pkt_pos;

    int index_loaded;

    int is_odml;

    int non_interleaved;

    int stream_index;

    DVDemuxContext *dv_demux;

    int odml_depth;

    int64_t odml_read;

    int64_t odml_max_pos;

    int use_odml;

#define MAX_ODML_DEPTH 1000

    int64_t dts_max;

} AVIContext;

static const AVOption options[] = {

    { "use_odml", "use odml index", offsetof(AVIContext, use_odml), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM},

    { NULL },

};

static const AVClass demuxer_class = {

    .class_name = "avi",

    .item_name  = av_default_item_name,

    .option     = options,

    .version    = LIBAVUTIL_VERSION_INT,

    .category   = AV_CLASS_CATEGORY_DEMUXER,

};

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 },

    { 'O', 'N', '2', ' ', 'O', 'N', '2', 'f'  },

    { 'R', 'I', 'F', 'F', 'A', 'M', 'V', ' '  },

    { 0 }

};

static const AVMetadataConv avi_metadata_conv[] = {

    { "strn", "title" },

    { "isbj", "subject" },

    { "inam", "title" },

    { "iart", "artist" },

    { "icop", "copyright" },

    { "icmt", "comment" },

    { "ignr", "genre" },

    { "iprd", "product" },

    { "isft", "software" },

    { 0 },

};

static int avi_load_index(AVFormatContext *s);

static int guess_ni_flag(AVFormatContext *s);

#define print_tag(s, str, tag, size)                                      \

    av_log(s, AV_LOG_TRACE, "pos:%"PRIX64" %s: tag=%s size=0x%x\n", \

           avio_tell(pb), str, av_fourcc2str(tag), size)                  \

static inline int get_duration(AVIStream *ast, int len)

{

    if (ast->sample_size)

        return len;

    else if (ast->dshow_block_align)

        return (len + (int64_t)ast->dshow_block_align - 1) / ast->dshow_block_align;

    else

        return 1;

}

static int get_riff(AVFormatContext *s, AVIOContext *pb)

{

    AVIContext *avi = s->priv_data;

    char header[8] = {0};

    int i;

    /* check RIFF header */

    avio_read(pb, header, 4);

    avi->riff_end  = avio_rl32(pb); /* RIFF chunk size */

    avi->riff_end += avio_tell(pb); /* RIFF chunk end */

    avio_read(pb, header + 4, 4);

    for (i = 0; avi_headers[i][0]; i++)

        if (!memcmp(header, avi_headers[i], 8))

            break;

    if (!avi_headers[i][0])

        return AVERROR_INVALIDDATA;

    if (header[7] == 0x19)

        av_log(s, AV_LOG_INFO,

               "This file has been generated by a totally broken muxer.\n");

    return 0;

}

static int read_odml_index(AVFormatContext *s, int64_t frame_num)

{

    AVIContext *avi     = s->priv_data;

    AVIOContext *pb     = s->pb;

    int longs_per_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);

    int stream_id       = ((chunk_id      & 0xFF) - '0') * 10 +

                          ((chunk_id >> 8 & 0xFF) - '0');

    AVStream *st;

    AVIStream *ast;

    int i;

    int64_t last_pos = -1;

    int64_t filesize = avi->fsize;

    av_log(s, AV_LOG_TRACE,

            "longs_per_entry:%d index_type:%d entries_in_use:%d "

            "chunk_id:%X base:%16"PRIX64" frame_num:%"PRId64"\n",

            longs_per_entry,

            index_type,

            entries_in_use,

            chunk_id,

            base,

            frame_num);

    if (stream_id >= s->nb_streams || stream_id < 0)

        return AVERROR_INVALIDDATA;

    st  = s->streams[stream_id];

    ast = st->priv_data;

    if (index_sub_type || entries_in_use < 0)

        return AVERROR_INVALIDDATA;

    avio_rl32(pb);

    if (index_type && longs_per_entry != 2)

        return AVERROR_INVALIDDATA;

    if (index_type > 1)

        return AVERROR_INVALIDDATA;

    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 AVERROR_INVALIDDATA;

    }

    for (i = 0; i < entries_in_use; i++) {

        avi->odml_max_pos = FFMAX(avi->odml_max_pos, avio_tell(pb));

        // If we read more than there are bytes then we must have been reading something twice

        if (avi->odml_read > avi->odml_max_pos)

            return AVERROR_INVALIDDATA;

        if (index_type) {

            int64_t pos = avio_rl32(pb) + base - 8;

            int len     = avio_rl32(pb);

            int key     = len >= 0;

            len &= 0x7FFFFFFF;

            avi->odml_read += 8;

            av_log(s, AV_LOG_TRACE, "pos:%"PRId64", len:%X\n", pos, len);

            if (avio_feof(pb))

                return AVERROR_INVALIDDATA;

            if (last_pos == pos || pos == base - 8)

                avi->non_interleaved = 1;

            if (last_pos != pos && len)

                av_add_index_entry(st, pos, ast->cum_len, len, 0,

                                   key ? AVINDEX_KEYFRAME : 0);

            ast->cum_len += get_duration(ast, len);

            last_pos      = pos;

        } else {

            int64_t offset, pos;

            int duration;

            int ret;

            avi->odml_read += 16;

            offset = avio_rl64(pb);

            avio_rl32(pb);       /* size */

            duration = avio_rl32(pb);

            if (avio_feof(pb) || offset > INT64_MAX - 8)

                return AVERROR_INVALIDDATA;

            pos = avio_tell(pb);

            if (avi->odml_depth > MAX_ODML_DEPTH) {

                av_log(s, AV_LOG_ERROR, "Too deeply nested ODML indexes\n");

                return AVERROR_INVALIDDATA;

            }

            if (avio_seek(pb, offset + 8, SEEK_SET) < 0)

                return -1;

            avi->odml_depth++;

            ret = read_odml_index(s, frame_num);

            avi->odml_depth--;

            frame_num += duration;

            if (avio_seek(pb, pos, SEEK_SET) < 0) {

                av_log(s, AV_LOG_ERROR, "Failed to restore position after reading index\n");

                return -1;

            }

            if (ret < 0)

                return ret;

        }

    }

    avi->index_loaded = 2;

    return 0;

}

static void clean_index(AVFormatContext *s)

{

    int i;

    int64_t j;

    for (i = 0; i < s->nb_streams; i++) {

        AVStream *st   = s->streams[i];

        FFStream *const sti = ffstream(st);

        AVIStream *ast = st->priv_data;

        int n          = sti->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  = sti->index_entries[0].pos;

        size = sti->index_entries[0].size;

        ts   = sti->index_entries[0].timestamp;

        for (j = 0; j < size; j += max)

            av_add_index_entry(st, pos + j, ts + j, FFMIN(max, size - j), 0,

                               AVINDEX_KEYFRAME);

    }

}

static int avi_read_tag(AVFormatContext *s, AVStream *st, uint32_t tag,

                        uint32_t size)

{

    AVIOContext *pb = s->pb;

    char key[5]     = { 0 };

    char *value;

    size += (size & 1);

    if (size == UINT_MAX)

        return AVERROR(EINVAL);

    value = av_malloc(size + 1);

    if (!value)

        return AVERROR(ENOMEM);

    if (avio_read(pb, value, size) != size) {

        av_freep(&value);

        return AVERROR_INVALIDDATA;

    }

    value[size] = 0;

    AV_WL32(key, tag);

    return av_dict_set(st ? &st->metadata : &s->metadata, key, value,

                       AV_DICT_DONT_STRDUP_VAL);

}

static const char months[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",

                                    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };

static void avi_metadata_creation_time(AVDictionary **metadata, char *date)

{

    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",

               month, &day, time, &year) == 4) {

        for (i = 0; i < 12; i++)

            if (!av_strcasecmp(month, months[i])) {

                snprintf(buffer, sizeof(buffer), "%.4d-%.2d-%.2d %s",

                         year, i + 1, day, time);

                av_dict_set(metadata, "creation_time", buffer, 0);

            }

    } else if (date[4] == '/' && date[7] == '/') {

        date[4] = date[7] = '-';

        av_dict_set(metadata, "creation_time", date, 0);

    }

}

static void avi_read_nikon(AVFormatContext *s, uint64_t end)

{

    while (avio_tell(s->pb) < end && !avio_feof(s->pb)) {

        uint32_t tag  = avio_rl32(s->pb);

        uint32_t size = avio_rl32(s->pb);

        switch (tag) {

        case MKTAG('n', 'c', 't', 'g'):  /* Nikon Tags */

        {

            uint64_t tag_end = avio_tell(s->pb) + size;

            while (avio_tell(s->pb) < tag_end && !avio_feof(s->pb)) {

                uint16_t tag2     = avio_rl16(s->pb);

                uint16_t size2    = avio_rl16(s->pb);

                const char *name = NULL;

                char buffer[64]  = { 0 };

                uint64_t remaining = tag_end - avio_tell(s->pb);

                size2  = FFMIN(size2, remaining);

                size2 -= avio_read(s->pb, buffer,

                                   FFMIN(size2, sizeof(buffer) - 1));

                switch (tag2) {

                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)

                    av_dict_set(&s->metadata, name, buffer, 0);

                avio_skip(s->pb, size2);

            }

            break;

        }

        default:

            avio_skip(s->pb, size);

            break;

        }

    }

}

static int avi_extract_stream_metadata(AVFormatContext *s, AVStream *st)

{

    GetByteContext gb;

    uint8_t *data = st->codecpar->extradata;

    int data_size = st->codecpar->extradata_size;

    int tag, offset;

    if (!data || data_size < 8) {

        return AVERROR_INVALIDDATA;

    }

    bytestream2_init(&gb, data, data_size);

    tag = bytestream2_get_le32(&gb);

    switch (tag) {

    case MKTAG('A', 'V', 'I', 'F'): {

        AVExifMetadata ifd = { 0 };

        int ret;

        // skip 4 byte padding

        bytestream2_skip(&gb, 4);

        offset = bytestream2_tell(&gb);

        // decode EXIF tags from IFD, AVI is always little-endian

        ret = av_exif_parse_buffer(s, data + offset, data_size - offset, &ifd, AV_EXIF_ASSUME_LE);

        if (ret < 0)

            return ret;

        ret = av_exif_ifd_to_dict(s, &ifd, &st->metadata);

        av_exif_free(&ifd);

        return ret;

    }

    case MKTAG('C', 'A', 'S', 'I'):

        avpriv_request_sample(s, "RIFF stream data tag type CASI (%u)", tag);

        break;

    case MKTAG('Z', 'o', 'r', 'a'):

        avpriv_request_sample(s, "RIFF stream data tag type Zora (%u)", tag);

        break;

    default:

        break;

    }

    return 0;

}

static int calculate_bitrate(AVFormatContext *s)

{

    AVIContext *avi = s->priv_data;

    int i, j;

    int64_t lensum = 0;

    int64_t maxpos = 0;

    for (i = 0; i<s->nb_streams; i++) {

        int64_t len = 0;

        FFStream *const sti = ffstream(s->streams[i]);

        if (!sti->nb_index_entries)

            continue;

        for (j = 0; j < sti->nb_index_entries; j++)

            len += sti->index_entries[j].size;

        maxpos = FFMAX(maxpos, sti->index_entries[j-1].pos);

        lensum += len;

    }

    if (maxpos < av_rescale(avi->io_fsize, 9, 10)) // index does not cover the whole file

        return 0;

    if (lensum*9/10 > maxpos || lensum < maxpos*9/10) // frame sum and filesize mismatch

        return 0;

    for (i = 0; i<s->nb_streams; i++) {

        int64_t len = 0;

        AVStream *st = s->streams[i];

        FFStream *const sti = ffstream(st);

        int64_t duration;

        AVInteger bitrate_i, den_i, num_i;

        for (j = 0; j < sti->nb_index_entries; j++)

            len += sti->index_entries[j].size;

        if (sti->nb_index_entries < 2 || st->codecpar->bit_rate > 0)

            continue;

        duration = sti->index_entries[j-1].timestamp - sti->index_entries[0].timestamp;

        den_i = av_mul_i(av_int2i(duration), av_int2i(st->time_base.num));

        num_i = av_add_i(av_mul_i(av_int2i(8*len), av_int2i(st->time_base.den)), av_shr_i(den_i, 1));

        bitrate_i = av_div_i(num_i, den_i);

        if (av_cmp_i(bitrate_i, av_int2i(INT64_MAX)) <= 0) {

            int64_t bitrate = av_i2int(bitrate_i);

            if (bitrate > 0) {

                st->codecpar->bit_rate = bitrate;

            }

        }

    }

    return 1;

}

static int avi_read_header(AVFormatContext *s)

{

    AVIContext *avi = s->priv_data;

    AVIOContext *pb = s->pb;

    unsigned int tag, tag1, handler;

    int codec_type, stream_index, frame_period;

    unsigned int size;

    int i;

    AVIStream *ast      = NULL;

    int avih_width      = 0, avih_height = 0;

    int amv_file_format = 0;

    uint64_t list_end   = 0;

    int64_t pos;

    int ret;

    AVDictionaryEntry *dict_entry;

    avi->stream_index = -1;

    ret = get_riff(s, pb);

    if (ret < 0)

        return ret;

    av_log(avi, AV_LOG_DEBUG, "use odml:%d\n", avi->use_odml);

    avi->io_fsize = avi->fsize = avio_size(pb);

    if (avi->fsize <= 0 || avi->fsize < avi->riff_end)

        avi->fsize = avi->riff_end == 8 ? INT64_MAX : avi->riff_end;

    /* first list tag */

    stream_index = -1;

    codec_type   = -1;

    frame_period = 0;

    for (;;) {

        if (avio_feof(pb))

            return AVERROR_INVALIDDATA;

        tag  = avio_rl32(pb);

        size = avio_rl32(pb);

        print_tag(s, "tag", tag, size);

        switch (tag) {

        case MKTAG('L', 'I', 'S', 'T'):

            list_end = avio_tell(pb) + size;

            /* Ignored, except at start of video packets. */

            tag1 = avio_rl32(pb);

            print_tag(s, "list", tag1, 0);

            if (tag1 == MKTAG('m', 'o', 'v', 'i')) {

                avi->movi_list = avio_tell(pb) - 4;

                if (size)

                    avi->movi_end = avi->movi_list + size + (size & 1);

                else

                    avi->movi_end = avi->fsize;

                av_log(s, AV_LOG_TRACE, "movi end=%"PRIx64"\n", avi->movi_end);

                goto end_of_header;

            } else if (tag1 == MKTAG('I', 'N', 'F', 'O')) {

                if (size < 4)

                    return AVERROR_INVALIDDATA;

                ff_read_riff_info(s, size - 4);

            } else if (tag1 == MKTAG('n', 'c', 'd', 't'))

                avi_read_nikon(s, list_end);

            break;

        case MKTAG('I', 'D', 'I', 'T'):

        {

            unsigned char date[64] = { 0 };

            size += (size & 1);

            size -= avio_read(pb, date, FFMIN(size, sizeof(date) - 1));

            avio_skip(pb, size);

            avi_metadata_creation_time(&s->metadata, date);

            break;

        }

        case MKTAG('d', 'm', 'l', 'h'):

            avi->is_odml = 1;

            avio_skip(pb, size + (size & 1));

            break;

        case MKTAG('a', 'm', 'v', 'h'):

            amv_file_format = 1;

            av_fallthrough;

        case MKTAG('a', 'v', 'i', 'h'):

            /* AVI header */

            /* using frame_period is bad idea */

            frame_period = avio_rl32(pb);

            avio_rl32(pb); /* max. bytes per second */

            avio_rl32(pb);

            avi->non_interleaved |= avio_rl32(pb) & AVIF_MUSTUSEINDEX;

            avio_skip(pb, 2 * 4);

            avio_rl32(pb);

            avio_rl32(pb);

            avih_width  = avio_rl32(pb);

            avih_height = avio_rl32(pb);

            avio_skip(pb, size - 10 * 4);

            break;

        case MKTAG('s', 't', 'r', 'h'): {

            /* stream header */

            tag1    = avio_rl32(pb);

            handler = avio_rl32(pb); /* codec tag */

            if (tag1 == MKTAG('p', 'a', 'd', 's')) {

                avio_skip(pb, size - 8);

                break;

            }

            stream_index++;

            AVStream *const st = avformat_new_stream(s, NULL);

            if (!st)

                return AVERROR(ENOMEM);

            st->id = stream_index;

            ast    = av_mallocz(sizeof(AVIStream));

            if (!ast)

                return AVERROR(ENOMEM);

            st->priv_data = ast;

            if (amv_file_format)

                tag1 = stream_index ? MKTAG('a', 'u', 'd', 's')

                                    : MKTAG('v', 'i', 'd', 's');

            print_tag(s, "strh", tag1, -1);

            if (tag1 == MKTAG('i', 'a', 'v', 's') ||

                tag1 == MKTAG('i', 'v', 'a', 's')) {

                int64_t dv_dur;

                /* After some consideration -- I don't think we

                 * have to support anything but DV in type1 AVIs. */

                if (s->nb_streams != 1)

                    return AVERROR_INVALIDDATA;

                if (handler != MKTAG('d', 'v', 's', 'd') &&

                    handler != MKTAG('d', 'v', 'h', 'd') &&

                    handler != MKTAG('d', 'v', 's', 'l'))

                    return AVERROR_INVALIDDATA;

                if (!CONFIG_DV_DEMUXER)

                    return AVERROR_DEMUXER_NOT_FOUND;

                ast = s->streams[0]->priv_data;

                st->priv_data = NULL;

                ff_remove_stream(s, st);

                avi->dv_demux = avpriv_dv_init_demux(s);

                if (!avi->dv_demux) {

                    av_free(ast);

                    return AVERROR(ENOMEM);

                }

                s->streams[0]->priv_data = ast;

                avio_skip(pb, 3 * 4);

                ast->scale = avio_rl32(pb);

                ast->rate  = avio_rl32(pb);

                avio_skip(pb, 4);  /* start time */

                dv_dur = avio_rl32(pb);

                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

                 * will make a guess based on bitrate. */

                stream_index = s->nb_streams - 1;

                avio_skip(pb, size - 9 * 4);

                break;

            }

            av_assert0(stream_index < s->nb_streams);

            ast->handler = handler;

            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);

            if (!(ast->scale && ast->rate)) {

                av_log(s, AV_LOG_WARNING,

                       "scale/rate is %"PRIu32"/%"PRIu32" which is invalid. "

                       "(This file has been generated by broken software.)\n",

                       ast->scale,

                       ast->rate);

                if (frame_period) {

                    ast->rate  = 1000000;

                    ast->scale = frame_period;

                } else {

                    ast->rate  = 25;

                    ast->scale = 1;

                }

            }

            avpriv_set_pts_info(st, 64, ast->scale, ast->rate);

            ast->cum_len  = avio_rl32(pb); /* start */

            st->nb_frames = avio_rl32(pb);

            st->start_time = 0;

            avio_rl32(pb); /* buffer size */

            avio_rl32(pb); /* quality */

            if (ast->cum_len > 3600LL * ast->rate / ast->scale) {

                av_log(s, AV_LOG_ERROR, "crazy start time, iam scared, giving up\n");

                ast->cum_len = 0;

            }

            ast->sample_size = avio_rl32(pb);

            ast->cum_len    *= FFMAX(1, ast->sample_size);

            av_log(s, AV_LOG_TRACE, "%"PRIu32" %"PRIu32" %d\n",

                    ast->rate, ast->scale, ast->sample_size);

            switch (tag1) {

            case MKTAG('v', 'i', 'd', 's'):

                codec_type = AVMEDIA_TYPE_VIDEO;

                ast->sample_size = 0;

                st->avg_frame_rate = av_inv_q(st->time_base);

                break;

            case MKTAG('a', 'u', 'd', 's'):

                codec_type = AVMEDIA_TYPE_AUDIO;

                break;

            case MKTAG('t', 'x', 't', 's'):

                codec_type = AVMEDIA_TYPE_SUBTITLE;

                break;

            case MKTAG('d', 'a', 't', 's'):

                codec_type = AVMEDIA_TYPE_DATA;

                break;

            default:

                av_log(s, AV_LOG_INFO, "unknown stream type %X\n", tag1);

            }

            if (ast->sample_size < 0) {

                if (s->error_recognition & AV_EF_EXPLODE) {

                    av_log(s, AV_LOG_ERROR,

                           "Invalid sample_size %d at stream %d\n",

                           ast->sample_size,

                           stream_index);

                    return AVERROR_INVALIDDATA;

                }

                av_log(s, AV_LOG_WARNING,

                       "Invalid sample_size %d at stream %d "

                       "setting it to 0\n",

                       ast->sample_size,

                       stream_index);

                ast->sample_size = 0;

            }

            if (ast->sample_size == 0) {

                st->duration = st->nb_frames;

                if (st->duration > 0 && avi->io_fsize > 0 && avi->riff_end > avi->io_fsize) {

                    av_log(s, AV_LOG_DEBUG, "File is truncated adjusting duration\n");

                    st->duration = av_rescale(st->duration, avi->io_fsize, avi->riff_end);

                }

            }

            ast->frame_offset = ast->cum_len;

            avio_skip(pb, size - 12 * 4);

            break;

        }

        case MKTAG('s', 't', 'r', 'f'):

            /* stream header */

            if (!size && (codec_type == AVMEDIA_TYPE_AUDIO ||

                          codec_type == AVMEDIA_TYPE_VIDEO))

                break;

            if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) {

                avio_skip(pb, size);

            } else {

                uint64_t cur_pos = avio_tell(pb);

                unsigned esize;

                if (cur_pos < list_end)

                    size = FFMIN(size, list_end - cur_pos);

                AVStream *const st = s->streams[stream_index];

                FFStream *const sti = ffstream(st);

                if (st->codecpar->codec_type != AVMEDIA_TYPE_UNKNOWN) {

                    avio_skip(pb, size);

                    break;

                }

                switch (codec_type) {

                case AVMEDIA_TYPE_VIDEO:

                    if (amv_file_format) {

                        st->codecpar->width      = avih_width;

                        st->codecpar->height     = avih_height;

                        st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

                        st->codecpar->codec_id   = AV_CODEC_ID_AMV;

                        avio_skip(pb, size);

                        break;

                    }

                    tag1 = ff_get_bmp_header(pb, st, &esize);

                    if (tag1 == MKTAG('D', 'X', 'S', 'B') ||

                        tag1 == MKTAG('D', 'X', 'S', 'A')) {

                        st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;

                        st->codecpar->codec_tag  = tag1;

                        st->codecpar->codec_id   = AV_CODEC_ID_XSUB;

                        break;

                    }

                    if (size > 10 * 4 && size < (1 << 30) && size < avi->fsize) {

                        if (esize == size-1 && (esize&1)) {

                            st->codecpar->extradata_size = esize - 10 * 4;

                        } else

                            st->codecpar->extradata_size =  size - 10 * 4;

                        if (st->codecpar->extradata) {

                            av_log(s, AV_LOG_WARNING, "New extradata in strf chunk, freeing previous one.\n");

                        }

                        ret = ff_get_extradata(s, st->codecpar, pb,

                                               st->codecpar->extradata_size);

                        if (ret < 0)

                            return ret;

                    }

                    // FIXME: check if the encoder really did this correctly

                    if (st->codecpar->extradata_size & 1)

                        avio_r8(pb);

                    /* Extract palette from extradata if bpp <= 8.

                     * This code assumes that extradata contains only palette.

                     * This is true for all paletted codecs implemented in

                     * FFmpeg. */

                    if (st->codecpar->extradata_size &&

                        (st->codecpar->bits_per_coded_sample <= 8)) {

                        int pal_size = (1 << st->codecpar->bits_per_coded_sample) << 2;

                        const uint8_t *pal_src;

                        pal_size = FFMIN(pal_size, st->codecpar->extradata_size);

                        pal_src  = st->codecpar->extradata +

                                   st->codecpar->extradata_size - pal_size;

                        /* Exclude the "BottomUp" field from the palette */

                        if (pal_src - st->codecpar->extradata >= 9 &&

                            !memcmp(st->codecpar->extradata + st->codecpar->extradata_size - 9, "BottomUp", 9))

                            pal_src -= 9;

                        for (i = 0; i < pal_size / 4; i++)

                            ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src + 4 * i);

                        ast->has_pal = 1;

                    }

                    print_tag(s, "video", tag1, 0);

                    st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

                    st->codecpar->codec_tag  = tag1;

                    st->codecpar->codec_id   = ff_codec_get_id(ff_codec_bmp_tags,

                                                            tag1);

                    /* If codec is not found yet, try with the mov tags. */

                    if (!st->codecpar->codec_id) {

                        st->codecpar->codec_id =

                            ff_codec_get_id(ff_codec_movvideo_tags, tag1);

                        if (st->codecpar->codec_id)

                           av_log(s, AV_LOG_WARNING,

                                  "mov tag found in avi (fourcc %s)\n",

                                  av_fourcc2str(tag1));

                    }

                    if (!st->codecpar->codec_id)

                        st->codecpar->codec_id = ff_codec_get_id(ff_codec_bmp_tags_unofficial, tag1);

                    /* This is needed to get the pict type which is necessary

                     * for generating correct pts. */

                    sti->need_parsing = AVSTREAM_PARSE_HEADERS;

                    if (st->codecpar->codec_id == AV_CODEC_ID_MPEG4 &&

                        ast->handler == MKTAG('X', 'V', 'I', 'D'))

                        st->codecpar->codec_tag = MKTAG('X', 'V', 'I', 'D');

                    if (st->codecpar->codec_tag == MKTAG('V', 'S', 'S', 'H'))

                        sti->need_parsing = AVSTREAM_PARSE_FULL;

                    if (st->codecpar->codec_id == AV_CODEC_ID_RV40)

                        sti->need_parsing = AVSTREAM_PARSE_NONE;

                    if (st->codecpar->codec_id == AV_CODEC_ID_HEVC &&

                        st->codecpar->codec_tag == MKTAG('H', '2', '6', '5'))

                        sti->need_parsing = AVSTREAM_PARSE_FULL;

                    if (st->codecpar->codec_id  == AV_CODEC_ID_AVRN &&

                        st->codecpar->codec_tag == MKTAG('A', 'V', 'R', 'n') &&

                        (st->codecpar->extradata_size < 31 ||

                          memcmp(&st->codecpar->extradata[28], "1:1", 3)))

                        st->codecpar->codec_id = AV_CODEC_ID_MJPEG;

                    if (st->codecpar->codec_tag == 0 && st->codecpar->height > 0 &&

                        st->codecpar->extradata_size < 1U << 30) {

                        st->codecpar->extradata_size += 9;

                        if ((ret = av_reallocp(&st->codecpar->extradata,

                                               st->codecpar->extradata_size +

                                               AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {

                            st->codecpar->extradata_size = 0;

                            return ret;

                        } else

                            memcpy(st->codecpar->extradata + st->codecpar->extradata_size - 9,

                                   "BottomUp", 9);

                    }

                    if (st->codecpar->height == INT_MIN)

                        return AVERROR_INVALIDDATA;

                    st->codecpar->height = FFABS(st->codecpar->height);

//                    avio_skip(pb, size - 5 * 4);

                    break;

                case AVMEDIA_TYPE_AUDIO:

                    ret = ff_get_wav_header(s, pb, st->codecpar, size, 0);

                    if (ret < 0)

                        return ret;

                    ast->dshow_block_align = st->codecpar->block_align;

                    if (ast->sample_size && st->codecpar->block_align &&

                        ast->sample_size != st->codecpar->block_align) {

                        av_log(s,

                               AV_LOG_WARNING,

                               "sample size (%d) != block align (%d)\n",

                               ast->sample_size,

                               st->codecpar->block_align);

                        ast->sample_size = st->codecpar->block_align;

                    }

                    /* 2-aligned

                     * (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */

                    if (size & 1)

                        avio_skip(pb, 1);

                    /* Force parsing as several audio frames can be in

                     * one packet and timestamps refer to packet start. */

                    sti->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;

                    /* ADTS header is in extradata, AAC without header must be

                     * stored as exact frames. Parser not needed and it will

                     * fail. */

                    if (st->codecpar->codec_id == AV_CODEC_ID_AAC &&

                        st->codecpar->extradata_size)

                        sti->need_parsing = AVSTREAM_PARSE_NONE;

                    // The flac parser does not work with AVSTREAM_PARSE_TIMESTAMPS

                    if (st->codecpar->codec_id == AV_CODEC_ID_FLAC)

                        sti->need_parsing = AVSTREAM_PARSE_NONE;

                    /* AVI files with Xan DPCM audio (wrongly) declare PCM

                     * audio in the header but have Axan as stream_code_tag. */

                    if (ast->handler == AV_RL32("Axan")) {

                        st->codecpar->codec_id  = AV_CODEC_ID_XAN_DPCM;

                        st->codecpar->codec_tag = 0;

                        ast->dshow_block_align = 0;

                    }

                    if (amv_file_format) {

                        st->codecpar->codec_id    = AV_CODEC_ID_ADPCM_IMA_AMV;

                        ast->dshow_block_align = 0;

                    }

                    if ((st->codecpar->codec_id == AV_CODEC_ID_AAC  ||

                         st->codecpar->codec_id == AV_CODEC_ID_FTR  ||

                         st->codecpar->codec_id == AV_CODEC_ID_FLAC ||

                         st->codecpar->codec_id == AV_CODEC_ID_MP2 ) && ast->dshow_block_align <= 4 && ast->dshow_block_align) {

                        av_log(s, AV_LOG_DEBUG, "overriding invalid dshow_block_align of %d\n", ast->dshow_block_align);

                        ast->dshow_block_align = 0;

                    }

                    if (st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 1024 && ast->sample_size == 1024 ||

                       st->codecpar->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 4096 && ast->sample_size == 4096 ||

                       st->codecpar->codec_id == AV_CODEC_ID_MP3 && ast->dshow_block_align == 1152 && ast->sample_size == 1152) {

                        av_log(s, AV_LOG_DEBUG, "overriding sample_size\n");

                        ast->sample_size = 0;

                    }

                    break;

                case AVMEDIA_TYPE_SUBTITLE:

                    st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;

                    sti->request_probe = 1;

                    avio_skip(pb, size);

                    break;

                default:

                    st->codecpar->codec_type = AVMEDIA_TYPE_DATA;

                    st->codecpar->codec_id   = AV_CODEC_ID_NONE;

                    st->codecpar->codec_tag  = 0;

                    avio_skip(pb, size);

                    break;

                }

            }

            break;

        case MKTAG('s', 't', 'r', 'd'):

            if (stream_index >= (unsigned)s->nb_streams

                || s->streams[stream_index]->codecpar->extradata_size

                || s->streams[stream_index]->codecpar->codec_tag == MKTAG('H','2','6','4')) {

                avio_skip(pb, size);

            } else {

                uint64_t cur_pos = avio_tell(pb);

                if (cur_pos < list_end)

                    size = FFMIN(size, list_end - cur_pos);

                AVStream *const st = s->streams[stream_index];

                if (size<(1<<30)) {

                    if (st->codecpar->extradata) {

                        av_log(s, AV_LOG_WARNING, "New extradata in strd chunk, freeing previous one.\n");

                    }

                    if ((ret = ff_get_extradata(s, st->codecpar, pb, size)) < 0)

                        return ret;

                }

                if (st->codecpar->extradata_size & 1) //FIXME check if the encoder really did this correctly

                    avio_r8(pb);

                ret = avi_extract_stream_metadata(s, st);

                if (ret < 0) {

                    av_log(s, AV_LOG_WARNING, "could not decoding EXIF data in stream header.\n");

                }

            }

            break;

        case MKTAG('i', 'n', 'd', 'x'):

            pos = avio_tell(pb);

            if ((pb->seekable & AVIO_SEEKABLE_NORMAL) && !(s->flags & AVFMT_FLAG_IGNIDX) &&

                avi->use_odml &&

                read_odml_index(s, 0) < 0 &&

                (s->error_recognition & AV_EF_EXPLODE))

                return AVERROR_INVALIDDATA;

            avio_seek(pb, pos + size, SEEK_SET);

            break;

        case MKTAG('v', 'p', 'r', 'p'):

            if (stream_index < (unsigned)s->nb_streams && size > 9 * 4) {

                AVStream *const st = s->streams[stream_index];

                AVRational active, active_aspect;

                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

                if (active_aspect.num && active_aspect.den &&

                    active.num && active.den) {

                    st->sample_aspect_ratio = av_div_q(active_aspect, active);

                    av_log(s, AV_LOG_TRACE, "vprp %d/%d %d/%d\n",

                            active_aspect.num, active_aspect.den,

                            active.num, active.den);

                }