/*****************************************************************************

 * avi.c : AVI file Stream input module for vlc

 *****************************************************************************

 * Copyright (C) 2001-2009 VLC authors and VideoLAN

 *

 * Authors: Laurent Aimar <fenrir@via.ecp.fr>

 *

 * This program 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.

 *

 * This program 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 this program; if not, write to the Free Software Foundation,

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

 *****************************************************************************/

/*****************************************************************************

 * Preamble

 *****************************************************************************/

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#include <assert.h>

#include <ctype.h>

#include <limits.h>

#include <stdint.h>

#include <vlc_common.h>

#include <vlc_arrays.h>

#include <vlc_plugin.h>

#include <vlc_demux.h>

#include <vlc_input.h>

#include <vlc_aout.h>

#include <vlc_dialog.h>

#include <vlc_meta.h>

#include <vlc_codecs.h>

#include <vlc_charset.h>

#include <vlc_arrays.h>

#include "libavi.h"

#include "../rawdv.h"

#include "bitmapinfoheader.h"

#include "../../packetizer/h264_nal.h"

#include "../../packetizer/hevc_nal.h"

/*****************************************************************************

 * Module descriptor

 *****************************************************************************/

#define INTERLEAVE_TEXT N_("Force interleaved method" )

#define INDEX_TEXT N_("Force index creation")

#define INDEX_LONGTEXT N_( \

    "Recreate a index for the AVI file. Use this if your AVI file is damaged "\

    "or incomplete (not seekable)." )

static int  Open ( vlc_object_t * );

static void Close( vlc_object_t * );

static const int pi_index[] = {0,1,2,3};

static const char *const ppsz_indexes[] = { N_("Ask for action"),

                                            N_("Always fix"),

                                            N_("Never fix"),

                                            N_("Fix when necessary")};

vlc_module_begin ()

    set_shortname( "AVI" )

    set_description( N_("AVI demuxer") )

    set_capability( "demux", 212 )

    set_subcategory( SUBCAT_INPUT_DEMUX )

    add_file_extension("avi")

    add_bool( "avi-interleaved", false,

              INTERLEAVE_TEXT, NULL )

    add_integer( "avi-index", 0,

              INDEX_TEXT, INDEX_LONGTEXT )

        change_integer_list( pi_index, ppsz_indexes )

    set_callbacks( Open, Close )

vlc_module_end ()

/*****************************************************************************

 * Local prototypes

 *****************************************************************************/

static int Control         ( demux_t *, int, va_list );

static int Seek            ( demux_t *, vlc_tick_t, double, bool );

static int Demux_Seekable  ( demux_t * );

static int Demux_UnSeekable( demux_t * );

static char *FromACP( const char *str )

{

    return FromCharset(vlc_pgettext("GetACP", "CP1252"), str, strlen(str));

}

#define IGNORE_ES DATA_ES

#define READ_LENGTH                VLC_TICK_FROM_MS(25)

#define READ_LENGTH_NONINTERLEAVED VLC_TICK_FROM_MS(1500)

//#define AVI_DEBUG

typedef struct

{

    vlc_fourcc_t i_fourcc;

    uint64_t     i_pos;

    uint32_t     i_size;

    vlc_fourcc_t i_type;     /* only for AVIFOURCC_LIST */

    uint8_t      i_peek[8];  /* first 8 bytes */

    unsigned int i_stream;

    enum es_format_category_e i_cat;

} avi_packet_t;

typedef struct

{

    uint64_t     i_pos;

    uint32_t     i_flags;

    uint32_t     i_length;

    uint64_t     i_lengthtotal;

} avi_entry_t;

typedef struct

{

    uint32_t        i_size;

    uint32_t        i_max;

    avi_entry_t     *p_entry;

} avi_index_t;

static void avi_index_Init( avi_index_t * );

static void avi_index_Clean( avi_index_t * );

static int64_t avi_index_Append( avi_index_t *, uint64_t *, avi_entry_t * );

typedef struct

{

    bool            b_activated;

    bool            b_eof;

    unsigned int    i_rate; /* for audio & video */

    unsigned int    i_scale;/* for audio & video */

    unsigned int    i_samplesize;

    struct bitmapinfoheader_properties bihprops;

    bool            is_qnap;

    es_format_t     fmt;

    es_out_id_t     *p_es;

    int             i_next_block_flags;

    int             i_dv_audio_rate;

    es_out_id_t     *p_es_dv_audio;

    /* SPU specific */

    vlc_tick_t      i_last_embedded_endtime;

    vlc_tick_t      i_next_embedded_time;

    /* Avi Index */

    avi_index_t     idx;

    unsigned int    i_idxposc;  /* numero of chunk */

    unsigned int    i_idxposb;  /* byte in the current chunk */

    /* For VBR audio only */

    unsigned int    i_blockno;

    unsigned int    i_blocksize;

    struct

    {

        bool b_ok;

        int64_t i_toread;

        int64_t i_posf; /* where we will read :

                       if i_idxposb == 0 : beginning of chunk (+8 to access data)

                       else : point on data directly */

    } demuxctx;

} avi_track_t;

typedef struct

{

    vlc_tick_t i_time;

    vlc_tick_t i_length;

    bool  b_interleaved;

    bool  b_seekable;

    bool  b_fastseekable;

    bool  b_indexloaded; /* if we read indexes from end of file before starting */

    vlc_tick_t i_read_increment;

    uint32_t i_avih_flags;

    avi_chunk_t ck_root;

    bool  b_odml;

    uint64_t i_movi_begin;

    uint64_t i_movi_lastchunk_pos;   /* XXX position of last valid chunk */

    /* number of streams and information */

    unsigned int i_track;

    avi_track_t  **track;

    /* meta */

    vlc_meta_t  *meta;

    unsigned int updates;

    unsigned int       i_attachment;

    input_attachment_t **attachment;

} demux_sys_t;

#define __EVEN(x) (((x) & 1) ? (x) + 1 : (x))

static int64_t AVI_PTSToChunk( avi_track_t *, vlc_tick_t i_pts );

static int64_t AVI_PTSToByte ( avi_track_t *, vlc_tick_t i_pts );

static vlc_tick_t AVI_GetDPTS   ( avi_track_t *, int64_t i_count );

static vlc_tick_t AVI_GetPTS    ( avi_track_t * );

static int AVI_StreamChunkFind( demux_t *, avi_track_t * );

static int AVI_StreamChunkSet ( demux_t *, avi_track_t *, unsigned int i_ck );

static int AVI_StreamBytesSet ( demux_t *, avi_track_t *, uint64_t i_byte );

vlc_fourcc_t AVI_FourccGetCodec( unsigned int i_cat, vlc_fourcc_t );

static int   AVI_GetKeyFlag    ( const avi_track_t *, const uint8_t * );

static int AVI_PacketGetHeader( demux_t *, avi_packet_t *p_pk );

static int AVI_PacketNext     ( demux_t * );

static int AVI_PacketSearch   ( demux_t * );

static void AVI_IndexLoad    ( demux_t * );

static void AVI_IndexCreate  ( demux_t * );

static void AVI_ExtractSubtitle( demux_t *, unsigned int i_stream, avi_chunk_list_t *, avi_chunk_STRING_t * );

static avi_track_t * AVI_GetVideoTrackForXsub( demux_sys_t * );

static int AVI_SeekSubtitleTrack( demux_sys_t *, avi_track_t * );

static void AVI_DvHandleAudio( demux_t *, avi_track_t *, block_t * );

static vlc_tick_t  AVI_MovieGetLength( demux_t * );

static void AVI_MetaLoad( demux_t *, avi_chunk_list_t *p_riff, avi_chunk_avih_t *p_avih );

/*****************************************************************************

 * Stream management

 *****************************************************************************/

static int        AVI_TrackSeek  ( demux_t *, int, vlc_tick_t );

static bool       AVI_TrackStopFinishedStreams( demux_t *);

/* Remarks:

 - For VBR mp3 stream:

    count blocks by rounded-up chunksizes instead of chunks

    we need full emulation of dshow avi demuxer bugs :(

    fixes silly nandub-style a-v delaying in avi with vbr mp3...

    (from mplayer 2002/08/02)

 - to complete....

 */

#define QNAP_VIDEO_HEADER_SIZE 56

/* https://github.com/qnap-dev/qnap-qiot-sdks/blob/master/doc/QVRPro/live_stream_parser.cpp#L90 */

static bool IsQNAPCodec(uint32_t biCompression)

{

    switch (biCompression)

    {

        case QNAP_FCC_w264:

        case QNAP_FCC_q264:

        case QNAP_FCC_Q264:

        case QNAP_FCC_wMP4:

        case QNAP_FCC_qMP4:

        case QNAP_FCC_QMP4:

        case QNAP_FCC_wIVG:

        case QNAP_FCC_qIVG:

        case QNAP_FCC_QIVG:

            return true;

        default:

            return false;

    }

}

#define XSUB_HEADER_SIZE 0x1B

static int ExtractXsubSampleInfo( const uint8_t *p_buf,

                                  vlc_tick_t *pi_start, vlc_tick_t *pi_end )

{

    unsigned t[8];

    char buffer[XSUB_HEADER_SIZE + 1];

    memcpy( buffer, p_buf, XSUB_HEADER_SIZE );

    buffer[XSUB_HEADER_SIZE] = '\0';

    if( sscanf( buffer, "[%u:%2u:%2u.%3u-%u:%2u:%2u.%3u]",

                &t[0], &t[1], &t[2], &t[3], &t[4], &t[5], &t[6], &t[7] ) != 8 )

        return VLC_EGENERIC;

    *pi_start = vlc_tick_from_sec( t[0] * 3600 + t[1] * 60 + t[2] ) +

                                   VLC_TICK_FROM_MS(t[3]);

    *pi_end = vlc_tick_from_sec( t[4] * 3600 + t[5] * 60 + t[6] ) +

                                 VLC_TICK_FROM_MS(t[7]);

    return VLC_SUCCESS;

}

static int AVI_PeekSample( stream_t *s, size_t i_skip,

                           const uint8_t **pp_peek, size_t i_peek )

{

    ssize_t i_ret = vlc_stream_Peek( s, pp_peek, i_skip + i_peek );

    *pp_peek += i_skip;

    if ( i_ret < 0 || (size_t) i_ret != i_skip + i_peek )

        return VLC_EGENERIC;

    return VLC_SUCCESS;

}

static vlc_tick_t AVI_GetXsubSampleTimeAt( stream_t *s, uint64_t pos )

{

    const uint8_t *p_peek;

    vlc_tick_t i_nzstart, i_nzend;

    if( vlc_stream_Seek( s, pos ) != VLC_SUCCESS ||

        AVI_PeekSample( s, 8, &p_peek, XSUB_HEADER_SIZE ) ||

        ExtractXsubSampleInfo( p_peek, &i_nzstart, &i_nzend ) )

        return VLC_TICK_INVALID;

    return VLC_TICK_0 + i_nzstart;

}

/*****************************************************************************

 * Close: frees unused data

 *****************************************************************************/

static void Close ( vlc_object_t * p_this )

{

    demux_t *    p_demux = (demux_t *)p_this;

    demux_sys_t *p_sys = p_demux->p_sys  ;

    for( unsigned int i = 0; i < p_sys->i_track; i++ )

    {

        if( p_sys->track[i] )

        {

            es_format_Clean( &p_sys->track[i]->fmt );

            avi_index_Clean( &p_sys->track[i]->idx );

            free( p_sys->track[i] );

        }

    }

    free( p_sys->track );

    AVI_ChunkFreeRoot( p_demux->s, &p_sys->ck_root );

    if( p_sys->meta )

        vlc_meta_Delete( p_sys->meta );

    for( unsigned i = 0; i < p_sys->i_attachment; i++)

        vlc_input_attachment_Release(p_sys->attachment[i]);

    free(p_sys->attachment);

    free( p_sys );

}

/*****************************************************************************

 * Open: check file and initializes AVI structures

 *****************************************************************************/

static int Open( vlc_object_t * p_this )

{

    demux_t  *p_demux = (demux_t *)p_this;

    demux_sys_t     *p_sys;

    bool       b_index = false, b_aborted = false;

    int              i_do_index;

    avi_chunk_list_t    *p_riff;

    avi_chunk_list_t    *p_hdrl, *p_movi;

    avi_chunk_avih_t    *p_avih;

    unsigned int i_track;

    unsigned int i_peeker;

    const uint8_t *p_peek;

    /* Is it an avi file ? */

    if( vlc_stream_Peek( p_demux->s, &p_peek, 200 ) < 200 )

        return VLC_EGENERIC;

    for( i_peeker = 0; i_peeker < 188; i_peeker++ )

    {

        if( !strncmp( (char *)&p_peek[0], "RIFF", 4 ) && !strncmp( (char *)&p_peek[8], "AVI ", 4 ) )

            break;

        if( !strncmp( (char *)&p_peek[0], "ON2 ", 4 ) && !strncmp( (char *)&p_peek[8], "ON2f", 4 ) )

            break;

        p_peek++;

    }

    if( i_peeker == 188 )

    {

        return VLC_EGENERIC;

    }

    if( i_peeker > 0 && vlc_stream_Read( p_demux->s, NULL, i_peeker ) != i_peeker )

        return VLC_EGENERIC;

    /* Initialize input structures. */

    p_sys = p_demux->p_sys = calloc( 1, sizeof(demux_sys_t) );

    if( unlikely(!p_sys) )

        return VLC_EGENERIC;

    p_sys->b_odml   = false;

    p_sys->meta     = NULL;

    TAB_INIT(p_sys->i_track, p_sys->track);

    TAB_INIT(p_sys->i_attachment, p_sys->attachment);

    vlc_stream_Control( p_demux->s, STREAM_CAN_FASTSEEK,

                        &p_sys->b_fastseekable );

    vlc_stream_Control( p_demux->s, STREAM_CAN_SEEK, &p_sys->b_seekable );

    p_sys->b_interleaved = var_InheritBool( p_demux, "avi-interleaved" );

    if( AVI_ChunkReadRoot( p_demux->s, &p_sys->ck_root ) )

    {

        msg_Err( p_demux, "avi module discarded (invalid file)" );

        free(p_sys);

        return VLC_EGENERIC;

    }

    if( AVI_ChunkCount( &p_sys->ck_root, AVIFOURCC_RIFF, true ) > 1 )

    {

        unsigned int i_count =

            AVI_ChunkCount( &p_sys->ck_root, AVIFOURCC_RIFF, true );

        msg_Warn( p_demux, "multiple riff -> OpenDML ?" );

        for( unsigned i = 1; i < i_count; i++ )

        {

            avi_chunk_list_t *p_sysx;

            p_sysx = AVI_ChunkFind( &p_sys->ck_root, AVIFOURCC_RIFF, i, true );

            if( p_sysx && p_sysx->i_type == AVIFOURCC_AVIX )

            {

                msg_Warn( p_demux, "detected OpenDML file" );

                p_sys->b_odml = true;

                break;

            }

        }

    }

    p_riff  = AVI_ChunkFind( &p_sys->ck_root, AVIFOURCC_RIFF, 0, true );

    p_hdrl  = AVI_ChunkFind( p_riff, AVIFOURCC_hdrl, 0, true );

    p_movi  = AVI_ChunkFind( p_riff, AVIFOURCC_movi, 0, true );

    if( !p_movi )

        p_movi  = AVI_ChunkFind( &p_sys->ck_root, AVIFOURCC_movi, 0, true );

    if( !p_hdrl || !p_movi )

    {

        msg_Err( p_demux, "invalid file: cannot find hdrl or movi chunks" );

        goto error;

    }

    if( !( p_avih = AVI_ChunkFind( p_hdrl, AVIFOURCC_avih, 0, false ) ) )

    {

        msg_Err( p_demux, "invalid file: cannot find avih chunk" );

        goto error;

    }

    i_track = AVI_ChunkCount( p_hdrl, AVIFOURCC_strl, true );

    if( p_avih->i_streams != i_track )

    {

        msg_Warn( p_demux,

                  "found %d stream but %d are declared",

                  i_track, p_avih->i_streams );

    }

    if( i_track > AVIF_MAX_STREAMS )

    {

        msg_Err( p_demux, "Invalid number of streams %u", i_track );

        goto error;

    }

    if( i_track == 0 )

    {

        msg_Err( p_demux, "no stream defined!" );

        goto error;

    }

    /* print information on streams */

    msg_Dbg( p_demux, "AVIH: %d stream, flags %s%s%s%s ",

             i_track,

             p_avih->i_flags&AVIF_HASINDEX?" HAS_INDEX":"",

             p_avih->i_flags&AVIF_MUSTUSEINDEX?" MUST_USE_INDEX":"",

             p_avih->i_flags&AVIF_ISINTERLEAVED?" IS_INTERLEAVED":"",

             p_avih->i_flags&AVIF_TRUSTCKTYPE?" TRUST_CKTYPE":"" );

    p_sys->b_interleaved |= (p_avih->i_flags & AVIF_ISINTERLEAVED);

    /* Set callbacks */

    p_demux->pf_control = Control;

    if( p_sys->b_fastseekable )

    {

        p_demux->pf_demux = Demux_Seekable;

        p_sys->i_read_increment = READ_LENGTH;

    }

    else if( p_sys->b_seekable )

    {

        p_demux->pf_demux = Demux_Seekable;

        p_sys->i_read_increment = READ_LENGTH_NONINTERLEAVED;

        if( !p_sys->b_interleaved )

            msg_Warn( p_demux, "Non interleaved content over slow seekable, "

                               "expect bad performance" );

    }

    else

    {

        msg_Warn( p_demux, "Non seekable content " );

        p_demux->pf_demux = Demux_UnSeekable;

        p_sys->i_read_increment = READ_LENGTH_NONINTERLEAVED;

         /* non seekable and non interleaved case ? well... */

        if( !p_sys->b_interleaved )

        {

            msg_Warn( p_demux, "Non seekable non interleaved content, "

                               "disabling other tracks" );

            i_track = __MIN(i_track, 1);

        }

    }

    AVI_MetaLoad( p_demux, p_riff, p_avih );

    p_sys->i_avih_flags = p_avih->i_flags;

    /* now read info on each stream and create ES */

    for( unsigned i = 0 ; i < i_track; i++ )

    {

        avi_track_t           *tk     = calloc( 1, sizeof( avi_track_t ) );

        if( unlikely( !tk ) )

            goto error;

        avi_chunk_list_t      *p_strl = AVI_ChunkFind( p_hdrl, AVIFOURCC_strl, i, true );

        avi_chunk_strh_t      *p_strh = AVI_ChunkFind( p_strl, AVIFOURCC_strh, 0, false );

        avi_chunk_STRING_t    *p_strn = AVI_ChunkFind( p_strl, AVIFOURCC_strn, 0, false );

        avi_chunk_strf_auds_t *p_auds = NULL;

        avi_chunk_strf_vids_t *p_vids = NULL;

        tk->b_eof = false;

        tk->b_activated = true;

        p_vids = (avi_chunk_strf_vids_t*)AVI_ChunkFind( p_strl, AVIFOURCC_strf, 0, false );

        p_auds = (avi_chunk_strf_auds_t*)p_vids;

        if( p_strl == NULL || p_strh == NULL || p_vids == NULL )

        {

            msg_Warn( p_demux, "stream[%d] incomplete", i );

            free( tk );

            continue;

        }

        tk->i_rate  = p_strh->i_rate;

        tk->i_scale = p_strh->i_scale;

        tk->i_samplesize = p_strh->i_samplesize;

        msg_Dbg( p_demux, "stream[%u] rate:%u scale:%u samplesize:%u",

                i, tk->i_rate, tk->i_scale, tk->i_samplesize );

        switch( p_strh->i_type )

        {

            case( AVIFOURCC_auds ):

            {

                es_format_Init( &tk->fmt, AUDIO_ES, 0 );

                if( p_auds->p_wf->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&

                    p_auds->p_wf->cbSize >= sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX) )

                {

                    WAVEFORMATEXTENSIBLE *p_wfe = container_of(p_auds->p_wf, WAVEFORMATEXTENSIBLE, Format);

                    tk->fmt.i_codec = AVI_FourccGetCodec( AUDIO_ES, p_wfe->SubFormat.Data1 );

                }

                else

                    tk->fmt.i_codec = AVI_FourccGetCodec( AUDIO_ES, p_auds->p_wf->wFormatTag );

                tk->i_blocksize = p_auds->p_wf->nBlockAlign;

                /* Fix blocksize == 0 and force interleaving PCM chunks samplesize == 0 */

                if( tk->i_samplesize == 0 || tk->i_blocksize == 0 )

                {

                    vlc_fourcc_t i_codec = vlc_fourcc_GetCodecAudio( tk->fmt.i_codec,

                                                                     p_auds->p_wf->wBitsPerSample );

                    unsigned bps = aout_BitsPerSample( i_codec );

                    if( bps > 0 ) /* PCM audio */

                    {

                        if( tk->i_blocksize == 0 )

                            tk->i_blocksize = bps * p_auds->p_wf->nChannels / 8;

                        if( tk->i_samplesize == 0 )

                            tk->i_samplesize = tk->i_blocksize;

                        tk->fmt.b_packetized = true;

                    }

                    else if( tk->i_blocksize == 0 )

                    {

                        tk->i_blocksize = 1;

                    }

                }

                else if( tk->i_samplesize != tk->i_blocksize )

                {

                    msg_Warn( p_demux, "track[%u] samplesize=%u and blocksize=%u are not equal."

                                       "Using blocksize as a workaround.",

                                       i, tk->i_samplesize, tk->i_blocksize );

                    tk->i_samplesize = tk->i_blocksize;

                }

                /* fix VBR decoding */

                if( tk->fmt.i_codec == VLC_CODEC_VORBIS ||

                    tk->fmt.i_codec == VLC_CODEC_FLAC )

                {

                    tk->i_blocksize = 0;

                }

                if ( tk->fmt.i_codec == VLC_CODEC_MP4A )

                {

                    tk->i_samplesize = 0; /* ADTS/AAC VBR */

                }

                /* Fix broken scale/rate */

                if ( tk->fmt.i_codec == VLC_CODEC_ADPCM_IMA_WAV &&

                     tk->i_samplesize && tk->i_samplesize > tk->i_rate )

                {

                    tk->i_scale = 1017;

                    tk->i_rate = p_auds->p_wf->nSamplesPerSec;

                }

                /* From libavformat */

                /* Fix broken sample size (which is mp2 num samples / frame) #12722 */

                if( tk->fmt.i_codec == VLC_CODEC_MPGA &&

                    tk->i_samplesize == 1152 && p_auds->p_wf->nBlockAlign == 1152 )

                {

                    p_auds->p_wf->nBlockAlign = tk->i_samplesize = 0;

                }

                tk->fmt.audio.i_channels        = p_auds->p_wf->nChannels;

                tk->fmt.audio.i_rate            = p_auds->p_wf->nSamplesPerSec;

                tk->fmt.i_bitrate               = p_auds->p_wf->nAvgBytesPerSec*8;

                tk->fmt.audio.i_blockalign      = p_auds->p_wf->nBlockAlign;

                tk->fmt.audio.i_bitspersample   = p_auds->p_wf->wBitsPerSample;

                tk->fmt.b_packetized            = !tk->i_blocksize;

                avi_chunk_list_t *p_info = AVI_ChunkFind( p_riff, AVIFOURCC_INFO, 0, true );

                if( p_info )

                {

                    int i_chunk = AVIFOURCC_IAS1 + ((i - 1) << 24);

                    avi_chunk_STRING_t *p_lang = AVI_ChunkFind( p_info, i_chunk, 0, false );

                    if( p_lang != NULL && p_lang->p_str != NULL )

                        tk->fmt.psz_language = FromACP( p_lang->p_str );

                }

                msg_Dbg( p_demux,

                    "stream[%u] audio(0x%x - %s) %d channels %dHz %dbits",

                    i, p_auds->p_wf->wFormatTag,

                    vlc_fourcc_GetDescription(AUDIO_ES, tk->fmt.i_codec),

                    p_auds->p_wf->nChannels,

                    p_auds->p_wf->nSamplesPerSec,

                    p_auds->p_wf->wBitsPerSample );

                const size_t i_cboff = sizeof(WAVEFORMATEX);

                const size_t i_incboff = ( p_auds->p_wf->wFormatTag == WAVE_FORMAT_EXTENSIBLE ) ?

                                          sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX): 0;

                if( p_auds->i_chunk_size >= i_cboff + p_auds->p_wf->cbSize &&

                    p_auds->p_wf->cbSize > i_incboff )

                {

                    int i_extra = p_auds->p_wf->cbSize - i_incboff;

                    tk->fmt.p_extra = malloc( i_extra );

                    if( unlikely(tk->fmt.p_extra == NULL) )

                    {

                        es_format_Clean( &tk->fmt );

                        free( tk );

                        goto error;

                    }

                    tk->fmt.i_extra = i_extra;

                    memcpy( tk->fmt.p_extra, ((uint8_t *)(&p_auds->p_wf[1])) + i_incboff, i_extra );

                }

                break;

            }

            case( AVIFOURCC_vids ):

            {

                if( p_vids->p_bih->biCompression == FOURCC_DXSB )

                {

                   msg_Dbg( p_demux, "stream[%u] subtitles", i );

                   es_format_Init( &tk->fmt, SPU_ES, p_vids->p_bih->biCompression );

                   tk->fmt.subs.spu.i_original_frame_width = p_vids->p_bih->biWidth;

                   tk->fmt.subs.spu.i_original_frame_height = p_vids->p_bih->biHeight;

                   break;

                }

                es_format_Init( &tk->fmt, VIDEO_ES, 0 );

                if( ParseBitmapInfoHeader( p_vids->p_bih, p_vids->i_chunk_size, &tk->fmt,

                                           &tk->bihprops ) != VLC_SUCCESS )

                {

                    es_format_Clean( &tk->fmt );

                    free( tk );

                    goto error;

                }

                if( tk->fmt.i_codec == VLC_CODEC_MP4V &&

                    !strncasecmp( (char*)&p_strh->i_handler, "XVID", 4 ) )

                {

                    tk->fmt.i_codec           =

                    tk->fmt.i_original_fourcc = FOURCC_XVID;

                    tk->fmt.b_packetized = false;

                }

                if( IsQNAPCodec( p_vids->p_bih->biCompression ) )

                {

                    tk->is_qnap = true;

                    tk->fmt.b_packetized = false;

                }

                if( tk->fmt.i_codec == VLC_CODEC_H264 && tk->fmt.i_extra )

                {

                    tk->fmt.i_original_fourcc = VLC_FOURCC('a','v','c','1');

                }

                /* Store original fourcc for SpeedHQ variants so decoder can distinguish between them */

                if( tk->fmt.i_codec == VLC_CODEC_SPEEDHQ && tk->fmt.i_original_fourcc == 0 )

                {

                    tk->fmt.i_original_fourcc = p_vids->p_bih->biCompression;

                }

                tk->i_samplesize = 0;

                tk->fmt.video.i_frame_rate = tk->i_rate;

                tk->fmt.video.i_frame_rate_base = tk->i_scale;

                avi_chunk_vprp_t *p_vprp = AVI_ChunkFind( p_strl, AVIFOURCC_vprp, 0, false );

                if( p_vprp )

                {

                    uint32_t i_frame_aspect_ratio = p_vprp->i_frame_aspect_ratio;

                    if( p_vprp->i_video_format_token >= 1 &&

                        p_vprp->i_video_format_token <= 4 )

                        i_frame_aspect_ratio = 0x00040003;

                    tk->fmt.video.i_sar_num = ((i_frame_aspect_ratio >> 16) & 0xffff) *

                                              tk->fmt.video.i_height;

                    tk->fmt.video.i_sar_den = ((i_frame_aspect_ratio >>  0) & 0xffff) *

                                              tk->fmt.video.i_width;

                }

                msg_Dbg( p_demux, "stream[%u] video(%4.4s) %"PRIu32"x%"PRIu32" %dbpp %ffps",

                         i, (char*)&p_vids->p_bih->biCompression,

                         p_vids->p_bih->biWidth,

                         (p_vids->p_bih->biHeight <= INT_MAX) ? p_vids->p_bih->biHeight

                                                              : -1 * p_vids->p_bih->biHeight,

                         p_vids->p_bih->biBitCount,

                         (float)tk->i_rate/(float)tk->i_scale );

                break;

            }

            case( AVIFOURCC_txts):

                msg_Dbg( p_demux, "stream[%u] subtitle attachment", i );

                AVI_ExtractSubtitle( p_demux, i, p_strl, p_strn );

                free( tk );

                continue;

            case( AVIFOURCC_iavs):

            case( AVIFOURCC_ivas):

                msg_Dbg( p_demux, "stream[%u] iavs with handler %4.4s", i, (char *)&p_strh->i_handler );

                es_format_Init( &tk->fmt, VIDEO_ES, AVI_FourccGetCodec( VIDEO_ES, p_strh->i_handler ) );

                tk->i_samplesize = 0;

                tk->i_dv_audio_rate = tk->fmt.i_codec == VLC_CODEC_DV ? -1 : 0;

                tk->fmt.video.i_visible_width =

                tk->fmt.video.i_width  = p_avih->i_width;

                tk->fmt.video.i_visible_height =

                tk->fmt.video.i_height = p_avih->i_height;

                break;

            case( AVIFOURCC_mids):

                msg_Dbg( p_demux, "stream[%u] midi is UNSUPPORTED", i );

                /* fall through */

            default:

                msg_Warn( p_demux, "stream[%u] unknown type %4.4s", i, (char *)&p_strh->i_type );

                free( tk );

                continue;

        }

        if( tk->fmt.i_cat != SPU_ES &&

           (!tk->i_scale || !tk->i_rate || !(tk->i_rate * CLOCK_FREQ / tk->i_scale)) )

        {

            msg_Warn( p_demux, "stream[%u] has invalid timescale", i );

            es_format_Clean(&tk->fmt);

            free( tk );

            continue;

        }

        tk->fmt.i_id = i;

        if( p_strn && p_strn->p_str )

            tk->fmt.psz_description = FromACP( p_strn->p_str );

        tk->p_es = es_out_Add( p_demux->out, &tk->fmt );

        TAB_APPEND( p_sys->i_track, p_sys->track, tk );

    }

    if( p_sys->i_track <= 0 )

    {

        msg_Err( p_demux, "no valid track" );

        goto error;

    }

    i_do_index = var_InheritInteger( p_demux, "avi-index" );

    if( i_do_index == 1 ) /* Always fix */

    {

aviindex:

        if( p_sys->b_fastseekable )

        {

            AVI_IndexCreate( p_demux );

        }

        else if( p_sys->b_seekable )

        {

            AVI_IndexLoad( p_demux );

        }

        else

        {

            msg_Warn( p_demux, "cannot create index (unseekable stream)" );

        }

    }

    else if( p_sys->b_seekable )

    {

        AVI_IndexLoad( p_demux );

    }

    /* *** movie length in vlc_tick_t *** */

    p_sys->i_length = AVI_MovieGetLength( p_demux );

    /* Check the index completeness */

    unsigned int i_idx_totalframes = 0;

    for( unsigned int i = 0; i < p_sys->i_track; i++ )

    {

        const avi_track_t *tk = p_sys->track[i];

        if( tk->fmt.i_cat == VIDEO_ES && tk->idx.p_entry )

            i_idx_totalframes = __MAX(i_idx_totalframes, tk->idx.i_size);

    }

    if( i_idx_totalframes != p_avih->i_totalframes &&

        p_sys->i_length < VLC_TICK_FROM_US( p_avih->i_totalframes *

                                            p_avih->i_microsecperframe ) )

    {

        msg_Warn( p_demux, "broken or missing index, 'seek' will be "

                           "approximative or will exhibit strange behavior" );

        if( (i_do_index == 0 || i_do_index == 3) && !b_index )

        {

            if( !p_sys->b_fastseekable ) {

                b_index = true;

                goto aviindex;

            }

            if( i_do_index == 0 )

            {

                const char *psz_msg = _(

                    "Because this file index is broken or missing, "

                    "seeking will not work correctly.\n"

                    "VLC won't repair your file but can temporary fix this "

                    "problem by building an index in memory.\n"

                    "This step might take a long time on a large file.\n"

                    "What do you want to do?");

                switch( vlc_dialog_wait_question( p_demux,

                                                  VLC_DIALOG_QUESTION_NORMAL,

                                                  _("Do not play"),

                                                  _("Build index then play"),

                                                  _("Play as is"),

                                                  _("Broken or missing Index"),

                                                  "%s", psz_msg ) )

                {

                    case 0:

                        b_aborted = true;

                        goto error;

                    case 1:

                        b_index = true;

                        msg_Dbg( p_demux, "Fixing AVI index" );

                        goto aviindex;

                }

            }

            else

            {

                b_index = true;

                msg_Dbg( p_demux, "Fixing AVI index" );

                goto aviindex;

            }

        }

    }

    /* fix some BeOS MediaKit generated file */

    for( unsigned i = 0 ; i < p_sys->i_track; i++ )

    {

        avi_track_t         *tk = p_sys->track[i];

        avi_chunk_list_t    *p_strl;

        avi_chunk_strf_auds_t    *p_auds;

        if( tk->fmt.i_cat != AUDIO_ES )

        {

            continue;

        }

        if( tk->idx.i_size < 1 ||

            tk->i_scale != 1 ||

            tk->i_samplesize != 0 )

        {

            continue;

        }

        p_strl = AVI_ChunkFind( p_hdrl, AVIFOURCC_strl, tk->fmt.i_id, true );

        p_auds = AVI_ChunkFind( p_strl, AVIFOURCC_strf, 0, false );

        if( p_auds &&

            p_auds->p_wf->wFormatTag != WAVE_FORMAT_PCM &&

            tk->i_rate == p_auds->p_wf->nSamplesPerSec )

        {

            int64_t i_track_length =

                tk->idx.p_entry[tk->idx.i_size-1].i_length +

                tk->idx.p_entry[tk->idx.i_size-1].i_lengthtotal;

            vlc_tick_t i_length = VLC_TICK_FROM_US( p_avih->i_totalframes *

                                                    p_avih->i_microsecperframe );

            if( i_length == 0 )

            {

                msg_Warn( p_demux, "track[%u] cannot be fixed (BeOS MediaKit generated)", i );

                continue;

            }

            tk->i_samplesize = 1;

            tk->i_rate       = i_track_length  * CLOCK_FREQ / i_length;

            msg_Warn( p_demux, "track[%u] fixed with rate=%u scale=%u (BeOS MediaKit generated)", i, tk->i_rate, tk->i_scale );

        }

    }

    if( p_sys->b_seekable )

    {

        /* we have read all chunk so go back to movi */

        if( vlc_stream_Seek( p_demux->s, p_movi->i_chunk_pos ) )

            goto error;

    }

    /* Skip movi header */

    if( vlc_stream_Read( p_demux->s, NULL, 12 ) != 12 )

        goto error;

    p_sys->i_movi_begin = p_movi->i_chunk_pos;

    return VLC_SUCCESS;

error:

    Close( p_this );

    return b_aborted ? VLC_ETIMEOUT : VLC_EGENERIC;

}

/*****************************************************************************

 * ReadFrame: Reads frame, using stride if necessary

 *****************************************************************************/

static block_t * ReadFrame( demux_t *p_demux, const avi_track_t *tk,

                            uint32_t i_header, uint32_t i_osize )

{

    /* skip header */

    if( i_header )

    {

        assert(i_header % 8 == 0);

        ssize_t i_skip = vlc_stream_Read( p_demux->s, NULL, i_header );

        if( i_skip < 0 || (size_t) i_skip < i_header )

            return NULL;

    }

    /* read size padded on word boundary */

    uint32_t i_size = __EVEN(i_osize);

    if( i_size == 0 )

        return block_Alloc(0); /* vlc_stream_Block can't read/alloc 0 sized */

    block_t *p_frame = vlc_stream_Block( p_demux->s, i_size );

    if ( !p_frame )

        return p_frame;

    if( i_osize == i_size - 1 )

        p_frame->i_buffer--;

    if( tk->fmt.i_codec == FOURCC_DXSB && p_frame->i_buffer > XSUB_HEADER_SIZE )

    {

        vlc_tick_t i_start, i_end;

        if( !ExtractXsubSampleInfo( p_frame->p_buffer, &i_start, &i_end ) )

        {

            p_frame->i_dts = p_frame->i_pts = VLC_TICK_0 + i_start;

            if( i_end > i_start )

                p_frame->i_length = i_start - i_end;

        }

    }

    if( tk->bihprops.i_stride > INT32_MAX - 3 )

    {

        p_frame->i_buffer = 0;

        return p_frame;

    }

    const unsigned int i_stride_bytes = (tk->bihprops.i_stride + 3) & ~3;

    if ( !tk->bihprops.i_stride || !i_stride_bytes )

        return p_frame;

    if( p_frame->i_buffer < i_stride_bytes )

    {

        p_frame->i_buffer = 0;