int ff_h263_decode_frame(AVCodecContext *avctx, 

                             void *data, int *data_size,

                             UINT8 *buf, int buf_size)

{

    MpegEncContext *s = avctx->priv_data;

    int ret,i;

    AVFrame *pict = data; 

    float new_aspect;

    

#ifdef PRINT_FRAME_TIME

uint64_t time= rdtsc();

#endif

#ifdef DEBUG

    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);

    printf("bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);

#endif

    s->flags= avctx->flags;



    *data_size = 0;

   

   /* no supplementary picture */

    if (buf_size == 0) {

        return 0;

    }

    

    if(s->flags&CODEC_FLAG_TRUNCATED){

        int next;

        ParseContext *pc= &s->parse_context;

        

        pc->last_index= pc->index;



        if(s->codec_id==CODEC_ID_MPEG4){

            next= mpeg4_find_frame_end(s, buf, buf_size);

        }else{

            fprintf(stderr, "this codec doesnt support truncated bitstreams\n");

            return -1;

        }

        if(next==-1){

            if(buf_size + FF_INPUT_BUFFER_PADDING_SIZE + pc->index > pc->buffer_size){

                pc->buffer_size= buf_size + pc->index + 10*1024;

                pc->buffer= realloc(pc->buffer, pc->buffer_size);

            }



            memcpy(&pc->buffer[pc->index], buf, buf_size);

            pc->index += buf_size;

            return buf_size;

        }



        if(pc->index){

            if(next + FF_INPUT_BUFFER_PADDING_SIZE + pc->index > pc->buffer_size){

                pc->buffer_size= next + pc->index + 10*1024;

                pc->buffer= realloc(pc->buffer, pc->buffer_size);

            }



            memcpy(&pc->buffer[pc->index], buf, next + FF_INPUT_BUFFER_PADDING_SIZE );

            pc->index = 0;

            buf= pc->buffer;

            buf_size= pc->last_index + next;

        }

    }



retry:

    

    if(s->bitstream_buffer_size && buf_size<20){ //divx 5.01+ frame reorder

        init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size);

    }else

        init_get_bits(&s->gb, buf, buf_size);

    s->bitstream_buffer_size=0;



    if (!s->context_initialized) {

        if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix

            return -1;

    }

      

    /* let's go :-) */

    if (s->msmpeg4_version==5) {

        ret= ff_wmv2_decode_picture_header(s);

    } else if (s->msmpeg4_version) {

        ret = msmpeg4_decode_picture_header(s);

    } else if (s->h263_pred) {

        if(s->avctx->extradata_size && s->picture_number==0){

            GetBitContext gb;

            

            init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size);

            ret = ff_mpeg4_decode_picture_header(s, &gb);

        }

        ret = ff_mpeg4_decode_picture_header(s, &s->gb);



        if(s->flags& CODEC_FLAG_LOW_DELAY)

            s->low_delay=1;

    } else if (s->h263_intel) {

        ret = intel_h263_decode_picture_header(s);

    } else {

        ret = h263_decode_picture_header(s);

    }

    avctx->has_b_frames= !s->low_delay;



    if(s->workaround_bugs&FF_BUG_AUTODETECT){

        if(s->padding_bug_score > -2 && !s->data_partitioning)

            s->workaround_bugs |=  FF_BUG_NO_PADDING;

        else

            s->workaround_bugs &= ~FF_BUG_NO_PADDING;



        if(s->avctx->fourcc == ff_get_fourcc("XVIX")) 

            s->workaround_bugs|= FF_BUG_XVID_ILACE;

#if 0

        if(s->avctx->fourcc == ff_get_fourcc("MP4S")) 

            s->workaround_bugs|= FF_BUG_AC_VLC;

        

        if(s->avctx->fourcc == ff_get_fourcc("M4S2")) 

            s->workaround_bugs|= FF_BUG_AC_VLC;

#endif

        if(s->avctx->fourcc == ff_get_fourcc("UMP4")){

            s->workaround_bugs|= FF_BUG_UMP4;

            s->workaround_bugs|= FF_BUG_AC_VLC;

        }



        if(s->divx_version){

            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;

        }



        if(s->avctx->fourcc == ff_get_fourcc("XVID") && s->xvid_build==0)

            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;

        

        if(s->avctx->fourcc == ff_get_fourcc("XVID") && s->xvid_build==0)

            s->padding_bug_score= 256*256*256*64;

        

        if(s->xvid_build && s->xvid_build<=3)

            s->padding_bug_score= 256*256*256*64;

        

        if(s->xvid_build && s->xvid_build<=1)

            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;



#define SET_QPEL_FUNC(postfix1, postfix2) \

    s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\

    s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\

    s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;



        if(s->lavc_build && s->lavc_build<4653)

            s->workaround_bugs|= FF_BUG_STD_QPEL;

        

//printf("padding_bug_score: %d\n", s->padding_bug_score);

#if 0

        if(s->divx_version==500)

            s->workaround_bugs|= FF_BUG_NO_PADDING;



        /* very ugly XVID padding bug detection FIXME/XXX solve this differently

         * lets hope this at least works

         */

        if(   s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0

           && s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)

            s->workaround_bugs|= FF_BUG_NO_PADDING;

        

        if(s->lavc_build && s->lavc_build<4609) //FIXME not sure about the version num but a 4609 file seems ok

            s->workaround_bugs|= FF_BUG_NO_PADDING;

#endif

    }

    

    if(s->workaround_bugs& FF_BUG_STD_QPEL){

        SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)



        SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)

    }



#if 0 // dump bits per frame / qp / complexity

{

    static FILE *f=NULL;

    if(!f) f=fopen("rate_qp_cplx.txt", "w");

    fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale);

}

#endif

       

        /* After H263 & mpeg4 header decode we have the height, width,*/

        /* and other parameters. So then we could init the picture   */

        /* FIXME: By the way H263 decoder is evolving it should have */

        /* an H263EncContext                                         */

    if(s->aspected_height)

        new_aspect= s->aspected_width*s->width / (float)(s->height*s->aspected_height);

    else

        new_aspect=0;

    

    if (   s->width != avctx->width || s->height != avctx->height 

        || ABS(new_aspect - avctx->aspect_ratio) > 0.001) {

        /* H.263 could change picture size any time */

        MPV_common_end(s);

        s->context_initialized=0;

    }

    if (!s->context_initialized) {

        avctx->width = s->width;

        avctx->height = s->height;

        avctx->aspect_ratio= new_aspect;



        goto retry;

    }



    if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P))

        s->gob_index = ff_h263_get_gob_height(s);



    if(ret==FRAME_SKIPED) return get_consumed_bytes(s, buf_size);

    /* skip if the header was thrashed */

    if (ret < 0){

        fprintf(stderr, "header damaged\n");

        return -1;

    }

    

    // for hurry_up==5

    s->current_picture.pict_type= s->pict_type;

    s->current_picture.key_frame= s->pict_type == I_TYPE;



    /* skip b frames if we dont have reference frames */

    if(s->last_picture.data[0]==NULL && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);

    /* skip b frames if we are in a hurry */

    if(avctx->hurry_up && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);

    /* skip everything if we are in a hurry>=5 */

    if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);

    

    if(s->next_p_frame_damaged){

        if(s->pict_type==B_TYPE)

            return get_consumed_bytes(s, buf_size);

        else

            s->next_p_frame_damaged=0;

    }



    if(MPV_frame_start(s, avctx) < 0)

        return -1;



#ifdef DEBUG

    printf("qscale=%d\n", s->qscale);

#endif



    if(s->error_resilience)

        memset(s->error_status_table, MV_ERROR|AC_ERROR|DC_ERROR|VP_START|AC_END|DC_END|MV_END, s->mb_num*sizeof(UINT8));

    

    /* decode each macroblock */

    s->block_wrap[0]=

    s->block_wrap[1]=

    s->block_wrap[2]=

    s->block_wrap[3]= s->mb_width*2 + 2;

    s->block_wrap[4]=

    s->block_wrap[5]= s->mb_width + 2;

    s->mb_x=0; 

    s->mb_y=0;

    

    decode_slice(s);

    s->error_status_table[0]|= VP_START;

    while(s->mb_y<s->mb_height && s->gb.size*8 - get_bits_count(&s->gb)>16){

        if(s->msmpeg4_version){

            if(s->mb_x!=0 || (s->mb_y%s->slice_height)!=0)

                break;

        }else{

            if(ff_h263_resync(s)<0)

                break;

        }

        

        if(s->msmpeg4_version<4 && s->h263_pred)

            ff_mpeg4_clean_buffers(s);



        decode_slice(s);



        s->error_status_table[s->resync_mb_x + s->resync_mb_y*s->mb_width]|= VP_START;

    }



    if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE)

        if(msmpeg4_decode_ext_header(s, buf_size) < 0){

            s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;

        }

    

    /* divx 5.01+ bistream reorder stuff */

    if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_version>=500){

        int current_pos= get_bits_count(&s->gb)>>3;



        if(   buf_size - current_pos > 5 

           && buf_size - current_pos < BITSTREAM_BUFFER_SIZE){

            int i;

            int startcode_found=0;

            for(i=current_pos; i<buf_size-3; i++){

                if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){

                    startcode_found=1;

                    break;

                }

            }

            if(startcode_found){

                memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos);

                s->bitstream_buffer_size= buf_size - current_pos;

            }

        }

    }



    if(s->error_resilience){

        int error=0, num_end_markers=0;

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

            int status= s->error_status_table[i];

#if 0

            if(i%s->mb_width == 0) printf("\n");

            printf("%2X ", status); 

#endif

            if(status==0) continue;



            if(status&(DC_ERROR|AC_ERROR|MV_ERROR))

                error=1;

            if(status&VP_START){

                if(num_end_markers) 

                    error=1;

                num_end_markers=3;

            }

            if(status&AC_END)

                num_end_markers--;

            if(status&DC_END)

                num_end_markers--;

            if(status&MV_END)

                num_end_markers--;

        }

        if(num_end_markers || error){

            fprintf(stderr, "concealing errors\n");

            ff_error_resilience(s);

        }

    }



    MPV_frame_end(s);



    if((avctx->debug&FF_DEBUG_VIS_MV) && s->last_picture.data[0]){

        const int shift= 1 + s->quarter_sample;

        int mb_y;

        uint8_t *ptr= s->last_picture.data[0];

        s->low_delay=0; //needed to see the vectors without trashing the buffers



        for(mb_y=0; mb_y<s->mb_height; mb_y++){

            int mb_x;

            for(mb_x=0; mb_x<s->mb_width; mb_x++){

                const int mb_index= mb_x + mb_y*s->mb_width;

                if(s->co_located_type_table[mb_index] == MV_TYPE_8X8){

                    int i;

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

                        int sx= mb_x*16 + 4 + 8*(i&1);

                        int sy= mb_y*16 + 4 + 8*(i>>1);

                        int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);

                        int mx= (s->motion_val[xy][0]>>shift) + sx;

                        int my= (s->motion_val[xy][1]>>shift) + sy;

                        draw_line(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);

                    }

                }else{

                    int sx= mb_x*16 + 8;

                    int sy= mb_y*16 + 8;

                    int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);

                    int mx= (s->motion_val[xy][0]>>shift) + sx;

                    int my= (s->motion_val[xy][1]>>shift) + sy;

                    draw_line(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);

                }

                s->mbskip_table[mb_index]=0;

            }

        }

    }





    if(s->pict_type==B_TYPE || s->low_delay){

        *pict= *(AVFrame*)&s->current_picture;

    } else {

        *pict= *(AVFrame*)&s->last_picture;

    }



    if(avctx->debug&FF_DEBUG_QP){

        int8_t *qtab= pict->qscale_table;

        int x,y;

        

        for(y=0; y<s->mb_height; y++){

            for(x=0; x<s->mb_width; x++){

                printf("%2d ", qtab[x + y*s->mb_width]);

            }

            printf("\n");

        }

        printf("\n");

    }



    /* Return the Picture timestamp as the frame number */

    /* we substract 1 because it is added on utils.c    */

    avctx->frame_number = s->picture_number - 1;



    /* dont output the last pic after seeking */

    if(s->last_picture.data[0] || s->low_delay)

        *data_size = sizeof(AVFrame);

#ifdef PRINT_FRAME_TIME

printf("%Ld\n", rdtsc()-time);

#endif

    return get_consumed_bytes(s, buf_size);

}

int ff_h263_decode_frame(AVCodecContext *avctx, 

                             void *data, int *data_size,

                             UINT8 *buf, int buf_size)

{

    MpegEncContext *s = avctx->priv_data;

    int ret,i;

    AVFrame *pict = data; 

    float new_aspect;

    

#ifdef PRINT_FRAME_TIME

uint64_t time= rdtsc();

#endif

#ifdef DEBUG

    printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);

    printf("bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);

#endif

    s->flags= avctx->flags;



    *data_size = 0;

   

   

    if (buf_size == 0) {

        return 0;

    }

    

    if(s->flags&CODEC_FLAG_TRUNCATED){

        int next;

        ParseContext *pc= &s->parse_context;

        

        pc->last_index= pc->index;



        if(s->codec_id==CODEC_ID_MPEG4){

            next= mpeg4_find_frame_end(s, buf, buf_size);

        }else{

            fprintf(stderr, "this codec doesnt support truncated bitstreams\n");

            return -1;

        }

        if(next==-1){

            if(buf_size + FF_INPUT_BUFFER_PADDING_SIZE + pc->index > pc->buffer_size){

                pc->buffer_size= buf_size + pc->index + 10*1024;

                pc->buffer= realloc(pc->buffer, pc->buffer_size);

            }



            memcpy(&pc->buffer[pc->index], buf, buf_size);

            pc->index += buf_size;

            return buf_size;

        }



        if(pc->index){

            if(next + FF_INPUT_BUFFER_PADDING_SIZE + pc->index > pc->buffer_size){

                pc->buffer_size= next + pc->index + 10*1024;

                pc->buffer= realloc(pc->buffer, pc->buffer_size);

            }



            memcpy(&pc->buffer[pc->index], buf, next + FF_INPUT_BUFFER_PADDING_SIZE );

            pc->index = 0;

            buf= pc->buffer;

            buf_size= pc->last_index + next;

        }

    }



retry:

    

    if(s->bitstream_buffer_size && buf_size<20){ 

        init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size);

    }else

        init_get_bits(&s->gb, buf, buf_size);

    s->bitstream_buffer_size=0;



    if (!s->context_initialized) {

        if (MPV_common_init(s) < 0) 

            return -1;

    }

      

    

    if (s->msmpeg4_version==5) {

        ret= ff_wmv2_decode_picture_header(s);

    } else if (s->msmpeg4_version) {

        ret = msmpeg4_decode_picture_header(s);

    } else if (s->h263_pred) {

        if(s->avctx->extradata_size && s->picture_number==0){

            GetBitContext gb;

            

            init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size);

            ret = ff_mpeg4_decode_picture_header(s, &gb);

        }

        ret = ff_mpeg4_decode_picture_header(s, &s->gb);



        if(s->flags& CODEC_FLAG_LOW_DELAY)

            s->low_delay=1;

    } else if (s->h263_intel) {

        ret = intel_h263_decode_picture_header(s);

    } else {

        ret = h263_decode_picture_header(s);

    }

    avctx->has_b_frames= !s->low_delay;



    if(s->workaround_bugs&FF_BUG_AUTODETECT){

        if(s->padding_bug_score > -2 && !s->data_partitioning)

            s->workaround_bugs |=  FF_BUG_NO_PADDING;

        else

            s->workaround_bugs &= ~FF_BUG_NO_PADDING;



        if(s->avctx->fourcc == ff_get_fourcc("XVIX")) 

            s->workaround_bugs|= FF_BUG_XVID_ILACE;

#if 0

        if(s->avctx->fourcc == ff_get_fourcc("MP4S")) 

            s->workaround_bugs|= FF_BUG_AC_VLC;

        

        if(s->avctx->fourcc == ff_get_fourcc("M4S2")) 

            s->workaround_bugs|= FF_BUG_AC_VLC;

#endif

        if(s->avctx->fourcc == ff_get_fourcc("UMP4")){

            s->workaround_bugs|= FF_BUG_UMP4;

            s->workaround_bugs|= FF_BUG_AC_VLC;

        }



        if(s->divx_version){

            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;

        }



        if(s->avctx->fourcc == ff_get_fourcc("XVID") && s->xvid_build==0)

            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;

        

        if(s->avctx->fourcc == ff_get_fourcc("XVID") && s->xvid_build==0)

            s->padding_bug_score= 256*256*256*64;

        

        if(s->xvid_build && s->xvid_build<=3)

            s->padding_bug_score= 256*256*256*64;

        

        if(s->xvid_build && s->xvid_build<=1)

            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;



#define SET_QPEL_FUNC(postfix1, postfix2) \

    s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\

    s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\

    s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;



        if(s->lavc_build && s->lavc_build<4653)

            s->workaround_bugs|= FF_BUG_STD_QPEL;

        



#if 0

        if(s->divx_version==500)

            s->workaround_bugs|= FF_BUG_NO_PADDING;



        





        if(   s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0

           && s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)

            s->workaround_bugs|= FF_BUG_NO_PADDING;

        

        if(s->lavc_build && s->lavc_build<4609) 

            s->workaround_bugs|= FF_BUG_NO_PADDING;

#endif

    }

    

    if(s->workaround_bugs& FF_BUG_STD_QPEL){

        SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)



        SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)

    }



#if 0 

{

    static FILE *f=NULL;

    if(!f) f=fopen("rate_qp_cplx.txt", "w");

    fprintf(f, "%d %d %f\n", buf_size, s->qscale, buf_size*(double)s->qscale);

}

#endif

       

        

        

        

        

    if(s->aspected_height)

        new_aspect= s->aspected_width*s->width / (float)(s->height*s->aspected_height);

    else

        new_aspect=0;

    

    if (   s->width != avctx->width || s->height != avctx->height 

        || ABS(new_aspect - avctx->aspect_ratio) > 0.001) {

        

        MPV_common_end(s);

        s->context_initialized=0;

    }

    if (!s->context_initialized) {

        avctx->width = s->width;

        avctx->height = s->height;

        avctx->aspect_ratio= new_aspect;



        goto retry;

    }



    if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P))

        s->gob_index = ff_h263_get_gob_height(s);



    if(ret==FRAME_SKIPED) return get_consumed_bytes(s, buf_size);

    

    if (ret < 0){

        fprintf(stderr, "header damaged\n");

        return -1;

    }

    

    

    s->current_picture.pict_type= s->pict_type;

    s->current_picture.key_frame= s->pict_type == I_TYPE;



    

    if(s->last_picture.data[0]==NULL && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);

    

    if(avctx->hurry_up && s->pict_type==B_TYPE) return get_consumed_bytes(s, buf_size);

    

    if(avctx->hurry_up>=5) return get_consumed_bytes(s, buf_size);

    

    if(s->next_p_frame_damaged){

        if(s->pict_type==B_TYPE)

            return get_consumed_bytes(s, buf_size);

        else

            s->next_p_frame_damaged=0;

    }



    if(MPV_frame_start(s, avctx) < 0)

        return -1;



#ifdef DEBUG

    printf("qscale=%d\n", s->qscale);

#endif



    if(s->error_resilience)

        memset(s->error_status_table, MV_ERROR|AC_ERROR|DC_ERROR|VP_START|AC_END|DC_END|MV_END, s->mb_num*sizeof(UINT8));

    

    

    s->block_wrap[0]=

    s->block_wrap[1]=

    s->block_wrap[2]=

    s->block_wrap[3]= s->mb_width*2 + 2;

    s->block_wrap[4]=

    s->block_wrap[5]= s->mb_width + 2;

    s->mb_x=0; 

    s->mb_y=0;

    

    decode_slice(s);

    s->error_status_table[0]|= VP_START;

    while(s->mb_y<s->mb_height && s->gb.size*8 - get_bits_count(&s->gb)>16){

        if(s->msmpeg4_version){

            if(s->mb_x!=0 || (s->mb_y%s->slice_height)!=0)

                break;

        }else{

            if(ff_h263_resync(s)<0)

                break;

        }

        

        if(s->msmpeg4_version<4 && s->h263_pred)

            ff_mpeg4_clean_buffers(s);



        decode_slice(s);



        s->error_status_table[s->resync_mb_x + s->resync_mb_y*s->mb_width]|= VP_START;

    }



    if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE)

        if(msmpeg4_decode_ext_header(s, buf_size) < 0){

            s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;

        }

    

    

    if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_version>=500){

        int current_pos= get_bits_count(&s->gb)>>3;



        if(   buf_size - current_pos > 5 

           && buf_size - current_pos < BITSTREAM_BUFFER_SIZE){

            int i;

            int startcode_found=0;

            for(i=current_pos; i<buf_size-3; i++){

                if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){

                    startcode_found=1;

                    break;

                }

            }

            if(startcode_found){

                memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos);

                s->bitstream_buffer_size= buf_size - current_pos;

            }

        }

    }



    if(s->error_resilience){

        int error=0, num_end_markers=0;

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

            int status= s->error_status_table[i];

#if 0

            if(i%s->mb_width == 0) printf("\n");

            printf("%2X ", status); 

#endif

            if(status==0) continue;



            if(status&(DC_ERROR|AC_ERROR|MV_ERROR))

                error=1;

            if(status&VP_START){

                if(num_end_markers) 

                    error=1;

                num_end_markers=3;

            }

            if(status&AC_END)

                num_end_markers--;

            if(status&DC_END)

                num_end_markers--;

            if(status&MV_END)

                num_end_markers--;

        }

        if(num_end_markers || error){

            fprintf(stderr, "concealing errors\n");

            ff_error_resilience(s);

        }

    }



    MPV_frame_end(s);



    if((avctx->debug&FF_DEBUG_VIS_MV) && s->last_picture.data[0]){

        const int shift= 1 + s->quarter_sample;

        int mb_y;

        uint8_t *ptr= s->last_picture.data[0];

        s->low_delay=0; 



        for(mb_y=0; mb_y<s->mb_height; mb_y++){

            int mb_x;

            for(mb_x=0; mb_x<s->mb_width; mb_x++){

                const int mb_index= mb_x + mb_y*s->mb_width;

                if(s->co_located_type_table[mb_index] == MV_TYPE_8X8){

                    int i;

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

                        int sx= mb_x*16 + 4 + 8*(i&1);

                        int sy= mb_y*16 + 4 + 8*(i>>1);

                        int xy= 1 + mb_x*2 + (i&1) + (mb_y*2 + 1 + (i>>1))*(s->mb_width*2 + 2);

                        int mx= (s->motion_val[xy][0]>>shift) + sx;

                        int my= (s->motion_val[xy][1]>>shift) + sy;

                        draw_line(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);

                    }

                }else{

                    int sx= mb_x*16 + 8;

                    int sy= mb_y*16 + 8;

                    int xy= 1 + mb_x*2 + (mb_y*2 + 1)*(s->mb_width*2 + 2);

                    int mx= (s->motion_val[xy][0]>>shift) + sx;

                    int my= (s->motion_val[xy][1]>>shift) + sy;

                    draw_line(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);

                }

                s->mbskip_table[mb_index]=0;

            }

        }

    }





    if(s->pict_type==B_TYPE || s->low_delay){

        *pict= *(AVFrame*)&s->current_picture;

    } else {

        *pict= *(AVFrame*)&s->last_picture;

    }



    if(avctx->debug&FF_DEBUG_QP){

        int8_t *qtab= pict->qscale_table;

        int x,y;

        

        for(y=0; y<s->mb_height; y++){

            for(x=0; x<s->mb_width; x++){

                printf("%2d ", qtab[x + y*s->mb_width]);

            }

            printf("\n");

        }

        printf("\n");

    }



    

    

    avctx->frame_number = s->picture_number - 1;



    

    if(s->last_picture.data[0] || s->low_delay)

        *data_size = sizeof(AVFrame);

#ifdef PRINT_FRAME_TIME

printf("%Ld\n", rdtsc()-time);

#endif

    return get_consumed_bytes(s, buf_size);

}

int FUNC_0(AVCodecContext *VAR_0, 

                             void *VAR_1, int *VAR_2,

                             UINT8 *VAR_3, int VAR_4)

{

    MpegEncContext *s = VAR_0->priv_data;

    int VAR_5,VAR_10;

    AVFrame *pict = VAR_1; 

    float VAR_7;

    

#ifdef PRINT_FRAME_TIME

uint64_t time= rdtsc();

#endif

#ifdef DEBUG

    printf("*****frame %d size=%d\n", VAR_0->frame_number, VAR_4);

    printf("bytes=%VAR_15 %VAR_15 %VAR_15 %VAR_15\n", VAR_3[0], VAR_3[1], VAR_3[2], VAR_3[3]);

#endif

    s->flags= VAR_0->flags;



    *VAR_2 = 0;

   

   

    if (VAR_4 == 0) {

        return 0;

    }

    

    if(s->flags&CODEC_FLAG_TRUNCATED){

        int VAR_8;

        ParseContext *pc= &s->parse_context;

        

        pc->last_index= pc->index;



        if(s->codec_id==CODEC_ID_MPEG4){

            VAR_8= mpeg4_find_frame_end(s, VAR_3, VAR_4);

        }else{

            fprintf(stderr, "this codec doesnt support truncated bitstreams\n");

            return -1;

        }

        if(VAR_8==-1){

            if(VAR_4 + FF_INPUT_BUFFER_PADDING_SIZE + pc->index > pc->buffer_size){

                pc->buffer_size= VAR_4 + pc->index + 10*1024;

                pc->buffer= realloc(pc->buffer, pc->buffer_size);

            }



            memcpy(&pc->buffer[pc->index], VAR_3, VAR_4);

            pc->index += VAR_4;

            return VAR_4;

        }



        if(pc->index){

            if(VAR_8 + FF_INPUT_BUFFER_PADDING_SIZE + pc->index > pc->buffer_size){

                pc->buffer_size= VAR_8 + pc->index + 10*1024;

                pc->buffer= realloc(pc->buffer, pc->buffer_size);

            }



            memcpy(&pc->buffer[pc->index], VAR_3, VAR_8 + FF_INPUT_BUFFER_PADDING_SIZE );

            pc->index = 0;

            VAR_3= pc->buffer;

            VAR_4= pc->last_index + VAR_8;

        }

    }



retry:

    

    if(s->bitstream_buffer_size && VAR_4<20){ 

        init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size);

    }else

        init_get_bits(&s->gb, VAR_3, VAR_4);

    s->bitstream_buffer_size=0;



    if (!s->context_initialized) {

        if (MPV_common_init(s) < 0) 

            return -1;

    }

      

    

    if (s->msmpeg4_version==5) {

        VAR_5= ff_wmv2_decode_picture_header(s);

    } else if (s->msmpeg4_version) {

        VAR_5 = msmpeg4_decode_picture_header(s);

    } else if (s->h263_pred) {

        if(s->VAR_0->extradata_size && s->picture_number==0){

            GetBitContext gb;

            

            init_get_bits(&gb, s->VAR_0->extradata, s->VAR_0->extradata_size);

            VAR_5 = ff_mpeg4_decode_picture_header(s, &gb);

        }

        VAR_5 = ff_mpeg4_decode_picture_header(s, &s->gb);



        if(s->flags& CODEC_FLAG_LOW_DELAY)

            s->low_delay=1;

    } else if (s->h263_intel) {

        VAR_5 = intel_h263_decode_picture_header(s);

    } else {

        VAR_5 = h263_decode_picture_header(s);

    }

    VAR_0->has_b_frames= !s->low_delay;



    if(s->workaround_bugs&FF_BUG_AUTODETECT){

        if(s->padding_bug_score > -2 && !s->data_partitioning)

            s->workaround_bugs |=  FF_BUG_NO_PADDING;

        else

            s->workaround_bugs &= ~FF_BUG_NO_PADDING;



        if(s->VAR_0->fourcc == ff_get_fourcc("XVIX")) 

            s->workaround_bugs|= FF_BUG_XVID_ILACE;

#if 0

        if(s->VAR_0->fourcc == ff_get_fourcc("MP4S")) 

            s->workaround_bugs|= FF_BUG_AC_VLC;

        

        if(s->VAR_0->fourcc == ff_get_fourcc("M4S2")) 

            s->workaround_bugs|= FF_BUG_AC_VLC;

#endif

        if(s->VAR_0->fourcc == ff_get_fourcc("UMP4")){

            s->workaround_bugs|= FF_BUG_UMP4;

            s->workaround_bugs|= FF_BUG_AC_VLC;

        }



        if(s->divx_version){

            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;

        }



        if(s->VAR_0->fourcc == ff_get_fourcc("XVID") && s->xvid_build==0)

            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;

        

        if(s->VAR_0->fourcc == ff_get_fourcc("XVID") && s->xvid_build==0)

            s->padding_bug_score= 256*256*256*64;

        

        if(s->xvid_build && s->xvid_build<=3)

            s->padding_bug_score= 256*256*256*64;

        

        if(s->xvid_build && s->xvid_build<=1)

            s->workaround_bugs|= FF_BUG_QPEL_CHROMA;



#define SET_QPEL_FUNC(postfix1, postfix2) \

    s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\

    s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\

    s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;



        if(s->lavc_build && s->lavc_build<4653)

            s->workaround_bugs|= FF_BUG_STD_QPEL;

        



#if 0

        if(s->divx_version==500)

            s->workaround_bugs|= FF_BUG_NO_PADDING;



        





        if(   s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0

           && s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)

            s->workaround_bugs|= FF_BUG_NO_PADDING;

        

        if(s->lavc_build && s->lavc_build<4609) 

            s->workaround_bugs|= FF_BUG_NO_PADDING;

#endif

    }

    

    if(s->workaround_bugs& FF_BUG_STD_QPEL){

        SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)



        SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)

        SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)

    }



#if 0 

{

    static FILE *f=NULL;

    if(!f) f=fopen("rate_qp_cplx.txt", "w");

    fprintf(f, "%d %d %f\n", VAR_4, s->qscale, VAR_4*(double)s->qscale);

}

#endif

       

        

        

        

        

    if(s->aspected_height)

        VAR_7= s->aspected_width*s->width / (float)(s->height*s->aspected_height);

    else

        VAR_7=0;

    

    if (   s->width != VAR_0->width || s->height != VAR_0->height 

        || ABS(VAR_7 - VAR_0->aspect_ratio) > 0.001) {

        

        MPV_common_end(s);

        s->context_initialized=0;

    }

    if (!s->context_initialized) {

        VAR_0->width = s->width;

        VAR_0->height = s->height;

        VAR_0->aspect_ratio= VAR_7;



        goto retry;

    }



    if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P))

        s->gob_index = ff_h263_get_gob_height(s);



    if(VAR_5==FRAME_SKIPED) return get_consumed_bytes(s, VAR_4);

    

    if (VAR_5 < 0){

        fprintf(stderr, "header damaged\n");

        return -1;

    }

    

    

    s->current_picture.pict_type= s->pict_type;

    s->current_picture.key_frame= s->pict_type == I_TYPE;



    

    if(s->last_picture.VAR_1[0]==NULL && s->pict_type==B_TYPE) return get_consumed_bytes(s, VAR_4);

    

    if(VAR_0->hurry_up && s->pict_type==B_TYPE) return get_consumed_bytes(s, VAR_4);

    

    if(VAR_0->hurry_up>=5) return get_consumed_bytes(s, VAR_4);

    

    if(s->next_p_frame_damaged){

        if(s->pict_type==B_TYPE)

            return get_consumed_bytes(s, VAR_4);

        else

            s->next_p_frame_damaged=0;

    }



    if(MPV_frame_start(s, VAR_0) < 0)

        return -1;



#ifdef DEBUG

    printf("qscale=%d\n", s->qscale);

#endif



    if(s->error_resilience)

        memset(s->error_status_table, MV_ERROR|AC_ERROR|DC_ERROR|VP_START|AC_END|DC_END|MV_END, s->mb_num*sizeof(UINT8));

    

    

    s->block_wrap[0]=

    s->block_wrap[1]=

    s->block_wrap[2]=

    s->block_wrap[3]= s->mb_width*2 + 2;

    s->block_wrap[4]=

    s->block_wrap[5]= s->mb_width + 2;

    s->mb_x=0; 

    s->VAR_14=0;

    

    decode_slice(s);

    s->error_status_table[0]|= VP_START;

    while(s->VAR_14<s->mb_height && s->gb.size*8 - get_bits_count(&s->gb)>16){

        if(s->msmpeg4_version){

            if(s->mb_x!=0 || (s->VAR_14%s->slice_height)!=0)

                break;

        }else{

            if(ff_h263_resync(s)<0)

                break;

        }

        

        if(s->msmpeg4_version<4 && s->h263_pred)

            ff_mpeg4_clean_buffers(s);



        decode_slice(s);



        s->error_status_table[s->resync_mb_x + s->resync_mb_y*s->mb_width]|= VP_START;

    }



    if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE)

        if(msmpeg4_decode_ext_header(s, VAR_4) < 0){

            s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR;

        }

    

    

    if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_version>=500){

        int VAR_9= get_bits_count(&s->gb)>>3;



        if(   VAR_4 - VAR_9 > 5 

           && VAR_4 - VAR_9 < BITSTREAM_BUFFER_SIZE){

            int VAR_10;

            int VAR_10=0;

            for(VAR_10=VAR_9; VAR_10<VAR_4-3; VAR_10++){

                if(VAR_3[VAR_10]==0 && VAR_3[VAR_10+1]==0 && VAR_3[VAR_10+2]==1 && VAR_3[VAR_10+3]==0xB6){

                    VAR_10=1;

                    break;

                }

            }

            if(VAR_10){

                memcpy(s->bitstream_buffer, VAR_3 + VAR_9, VAR_4 - VAR_9);

                s->bitstream_buffer_size= VAR_4 - VAR_9;

            }

        }

    }



    if(s->error_resilience){

        int VAR_11=0, VAR_12=0;

        for(VAR_10=0; VAR_10<s->mb_num; VAR_10++){

            int status= s->error_status_table[VAR_10];

#if 0

            if(VAR_10%s->mb_width == 0) printf("\n");

            printf("%2X ", status); 

#endif

            if(status==0) continue;



            if(status&(DC_ERROR|AC_ERROR|MV_ERROR))

                VAR_11=1;

            if(status&VP_START){

                if(VAR_12) 

                    VAR_11=1;

                VAR_12=3;

            }

            if(status&AC_END)

                VAR_12--;

            if(status&DC_END)

                VAR_12--;

            if(status&MV_END)

                VAR_12--;

        }

        if(VAR_12 || VAR_11){

            fprintf(stderr, "concealing errors\n");

            ff_error_resilience(s);

        }

    }



    MPV_frame_end(s);



    if((VAR_0->debug&FF_DEBUG_VIS_MV) && s->last_picture.VAR_1[0]){

        const int VAR_13= 1 + s->quarter_sample;

        int VAR_14;

        uint8_t *ptr= s->last_picture.VAR_1[0];

        s->low_delay=0; 



        for(VAR_14=0; VAR_14<s->mb_height; VAR_14++){

            int mb_x;

            for(mb_x=0; mb_x<s->mb_width; mb_x++){

                const int mb_index= mb_x + VAR_14*s->mb_width;

                if(s->co_located_type_table[mb_index] == MV_TYPE_8X8){

                    int VAR_10;

                    for(VAR_10=0; VAR_10<4; VAR_10++){

                        int sx= mb_x*16 + 4 + 8*(VAR_10&1);

                        int sy= VAR_14*16 + 4 + 8*(VAR_10>>1);

                        int xy= 1 + mb_x*2 + (VAR_10&1) + (VAR_14*2 + 1 + (VAR_10>>1))*(s->mb_width*2 + 2);

                        int mx= (s->motion_val[xy][0]>>VAR_13) + sx;

                        int my= (s->motion_val[xy][1]>>VAR_13) + sy;

                        draw_line(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);

                    }

                }else{

                    int sx= mb_x*16 + 8;

                    int sy= VAR_14*16 + 8;

                    int xy= 1 + mb_x*2 + (VAR_14*2 + 1)*(s->mb_width*2 + 2);

                    int mx= (s->motion_val[xy][0]>>VAR_13) + sx;

                    int my= (s->motion_val[xy][1]>>VAR_13) + sy;

                    draw_line(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100);

                }

                s->mbskip_table[mb_index]=0;

            }

        }

    }





    if(s->pict_type==B_TYPE || s->low_delay){

        *pict= *(AVFrame*)&s->current_picture;

    } else {

        *pict= *(AVFrame*)&s->last_picture;

    }



    if(VAR_0->debug&FF_DEBUG_QP){

        int8_t *qtab= pict->qscale_table;

        int VAR_15,VAR_16;

        

        for(VAR_16=0; VAR_16<s->mb_height; VAR_16++){

            for(VAR_15=0; VAR_15<s->mb_width; VAR_15++){

                printf("%2d ", qtab[VAR_15 + VAR_16*s->mb_width]);

            }

            printf("\n");

        }

        printf("\n");

    }



    

    

    VAR_0->frame_number = s->picture_number - 1;



    

    if(s->last_picture.VAR_1[0] || s->low_delay)

        *VAR_2 = sizeof(AVFrame);

#ifdef PRINT_FRAME_TIME

printf("%Ld\n", rdtsc()-time);

#endif

    return get_consumed_bytes(s, VAR_4);

}

int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2,
UINT8 *VAR_3, int VAR_4)
{ MpegEncContext *s = VAR_0->priv_data; int VAR_5,VAR_10; AVFrame *pict = VAR_1; float VAR_7; #ifdef PRINT_FRAME_TIME
uint64_t time= rdtsc(); #endif
#ifdef DEBUG
printf("*****frame %d size=%d\n", VAR_0->frame_number, VAR_4); printf("bytes=%VAR_15 %VAR_15 %VAR_15 %VAR_15\n", VAR_3[0], VAR_3[1], VAR_3[2], VAR_3[3]); #endif
s->flags= VAR_0->flags; *VAR_2 = 0; if (VAR_4 == 0) { return 0; } if(s->flags&CODEC_FLAG_TRUNCATED){ int VAR_8; ParseContext *pc= &s->parse_context; pc->last_index= pc->index; if(s->codec_id==CODEC_ID_MPEG4){ VAR_8= mpeg4_find_frame_end(s, VAR_3, VAR_4); }else{ fprintf(stderr, "this codec doesnt support truncated bitstreams\n"); return -1; } if(VAR_8==-1){ if(VAR_4 + FF_INPUT_BUFFER_PADDING_SIZE + pc->index > pc->buffer_size){ pc->buffer_size= VAR_4 + pc->index + 10*1024; pc->buffer= realloc(pc->buffer, pc->buffer_size); } memcpy(&pc->buffer[pc->index], VAR_3, VAR_4); pc->index += VAR_4; return VAR_4; } if(pc->index){ if(VAR_8 + FF_INPUT_BUFFER_PADDING_SIZE + pc->index > pc->buffer_size){ pc->buffer_size= VAR_8 + pc->index + 10*1024; pc->buffer= realloc(pc->buffer, pc->buffer_size); } memcpy(&pc->buffer[pc->index], VAR_3, VAR_8 + FF_INPUT_BUFFER_PADDING_SIZE ); pc->index = 0; VAR_3= pc->buffer; VAR_4= pc->last_index + VAR_8; } } retry:
if(s->bitstream_buffer_size && VAR_4<20){ init_get_bits(&s->gb, s->bitstream_buffer, s->bitstream_buffer_size); }else init_get_bits(&s->gb, VAR_3, VAR_4); s->bitstream_buffer_size=0; if (!s->context_initialized) { if (MPV_common_init(s) < 0)
return -1; } if (s->msmpeg4_version==5) { VAR_5= ff_wmv2_decode_picture_header(s); } else if (s->msmpeg4_version) { VAR_5 = msmpeg4_decode_picture_header(s); } else if (s->h263_pred) { if(s->VAR_0->extradata_size && s->picture_number==0){ GetBitContext gb; init_get_bits(&gb, s->VAR_0->extradata, s->VAR_0->extradata_size); VAR_5 = ff_mpeg4_decode_picture_header(s, &gb); } VAR_5 = ff_mpeg4_decode_picture_header(s, &s->gb); if(s->flags& CODEC_FLAG_LOW_DELAY)
s->low_delay=1; } else if (s->h263_intel) { VAR_5 = intel_h263_decode_picture_header(s); } else { VAR_5 = h263_decode_picture_header(s); } VAR_0->has_b_frames= !s->low_delay; if(s->workaround_bugs&FF_BUG_AUTODETECT){ if(s->padding_bug_score > -2 && !s->data_partitioning)
s->workaround_bugs |=  FF_BUG_NO_PADDING; else
s->workaround_bugs &= ~FF_BUG_NO_PADDING; if(s->VAR_0->fourcc == ff_get_fourcc("XVIX"))
s->workaround_bugs|= FF_BUG_XVID_ILACE; #if 0
if(s->VAR_0->fourcc == ff_get_fourcc("MP4S"))
s->workaround_bugs|= FF_BUG_AC_VLC; if(s->VAR_0->fourcc == ff_get_fourcc("M4S2"))
s->workaround_bugs|= FF_BUG_AC_VLC; #endif
if(s->VAR_0->fourcc == ff_get_fourcc("UMP4")){ s->workaround_bugs|= FF_BUG_UMP4; s->workaround_bugs|= FF_BUG_AC_VLC; } if(s->divx_version){ s->workaround_bugs|= FF_BUG_QPEL_CHROMA; } if(s->VAR_0->fourcc == ff_get_fourcc("XVID") && s->xvid_build==0)
s->workaround_bugs|= FF_BUG_QPEL_CHROMA; if(s->VAR_0->fourcc == ff_get_fourcc("XVID") && s->xvid_build==0)
s->padding_bug_score= 256*256*256*64; if(s->xvid_build && s->xvid_build<=3)
s->padding_bug_score= 256*256*256*64; if(s->xvid_build && s->xvid_build<=1)
s->workaround_bugs|= FF_BUG_QPEL_CHROMA; #define SET_QPEL_FUNC(postfix1, postfix2) \
s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\ s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\ s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2; if(s->lavc_build && s->lavc_build<4653)
s->workaround_bugs|= FF_BUG_STD_QPEL; #if 0
if(s->divx_version==500)
s->workaround_bugs|= FF_BUG_NO_PADDING; if(   s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==0
&& s->codec_id==CODEC_ID_MPEG4 && s->vo_type==0)
s->workaround_bugs|= FF_BUG_NO_PADDING; if(s->lavc_build && s->lavc_build<4609)
s->workaround_bugs|= FF_BUG_NO_PADDING; #endif
} if(s->workaround_bugs& FF_BUG_STD_QPEL){ SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)
SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)
} #if 0
{ static FILE *f=NULL; if(!f) f=fopen("rate_qp_cplx.txt", "w"); fprintf(f, "%d %d %f\n", VAR_4, s->qscale, VAR_4*(double)s->qscale); } #endif
if(s->aspected_height)
VAR_7= s->aspected_width*s->width / (float)(s->height*s->aspected_height); else
VAR_7=0; if (   s->width != VAR_0->width || s->height != VAR_0->height
|| ABS(VAR_7 - VAR_0->aspect_ratio) > 0.001) { MPV_common_end(s); s->context_initialized=0; } if (!s->context_initialized) { VAR_0->width = s->width; VAR_0->height = s->height; VAR_0->aspect_ratio= VAR_7; goto retry; } if((s->codec_id==CODEC_ID_H263 || s->codec_id==CODEC_ID_H263P))
s->gob_index = ff_h263_get_gob_height(s); if(VAR_5==FRAME_SKIPED) return get_consumed_bytes(s, VAR_4); if (VAR_5 < 0){ fprintf(stderr, "header damaged\n"); return -1; } s->current_picture.pict_type= s->pict_type; s->current_picture.key_frame= s->pict_type == I_TYPE; if(s->last_picture.VAR_1[0]==NULL && s->pict_type==B_TYPE) return get_consumed_bytes(s, VAR_4); if(VAR_0->hurry_up && s->pict_type==B_TYPE) return get_consumed_bytes(s, VAR_4); if(VAR_0->hurry_up>=5) return get_consumed_bytes(s, VAR_4); if(s->next_p_frame_damaged){ if(s->pict_type==B_TYPE)
return get_consumed_bytes(s, VAR_4); else
s->next_p_frame_damaged=0; } if(MPV_frame_start(s, VAR_0) < 0)
return -1; #ifdef DEBUG
printf("qscale=%d\n", s->qscale); #endif
if(s->error_resilience)
memset(s->error_status_table, MV_ERROR|AC_ERROR|DC_ERROR|VP_START|AC_END|DC_END|MV_END, s->mb_num*sizeof(UINT8)); s->block_wrap[0]=
s->block_wrap[1]=
s->block_wrap[2]=
s->block_wrap[3]= s->mb_width*2 + 2; s->block_wrap[4]=
s->block_wrap[5]= s->mb_width + 2; s->mb_x=0; s->VAR_14=0; decode_slice(s); s->error_status_table[0]|= VP_START; while(s->VAR_14<s->mb_height && s->gb.size*8 - get_bits_count(&s->gb)>16){ if(s->msmpeg4_version){ if(s->mb_x!=0 || (s->VAR_14%s->slice_height)!=0)
break; }else{ if(ff_h263_resync(s)<0)
break; } if(s->msmpeg4_version<4 && s->h263_pred)
ff_mpeg4_clean_buffers(s); decode_slice(s); s->error_status_table[s->resync_mb_x + s->resync_mb_y*s->mb_width]|= VP_START; } if (s->h263_msmpeg4 && s->msmpeg4_version<4 && s->pict_type==I_TYPE)
if(msmpeg4_decode_ext_header(s, VAR_4) < 0){ s->error_status_table[s->mb_num-1]= AC_ERROR|DC_ERROR|MV_ERROR; } if(s->codec_id==CODEC_ID_MPEG4 && s->bitstream_buffer_size==0 && s->divx_version>=500){ int VAR_9= get_bits_count(&s->gb)>>3; if(   VAR_4 - VAR_9 > 5
&& VAR_4 - VAR_9 < BITSTREAM_BUFFER_SIZE){ int VAR_10; int VAR_10=0; for(VAR_10=VAR_9; VAR_10<VAR_4-3; VAR_10++){ if(VAR_3[VAR_10]==0 && VAR_3[VAR_10+1]==0 && VAR_3[VAR_10+2]==1 && VAR_3[VAR_10+3]==0xB6){ VAR_10=1; break; } } if(VAR_10){ memcpy(s->bitstream_buffer, VAR_3 + VAR_9, VAR_4 - VAR_9); s->bitstream_buffer_size= VAR_4 - VAR_9; } } } if(s->error_resilience){ int VAR_11=0, VAR_12=0; for(VAR_10=0; VAR_10<s->mb_num; VAR_10++){ int status= s->error_status_table[VAR_10]; #if 0
if(VAR_10%s->mb_width == 0) printf("\n"); printf("%2X ", status); #endif
if(status==0) continue; if(status&(DC_ERROR|AC_ERROR|MV_ERROR))
VAR_11=1; if(status&VP_START){ if(VAR_12)
VAR_11=1; VAR_12=3; } if(status&AC_END)
VAR_12--; if(status&DC_END)
VAR_12--; if(status&MV_END)
VAR_12--; } if(VAR_12 || VAR_11){ fprintf(stderr, "concealing errors\n"); ff_error_resilience(s); } } MPV_frame_end(s); if((VAR_0->debug&FF_DEBUG_VIS_MV) && s->last_picture.VAR_1[0]){ const int VAR_13= 1 + s->quarter_sample; int VAR_14; uint8_t *ptr= s->last_picture.VAR_1[0]; s->low_delay=0; for(VAR_14=0; VAR_14<s->mb_height; VAR_14++){ int mb_x; for(mb_x=0; mb_x<s->mb_width; mb_x++){ const int mb_index= mb_x + VAR_14*s->mb_width; if(s->co_located_type_table[mb_index] == MV_TYPE_8X8){ int VAR_10; for(VAR_10=0; VAR_10<4; VAR_10++){ int sx= mb_x*16 + 4 + 8*(VAR_10&1); int sy= VAR_14*16 + 4 + 8*(VAR_10>>1); int xy= 1 + mb_x*2 + (VAR_10&1) + (VAR_14*2 + 1 + (VAR_10>>1))*(s->mb_width*2 + 2); int mx= (s->motion_val[xy][0]>>VAR_13) + sx; int my= (s->motion_val[xy][1]>>VAR_13) + sy; draw_line(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100); } }else{ int sx= mb_x*16 + 8; int sy= VAR_14*16 + 8; int xy= 1 + mb_x*2 + (VAR_14*2 + 1)*(s->mb_width*2 + 2); int mx= (s->motion_val[xy][0]>>VAR_13) + sx; int my= (s->motion_val[xy][1]>>VAR_13) + sy; draw_line(ptr, sx, sy, mx, my, s->width, s->height, s->linesize, 100); } s->mbskip_table[mb_index]=0; } } } if(s->pict_type==B_TYPE || s->low_delay){ *pict= *(AVFrame*)&s->current_picture; } else { *pict= *(AVFrame*)&s->last_picture; } if(VAR_0->debug&FF_DEBUG_QP){ int8_t *qtab= pict->qscale_table; int VAR_15,VAR_16; for(VAR_16=0; VAR_16<s->mb_height; VAR_16++){ for(VAR_15=0; VAR_15<s->mb_width; VAR_15++){ printf("%2d ", qtab[VAR_15 + VAR_16*s->mb_width]); } printf("\n"); } printf("\n"); } VAR_0->frame_number = s->picture_number - 1; if(s->last_picture.VAR_1[0] || s->low_delay)
*VAR_2 = sizeof(AVFrame); #ifdef PRINT_FRAME_TIME
printf("%Ld\n", rdtsc()-time); #endif
return get_consumed_bytes(s, VAR_4); }