static inline void dv_decode_video_segment(DVVideoDecodeContext *s, 

                                           UINT8 *buf_ptr1, 

                                           const UINT16 *mb_pos_ptr)

{

    int quant, dc, dct_mode, class1, j;

    int mb_index, mb_x, mb_y, v, last_index;

    DCTELEM *block, *block1;

    int c_offset, bits_left;

    UINT8 *y_ptr;

    BlockInfo mb_data[5 * 6], *mb, *mb1;

    void (*idct_put)(UINT8 *dest, int line_size, DCTELEM *block);

    UINT8 *buf_ptr;

    PutBitContext pb, vs_pb;

    UINT8 mb_bit_buffer[80 + 4]; /* allow some slack */

    int mb_bit_count;

    UINT8 vs_bit_buffer[5 * 80 + 4]; /* allow some slack */

    int vs_bit_count;

    

    memset(s->block, 0, sizeof(s->block));



    /* pass 1 : read DC and AC coefficients in blocks */

    buf_ptr = buf_ptr1;

    block1 = &s->block[0][0];

    mb1 = mb_data;

    init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80, NULL, NULL);

    vs_bit_count = 0;

    for(mb_index = 0; mb_index < 5; mb_index++) {

        /* skip header */

        quant = buf_ptr[3] & 0x0f;

        buf_ptr += 4;

        init_put_bits(&pb, mb_bit_buffer, 80, NULL, NULL);

        mb_bit_count = 0;

        mb = mb1;

        block = block1;

        for(j = 0;j < 6; j++) {

            /* NOTE: size is not important here */

            init_get_bits(&s->gb, buf_ptr, 14);

            

            /* get the dc */

            dc = get_bits(&s->gb, 9);

            dc = (dc << (32 - 9)) >> (32 - 9);

            dct_mode = get_bits1(&s->gb);

            mb->dct_mode = dct_mode;

            mb->scan_table = s->dv_zigzag[dct_mode];

            class1 = get_bits(&s->gb, 2);

            mb->shift_offset = (class1 == 3);

            mb->shift_table = s->dv_shift[dct_mode]

                [quant + dv_quant_offset[class1]];

            dc = dc << 2;

            /* convert to unsigned because 128 is not added in the

               standard IDCT */

            dc += 1024;

            block[0] = dc;

            last_index = block_sizes[j];

            buf_ptr += last_index >> 3;

            mb->pos = 0;

            mb->partial_bit_count = 0;



            dv_decode_ac(s, mb, block, last_index);



            /* write the remaining bits  in a new buffer only if the

               block is finished */

            bits_left = last_index - s->gb.index;

            if (mb->eob_reached) {

                mb->partial_bit_count = 0;

                mb_bit_count += bits_left;

                bit_copy(&pb, &s->gb, bits_left);

            } else {

                /* should be < 16 bits otherwise a codeword could have

                   been parsed */

                mb->partial_bit_count = bits_left;

                mb->partial_bit_buffer = get_bits(&s->gb, bits_left);

            }

            block += 64;

            mb++;

        }

        

        flush_put_bits(&pb);



        /* pass 2 : we can do it just after */

#ifdef VLC_DEBUG

        printf("***pass 2 size=%d\n", mb_bit_count);

#endif

        block = block1;

        mb = mb1;

        init_get_bits(&s->gb, mb_bit_buffer, 80);

        for(j = 0;j < 6; j++) {

            if (!mb->eob_reached && s->gb.index < mb_bit_count) {

                dv_decode_ac(s, mb, block, mb_bit_count);

                /* if still not finished, no need to parse other blocks */

                if (!mb->eob_reached) {

                    /* we could not parse the current AC coefficient,

                       so we add the remaining bytes */

                    bits_left = mb_bit_count - s->gb.index;

                    if (bits_left > 0) {

                        mb->partial_bit_count += bits_left;

                        mb->partial_bit_buffer = 

                            (mb->partial_bit_buffer << bits_left) | 

                            get_bits(&s->gb, bits_left);

                    }

                    goto next_mb;

                }

            }

            block += 64;

            mb++;

        }

        /* all blocks are finished, so the extra bytes can be used at

           the video segment level */

        bits_left = mb_bit_count - s->gb.index;

        vs_bit_count += bits_left;

        bit_copy(&vs_pb, &s->gb, bits_left);

    next_mb:

        mb1 += 6;

        block1 += 6 * 64;

    }



    /* we need a pass other the whole video segment */

    flush_put_bits(&vs_pb);

        

#ifdef VLC_DEBUG

    printf("***pass 3 size=%d\n", vs_bit_count);

#endif

    block = &s->block[0][0];

    mb = mb_data;

    init_get_bits(&s->gb, vs_bit_buffer, 5 * 80);

    for(mb_index = 0; mb_index < 5; mb_index++) {

        for(j = 0;j < 6; j++) {

            if (!mb->eob_reached) {

#ifdef VLC_DEBUG

                printf("start %d:%d\n", mb_index, j);

#endif

                dv_decode_ac(s, mb, block, vs_bit_count);

            }

            block += 64;

            mb++;

        }

    }

    

    /* compute idct and place blocks */

    block = &s->block[0][0];

    mb = mb_data;

    for(mb_index = 0; mb_index < 5; mb_index++) {

        v = *mb_pos_ptr++;

        mb_x = v & 0xff;

        mb_y = v >> 8;

        y_ptr = s->current_picture[0] + (mb_y * s->linesize[0] * 8) + (mb_x * 8);

        if (s->sampling_411)

            c_offset = (mb_y * s->linesize[1] * 8) + ((mb_x >> 2) * 8);

        else

            c_offset = ((mb_y >> 1) * s->linesize[1] * 8) + ((mb_x >> 1) * 8);

        for(j = 0;j < 6; j++) {

            idct_put = s->idct_put[mb->dct_mode];

            if (j < 4) {

                if (s->sampling_411 && mb_x < (704 / 8)) {

                    /* NOTE: at end of line, the macroblock is handled as 420 */

                    idct_put(y_ptr + (j * 8), s->linesize[0], block);

                } else {

                    idct_put(y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->linesize[0]),

                             s->linesize[0], block);

                }

            } else {

                if (s->sampling_411 && mb_x >= (704 / 8)) {

                    uint8_t pixels[64], *c_ptr, *c_ptr1, *ptr;

                    int y, linesize;

                    /* NOTE: at end of line, the macroblock is handled as 420 */

                    idct_put(pixels, 8, block);

                    linesize = s->linesize[6 - j];

                    c_ptr = s->current_picture[6 - j] + c_offset;

                    ptr = pixels;

                    for(y = 0;y < 8; y++) {

                        /* convert to 411P */

                        c_ptr1 = c_ptr + linesize;

                        c_ptr1[0] = c_ptr[0] = (ptr[0] + ptr[1]) >> 1;

                        c_ptr1[1] = c_ptr[1] = (ptr[2] + ptr[3]) >> 1;

                        c_ptr1[2] = c_ptr[2] = (ptr[4] + ptr[5]) >> 1;

                        c_ptr1[3] = c_ptr[3] = (ptr[6] + ptr[7]) >> 1;

                        c_ptr += linesize * 2;

                        ptr += 8;

                    }

                } else {

                    /* don't ask me why they inverted Cb and Cr ! */

                    idct_put(s->current_picture[6 - j] + c_offset, 

                             s->linesize[6 - j], block);

                }

            }

            block += 64;

            mb++;

        }

    }

}

static inline void dv_decode_video_segment(DVVideoDecodeContext *s, 

                                           UINT8 *buf_ptr1, 

                                           const UINT16 *mb_pos_ptr)

{

    int quant, dc, dct_mode, class1, j;

    int mb_index, mb_x, mb_y, v, last_index;

    DCTELEM *block, *block1;

    int c_offset, bits_left;

    UINT8 *y_ptr;

    BlockInfo mb_data[5 * 6], *mb, *mb1;

    void (*idct_put)(UINT8 *dest, int line_size, DCTELEM *block);

    UINT8 *buf_ptr;

    PutBitContext pb, vs_pb;

    UINT8 mb_bit_buffer[80 + 4]; 

    int mb_bit_count;

    UINT8 vs_bit_buffer[5 * 80 + 4]; 

    int vs_bit_count;

    

    memset(s->block, 0, sizeof(s->block));



    

    buf_ptr = buf_ptr1;

    block1 = &s->block[0][0];

    mb1 = mb_data;

    init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80, NULL, NULL);

    vs_bit_count = 0;

    for(mb_index = 0; mb_index < 5; mb_index++) {

        

        quant = buf_ptr[3] & 0x0f;

        buf_ptr += 4;

        init_put_bits(&pb, mb_bit_buffer, 80, NULL, NULL);

        mb_bit_count = 0;

        mb = mb1;

        block = block1;

        for(j = 0;j < 6; j++) {

            

            init_get_bits(&s->gb, buf_ptr, 14);

            

            

            dc = get_bits(&s->gb, 9);

            dc = (dc << (32 - 9)) >> (32 - 9);

            dct_mode = get_bits1(&s->gb);

            mb->dct_mode = dct_mode;

            mb->scan_table = s->dv_zigzag[dct_mode];

            class1 = get_bits(&s->gb, 2);

            mb->shift_offset = (class1 == 3);

            mb->shift_table = s->dv_shift[dct_mode]

                [quant + dv_quant_offset[class1]];

            dc = dc << 2;

            



            dc += 1024;

            block[0] = dc;

            last_index = block_sizes[j];

            buf_ptr += last_index >> 3;

            mb->pos = 0;

            mb->partial_bit_count = 0;



            dv_decode_ac(s, mb, block, last_index);



            



            bits_left = last_index - s->gb.index;

            if (mb->eob_reached) {

                mb->partial_bit_count = 0;

                mb_bit_count += bits_left;

                bit_copy(&pb, &s->gb, bits_left);

            } else {

                



                mb->partial_bit_count = bits_left;

                mb->partial_bit_buffer = get_bits(&s->gb, bits_left);

            }

            block += 64;

            mb++;

        }

        

        flush_put_bits(&pb);



        

#ifdef VLC_DEBUG

        printf("***pass 2 size=%d\n", mb_bit_count);

#endif

        block = block1;

        mb = mb1;

        init_get_bits(&s->gb, mb_bit_buffer, 80);

        for(j = 0;j < 6; j++) {

            if (!mb->eob_reached && s->gb.index < mb_bit_count) {

                dv_decode_ac(s, mb, block, mb_bit_count);

                

                if (!mb->eob_reached) {

                    



                    bits_left = mb_bit_count - s->gb.index;

                    if (bits_left > 0) {

                        mb->partial_bit_count += bits_left;

                        mb->partial_bit_buffer = 

                            (mb->partial_bit_buffer << bits_left) | 

                            get_bits(&s->gb, bits_left);

                    }

                    goto next_mb;

                }

            }

            block += 64;

            mb++;

        }

        



        bits_left = mb_bit_count - s->gb.index;

        vs_bit_count += bits_left;

        bit_copy(&vs_pb, &s->gb, bits_left);

    next_mb:

        mb1 += 6;

        block1 += 6 * 64;

    }



    

    flush_put_bits(&vs_pb);

        

#ifdef VLC_DEBUG

    printf("***pass 3 size=%d\n", vs_bit_count);

#endif

    block = &s->block[0][0];

    mb = mb_data;

    init_get_bits(&s->gb, vs_bit_buffer, 5 * 80);

    for(mb_index = 0; mb_index < 5; mb_index++) {

        for(j = 0;j < 6; j++) {

            if (!mb->eob_reached) {

#ifdef VLC_DEBUG

                printf("start %d:%d\n", mb_index, j);

#endif

                dv_decode_ac(s, mb, block, vs_bit_count);

            }

            block += 64;

            mb++;

        }

    }

    

    

    block = &s->block[0][0];

    mb = mb_data;

    for(mb_index = 0; mb_index < 5; mb_index++) {

        v = *mb_pos_ptr++;

        mb_x = v & 0xff;

        mb_y = v >> 8;

        y_ptr = s->current_picture[0] + (mb_y * s->linesize[0] * 8) + (mb_x * 8);

        if (s->sampling_411)

            c_offset = (mb_y * s->linesize[1] * 8) + ((mb_x >> 2) * 8);

        else

            c_offset = ((mb_y >> 1) * s->linesize[1] * 8) + ((mb_x >> 1) * 8);

        for(j = 0;j < 6; j++) {

            idct_put = s->idct_put[mb->dct_mode];

            if (j < 4) {

                if (s->sampling_411 && mb_x < (704 / 8)) {

                    

                    idct_put(y_ptr + (j * 8), s->linesize[0], block);

                } else {

                    idct_put(y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->linesize[0]),

                             s->linesize[0], block);

                }

            } else {

                if (s->sampling_411 && mb_x >= (704 / 8)) {

                    uint8_t pixels[64], *c_ptr, *c_ptr1, *ptr;

                    int y, linesize;

                    

                    idct_put(pixels, 8, block);

                    linesize = s->linesize[6 - j];

                    c_ptr = s->current_picture[6 - j] + c_offset;

                    ptr = pixels;

                    for(y = 0;y < 8; y++) {

                        

                        c_ptr1 = c_ptr + linesize;

                        c_ptr1[0] = c_ptr[0] = (ptr[0] + ptr[1]) >> 1;

                        c_ptr1[1] = c_ptr[1] = (ptr[2] + ptr[3]) >> 1;

                        c_ptr1[2] = c_ptr[2] = (ptr[4] + ptr[5]) >> 1;

                        c_ptr1[3] = c_ptr[3] = (ptr[6] + ptr[7]) >> 1;

                        c_ptr += linesize * 2;

                        ptr += 8;

                    }

                } else {

                    

                    idct_put(s->current_picture[6 - j] + c_offset, 

                             s->linesize[6 - j], block);

                }

            }

            block += 64;

            mb++;

        }

    }

}

static inline void FUNC_0(DVVideoDecodeContext *VAR_0, 

                                           UINT8 *VAR_1, 

                                           const UINT16 *VAR_2)

{

    int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;

    int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12;

    DCTELEM *VAR_18, *block1;

    int VAR_13, VAR_14;

    UINT8 *y_ptr;

    BlockInfo mb_data[5 * 6], *mb, *mb1;

    void (*VAR_15)(UINT8 *VAR_16, int VAR_17, DCTELEM *VAR_18);

    UINT8 *buf_ptr;

    PutBitContext pb, vs_pb;

    UINT8 mb_bit_buffer[80 + 4]; 

    int VAR_19;

    UINT8 vs_bit_buffer[5 * 80 + 4]; 

    int VAR_20;

    

    memset(VAR_0->VAR_18, 0, sizeof(VAR_0->VAR_18));



    

    buf_ptr = VAR_1;

    block1 = &VAR_0->VAR_18[0][0];

    mb1 = mb_data;

    init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80, NULL, NULL);

    VAR_20 = 0;

    for(VAR_8 = 0; VAR_8 < 5; VAR_8++) {

        

        VAR_3 = buf_ptr[3] & 0x0f;

        buf_ptr += 4;

        init_put_bits(&pb, mb_bit_buffer, 80, NULL, NULL);

        VAR_19 = 0;

        mb = mb1;

        VAR_18 = block1;

        for(VAR_7 = 0;VAR_7 < 6; VAR_7++) {

            

            init_get_bits(&VAR_0->gb, buf_ptr, 14);

            

            

            VAR_4 = get_bits(&VAR_0->gb, 9);

            VAR_4 = (VAR_4 << (32 - 9)) >> (32 - 9);

            VAR_5 = get_bits1(&VAR_0->gb);

            mb->VAR_5 = VAR_5;

            mb->scan_table = VAR_0->dv_zigzag[VAR_5];

            VAR_6 = get_bits(&VAR_0->gb, 2);

            mb->shift_offset = (VAR_6 == 3);

            mb->shift_table = VAR_0->dv_shift[VAR_5]

                [VAR_3 + dv_quant_offset[VAR_6]];

            VAR_4 = VAR_4 << 2;

            



            VAR_4 += 1024;

            VAR_18[0] = VAR_4;

            VAR_12 = block_sizes[VAR_7];

            buf_ptr += VAR_12 >> 3;

            mb->pos = 0;

            mb->partial_bit_count = 0;



            dv_decode_ac(VAR_0, mb, VAR_18, VAR_12);



            



            VAR_14 = VAR_12 - VAR_0->gb.index;

            if (mb->eob_reached) {

                mb->partial_bit_count = 0;

                VAR_19 += VAR_14;

                bit_copy(&pb, &VAR_0->gb, VAR_14);

            } else {

                



                mb->partial_bit_count = VAR_14;

                mb->partial_bit_buffer = get_bits(&VAR_0->gb, VAR_14);

            }

            VAR_18 += 64;

            mb++;

        }

        

        flush_put_bits(&pb);



        

#ifdef VLC_DEBUG

        printf("***pass 2 size=%d\n", VAR_19);

#endif

        VAR_18 = block1;

        mb = mb1;

        init_get_bits(&VAR_0->gb, mb_bit_buffer, 80);

        for(VAR_7 = 0;VAR_7 < 6; VAR_7++) {

            if (!mb->eob_reached && VAR_0->gb.index < VAR_19) {

                dv_decode_ac(VAR_0, mb, VAR_18, VAR_19);

                

                if (!mb->eob_reached) {

                    



                    VAR_14 = VAR_19 - VAR_0->gb.index;

                    if (VAR_14 > 0) {

                        mb->partial_bit_count += VAR_14;

                        mb->partial_bit_buffer = 

                            (mb->partial_bit_buffer << VAR_14) | 

                            get_bits(&VAR_0->gb, VAR_14);

                    }

                    goto next_mb;

                }

            }

            VAR_18 += 64;

            mb++;

        }

        



        VAR_14 = VAR_19 - VAR_0->gb.index;

        VAR_20 += VAR_14;

        bit_copy(&vs_pb, &VAR_0->gb, VAR_14);

    next_mb:

        mb1 += 6;

        block1 += 6 * 64;

    }



    

    flush_put_bits(&vs_pb);

        

#ifdef VLC_DEBUG

    printf("***pass 3 size=%d\n", VAR_20);

#endif

    VAR_18 = &VAR_0->VAR_18[0][0];

    mb = mb_data;

    init_get_bits(&VAR_0->gb, vs_bit_buffer, 5 * 80);

    for(VAR_8 = 0; VAR_8 < 5; VAR_8++) {

        for(VAR_7 = 0;VAR_7 < 6; VAR_7++) {

            if (!mb->eob_reached) {

#ifdef VLC_DEBUG

                printf("start %d:%d\n", VAR_8, VAR_7);

#endif

                dv_decode_ac(VAR_0, mb, VAR_18, VAR_20);

            }

            VAR_18 += 64;

            mb++;

        }

    }

    

    

    VAR_18 = &VAR_0->VAR_18[0][0];

    mb = mb_data;

    for(VAR_8 = 0; VAR_8 < 5; VAR_8++) {

        VAR_11 = *VAR_2++;

        VAR_9 = VAR_11 & 0xff;

        VAR_10 = VAR_11 >> 8;

        y_ptr = VAR_0->current_picture[0] + (VAR_10 * VAR_0->VAR_22[0] * 8) + (VAR_9 * 8);

        if (VAR_0->sampling_411)

            VAR_13 = (VAR_10 * VAR_0->VAR_22[1] * 8) + ((VAR_9 >> 2) * 8);

        else

            VAR_13 = ((VAR_10 >> 1) * VAR_0->VAR_22[1] * 8) + ((VAR_9 >> 1) * 8);

        for(VAR_7 = 0;VAR_7 < 6; VAR_7++) {

            VAR_15 = VAR_0->VAR_15[mb->VAR_5];

            if (VAR_7 < 4) {

                if (VAR_0->sampling_411 && VAR_9 < (704 / 8)) {

                    

                    VAR_15(y_ptr + (VAR_7 * 8), VAR_0->VAR_22[0], VAR_18);

                } else {

                    VAR_15(y_ptr + ((VAR_7 & 1) * 8) + ((VAR_7 >> 1) * 8 * VAR_0->VAR_22[0]),

                             VAR_0->VAR_22[0], VAR_18);

                }

            } else {

                if (VAR_0->sampling_411 && VAR_9 >= (704 / 8)) {

                    uint8_t pixels[64], *c_ptr, *c_ptr1, *ptr;

                    int VAR_21, VAR_22;

                    

                    VAR_15(pixels, 8, VAR_18);

                    VAR_22 = VAR_0->VAR_22[6 - VAR_7];

                    c_ptr = VAR_0->current_picture[6 - VAR_7] + VAR_13;

                    ptr = pixels;

                    for(VAR_21 = 0;VAR_21 < 8; VAR_21++) {

                        

                        c_ptr1 = c_ptr + VAR_22;

                        c_ptr1[0] = c_ptr[0] = (ptr[0] + ptr[1]) >> 1;

                        c_ptr1[1] = c_ptr[1] = (ptr[2] + ptr[3]) >> 1;

                        c_ptr1[2] = c_ptr[2] = (ptr[4] + ptr[5]) >> 1;

                        c_ptr1[3] = c_ptr[3] = (ptr[6] + ptr[7]) >> 1;

                        c_ptr += VAR_22 * 2;

                        ptr += 8;

                    }

                } else {

                    

                    VAR_15(VAR_0->current_picture[6 - VAR_7] + VAR_13, 

                             VAR_0->VAR_22[6 - VAR_7], VAR_18);

                }

            }

            VAR_18 += 64;

            mb++;

        }

    }

}

static inline void FUNC_0(DVVideoDecodeContext *VAR_0,
UINT8 *VAR_1,
const UINT16 *VAR_2)
{ int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7; int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12; DCTELEM *VAR_18, *block1; int VAR_13, VAR_14; UINT8 *y_ptr; BlockInfo mb_data[5 * 6], *mb, *mb1; void (*VAR_15)(UINT8 *VAR_16, int VAR_17, DCTELEM *VAR_18); UINT8 *buf_ptr; PutBitContext pb, vs_pb; UINT8 mb_bit_buffer[80 + 4]; int VAR_19; UINT8 vs_bit_buffer[5 * 80 + 4]; int VAR_20; memset(VAR_0->VAR_18, 0, sizeof(VAR_0->VAR_18)); buf_ptr = VAR_1; block1 = &VAR_0->VAR_18[0][0]; mb1 = mb_data; init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80, NULL, NULL); VAR_20 = 0; for(VAR_8 = 0; VAR_8 < 5; VAR_8++) { VAR_3 = buf_ptr[3] & 0x0f; buf_ptr += 4; init_put_bits(&pb, mb_bit_buffer, 80, NULL, NULL); VAR_19 = 0; mb = mb1; VAR_18 = block1; for(VAR_7 = 0;VAR_7 < 6; VAR_7++) { init_get_bits(&VAR_0->gb, buf_ptr, 14); VAR_4 = get_bits(&VAR_0->gb, 9); VAR_4 = (VAR_4 << (32 - 9)) >> (32 - 9); VAR_5 = get_bits1(&VAR_0->gb); mb->VAR_5 = VAR_5; mb->scan_table = VAR_0->dv_zigzag[VAR_5]; VAR_6 = get_bits(&VAR_0->gb, 2); mb->shift_offset = (VAR_6 == 3); mb->shift_table = VAR_0->dv_shift[VAR_5]
[VAR_3 + dv_quant_offset[VAR_6]]; VAR_4 = VAR_4 << 2; VAR_4 += 1024; VAR_18[0] = VAR_4; VAR_12 = block_sizes[VAR_7]; buf_ptr += VAR_12 >> 3; mb->pos = 0; mb->partial_bit_count = 0; dv_decode_ac(VAR_0, mb, VAR_18, VAR_12); VAR_14 = VAR_12 - VAR_0->gb.index; if (mb->eob_reached) { mb->partial_bit_count = 0; VAR_19 += VAR_14; bit_copy(&pb, &VAR_0->gb, VAR_14); } else { mb->partial_bit_count = VAR_14; mb->partial_bit_buffer = get_bits(&VAR_0->gb, VAR_14); } VAR_18 += 64; mb++; } flush_put_bits(&pb); #ifdef VLC_DEBUG
printf("***pass 2 size=%d\n", VAR_19); #endif
VAR_18 = block1; mb = mb1; init_get_bits(&VAR_0->gb, mb_bit_buffer, 80); for(VAR_7 = 0;VAR_7 < 6; VAR_7++) { if (!mb->eob_reached && VAR_0->gb.index < VAR_19) { dv_decode_ac(VAR_0, mb, VAR_18, VAR_19); if (!mb->eob_reached) { VAR_14 = VAR_19 - VAR_0->gb.index; if (VAR_14 > 0) { mb->partial_bit_count += VAR_14; mb->partial_bit_buffer =
(mb->partial_bit_buffer << VAR_14) |
get_bits(&VAR_0->gb, VAR_14); } goto next_mb; } } VAR_18 += 64; mb++; } VAR_14 = VAR_19 - VAR_0->gb.index; VAR_20 += VAR_14; bit_copy(&vs_pb, &VAR_0->gb, VAR_14); next_mb:
mb1 += 6; block1 += 6 * 64; } flush_put_bits(&vs_pb); #ifdef VLC_DEBUG
printf("***pass 3 size=%d\n", VAR_20); #endif
VAR_18 = &VAR_0->VAR_18[0][0]; mb = mb_data; init_get_bits(&VAR_0->gb, vs_bit_buffer, 5 * 80); for(VAR_8 = 0; VAR_8 < 5; VAR_8++) { for(VAR_7 = 0;VAR_7 < 6; VAR_7++) { if (!mb->eob_reached) { #ifdef VLC_DEBUG
printf("start %d:%d\n", VAR_8, VAR_7); #endif
dv_decode_ac(VAR_0, mb, VAR_18, VAR_20); } VAR_18 += 64; mb++; } } VAR_18 = &VAR_0->VAR_18[0][0]; mb = mb_data; for(VAR_8 = 0; VAR_8 < 5; VAR_8++) { VAR_11 = *VAR_2++; VAR_9 = VAR_11 & 0xff; VAR_10 = VAR_11 >> 8; y_ptr = VAR_0->current_picture[0] + (VAR_10 * VAR_0->VAR_22[0] * 8) + (VAR_9 * 8); if (VAR_0->sampling_411)
VAR_13 = (VAR_10 * VAR_0->VAR_22[1] * 8) + ((VAR_9 >> 2) * 8); else
VAR_13 = ((VAR_10 >> 1) * VAR_0->VAR_22[1] * 8) + ((VAR_9 >> 1) * 8); for(VAR_7 = 0;VAR_7 < 6; VAR_7++) { VAR_15 = VAR_0->VAR_15[mb->VAR_5]; if (VAR_7 < 4) { if (VAR_0->sampling_411 && VAR_9 < (704 / 8)) { VAR_15(y_ptr + (VAR_7 * 8), VAR_0->VAR_22[0], VAR_18); } else { VAR_15(y_ptr + ((VAR_7 & 1) * 8) + ((VAR_7 >> 1) * 8 * VAR_0->VAR_22[0]),
VAR_0->VAR_22[0], VAR_18); } } else { if (VAR_0->sampling_411 && VAR_9 >= (704 / 8)) { uint8_t pixels[64], *c_ptr, *c_ptr1, *ptr; int VAR_21, VAR_22; VAR_15(pixels, 8, VAR_18); VAR_22 = VAR_0->VAR_22[6 - VAR_7]; c_ptr = VAR_0->current_picture[6 - VAR_7] + VAR_13; ptr = pixels; for(VAR_21 = 0;VAR_21 < 8; VAR_21++) { c_ptr1 = c_ptr + VAR_22; c_ptr1[0] = c_ptr[0] = (ptr[0] + ptr[1]) >> 1; c_ptr1[1] = c_ptr[1] = (ptr[2] + ptr[3]) >> 1; c_ptr1[2] = c_ptr[2] = (ptr[4] + ptr[5]) >> 1; c_ptr1[3] = c_ptr[3] = (ptr[6] + ptr[7]) >> 1; c_ptr += VAR_22 * 2; ptr += 8; } } else { VAR_15(VAR_0->current_picture[6 - VAR_7] + VAR_13,
VAR_0->VAR_22[6 - VAR_7], VAR_18); } } VAR_18 += 64; mb++; } } }