static int fourxm_read_header(AVFormatContext *s)

{

    AVIOContext *pb = s->pb;

    unsigned int fourcc_tag;

    unsigned int size;

    int header_size;

    FourxmDemuxContext *fourxm = s->priv_data;

    unsigned char *header;

    int i, ret;

    AVStream *st;



    fourxm->track_count = 0;

    fourxm->tracks = NULL;

    fourxm->fps = 1.0;



    /* skip the first 3 32-bit numbers */

    avio_skip(pb, 12);



    /* check for LIST-HEAD */

    GET_LIST_HEADER();

    header_size = size - 4;

    if (fourcc_tag != HEAD_TAG || header_size < 0)

        return AVERROR_INVALIDDATA;



    /* allocate space for the header and load the whole thing */

    header = av_malloc(header_size);

    if (!header)

        return AVERROR(ENOMEM);

    if (avio_read(pb, header, header_size) != header_size){

        av_free(header);

        return AVERROR(EIO);




    /* take the lazy approach and search for any and all vtrk and strk chunks */

    for (i = 0; i < header_size - 8; i++) {

        fourcc_tag = AV_RL32(&header[i]);

        size = AV_RL32(&header[i + 4]);

        if (size > header_size - i - 8 && (fourcc_tag == vtrk_TAG || fourcc_tag == strk_TAG)) {

            av_log(s, AV_LOG_ERROR, "chunk larger than array %d>%d\n", size, header_size - i - 8);

            return AVERROR_INVALIDDATA;




        if (fourcc_tag == std__TAG) {

            fourxm->fps = av_int2float(AV_RL32(&header[i + 12]));

        } else if (fourcc_tag == vtrk_TAG) {

            /* check that there is enough data */

            if (size != vtrk_SIZE) {

                ret= AVERROR_INVALIDDATA;



            fourxm->width  = AV_RL32(&header[i + 36]);

            fourxm->height = AV_RL32(&header[i + 40]);



            /* allocate a new AVStream */

            st = avformat_new_stream(s, NULL);

            if (!st){

                ret= AVERROR(ENOMEM);



            avpriv_set_pts_info(st, 60, 1, fourxm->fps);



            fourxm->video_stream_index = st->index;



            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

            st->codec->codec_id = CODEC_ID_4XM;

            st->codec->extradata_size = 4;

            st->codec->extradata = av_malloc(4);

            AV_WL32(st->codec->extradata, AV_RL32(&header[i + 16]));

            st->codec->width  = fourxm->width;

            st->codec->height = fourxm->height;



            i += 8 + size;

        } else if (fourcc_tag == strk_TAG) {

            int current_track;

            /* check that there is enough data */

            if (size != strk_SIZE) {

                ret= AVERROR_INVALIDDATA;



            current_track = AV_RL32(&header[i + 8]);

            if((unsigned)current_track >= UINT_MAX / sizeof(AudioTrack) - 1){

                av_log(s, AV_LOG_ERROR, "current_track too large\n");




            if (current_track + 1 > fourxm->track_count) {

                fourxm->tracks = av_realloc_f(fourxm->tracks,

                                              sizeof(AudioTrack),

                                              current_track + 1);

                if (!fourxm->tracks) {

                    ret = AVERROR(ENOMEM);



                memset(&fourxm->tracks[fourxm->track_count], 0,

                       sizeof(AudioTrack) * (current_track + 1 - fourxm->track_count));

                fourxm->track_count = current_track + 1;


            fourxm->tracks[current_track].adpcm       = AV_RL32(&header[i + 12]);

            fourxm->tracks[current_track].channels    = AV_RL32(&header[i + 36]);

            fourxm->tracks[current_track].sample_rate = AV_RL32(&header[i + 40]);

            fourxm->tracks[current_track].bits        = AV_RL32(&header[i + 44]);

            fourxm->tracks[current_track].audio_pts   = 0;

            if(   fourxm->tracks[current_track].channels    <= 0

               || fourxm->tracks[current_track].sample_rate <= 0

               || fourxm->tracks[current_track].bits        <  0){

                av_log(s, AV_LOG_ERROR, "audio header invalid\n");









            i += 8 + size;



            /* allocate a new AVStream */

            st = avformat_new_stream(s, NULL);

            if (!st){

                ret= AVERROR(ENOMEM);





            st->id = current_track;

            avpriv_set_pts_info(st, 60, 1, fourxm->tracks[current_track].sample_rate);



            fourxm->tracks[current_track].stream_index = st->index;



            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

            st->codec->codec_tag = 0;

            st->codec->channels              = fourxm->tracks[current_track].channels;

            st->codec->sample_rate           = fourxm->tracks[current_track].sample_rate;

            st->codec->bits_per_coded_sample = fourxm->tracks[current_track].bits;

            st->codec->bit_rate              = st->codec->channels * st->codec->sample_rate *

                st->codec->bits_per_coded_sample;

            st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample;

            if (fourxm->tracks[current_track].adpcm){

                st->codec->codec_id = CODEC_ID_ADPCM_4XM;

            }else if (st->codec->bits_per_coded_sample == 8){

                st->codec->codec_id = CODEC_ID_PCM_U8;

            }else

                st->codec->codec_id = CODEC_ID_PCM_S16LE;





    /* skip over the LIST-MOVI chunk (which is where the stream should be */

    GET_LIST_HEADER();

    if (fourcc_tag != MOVI_TAG){

        ret= AVERROR_INVALIDDATA;





    av_free(header);

    /* initialize context members */

    fourxm->video_pts = -1;  /* first frame will push to 0 */



    return 0;

fail:

    av_freep(&fourxm->tracks);

    av_free(header);

    return ret;

static int fourxm_read_header(AVFormatContext *s)

{

    AVIOContext *pb = s->pb;

    unsigned int fourcc_tag;

    unsigned int size;

    int header_size;

    FourxmDemuxContext *fourxm = s->priv_data;

    unsigned char *header;

    int i, ret;

    AVStream *st;



    fourxm->track_count = 0;

    fourxm->tracks = NULL;

    fourxm->fps = 1.0;



    

    avio_skip(pb, 12);



    

    GET_LIST_HEADER();

    header_size = size - 4;

    if (fourcc_tag != HEAD_TAG || header_size < 0)

        return AVERROR_INVALIDDATA;



    

    header = av_malloc(header_size);

    if (!header)

        return AVERROR(ENOMEM);

    if (avio_read(pb, header, header_size) != header_size){

        av_free(header);

        return AVERROR(EIO);




    

    for (i = 0; i < header_size - 8; i++) {

        fourcc_tag = AV_RL32(&header[i]);

        size = AV_RL32(&header[i + 4]);

        if (size > header_size - i - 8 && (fourcc_tag == vtrk_TAG || fourcc_tag == strk_TAG)) {

            av_log(s, AV_LOG_ERROR, "chunk larger than array %d>%d\n", size, header_size - i - 8);

            return AVERROR_INVALIDDATA;




        if (fourcc_tag == std__TAG) {

            fourxm->fps = av_int2float(AV_RL32(&header[i + 12]));

        } else if (fourcc_tag == vtrk_TAG) {

            

            if (size != vtrk_SIZE) {

                ret= AVERROR_INVALIDDATA;



            fourxm->width  = AV_RL32(&header[i + 36]);

            fourxm->height = AV_RL32(&header[i + 40]);



            

            st = avformat_new_stream(s, NULL);

            if (!st){

                ret= AVERROR(ENOMEM);



            avpriv_set_pts_info(st, 60, 1, fourxm->fps);



            fourxm->video_stream_index = st->index;



            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

            st->codec->codec_id = CODEC_ID_4XM;

            st->codec->extradata_size = 4;

            st->codec->extradata = av_malloc(4);

            AV_WL32(st->codec->extradata, AV_RL32(&header[i + 16]));

            st->codec->width  = fourxm->width;

            st->codec->height = fourxm->height;



            i += 8 + size;

        } else if (fourcc_tag == strk_TAG) {

            int current_track;

            

            if (size != strk_SIZE) {

                ret= AVERROR_INVALIDDATA;



            current_track = AV_RL32(&header[i + 8]);

            if((unsigned)current_track >= UINT_MAX / sizeof(AudioTrack) - 1){

                av_log(s, AV_LOG_ERROR, "current_track too large\n");




            if (current_track + 1 > fourxm->track_count) {

                fourxm->tracks = av_realloc_f(fourxm->tracks,

                                              sizeof(AudioTrack),

                                              current_track + 1);

                if (!fourxm->tracks) {

                    ret = AVERROR(ENOMEM);



                memset(&fourxm->tracks[fourxm->track_count], 0,

                       sizeof(AudioTrack) * (current_track + 1 - fourxm->track_count));

                fourxm->track_count = current_track + 1;


            fourxm->tracks[current_track].adpcm       = AV_RL32(&header[i + 12]);

            fourxm->tracks[current_track].channels    = AV_RL32(&header[i + 36]);

            fourxm->tracks[current_track].sample_rate = AV_RL32(&header[i + 40]);

            fourxm->tracks[current_track].bits        = AV_RL32(&header[i + 44]);

            fourxm->tracks[current_track].audio_pts   = 0;

            if(   fourxm->tracks[current_track].channels    <= 0

               || fourxm->tracks[current_track].sample_rate <= 0

               || fourxm->tracks[current_track].bits        <  0){

                av_log(s, AV_LOG_ERROR, "audio header invalid\n");









            i += 8 + size;



            

            st = avformat_new_stream(s, NULL);

            if (!st){

                ret= AVERROR(ENOMEM);





            st->id = current_track;

            avpriv_set_pts_info(st, 60, 1, fourxm->tracks[current_track].sample_rate);



            fourxm->tracks[current_track].stream_index = st->index;



            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

            st->codec->codec_tag = 0;

            st->codec->channels              = fourxm->tracks[current_track].channels;

            st->codec->sample_rate           = fourxm->tracks[current_track].sample_rate;

            st->codec->bits_per_coded_sample = fourxm->tracks[current_track].bits;

            st->codec->bit_rate              = st->codec->channels * st->codec->sample_rate *

                st->codec->bits_per_coded_sample;

            st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample;

            if (fourxm->tracks[current_track].adpcm){

                st->codec->codec_id = CODEC_ID_ADPCM_4XM;

            }else if (st->codec->bits_per_coded_sample == 8){

                st->codec->codec_id = CODEC_ID_PCM_U8;

            }else

                st->codec->codec_id = CODEC_ID_PCM_S16LE;





    

    GET_LIST_HEADER();

    if (fourcc_tag != MOVI_TAG){

        ret= AVERROR_INVALIDDATA;





    av_free(header);

    

    fourxm->video_pts = -1;  



    return 0;

fail:

    av_freep(&fourxm->tracks);

    av_free(header);

    return ret;

static int FUNC_0(AVFormatContext *VAR_0)

{

    AVIOContext *pb = VAR_0->pb;

    unsigned int VAR_1;

    unsigned int VAR_2;

    int VAR_3;

    FourxmDemuxContext *fourxm = VAR_0->priv_data;

    unsigned char *VAR_4;

    int VAR_5, VAR_6;

    AVStream *st;



    fourxm->track_count = 0;

    fourxm->tracks = NULL;

    fourxm->fps = 1.0;



    

    avio_skip(pb, 12);



    

    GET_LIST_HEADER();

    VAR_3 = VAR_2 - 4;

    if (VAR_1 != HEAD_TAG || VAR_3 < 0)

        return AVERROR_INVALIDDATA;



    

    VAR_4 = av_malloc(VAR_3);

    if (!VAR_4)

        return AVERROR(ENOMEM);

    if (avio_read(pb, VAR_4, VAR_3) != VAR_3){

        av_free(VAR_4);

        return AVERROR(EIO);




    

    for (VAR_5 = 0; VAR_5 < VAR_3 - 8; VAR_5++) {

        VAR_1 = AV_RL32(&VAR_4[VAR_5]);

        VAR_2 = AV_RL32(&VAR_4[VAR_5 + 4]);

        if (VAR_2 > VAR_3 - VAR_5 - 8 && (VAR_1 == vtrk_TAG || VAR_1 == strk_TAG)) {

            av_log(VAR_0, AV_LOG_ERROR, "chunk larger than array %d>%d\n", VAR_2, VAR_3 - VAR_5 - 8);

            return AVERROR_INVALIDDATA;




        if (VAR_1 == std__TAG) {

            fourxm->fps = av_int2float(AV_RL32(&VAR_4[VAR_5 + 12]));

        } else if (VAR_1 == vtrk_TAG) {

            

            if (VAR_2 != vtrk_SIZE) {

                VAR_6= AVERROR_INVALIDDATA;



            fourxm->width  = AV_RL32(&VAR_4[VAR_5 + 36]);

            fourxm->height = AV_RL32(&VAR_4[VAR_5 + 40]);



            

            st = avformat_new_stream(VAR_0, NULL);

            if (!st){

                VAR_6= AVERROR(ENOMEM);



            avpriv_set_pts_info(st, 60, 1, fourxm->fps);



            fourxm->video_stream_index = st->index;



            st->codec->codec_type = AVMEDIA_TYPE_VIDEO;

            st->codec->codec_id = CODEC_ID_4XM;

            st->codec->extradata_size = 4;

            st->codec->extradata = av_malloc(4);

            AV_WL32(st->codec->extradata, AV_RL32(&VAR_4[VAR_5 + 16]));

            st->codec->width  = fourxm->width;

            st->codec->height = fourxm->height;



            VAR_5 += 8 + VAR_2;

        } else if (VAR_1 == strk_TAG) {

            int VAR_7;

            

            if (VAR_2 != strk_SIZE) {

                VAR_6= AVERROR_INVALIDDATA;



            VAR_7 = AV_RL32(&VAR_4[VAR_5 + 8]);

            if((unsigned)VAR_7 >= UINT_MAX / sizeof(AudioTrack) - 1){

                av_log(VAR_0, AV_LOG_ERROR, "VAR_7 too large\n");




            if (VAR_7 + 1 > fourxm->track_count) {

                fourxm->tracks = av_realloc_f(fourxm->tracks,

                                              sizeof(AudioTrack),

                                              VAR_7 + 1);

                if (!fourxm->tracks) {

                    VAR_6 = AVERROR(ENOMEM);



                memset(&fourxm->tracks[fourxm->track_count], 0,

                       sizeof(AudioTrack) * (VAR_7 + 1 - fourxm->track_count));

                fourxm->track_count = VAR_7 + 1;


            fourxm->tracks[VAR_7].adpcm       = AV_RL32(&VAR_4[VAR_5 + 12]);

            fourxm->tracks[VAR_7].channels    = AV_RL32(&VAR_4[VAR_5 + 36]);

            fourxm->tracks[VAR_7].sample_rate = AV_RL32(&VAR_4[VAR_5 + 40]);

            fourxm->tracks[VAR_7].bits        = AV_RL32(&VAR_4[VAR_5 + 44]);

            fourxm->tracks[VAR_7].audio_pts   = 0;

            if(   fourxm->tracks[VAR_7].channels    <= 0

               || fourxm->tracks[VAR_7].sample_rate <= 0

               || fourxm->tracks[VAR_7].bits        <  0){

                av_log(VAR_0, AV_LOG_ERROR, "audio VAR_4 invalid\n");









            VAR_5 += 8 + VAR_2;



            

            st = avformat_new_stream(VAR_0, NULL);

            if (!st){

                VAR_6= AVERROR(ENOMEM);





            st->id = VAR_7;

            avpriv_set_pts_info(st, 60, 1, fourxm->tracks[VAR_7].sample_rate);



            fourxm->tracks[VAR_7].stream_index = st->index;



            st->codec->codec_type = AVMEDIA_TYPE_AUDIO;

            st->codec->codec_tag = 0;

            st->codec->channels              = fourxm->tracks[VAR_7].channels;

            st->codec->sample_rate           = fourxm->tracks[VAR_7].sample_rate;

            st->codec->bits_per_coded_sample = fourxm->tracks[VAR_7].bits;

            st->codec->bit_rate              = st->codec->channels * st->codec->sample_rate *

                st->codec->bits_per_coded_sample;

            st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample;

            if (fourxm->tracks[VAR_7].adpcm){

                st->codec->codec_id = CODEC_ID_ADPCM_4XM;

            }else if (st->codec->bits_per_coded_sample == 8){

                st->codec->codec_id = CODEC_ID_PCM_U8;

            }else

                st->codec->codec_id = CODEC_ID_PCM_S16LE;





    

    GET_LIST_HEADER();

    if (VAR_1 != MOVI_TAG){

        VAR_6= AVERROR_INVALIDDATA;





    av_free(VAR_4);

    

    fourxm->video_pts = -1;  



    return 0;

fail:

    av_freep(&fourxm->tracks);

    av_free(VAR_4);

    return VAR_6;

static int FUNC_0(AVFormatContext *VAR_0)
{ AVIOContext *pb = VAR_0->pb; unsigned int VAR_1; unsigned int VAR_2; int VAR_3; FourxmDemuxContext *fourxm = VAR_0->priv_data; unsigned char *VAR_4; int VAR_5, VAR_6; AVStream *st; fourxm->track_count = 0; fourxm->tracks = NULL; fourxm->fps = 1.0; avio_skip(pb, 12); GET_LIST_HEADER(); VAR_3 = VAR_2 - 4; if (VAR_1 != HEAD_TAG || VAR_3 < 0)
return AVERROR_INVALIDDATA; VAR_4 = av_malloc(VAR_3); if (!VAR_4)
return AVERROR(ENOMEM); if (avio_read(pb, VAR_4, VAR_3) != VAR_3){ av_free(VAR_4); return AVERROR(EIO); for (VAR_5 = 0; VAR_5 < VAR_3 - 8; VAR_5++) { VAR_1 = AV_RL32(&VAR_4[VAR_5]); VAR_2 = AV_RL32(&VAR_4[VAR_5 + 4]); if (VAR_2 > VAR_3 - VAR_5 - 8 && (VAR_1 == vtrk_TAG || VAR_1 == strk_TAG)) { av_log(VAR_0, AV_LOG_ERROR, "chunk larger than array %d>%d\n", VAR_2, VAR_3 - VAR_5 - 8); return AVERROR_INVALIDDATA; if (VAR_1 == std__TAG) { fourxm->fps = av_int2float(AV_RL32(&VAR_4[VAR_5 + 12])); } else if (VAR_1 == vtrk_TAG) { if (VAR_2 != vtrk_SIZE) { VAR_6= AVERROR_INVALIDDATA; fourxm->width  = AV_RL32(&VAR_4[VAR_5 + 36]); fourxm->height = AV_RL32(&VAR_4[VAR_5 + 40]); st = avformat_new_stream(VAR_0, NULL); if (!st){ VAR_6= AVERROR(ENOMEM); avpriv_set_pts_info(st, 60, 1, fourxm->fps); fourxm->video_stream_index = st->index; st->codec->codec_type = AVMEDIA_TYPE_VIDEO; st->codec->codec_id = CODEC_ID_4XM; st->codec->extradata_size = 4; st->codec->extradata = av_malloc(4); AV_WL32(st->codec->extradata, AV_RL32(&VAR_4[VAR_5 + 16])); st->codec->width  = fourxm->width; st->codec->height = fourxm->height; VAR_5 += 8 + VAR_2; } else if (VAR_1 == strk_TAG) { int VAR_7; if (VAR_2 != strk_SIZE) { VAR_6= AVERROR_INVALIDDATA; VAR_7 = AV_RL32(&VAR_4[VAR_5 + 8]); if((unsigned)VAR_7 >= UINT_MAX / sizeof(AudioTrack) - 1){ av_log(VAR_0, AV_LOG_ERROR, "VAR_7 too large\n"); if (VAR_7 + 1 > fourxm->track_count) { fourxm->tracks = av_realloc_f(fourxm->tracks,
sizeof(AudioTrack),
VAR_7 + 1); if (!fourxm->tracks) { VAR_6 = AVERROR(ENOMEM); memset(&fourxm->tracks[fourxm->track_count], 0,
sizeof(AudioTrack) * (VAR_7 + 1 - fourxm->track_count)); fourxm->track_count = VAR_7 + 1; fourxm->tracks[VAR_7].adpcm       = AV_RL32(&VAR_4[VAR_5 + 12]); fourxm->tracks[VAR_7].channels    = AV_RL32(&VAR_4[VAR_5 + 36]); fourxm->tracks[VAR_7].sample_rate = AV_RL32(&VAR_4[VAR_5 + 40]); fourxm->tracks[VAR_7].bits        = AV_RL32(&VAR_4[VAR_5 + 44]); fourxm->tracks[VAR_7].audio_pts   = 0; if(   fourxm->tracks[VAR_7].channels    <= 0
|| fourxm->tracks[VAR_7].sample_rate <= 0
|| fourxm->tracks[VAR_7].bits        <  0){ av_log(VAR_0, AV_LOG_ERROR, "audio VAR_4 invalid\n"); VAR_5 += 8 + VAR_2; st = avformat_new_stream(VAR_0, NULL); if (!st){ VAR_6= AVERROR(ENOMEM); st->id = VAR_7; avpriv_set_pts_info(st, 60, 1, fourxm->tracks[VAR_7].sample_rate); fourxm->tracks[VAR_7].stream_index = st->index; st->codec->codec_type = AVMEDIA_TYPE_AUDIO; st->codec->codec_tag = 0; st->codec->channels              = fourxm->tracks[VAR_7].channels; st->codec->sample_rate           = fourxm->tracks[VAR_7].sample_rate; st->codec->bits_per_coded_sample = fourxm->tracks[VAR_7].bits; st->codec->bit_rate              = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_coded_sample; st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample; if (fourxm->tracks[VAR_7].adpcm){ st->codec->codec_id = CODEC_ID_ADPCM_4XM; }else if (st->codec->bits_per_coded_sample == 8){ st->codec->codec_id = CODEC_ID_PCM_U8; }else st->codec->codec_id = CODEC_ID_PCM_S16LE; GET_LIST_HEADER(); if (VAR_1 != MOVI_TAG){ VAR_6= AVERROR_INVALIDDATA; av_free(VAR_4); fourxm->video_pts = -1; return 0; fail:
av_freep(&fourxm->tracks); av_free(VAR_4); return VAR_6;