static void vqa_decode_chunk(VqaContext *s)

{

    unsigned int chunk_type;

    unsigned int chunk_size;

    int byte_skip;

    unsigned int index = 0;

    int i;

    unsigned char r, g, b;

    int index_shift;



    int cbf0_chunk = -1;

    int cbfz_chunk = -1;

    int cbp0_chunk = -1;

    int cbpz_chunk = -1;

    int cpl0_chunk = -1;

    int cplz_chunk = -1;

    int vptz_chunk = -1;



    int x, y;

    int lines = 0;

    int pixel_ptr;

    int vector_index = 0;

    int lobyte = 0;

    int hibyte = 0;

    int lobytes = 0;

    int hibytes = s->decode_buffer_size / 2;



    /* first, traverse through the frame and find the subchunks */

    while (index < s->size) {



        chunk_type = AV_RB32(&s->buf[index]);

        chunk_size = AV_RB32(&s->buf[index + 4]);



        switch (chunk_type) {



        case CBF0_TAG:

            cbf0_chunk = index;

            break;



        case CBFZ_TAG:

            cbfz_chunk = index;

            break;



        case CBP0_TAG:

            cbp0_chunk = index;

            break;



        case CBPZ_TAG:

            cbpz_chunk = index;

            break;



        case CPL0_TAG:

            cpl0_chunk = index;

            break;



        case CPLZ_TAG:

            cplz_chunk = index;

            break;



        case VPTZ_TAG:

            vptz_chunk = index;

            break;



        default:

            av_log(s->avctx, AV_LOG_ERROR, "  VQA video: Found unknown chunk type: %c%c%c%c (%08X)\n",

            (chunk_type >> 24) & 0xFF,

            (chunk_type >> 16) & 0xFF,

            (chunk_type >>  8) & 0xFF,

            (chunk_type >>  0) & 0xFF,

            chunk_type);

            break;

        }



        byte_skip = chunk_size & 0x01;

        index += (CHUNK_PREAMBLE_SIZE + chunk_size + byte_skip);

    }



    /* next, deal with the palette */

    if ((cpl0_chunk != -1) && (cplz_chunk != -1)) {



        /* a chunk should not have both chunk types */

        av_log(s->avctx, AV_LOG_ERROR, "  VQA video: problem: found both CPL0 and CPLZ chunks\n");

        return;

    }



    /* decompress the palette chunk */

    if (cplz_chunk != -1) {



/* yet to be handled */



    }



    /* convert the RGB palette into the machine's endian format */

    if (cpl0_chunk != -1) {



        chunk_size = AV_RB32(&s->buf[cpl0_chunk + 4]);

        /* sanity check the palette size */

        if (chunk_size / 3 > 256) {

            av_log(s->avctx, AV_LOG_ERROR, "  VQA video: problem: found a palette chunk with %d colors\n",

                chunk_size / 3);

            return;

        }

        cpl0_chunk += CHUNK_PREAMBLE_SIZE;

        for (i = 0; i < chunk_size / 3; i++) {

            /* scale by 4 to transform 6-bit palette -> 8-bit */

            r = s->buf[cpl0_chunk++] * 4;

            g = s->buf[cpl0_chunk++] * 4;

            b = s->buf[cpl0_chunk++] * 4;

            s->palette[i] = (r << 16) | (g << 8) | (b);

        }

    }



    /* next, look for a full codebook */

    if ((cbf0_chunk != -1) && (cbfz_chunk != -1)) {



        /* a chunk should not have both chunk types */

        av_log(s->avctx, AV_LOG_ERROR, "  VQA video: problem: found both CBF0 and CBFZ chunks\n");

        return;

    }



    /* decompress the full codebook chunk */

    if (cbfz_chunk != -1) {



        chunk_size = AV_RB32(&s->buf[cbfz_chunk + 4]);

        cbfz_chunk += CHUNK_PREAMBLE_SIZE;

        decode_format80(&s->buf[cbfz_chunk], chunk_size,

            s->codebook, s->codebook_size, 0);

    }



    /* copy a full codebook */

    if (cbf0_chunk != -1) {



        chunk_size = AV_RB32(&s->buf[cbf0_chunk + 4]);

        /* sanity check the full codebook size */

        if (chunk_size > MAX_CODEBOOK_SIZE) {

            av_log(s->avctx, AV_LOG_ERROR, "  VQA video: problem: CBF0 chunk too large (0x%X bytes)\n",

                chunk_size);

            return;

        }

        cbf0_chunk += CHUNK_PREAMBLE_SIZE;



        memcpy(s->codebook, &s->buf[cbf0_chunk], chunk_size);

    }



    /* decode the frame */

    if (vptz_chunk == -1) {



        /* something is wrong if there is no VPTZ chunk */

        av_log(s->avctx, AV_LOG_ERROR, "  VQA video: problem: no VPTZ chunk found\n");

        return;

    }



    chunk_size = AV_RB32(&s->buf[vptz_chunk + 4]);

    vptz_chunk += CHUNK_PREAMBLE_SIZE;

    decode_format80(&s->buf[vptz_chunk], chunk_size,

        s->decode_buffer, s->decode_buffer_size, 1);



    /* render the final PAL8 frame */

    if (s->vector_height == 4)

        index_shift = 4;

    else

        index_shift = 3;

    for (y = 0; y < s->frame.linesize[0] * s->height;

        y += s->frame.linesize[0] * s->vector_height) {



        for (x = y; x < y + s->width; x += 4, lobytes++, hibytes++) {

            pixel_ptr = x;



            /* get the vector index, the method for which varies according to

             * VQA file version */

            switch (s->vqa_version) {



            case 1:

                lobyte = s->decode_buffer[lobytes * 2];

                hibyte = s->decode_buffer[(lobytes * 2) + 1];

                vector_index = ((hibyte << 8) | lobyte) >> 3;

                vector_index <<= index_shift;

                lines = s->vector_height;

                /* uniform color fill - a quick hack */

                if (hibyte == 0xFF) {

                    while (lines--) {

                        s->frame.data[0][pixel_ptr + 0] = 255 - lobyte;

                        s->frame.data[0][pixel_ptr + 1] = 255 - lobyte;

                        s->frame.data[0][pixel_ptr + 2] = 255 - lobyte;

                        s->frame.data[0][pixel_ptr + 3] = 255 - lobyte;

                        pixel_ptr += s->frame.linesize[0];

                    }

                    lines=0;

                }

                break;



            case 2:

                lobyte = s->decode_buffer[lobytes];

                hibyte = s->decode_buffer[hibytes];

                vector_index = (hibyte << 8) | lobyte;

                vector_index <<= index_shift;

                lines = s->vector_height;

                break;



            case 3:

/* not implemented yet */

                lines = 0;

                break;

            }



            while (lines--) {

                s->frame.data[0][pixel_ptr + 0] = s->codebook[vector_index++];

                s->frame.data[0][pixel_ptr + 1] = s->codebook[vector_index++];

                s->frame.data[0][pixel_ptr + 2] = s->codebook[vector_index++];

                s->frame.data[0][pixel_ptr + 3] = s->codebook[vector_index++];

                pixel_ptr += s->frame.linesize[0];

            }

        }

    }



    /* handle partial codebook */

    if ((cbp0_chunk != -1) && (cbpz_chunk != -1)) {

        /* a chunk should not have both chunk types */

        av_log(s->avctx, AV_LOG_ERROR, "  VQA video: problem: found both CBP0 and CBPZ chunks\n");

        return;

    }



    if (cbp0_chunk != -1) {



        chunk_size = AV_RB32(&s->buf[cbp0_chunk + 4]);

        cbp0_chunk += CHUNK_PREAMBLE_SIZE;



        /* accumulate partial codebook */

        memcpy(&s->next_codebook_buffer[s->next_codebook_buffer_index],

            &s->buf[cbp0_chunk], chunk_size);

        s->next_codebook_buffer_index += chunk_size;



        s->partial_countdown--;

        if (s->partial_countdown == 0) {



            /* time to replace codebook */

            memcpy(s->codebook, s->next_codebook_buffer,

                s->next_codebook_buffer_index);



            /* reset accounting */

            s->next_codebook_buffer_index = 0;

            s->partial_countdown = s->partial_count;

        }

    }



    if (cbpz_chunk != -1) {



        chunk_size = AV_RB32(&s->buf[cbpz_chunk + 4]);

        cbpz_chunk += CHUNK_PREAMBLE_SIZE;



        /* accumulate partial codebook */

        memcpy(&s->next_codebook_buffer[s->next_codebook_buffer_index],

            &s->buf[cbpz_chunk], chunk_size);

        s->next_codebook_buffer_index += chunk_size;



        s->partial_countdown--;

        if (s->partial_countdown == 0) {



            /* decompress codebook */

            decode_format80(s->next_codebook_buffer,

                s->next_codebook_buffer_index,

                s->codebook, s->codebook_size, 0);



            /* reset accounting */

            s->next_codebook_buffer_index = 0;

            s->partial_countdown = s->partial_count;

        }

    }

}

static void vqa_decode_chunk(VqaContext *s)

{

    unsigned int chunk_type;

    unsigned int chunk_size;

    int byte_skip;

    unsigned int index = 0;

    int i;

    unsigned char r, g, b;

    int index_shift;



    int cbf0_chunk = -1;

    int cbfz_chunk = -1;

    int cbp0_chunk = -1;

    int cbpz_chunk = -1;

    int cpl0_chunk = -1;

    int cplz_chunk = -1;

    int vptz_chunk = -1;



    int x, y;

    int lines = 0;

    int pixel_ptr;

    int vector_index = 0;

    int lobyte = 0;

    int hibyte = 0;

    int lobytes = 0;

    int hibytes = s->decode_buffer_size / 2;



    

    while (index < s->size) {



        chunk_type = AV_RB32(&s->buf[index]);

        chunk_size = AV_RB32(&s->buf[index + 4]);



        switch (chunk_type) {



        case CBF0_TAG:

            cbf0_chunk = index;

            break;



        case CBFZ_TAG:

            cbfz_chunk = index;

            break;



        case CBP0_TAG:

            cbp0_chunk = index;

            break;



        case CBPZ_TAG:

            cbpz_chunk = index;

            break;



        case CPL0_TAG:

            cpl0_chunk = index;

            break;



        case CPLZ_TAG:

            cplz_chunk = index;

            break;



        case VPTZ_TAG:

            vptz_chunk = index;

            break;



        default:

            av_log(s->avctx, AV_LOG_ERROR, "  VQA video: Found unknown chunk type: %c%c%c%c (%08X)\n",

            (chunk_type >> 24) & 0xFF,

            (chunk_type >> 16) & 0xFF,

            (chunk_type >>  8) & 0xFF,

            (chunk_type >>  0) & 0xFF,

            chunk_type);

            break;

        }



        byte_skip = chunk_size & 0x01;

        index += (CHUNK_PREAMBLE_SIZE + chunk_size + byte_skip);

    }



    

    if ((cpl0_chunk != -1) && (cplz_chunk != -1)) {



        

        av_log(s->avctx, AV_LOG_ERROR, "  VQA video: problem: found both CPL0 and CPLZ chunks\n");

        return;

    }



    

    if (cplz_chunk != -1) {







    }



    

    if (cpl0_chunk != -1) {



        chunk_size = AV_RB32(&s->buf[cpl0_chunk + 4]);

        

        if (chunk_size / 3 > 256) {

            av_log(s->avctx, AV_LOG_ERROR, "  VQA video: problem: found a palette chunk with %d colors\n",

                chunk_size / 3);

            return;

        }

        cpl0_chunk += CHUNK_PREAMBLE_SIZE;

        for (i = 0; i < chunk_size / 3; i++) {

            

            r = s->buf[cpl0_chunk++] * 4;

            g = s->buf[cpl0_chunk++] * 4;

            b = s->buf[cpl0_chunk++] * 4;

            s->palette[i] = (r << 16) | (g << 8) | (b);

        }

    }



    

    if ((cbf0_chunk != -1) && (cbfz_chunk != -1)) {



        

        av_log(s->avctx, AV_LOG_ERROR, "  VQA video: problem: found both CBF0 and CBFZ chunks\n");

        return;

    }



    

    if (cbfz_chunk != -1) {



        chunk_size = AV_RB32(&s->buf[cbfz_chunk + 4]);

        cbfz_chunk += CHUNK_PREAMBLE_SIZE;

        decode_format80(&s->buf[cbfz_chunk], chunk_size,

            s->codebook, s->codebook_size, 0);

    }



    

    if (cbf0_chunk != -1) {



        chunk_size = AV_RB32(&s->buf[cbf0_chunk + 4]);

        

        if (chunk_size > MAX_CODEBOOK_SIZE) {

            av_log(s->avctx, AV_LOG_ERROR, "  VQA video: problem: CBF0 chunk too large (0x%X bytes)\n",

                chunk_size);

            return;

        }

        cbf0_chunk += CHUNK_PREAMBLE_SIZE;



        memcpy(s->codebook, &s->buf[cbf0_chunk], chunk_size);

    }



    

    if (vptz_chunk == -1) {



        

        av_log(s->avctx, AV_LOG_ERROR, "  VQA video: problem: no VPTZ chunk found\n");

        return;

    }



    chunk_size = AV_RB32(&s->buf[vptz_chunk + 4]);

    vptz_chunk += CHUNK_PREAMBLE_SIZE;

    decode_format80(&s->buf[vptz_chunk], chunk_size,

        s->decode_buffer, s->decode_buffer_size, 1);



    

    if (s->vector_height == 4)

        index_shift = 4;

    else

        index_shift = 3;

    for (y = 0; y < s->frame.linesize[0] * s->height;

        y += s->frame.linesize[0] * s->vector_height) {



        for (x = y; x < y + s->width; x += 4, lobytes++, hibytes++) {

            pixel_ptr = x;



            



            switch (s->vqa_version) {



            case 1:

                lobyte = s->decode_buffer[lobytes * 2];

                hibyte = s->decode_buffer[(lobytes * 2) + 1];

                vector_index = ((hibyte << 8) | lobyte) >> 3;

                vector_index <<= index_shift;

                lines = s->vector_height;

                

                if (hibyte == 0xFF) {

                    while (lines--) {

                        s->frame.data[0][pixel_ptr + 0] = 255 - lobyte;

                        s->frame.data[0][pixel_ptr + 1] = 255 - lobyte;

                        s->frame.data[0][pixel_ptr + 2] = 255 - lobyte;

                        s->frame.data[0][pixel_ptr + 3] = 255 - lobyte;

                        pixel_ptr += s->frame.linesize[0];

                    }

                    lines=0;

                }

                break;



            case 2:

                lobyte = s->decode_buffer[lobytes];

                hibyte = s->decode_buffer[hibytes];

                vector_index = (hibyte << 8) | lobyte;

                vector_index <<= index_shift;

                lines = s->vector_height;

                break;



            case 3:



                lines = 0;

                break;

            }



            while (lines--) {

                s->frame.data[0][pixel_ptr + 0] = s->codebook[vector_index++];

                s->frame.data[0][pixel_ptr + 1] = s->codebook[vector_index++];

                s->frame.data[0][pixel_ptr + 2] = s->codebook[vector_index++];

                s->frame.data[0][pixel_ptr + 3] = s->codebook[vector_index++];

                pixel_ptr += s->frame.linesize[0];

            }

        }

    }



    

    if ((cbp0_chunk != -1) && (cbpz_chunk != -1)) {

        

        av_log(s->avctx, AV_LOG_ERROR, "  VQA video: problem: found both CBP0 and CBPZ chunks\n");

        return;

    }



    if (cbp0_chunk != -1) {



        chunk_size = AV_RB32(&s->buf[cbp0_chunk + 4]);

        cbp0_chunk += CHUNK_PREAMBLE_SIZE;



        

        memcpy(&s->next_codebook_buffer[s->next_codebook_buffer_index],

            &s->buf[cbp0_chunk], chunk_size);

        s->next_codebook_buffer_index += chunk_size;



        s->partial_countdown--;

        if (s->partial_countdown == 0) {



            

            memcpy(s->codebook, s->next_codebook_buffer,

                s->next_codebook_buffer_index);



            

            s->next_codebook_buffer_index = 0;

            s->partial_countdown = s->partial_count;

        }

    }



    if (cbpz_chunk != -1) {



        chunk_size = AV_RB32(&s->buf[cbpz_chunk + 4]);

        cbpz_chunk += CHUNK_PREAMBLE_SIZE;



        

        memcpy(&s->next_codebook_buffer[s->next_codebook_buffer_index],

            &s->buf[cbpz_chunk], chunk_size);

        s->next_codebook_buffer_index += chunk_size;



        s->partial_countdown--;

        if (s->partial_countdown == 0) {



            

            decode_format80(s->next_codebook_buffer,

                s->next_codebook_buffer_index,

                s->codebook, s->codebook_size, 0);



            

            s->next_codebook_buffer_index = 0;

            s->partial_countdown = s->partial_count;

        }

    }

}

static void vqa_decode_chunk(VqaContext *s)     while (index < s->size) {         chunk_type = AV_RB32(&s->buf[index]);         chunk_size = AV_RB32(&s->buf[index + 4]);         index += (CHUNK_PREAMBLE_SIZE + chunk_size + byte_skip);         chunk_size = AV_RB32(&s->buf[cpl0_chunk + 4]);         cpl0_chunk += CHUNK_PREAMBLE_SIZE;             r = s->buf[cpl0_chunk++] * 4;             g = s->buf[cpl0_chunk++] * 4;             b = s->buf[cpl0_chunk++] * 4;         chunk_size = AV_RB32(&s->buf[cbfz_chunk + 4]);         cbfz_chunk += CHUNK_PREAMBLE_SIZE;         decode_format80(&s->buf[cbfz_chunk], chunk_size,             s->codebook, s->codebook_size, 0);         chunk_size = AV_RB32(&s->buf[cbf0_chunk + 4]);         cbf0_chunk += CHUNK_PREAMBLE_SIZE;         memcpy(s->codebook, &s->buf[cbf0_chunk], chunk_size);     chunk_size = AV_RB32(&s->buf[vptz_chunk + 4]);     vptz_chunk += CHUNK_PREAMBLE_SIZE;     decode_format80(&s->buf[vptz_chunk], chunk_size,         s->decode_buffer, s->decode_buffer_size, 1);         chunk_size = AV_RB32(&s->buf[cbp0_chunk + 4]);         cbp0_chunk += CHUNK_PREAMBLE_SIZE;         memcpy(&s->next_codebook_buffer[s->next_codebook_buffer_index],             &s->buf[cbp0_chunk], chunk_size);         chunk_size = AV_RB32(&s->buf[cbpz_chunk + 4]);         cbpz_chunk += CHUNK_PREAMBLE_SIZE;         memcpy(&s->next_codebook_buffer[s->next_codebook_buffer_index],             &s->buf[cbpz_chunk], chunk_size);             decode_format80(s->next_codebook_buffer,                 s->next_codebook_buffer_index,                 s->codebook, s->codebook_size, 0);
static void FUNC_0(VqaContext *VAR_0)

{

    unsigned int VAR_1;

    unsigned int VAR_2;

    int VAR_3;

    unsigned int VAR_4 = 0;

    int VAR_5;

    unsigned char VAR_6, VAR_7, VAR_8;

    int VAR_9;



    int VAR_10 = -1;

    int VAR_11 = -1;

    int VAR_12 = -1;

    int VAR_13 = -1;

    int VAR_14 = -1;

    int VAR_15 = -1;

    int VAR_16 = -1;



    int VAR_17, VAR_18;

    int VAR_19 = 0;

    int VAR_20;

    int VAR_21 = 0;

    int VAR_22 = 0;

    int VAR_23 = 0;

    int VAR_24 = 0;

    int VAR_25 = VAR_0->decode_buffer_size / 2;



    

    while (VAR_4 < VAR_0->size) {



        VAR_1 = AV_RB32(&VAR_0->buf[VAR_4]);

        VAR_2 = AV_RB32(&VAR_0->buf[VAR_4 + 4]);



        switch (VAR_1) {



        case CBF0_TAG:

            VAR_10 = VAR_4;

            break;



        case CBFZ_TAG:

            VAR_11 = VAR_4;

            break;



        case CBP0_TAG:

            VAR_12 = VAR_4;

            break;



        case CBPZ_TAG:

            VAR_13 = VAR_4;

            break;



        case CPL0_TAG:

            VAR_14 = VAR_4;

            break;



        case CPLZ_TAG:

            VAR_15 = VAR_4;

            break;



        case VPTZ_TAG:

            VAR_16 = VAR_4;

            break;



        default:

            av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: Found unknown chunk type: %c%c%c%c (%08X)\n",

            (VAR_1 >> 24) & 0xFF,

            (VAR_1 >> 16) & 0xFF,

            (VAR_1 >>  8) & 0xFF,

            (VAR_1 >>  0) & 0xFF,

            VAR_1);

            break;

        }



        VAR_3 = VAR_2 & 0x01;

        VAR_4 += (CHUNK_PREAMBLE_SIZE + VAR_2 + VAR_3);

    }



    

    if ((VAR_14 != -1) && (VAR_15 != -1)) {



        

        av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: problem: found both CPL0 and CPLZ chunks\n");

        return;

    }



    

    if (VAR_15 != -1) {







    }



    

    if (VAR_14 != -1) {



        VAR_2 = AV_RB32(&VAR_0->buf[VAR_14 + 4]);

        

        if (VAR_2 / 3 > 256) {

            av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: problem: found a palette chunk with %d colors\n",

                VAR_2 / 3);

            return;

        }

        VAR_14 += CHUNK_PREAMBLE_SIZE;

        for (VAR_5 = 0; VAR_5 < VAR_2 / 3; VAR_5++) {

            

            VAR_6 = VAR_0->buf[VAR_14++] * 4;

            VAR_7 = VAR_0->buf[VAR_14++] * 4;

            VAR_8 = VAR_0->buf[VAR_14++] * 4;

            VAR_0->palette[VAR_5] = (VAR_6 << 16) | (VAR_7 << 8) | (VAR_8);

        }

    }



    

    if ((VAR_10 != -1) && (VAR_11 != -1)) {



        

        av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: problem: found both CBF0 and CBFZ chunks\n");

        return;

    }



    

    if (VAR_11 != -1) {



        VAR_2 = AV_RB32(&VAR_0->buf[VAR_11 + 4]);

        VAR_11 += CHUNK_PREAMBLE_SIZE;

        decode_format80(&VAR_0->buf[VAR_11], VAR_2,

            VAR_0->codebook, VAR_0->codebook_size, 0);

    }



    

    if (VAR_10 != -1) {



        VAR_2 = AV_RB32(&VAR_0->buf[VAR_10 + 4]);

        

        if (VAR_2 > MAX_CODEBOOK_SIZE) {

            av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: problem: CBF0 chunk too large (0x%X bytes)\n",

                VAR_2);

            return;

        }

        VAR_10 += CHUNK_PREAMBLE_SIZE;



        memcpy(VAR_0->codebook, &VAR_0->buf[VAR_10], VAR_2);

    }



    

    if (VAR_16 == -1) {



        

        av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: problem: no VPTZ chunk found\n");

        return;

    }



    VAR_2 = AV_RB32(&VAR_0->buf[VAR_16 + 4]);

    VAR_16 += CHUNK_PREAMBLE_SIZE;

    decode_format80(&VAR_0->buf[VAR_16], VAR_2,

        VAR_0->decode_buffer, VAR_0->decode_buffer_size, 1);



    

    if (VAR_0->vector_height == 4)

        VAR_9 = 4;

    else

        VAR_9 = 3;

    for (VAR_18 = 0; VAR_18 < VAR_0->frame.linesize[0] * VAR_0->height;

        VAR_18 += VAR_0->frame.linesize[0] * VAR_0->vector_height) {



        for (VAR_17 = VAR_18; VAR_17 < VAR_18 + VAR_0->width; VAR_17 += 4, VAR_24++, VAR_25++) {

            VAR_20 = VAR_17;



            



            switch (VAR_0->vqa_version) {



            case 1:

                VAR_22 = VAR_0->decode_buffer[VAR_24 * 2];

                VAR_23 = VAR_0->decode_buffer[(VAR_24 * 2) + 1];

                VAR_21 = ((VAR_23 << 8) | VAR_22) >> 3;

                VAR_21 <<= VAR_9;

                VAR_19 = VAR_0->vector_height;

                

                if (VAR_23 == 0xFF) {

                    while (VAR_19--) {

                        VAR_0->frame.data[0][VAR_20 + 0] = 255 - VAR_22;

                        VAR_0->frame.data[0][VAR_20 + 1] = 255 - VAR_22;

                        VAR_0->frame.data[0][VAR_20 + 2] = 255 - VAR_22;

                        VAR_0->frame.data[0][VAR_20 + 3] = 255 - VAR_22;

                        VAR_20 += VAR_0->frame.linesize[0];

                    }

                    VAR_19=0;

                }

                break;



            case 2:

                VAR_22 = VAR_0->decode_buffer[VAR_24];

                VAR_23 = VAR_0->decode_buffer[VAR_25];

                VAR_21 = (VAR_23 << 8) | VAR_22;

                VAR_21 <<= VAR_9;

                VAR_19 = VAR_0->vector_height;

                break;



            case 3:



                VAR_19 = 0;

                break;

            }



            while (VAR_19--) {

                VAR_0->frame.data[0][VAR_20 + 0] = VAR_0->codebook[VAR_21++];

                VAR_0->frame.data[0][VAR_20 + 1] = VAR_0->codebook[VAR_21++];

                VAR_0->frame.data[0][VAR_20 + 2] = VAR_0->codebook[VAR_21++];

                VAR_0->frame.data[0][VAR_20 + 3] = VAR_0->codebook[VAR_21++];

                VAR_20 += VAR_0->frame.linesize[0];

            }

        }

    }



    

    if ((VAR_12 != -1) && (VAR_13 != -1)) {

        

        av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: problem: found both CBP0 and CBPZ chunks\n");

        return;

    }



    if (VAR_12 != -1) {



        VAR_2 = AV_RB32(&VAR_0->buf[VAR_12 + 4]);

        VAR_12 += CHUNK_PREAMBLE_SIZE;



        

        memcpy(&VAR_0->next_codebook_buffer[VAR_0->next_codebook_buffer_index],

            &VAR_0->buf[VAR_12], VAR_2);

        VAR_0->next_codebook_buffer_index += VAR_2;



        VAR_0->partial_countdown--;

        if (VAR_0->partial_countdown == 0) {



            

            memcpy(VAR_0->codebook, VAR_0->next_codebook_buffer,

                VAR_0->next_codebook_buffer_index);



            

            VAR_0->next_codebook_buffer_index = 0;

            VAR_0->partial_countdown = VAR_0->partial_count;

        }

    }



    if (VAR_13 != -1) {



        VAR_2 = AV_RB32(&VAR_0->buf[VAR_13 + 4]);

        VAR_13 += CHUNK_PREAMBLE_SIZE;



        

        memcpy(&VAR_0->next_codebook_buffer[VAR_0->next_codebook_buffer_index],

            &VAR_0->buf[VAR_13], VAR_2);

        VAR_0->next_codebook_buffer_index += VAR_2;



        VAR_0->partial_countdown--;

        if (VAR_0->partial_countdown == 0) {



            

            decode_format80(VAR_0->next_codebook_buffer,

                VAR_0->next_codebook_buffer_index,

                VAR_0->codebook, VAR_0->codebook_size, 0);



            

            VAR_0->next_codebook_buffer_index = 0;

            VAR_0->partial_countdown = VAR_0->partial_count;

        }

    }

}

static void FUNC_0(VqaContext *VAR_0)
{ unsigned int VAR_1; unsigned int VAR_2; int VAR_3; unsigned int VAR_4 = 0; int VAR_5; unsigned char VAR_6, VAR_7, VAR_8; int VAR_9; int VAR_10 = -1; int VAR_11 = -1; int VAR_12 = -1; int VAR_13 = -1; int VAR_14 = -1; int VAR_15 = -1; int VAR_16 = -1; int VAR_17, VAR_18; int VAR_19 = 0; int VAR_20; int VAR_21 = 0; int VAR_22 = 0; int VAR_23 = 0; int VAR_24 = 0; int VAR_25 = VAR_0->decode_buffer_size / 2; while (VAR_4 < VAR_0->size) { VAR_1 = AV_RB32(&VAR_0->buf[VAR_4]); VAR_2 = AV_RB32(&VAR_0->buf[VAR_4 + 4]); switch (VAR_1) { case CBF0_TAG:
VAR_10 = VAR_4; break; case CBFZ_TAG:
VAR_11 = VAR_4; break; case CBP0_TAG:
VAR_12 = VAR_4; break; case CBPZ_TAG:
VAR_13 = VAR_4; break; case CPL0_TAG:
VAR_14 = VAR_4; break; case CPLZ_TAG:
VAR_15 = VAR_4; break; case VPTZ_TAG:
VAR_16 = VAR_4; break; default:
av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: Found unknown chunk type: %c%c%c%c (%08X)\n",
(VAR_1 >> 24) & 0xFF,
(VAR_1 >> 16) & 0xFF,
(VAR_1 >>  8) & 0xFF,
(VAR_1 >>  0) & 0xFF,
VAR_1); break; } VAR_3 = VAR_2 & 0x01; VAR_4 += (CHUNK_PREAMBLE_SIZE + VAR_2 + VAR_3); } if ((VAR_14 != -1) && (VAR_15 != -1)) { av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: problem: found both CPL0 and CPLZ chunks\n"); return; } if (VAR_15 != -1) { } if (VAR_14 != -1) { VAR_2 = AV_RB32(&VAR_0->buf[VAR_14 + 4]); if (VAR_2 / 3 > 256) { av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: problem: found a palette chunk with %d colors\n",
VAR_2 / 3); return; } VAR_14 += CHUNK_PREAMBLE_SIZE; for (VAR_5 = 0; VAR_5 < VAR_2 / 3; VAR_5++) { VAR_6 = VAR_0->buf[VAR_14++] * 4; VAR_7 = VAR_0->buf[VAR_14++] * 4; VAR_8 = VAR_0->buf[VAR_14++] * 4; VAR_0->palette[VAR_5] = (VAR_6 << 16) | (VAR_7 << 8) | (VAR_8); } } if ((VAR_10 != -1) && (VAR_11 != -1)) { av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: problem: found both CBF0 and CBFZ chunks\n"); return; } if (VAR_11 != -1) { VAR_2 = AV_RB32(&VAR_0->buf[VAR_11 + 4]); VAR_11 += CHUNK_PREAMBLE_SIZE; decode_format80(&VAR_0->buf[VAR_11], VAR_2,
VAR_0->codebook, VAR_0->codebook_size, 0); } if (VAR_10 != -1) { VAR_2 = AV_RB32(&VAR_0->buf[VAR_10 + 4]); if (VAR_2 > MAX_CODEBOOK_SIZE) { av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: problem: CBF0 chunk too large (0x%X bytes)\n",
VAR_2); return; } VAR_10 += CHUNK_PREAMBLE_SIZE; memcpy(VAR_0->codebook, &VAR_0->buf[VAR_10], VAR_2); } if (VAR_16 == -1) { av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: problem: no VPTZ chunk found\n"); return; } VAR_2 = AV_RB32(&VAR_0->buf[VAR_16 + 4]); VAR_16 += CHUNK_PREAMBLE_SIZE; decode_format80(&VAR_0->buf[VAR_16], VAR_2,
VAR_0->decode_buffer, VAR_0->decode_buffer_size, 1); if (VAR_0->vector_height == 4)
VAR_9 = 4; else
VAR_9 = 3; for (VAR_18 = 0; VAR_18 < VAR_0->frame.linesize[0] * VAR_0->height; VAR_18 += VAR_0->frame.linesize[0] * VAR_0->vector_height) { for (VAR_17 = VAR_18; VAR_17 < VAR_18 + VAR_0->width; VAR_17 += 4, VAR_24++, VAR_25++) { VAR_20 = VAR_17; switch (VAR_0->vqa_version) { case 1:
VAR_22 = VAR_0->decode_buffer[VAR_24 * 2]; VAR_23 = VAR_0->decode_buffer[(VAR_24 * 2) + 1]; VAR_21 = ((VAR_23 << 8) | VAR_22) >> 3; VAR_21 <<= VAR_9; VAR_19 = VAR_0->vector_height; if (VAR_23 == 0xFF) { while (VAR_19--) { VAR_0->frame.data[0][VAR_20 + 0] = 255 - VAR_22; VAR_0->frame.data[0][VAR_20 + 1] = 255 - VAR_22; VAR_0->frame.data[0][VAR_20 + 2] = 255 - VAR_22; VAR_0->frame.data[0][VAR_20 + 3] = 255 - VAR_22; VAR_20 += VAR_0->frame.linesize[0]; } VAR_19=0; } break; case 2:
VAR_22 = VAR_0->decode_buffer[VAR_24]; VAR_23 = VAR_0->decode_buffer[VAR_25]; VAR_21 = (VAR_23 << 8) | VAR_22; VAR_21 <<= VAR_9; VAR_19 = VAR_0->vector_height; break; case 3:
VAR_19 = 0; break; } while (VAR_19--) { VAR_0->frame.data[0][VAR_20 + 0] = VAR_0->codebook[VAR_21++]; VAR_0->frame.data[0][VAR_20 + 1] = VAR_0->codebook[VAR_21++]; VAR_0->frame.data[0][VAR_20 + 2] = VAR_0->codebook[VAR_21++]; VAR_0->frame.data[0][VAR_20 + 3] = VAR_0->codebook[VAR_21++]; VAR_20 += VAR_0->frame.linesize[0]; } } } if ((VAR_12 != -1) && (VAR_13 != -1)) { av_log(VAR_0->avctx, AV_LOG_ERROR, "  VQA video: problem: found both CBP0 and CBPZ chunks\n"); return; } if (VAR_12 != -1) { VAR_2 = AV_RB32(&VAR_0->buf[VAR_12 + 4]); VAR_12 += CHUNK_PREAMBLE_SIZE; memcpy(&VAR_0->next_codebook_buffer[VAR_0->next_codebook_buffer_index],
&VAR_0->buf[VAR_12], VAR_2); VAR_0->next_codebook_buffer_index += VAR_2; VAR_0->partial_countdown--; if (VAR_0->partial_countdown == 0) { memcpy(VAR_0->codebook, VAR_0->next_codebook_buffer,
VAR_0->next_codebook_buffer_index); VAR_0->next_codebook_buffer_index = 0; VAR_0->partial_countdown = VAR_0->partial_count; } } if (VAR_13 != -1) { VAR_2 = AV_RB32(&VAR_0->buf[VAR_13 + 4]); VAR_13 += CHUNK_PREAMBLE_SIZE; memcpy(&VAR_0->next_codebook_buffer[VAR_0->next_codebook_buffer_index],
&VAR_0->buf[VAR_13], VAR_2); VAR_0->next_codebook_buffer_index += VAR_2; VAR_0->partial_countdown--; if (VAR_0->partial_countdown == 0) { decode_format80(VAR_0->next_codebook_buffer,
VAR_0->next_codebook_buffer_index,
VAR_0->codebook, VAR_0->codebook_size, 0); VAR_0->next_codebook_buffer_index = 0; VAR_0->partial_countdown = VAR_0->partial_count; } } }