PeerStreamer

/*

 * H.26L/H.264/AVC/JVT/14496-10/... decoder

 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>

 *

 * This file is part of Libav.

 *

 * Libav is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * Libav is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with Libav; if not, write to the Free Software

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

 */

/**

 * @file

 * H.264 / AVC / MPEG4 part10 codec.

 * @author Michael Niedermayer <michaelni@gmx.at>

 */

#include "libavutil/imgutils.h"

#include "internal.h"

#include "dsputil.h"

#include "avcodec.h"

#include "mpegvideo.h"

#include "h264.h"

#include "h264data.h"

#include "h264_mvpred.h"

#include "golomb.h"

#include "mathops.h"

#include "rectangle.h"

#include "vdpau_internal.h"

#include "libavutil/avassert.h"

#include "cabac.h"

//#undef NDEBUG

#include <assert.h>

static const uint8_t rem6[52]={

0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,

};

static const uint8_t div6[52]={

0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8,

};

static const enum PixelFormat hwaccel_pixfmt_list_h264_jpeg_420[] = {

    PIX_FMT_DXVA2_VLD,

    PIX_FMT_VAAPI_VLD,

    PIX_FMT_YUVJ420P,

    PIX_FMT_NONE

};

void ff_h264_write_back_intra_pred_mode(H264Context *h){

    int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[h->mb_xy];

    AV_COPY32(mode, h->intra4x4_pred_mode_cache + 4 + 8*4);

    mode[4]= h->intra4x4_pred_mode_cache[7+8*3];

    mode[5]= h->intra4x4_pred_mode_cache[7+8*2];

    mode[6]= h->intra4x4_pred_mode_cache[7+8*1];

}

/**

 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.

 */

int ff_h264_check_intra4x4_pred_mode(H264Context *h){

    MpegEncContext * const s = &h->s;

    static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};

    static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};

    int i;

    if(!(h->top_samples_available&0x8000)){

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

            int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];

            if(status<0){

                av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);

                return -1;

            } else if(status){

                h->intra4x4_pred_mode_cache[scan8[0] + i]= status;

            }

        }

    }

    if((h->left_samples_available&0x8888)!=0x8888){

        static const int mask[4]={0x8000,0x2000,0x80,0x20};

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

            if(!(h->left_samples_available&mask[i])){

                int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];

                if(status<0){

                    av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);

                    return -1;

                } else if(status){

                    h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;

                }

            }

        }

    }

    return 0;

} //FIXME cleanup like ff_h264_check_intra_pred_mode

/**

 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.

 */

int ff_h264_check_intra_pred_mode(H264Context *h, int mode){

    MpegEncContext * const s = &h->s;

    static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};

    static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};

    if(mode > 6U) {

        av_log(h->s.avctx, AV_LOG_ERROR, "out of range intra chroma pred mode at %d %d\n", s->mb_x, s->mb_y);

        return -1;

    }

    if(!(h->top_samples_available&0x8000)){

        mode= top[ mode ];

        if(mode<0){

            av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);

            return -1;

        }

    }

    if((h->left_samples_available&0x8080) != 0x8080){

        mode= left[ mode ];

        if(h->left_samples_available&0x8080){ //mad cow disease mode, aka MBAFF + constrained_intra_pred

            mode= ALZHEIMER_DC_L0T_PRED8x8 + (!(h->left_samples_available&0x8000)) + 2*(mode == DC_128_PRED8x8);

        }

        if(mode<0){

            av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);

            return -1;

        }

    }

    return mode;

}

const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){

    int i, si, di;

    uint8_t *dst;

    int bufidx;

//    src[0]&0x80;                //forbidden bit

    h->nal_ref_idc= src[0]>>5;

    h->nal_unit_type= src[0]&0x1F;

    src++; length--;

#if 0

    for(i=0; i<length; i++)

        printf("%2X ", src[i]);

#endif

#if HAVE_FAST_UNALIGNED

# if HAVE_FAST_64BIT

#   define RS 7

    for(i=0; i+1<length; i+=9){

        if(!((~AV_RN64A(src+i) & (AV_RN64A(src+i) - 0x0100010001000101ULL)) & 0x8000800080008080ULL))

# else

#   define RS 3

    for(i=0; i+1<length; i+=5){

        if(!((~AV_RN32A(src+i) & (AV_RN32A(src+i) - 0x01000101U)) & 0x80008080U))

# endif

            continue;

        if(i>0 && !src[i]) i--;

        while(src[i]) i++;

#else

#   define RS 0

    for(i=0; i+1<length; i+=2){

        if(src[i]) continue;

        if(i>0 && src[i-1]==0) i--;

#endif

        if(i+2<length && src[i+1]==0 && src[i+2]<=3){

            if(src[i+2]!=3){

                /* startcode, so we must be past the end */

                length=i;

            }

            break;

        }

        i-= RS;

    }

    if(i>=length-1){ //no escaped 0

        *dst_length= length;

        *consumed= length+1; //+1 for the header

        return src;

    }

    bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data

    av_fast_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE);

    dst= h->rbsp_buffer[bufidx];

    if (dst == NULL){

        return NULL;

    }

//printf("decoding esc\n");

    memcpy(dst, src, i);

    si=di=i;

    while(si+2<length){

        //remove escapes (very rare 1:2^22)

        if(src[si+2]>3){

            dst[di++]= src[si++];

            dst[di++]= src[si++];

        }else if(src[si]==0 && src[si+1]==0){

            if(src[si+2]==3){ //escape

                dst[di++]= 0;

                dst[di++]= 0;

                si+=3;

                continue;

            }else //next start code

                goto nsc;

        }

        dst[di++]= src[si++];

    }

    while(si<length)

        dst[di++]= src[si++];

nsc:

    memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);

    *dst_length= di;

    *consumed= si + 1;//+1 for the header

//FIXME store exact number of bits in the getbitcontext (it is needed for decoding)

    return dst;

}

/**

 * Identify the exact end of the bitstream

 * @return the length of the trailing, or 0 if damaged

 */

static int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src){

    int v= *src;

    int r;

    tprintf(h->s.avctx, "rbsp trailing %X\n", v);

    for(r=1; r<9; r++){

        if(v&1) return r;

        v>>=1;

    }

    return 0;

}

#if 0

/**

 * DCT transforms the 16 dc values.

 * @param qp quantization parameter ??? FIXME

 */

static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){

//    const int qmul= dequant_coeff[qp][0];

    int i;

    int temp[16]; //FIXME check if this is a good idea

    static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};

    static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};

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

        const int offset= y_offset[i];

        const int z0= block[offset+stride*0] + block[offset+stride*4];

        const int z1= block[offset+stride*0] - block[offset+stride*4];

        const int z2= block[offset+stride*1] - block[offset+stride*5];

        const int z3= block[offset+stride*1] + block[offset+stride*5];

        temp[4*i+0]= z0+z3;

        temp[4*i+1]= z1+z2;

        temp[4*i+2]= z1-z2;

        temp[4*i+3]= z0-z3;

    }

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

        const int offset= x_offset[i];

        const int z0= temp[4*0+i] + temp[4*2+i];

        const int z1= temp[4*0+i] - temp[4*2+i];

        const int z2= temp[4*1+i] - temp[4*3+i];

        const int z3= temp[4*1+i] + temp[4*3+i];

        block[stride*0 +offset]= (z0 + z3)>>1;

        block[stride*2 +offset]= (z1 + z2)>>1;

        block[stride*8 +offset]= (z1 - z2)>>1;

        block[stride*10+offset]= (z0 - z3)>>1;

    }

}

#endif

#undef xStride

#undef stride

static void chroma_dc_dequant_idct_c(DCTELEM *block, int qmul){

    const int stride= 16*2;

    const int xStride= 16;

    int a,b,c,d,e;

    a= block[stride*0 + xStride*0];

    b= block[stride*0 + xStride*1];

    c= block[stride*1 + xStride*0];

    d= block[stride*1 + xStride*1];

    e= a-b;

    a= a+b;

    b= c-d;

    c= c+d;

    block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;

    block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;

    block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;

    block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;

}

#if 0

static void chroma_dc_dct_c(DCTELEM *block){

    const int stride= 16*2;

    const int xStride= 16;

    int a,b,c,d,e;

    a= block[stride*0 + xStride*0];

    b= block[stride*0 + xStride*1];

    c= block[stride*1 + xStride*0];

    d= block[stride*1 + xStride*1];

    e= a-b;

    a= a+b;

    b= c-d;

    c= c+d;

    block[stride*0 + xStride*0]= (a+c);

    block[stride*0 + xStride*1]= (e+b);

    block[stride*1 + xStride*0]= (a-c);

    block[stride*1 + xStride*1]= (e-b);

}

#endif

static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,

                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

                           int src_x_offset, int src_y_offset,

                           qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){

    MpegEncContext * const s = &h->s;

    const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;

    int my=       h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;

    const int luma_xy= (mx&3) + ((my&3)<<2);

    uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize;

    uint8_t * src_cb, * src_cr;

    int extra_width= h->emu_edge_width;

    int extra_height= h->emu_edge_height;

    int emu=0;

    const int full_mx= mx>>2;

    const int full_my= my>>2;

    const int pic_width  = 16*s->mb_width;

    const int pic_height = 16*s->mb_height >> MB_FIELD;

    if(mx&7) extra_width -= 3;

    if(my&7) extra_height -= 3;

    if(   full_mx < 0-extra_width

       || full_my < 0-extra_height

       || full_mx + 16/*FIXME*/ > pic_width + extra_width

       || full_my + 16/*FIXME*/ > pic_height + extra_height){

        s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*h->mb_linesize, h->mb_linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);

            src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize;

        emu=1;

    }

    qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps?

    if(!square){

        qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);

    }

    if(CONFIG_GRAY && s->flags&CODEC_FLAG_GRAY) return;

    if(MB_FIELD){

        // chroma offset when predicting from a field of opposite parity

        my += 2 * ((s->mb_y & 1) - (pic->reference - 1));

        emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);

    }

    src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize;

    src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize;

    if(emu){

        s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cb, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);

            src_cb= s->edge_emu_buffer;

    }

    chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);

    if(emu){

        s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cr, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);

            src_cr= s->edge_emu_buffer;

    }

    chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);

}

static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,

                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

                           int x_offset, int y_offset,

                           qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,

                           qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,

                           int list0, int list1){

    MpegEncContext * const s = &h->s;

    qpel_mc_func *qpix_op=  qpix_put;

    h264_chroma_mc_func chroma_op= chroma_put;

    dest_y  += 2*x_offset + 2*y_offset*h->  mb_linesize;

    dest_cb +=   x_offset +   y_offset*h->mb_uvlinesize;

    dest_cr +=   x_offset +   y_offset*h->mb_uvlinesize;

    x_offset += 8*s->mb_x;

    y_offset += 8*(s->mb_y >> MB_FIELD);

    if(list0){

        Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];

        mc_dir_part(h, ref, n, square, chroma_height, delta, 0,

                           dest_y, dest_cb, dest_cr, x_offset, y_offset,

                           qpix_op, chroma_op);

        qpix_op=  qpix_avg;

        chroma_op= chroma_avg;

    }

    if(list1){

        Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];

        mc_dir_part(h, ref, n, square, chroma_height, delta, 1,

                           dest_y, dest_cb, dest_cr, x_offset, y_offset,

                           qpix_op, chroma_op);

    }

}

static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,

                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

                           int x_offset, int y_offset,

                           qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,

                           h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,

                           h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,

                           int list0, int list1){

    MpegEncContext * const s = &h->s;

    dest_y  += 2*x_offset + 2*y_offset*h->  mb_linesize;

    dest_cb +=   x_offset +   y_offset*h->mb_uvlinesize;

    dest_cr +=   x_offset +   y_offset*h->mb_uvlinesize;

    x_offset += 8*s->mb_x;

    y_offset += 8*(s->mb_y >> MB_FIELD);

    if(list0 && list1){

        /* don't optimize for luma-only case, since B-frames usually

         * use implicit weights => chroma too. */

        uint8_t *tmp_cb = s->obmc_scratchpad;

        uint8_t *tmp_cr = s->obmc_scratchpad + 8;

        uint8_t *tmp_y  = s->obmc_scratchpad + 8*h->mb_uvlinesize;

        int refn0 = h->ref_cache[0][ scan8[n] ];

        int refn1 = h->ref_cache[1][ scan8[n] ];

        mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,

                    dest_y, dest_cb, dest_cr,

                    x_offset, y_offset, qpix_put, chroma_put);

        mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,

                    tmp_y, tmp_cb, tmp_cr,

                    x_offset, y_offset, qpix_put, chroma_put);

        if(h->use_weight == 2){

            int weight0 = h->implicit_weight[refn0][refn1][s->mb_y&1];

            int weight1 = 64 - weight0;

            luma_weight_avg(  dest_y,  tmp_y,  h->  mb_linesize, 5, weight0, weight1, 0);

            chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);

            chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);

        }else{

            luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,

                            h->luma_weight[refn0][0][0] , h->luma_weight[refn1][1][0],

                            h->luma_weight[refn0][0][1] + h->luma_weight[refn1][1][1]);

            chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,

                            h->chroma_weight[refn0][0][0][0] , h->chroma_weight[refn1][1][0][0],

                            h->chroma_weight[refn0][0][0][1] + h->chroma_weight[refn1][1][0][1]);

            chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,

                            h->chroma_weight[refn0][0][1][0] , h->chroma_weight[refn1][1][1][0],

                            h->chroma_weight[refn0][0][1][1] + h->chroma_weight[refn1][1][1][1]);

        }

    }else{

        int list = list1 ? 1 : 0;

        int refn = h->ref_cache[list][ scan8[n] ];

        Picture *ref= &h->ref_list[list][refn];

        mc_dir_part(h, ref, n, square, chroma_height, delta, list,

                    dest_y, dest_cb, dest_cr, x_offset, y_offset,

                    qpix_put, chroma_put);

        luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,

                       h->luma_weight[refn][list][0], h->luma_weight[refn][list][1]);

        if(h->use_weight_chroma){

            chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,

                             h->chroma_weight[refn][list][0][0], h->chroma_weight[refn][list][0][1]);

            chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,

                             h->chroma_weight[refn][list][1][0], h->chroma_weight[refn][list][1][1]);

        }

    }

}

static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,

                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

                           int x_offset, int y_offset,

                           qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,

                           qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,

                           h264_weight_func *weight_op, h264_biweight_func *weight_avg,

                           int list0, int list1){

    if((h->use_weight==2 && list0 && list1

        && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ][h->s.mb_y&1] != 32))

       || h->use_weight==1)

        mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,

                         x_offset, y_offset, qpix_put, chroma_put,

                         weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1);

    else

        mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,

                    x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1);

}

static inline void prefetch_motion(H264Context *h, int list){

    /* fetch pixels for estimated mv 4 macroblocks ahead

     * optimized for 64byte cache lines */

    MpegEncContext * const s = &h->s;

    const int refn = h->ref_cache[list][scan8[0]];

    if(refn >= 0){

        const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;

        const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;

        uint8_t **src= h->ref_list[list][refn].data;

        int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64;

        s->dsp.prefetch(src[0]+off, s->linesize, 4);

        off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;

        s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);

    }

}

static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,

                      qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),

                      qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),

                      h264_weight_func *weight_op, h264_biweight_func *weight_avg){

    MpegEncContext * const s = &h->s;

    const int mb_xy= h->mb_xy;

    const int mb_type= s->current_picture.mb_type[mb_xy];

    assert(IS_INTER(mb_type));

    prefetch_motion(h, 0);

    if(IS_16X16(mb_type)){

        mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,

                qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],

                weight_op, weight_avg,

                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));

    }else if(IS_16X8(mb_type)){

        mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,

                qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],

                &weight_op[1], &weight_avg[1],

                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));

        mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,

                qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],

                &weight_op[1], &weight_avg[1],

                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));

    }else if(IS_8X16(mb_type)){

        mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,

                qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],

                &weight_op[2], &weight_avg[2],

                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));

        mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,

                qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],

                &weight_op[2], &weight_avg[2],

                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));

    }else{

        int i;

        assert(IS_8X8(mb_type));

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

            const int sub_mb_type= h->sub_mb_type[i];

            const int n= 4*i;

            int x_offset= (i&1)<<2;

            int y_offset= (i&2)<<1;

            if(IS_SUB_8X8(sub_mb_type)){

                mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,

                    qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],

                    &weight_op[3], &weight_avg[3],

                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

            }else if(IS_SUB_8X4(sub_mb_type)){

                mc_part(h, n  , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,

                    qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],

                    &weight_op[4], &weight_avg[4],

                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

                mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,

                    qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],

                    &weight_op[4], &weight_avg[4],

                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

            }else if(IS_SUB_4X8(sub_mb_type)){

                mc_part(h, n  , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,

                    qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],

                    &weight_op[5], &weight_avg[5],

                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

                mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,

                    qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],

                    &weight_op[5], &weight_avg[5],

                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

            }else{

                int j;

                assert(IS_SUB_4X4(sub_mb_type));

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

                    int sub_x_offset= x_offset + 2*(j&1);

                    int sub_y_offset= y_offset +   (j&2);

                    mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,

                        qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],

                        &weight_op[6], &weight_avg[6],

                        IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));

                }

            }

        }

    }

    prefetch_motion(h, 1);

}

static void free_tables(H264Context *h, int free_rbsp){

    int i;

    H264Context *hx;

    av_freep(&h->intra4x4_pred_mode);

    av_freep(&h->chroma_pred_mode_table);

    av_freep(&h->cbp_table);

    av_freep(&h->mvd_table[0]);

    av_freep(&h->mvd_table[1]);

    av_freep(&h->direct_table);

    av_freep(&h->non_zero_count);

    av_freep(&h->slice_table_base);

    h->slice_table= NULL;

    av_freep(&h->list_counts);

    av_freep(&h->mb2b_xy);

    av_freep(&h->mb2br_xy);

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

        hx = h->thread_context[i];

        if(!hx) continue;

        av_freep(&hx->top_borders[1]);

        av_freep(&hx->top_borders[0]);

        av_freep(&hx->s.obmc_scratchpad);

        if (free_rbsp){

            av_freep(&hx->rbsp_buffer[1]);

            av_freep(&hx->rbsp_buffer[0]);

            hx->rbsp_buffer_size[0] = 0;

            hx->rbsp_buffer_size[1] = 0;

        }

        if (i) av_freep(&h->thread_context[i]);

    }

}

static void init_dequant8_coeff_table(H264Context *h){

    int i,q,x;

    h->dequant8_coeff[0] = h->dequant8_buffer[0];

    h->dequant8_coeff[1] = h->dequant8_buffer[1];

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

        if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){

            h->dequant8_coeff[1] = h->dequant8_buffer[0];

            break;

        }

        for(q=0; q<52; q++){

            int shift = div6[q];

            int idx = rem6[q];

            for(x=0; x<64; x++)

                h->dequant8_coeff[i][q][(x>>3)|((x&7)<<3)] =

                    ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *

                    h->pps.scaling_matrix8[i][x]) << shift;

        }

    }

}

static void init_dequant4_coeff_table(H264Context *h){

    int i,j,q,x;

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

        h->dequant4_coeff[i] = h->dequant4_buffer[i];

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

            if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){

                h->dequant4_coeff[i] = h->dequant4_buffer[j];

                break;

            }

        }

        if(j<i)

            continue;

        for(q=0; q<52; q++){

            int shift = div6[q] + 2;

            int idx = rem6[q];

            for(x=0; x<16; x++)

                h->dequant4_coeff[i][q][(x>>2)|((x<<2)&0xF)] =

                    ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *

                    h->pps.scaling_matrix4[i][x]) << shift;

        }

    }

}

static void init_dequant_tables(H264Context *h){

    int i,x;

    init_dequant4_coeff_table(h);

    if(h->pps.transform_8x8_mode)

        init_dequant8_coeff_table(h);

    if(h->sps.transform_bypass){

        for(i=0; i<6; i++)

            for(x=0; x<16; x++)

                h->dequant4_coeff[i][0][x] = 1<<6;

        if(h->pps.transform_8x8_mode)

            for(i=0; i<2; i++)

                for(x=0; x<64; x++)

                    h->dequant8_coeff[i][0][x] = 1<<6;

    }

}

int ff_h264_alloc_tables(H264Context *h){

    MpegEncContext * const s = &h->s;

    const int big_mb_num= s->mb_stride * (s->mb_height+1);

    const int row_mb_num= 2*s->mb_stride*s->avctx->thread_count;

    int x,y;

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->intra4x4_pred_mode, row_mb_num * 8  * sizeof(uint8_t), fail)

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->non_zero_count    , big_mb_num * 32 * sizeof(uint8_t), fail)

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->slice_table_base  , (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base), fail)

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->cbp_table, big_mb_num * sizeof(uint16_t), fail)

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t), fail)

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[0], 16*row_mb_num * sizeof(uint8_t), fail);

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[1], 16*row_mb_num * sizeof(uint8_t), fail);

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->direct_table, 4*big_mb_num * sizeof(uint8_t) , fail);

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->list_counts, big_mb_num * sizeof(uint8_t), fail)

    memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride)  * sizeof(*h->slice_table_base));

    h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2b_xy  , big_mb_num * sizeof(uint32_t), fail);

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2br_xy , big_mb_num * sizeof(uint32_t), fail);

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

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

            const int mb_xy= x + y*s->mb_stride;

            const int b_xy = 4*x + 4*y*h->b_stride;

            h->mb2b_xy [mb_xy]= b_xy;

            h->mb2br_xy[mb_xy]= 8*(FMO ? mb_xy : (mb_xy % (2*s->mb_stride)));

        }

    }

    s->obmc_scratchpad = NULL;

    if(!h->dequant4_coeff[0])

        init_dequant_tables(h);

    return 0;

fail:

    free_tables(h, 1);

    return -1;

}

/**

 * Mimic alloc_tables(), but for every context thread.

 */

static void clone_tables(H264Context *dst, H264Context *src, int i){

    MpegEncContext * const s = &src->s;

    dst->intra4x4_pred_mode       = src->intra4x4_pred_mode + i*8*2*s->mb_stride;

    dst->non_zero_count           = src->non_zero_count;

    dst->slice_table              = src->slice_table;

    dst->cbp_table                = src->cbp_table;

    dst->mb2b_xy                  = src->mb2b_xy;

    dst->mb2br_xy                 = src->mb2br_xy;

    dst->chroma_pred_mode_table   = src->chroma_pred_mode_table;

    dst->mvd_table[0]             = src->mvd_table[0] + i*8*2*s->mb_stride;

    dst->mvd_table[1]             = src->mvd_table[1] + i*8*2*s->mb_stride;

    dst->direct_table             = src->direct_table;

    dst->list_counts              = src->list_counts;

    dst->s.obmc_scratchpad = NULL;

    ff_h264_pred_init(&dst->hpc, src->s.codec_id);

}

/**

 * Init context

 * Allocate buffers which are not shared amongst multiple threads.

 */

static int context_init(H264Context *h){

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[0], h->s.mb_width * (16+8+8) * sizeof(uint8_t), fail)

    FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[1], h->s.mb_width * (16+8+8) * sizeof(uint8_t), fail)

    h->ref_cache[0][scan8[5 ]+1] = h->ref_cache[0][scan8[7 ]+1] = h->ref_cache[0][scan8[13]+1] =

    h->ref_cache[1][scan8[5 ]+1] = h->ref_cache[1][scan8[7 ]+1] = h->ref_cache[1][scan8[13]+1] = PART_NOT_AVAILABLE;

    return 0;

fail:

    return -1; // free_tables will clean up for us

}

static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size);

static av_cold void common_init(H264Context *h){

    MpegEncContext * const s = &h->s;

    s->width = s->avctx->width;

    s->height = s->avctx->height;

    s->codec_id= s->avctx->codec->id;

    ff_h264dsp_init(&h->h264dsp);

    ff_h264_pred_init(&h->hpc, s->codec_id);

    h->dequant_coeff_pps= -1;

    s->unrestricted_mv=1;

    s->decode=1; //FIXME

    dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early

    memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));

    memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));

}

int ff_h264_decode_extradata(H264Context *h)

{

    AVCodecContext *avctx = h->s.avctx;

    if(*(char *)avctx->extradata == 1){

        int i, cnt, nalsize;

        unsigned char *p = avctx->extradata;

        h->is_avc = 1;

        if(avctx->extradata_size < 7) {

            av_log(avctx, AV_LOG_ERROR, "avcC too short\n");

            return -1;

        }

        /* sps and pps in the avcC always have length coded with 2 bytes,

           so put a fake nal_length_size = 2 while parsing them */

        h->nal_length_size = 2;

        // Decode sps from avcC

        cnt = *(p+5) & 0x1f; // Number of sps

        p += 6;

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

            nalsize = AV_RB16(p) + 2;

            if(decode_nal_units(h, p, nalsize) < 0) {

                av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);

                return -1;

            }

            p += nalsize;

        }

        // Decode pps from avcC

        cnt = *(p++); // Number of pps

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

            nalsize = AV_RB16(p) + 2;

            if(decode_nal_units(h, p, nalsize)  != nalsize) {

                av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);

                return -1;

            }

            p += nalsize;

        }

        // Now store right nal length size, that will be use to parse all other nals

        h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1;

    } else {

        h->is_avc = 0;

        if(decode_nal_units(h, avctx->extradata, avctx->extradata_size) < 0)

            return -1;

    }

    return 0;

}

av_cold int ff_h264_decode_init(AVCodecContext *avctx){

    H264Context *h= avctx->priv_data;

    MpegEncContext * const s = &h->s;

    MPV_decode_defaults(s);

    s->avctx = avctx;

    common_init(h);

    s->out_format = FMT_H264;

    s->workaround_bugs= avctx->workaround_bugs;

    // set defaults

//    s->decode_mb= ff_h263_decode_mb;

    s->quarter_sample = 1;

    if(!avctx->has_b_frames)

    s->low_delay= 1;

    avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;

    ff_h264_decode_init_vlc();

    h->thread_context[0] = h;

    h->outputed_poc = INT_MIN;

    h->prev_poc_msb= 1<<16;

    h->x264_build = -1;

    ff_h264_reset_sei(h);

    if(avctx->codec_id == CODEC_ID_H264){

        if(avctx->ticks_per_frame == 1){

            s->avctx->time_base.den *=2;

        }

        avctx->ticks_per_frame = 2;

    }

    if(avctx->extradata_size > 0 && avctx->extradata &&

        ff_h264_decode_extradata(h))

        return -1;

    if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames < h->sps.num_reorder_frames){

        s->avctx->has_b_frames = h->sps.num_reorder_frames;

        s->low_delay = 0;

    }

    return 0;

}

int ff_h264_frame_start(H264Context *h){

    MpegEncContext * const s = &h->s;

    int i;

    if(MPV_frame_start(s, s->avctx) < 0)

        return -1;

    ff_er_frame_start(s);

    /*

     * MPV_frame_start uses pict_type to derive key_frame.

     * This is incorrect for H.264; IDR markings must be used.

     * Zero here; IDR markings per slice in frame or fields are ORed in later.

     * See decode_nal_units().

     */

    s->current_picture_ptr->key_frame= 0;

    s->current_picture_ptr->mmco_reset= 0;

    assert(s->linesize && s->uvlinesize);

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

        h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);

        h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);

    }

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

        h->block_offset[16+i]=

        h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);

        h->block_offset[24+16+i]=

        h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);

    }

    /* can't be in alloc_tables because linesize isn't known there.

     * FIXME: redo bipred weight to not require extra buffer? */

    for(i = 0; i < s->avctx->thread_count; i++)

        if(h->thread_context[i] && !h->thread_context[i]->s.obmc_scratchpad)

            h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);

    /* some macroblocks can be accessed before they're available in case of lost slices, mbaff or threading*/

    memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(*h->slice_table));

//    s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;

    // We mark the current picture as non-reference after allocating it, so

    // that if we break out due to an error it can be released automatically

    // in the next MPV_frame_start().

    // SVQ3 as well as most other codecs have only last/next/current and thus

    // get released even with set reference, besides SVQ3 and others do not

    // mark frames as reference later "naturally".

    if(s->codec_id != CODEC_ID_SVQ3)

        s->current_picture_ptr->reference= 0;

    s->current_picture_ptr->field_poc[0]=

    s->current_picture_ptr->field_poc[1]= INT_MAX;

    assert(s->current_picture_ptr->long_ref==0);

    return 0;

}

static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int simple){

    MpegEncContext * const s = &h->s;

    uint8_t *top_border;

    int top_idx = 1;

    src_y  -=   linesize;

    src_cb -= uvlinesize;

    src_cr -= uvlinesize;

    if(!simple && FRAME_MBAFF){

        if(s->mb_y&1){

            if(!MB_MBAFF){

                top_border = h->top_borders[0][s->mb_x];

                AV_COPY128(top_border, src_y + 15*linesize);

                if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

                    AV_COPY64(top_border+16, src_cb+7*uvlinesize);

                    AV_COPY64(top_border+24, src_cr+7*uvlinesize);

                }

            }

        }else if(MB_MBAFF){

            top_idx = 0;

        }else

            return;

    }

    top_border = h->top_borders[top_idx][s->mb_x];

    // There are two lines saved, the line above the the top macroblock of a pair,

    // and the line above the bottom macroblock

    AV_COPY128(top_border, src_y + 16*linesize);

    if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

        AV_COPY64(top_border+16, src_cb+8*uvlinesize);

        AV_COPY64(top_border+24, src_cr+8*uvlinesize);

    }

}

static inline void xchg_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg, int simple){

    MpegEncContext * const s = &h->s;

    int deblock_left;

    int deblock_top;

    int top_idx = 1;

    uint8_t *top_border_m1;

    uint8_t *top_border;

    if(!simple && FRAME_MBAFF){

        if(s->mb_y&1){

            if(!MB_MBAFF)

                return;

        }else{

            top_idx = MB_MBAFF ? 0 : 1;

        }

    }

    if(h->deblocking_filter == 2) {

        deblock_left = h->left_type[0];

        deblock_top  = h->top_type;

    } else {

        deblock_left = (s->mb_x > 0);

        deblock_top =  (s->mb_y > !!MB_FIELD);

    }

    src_y  -=   linesize + 1;

    src_cb -= uvlinesize + 1;

    src_cr -= uvlinesize + 1;

    top_border_m1 = h->top_borders[top_idx][s->mb_x-1];

    top_border    = h->top_borders[top_idx][s->mb_x];

#define XCHG(a,b,xchg)\

if (xchg) AV_SWAP64(b,a);\

else      AV_COPY64(b,a);

    if(deblock_top){

        if(deblock_left){

            XCHG(top_border_m1+8, src_y -7, 1);

        }

        XCHG(top_border+0, src_y +1, xchg);

        XCHG(top_border+8, src_y +9, 1);

        if(s->mb_x+1 < s->mb_width){

            XCHG(h->top_borders[top_idx][s->mb_x+1], src_y +17, 1);

        }

    }

    if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

        if(deblock_top){

            if(deblock_left){

                XCHG(top_border_m1+16, src_cb -7, 1);

                XCHG(top_border_m1+24, src_cr -7, 1);

            }

            XCHG(top_border+16, src_cb+1, 1);

            XCHG(top_border+24, src_cr+1, 1);

        }

    }

}

static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple){

    MpegEncContext * const s = &h->s;

    const int mb_x= s->mb_x;

    const int mb_y= s->mb_y;

    const int mb_xy= h->mb_xy;

    const int mb_type= s->current_picture.mb_type[mb_xy];

    uint8_t  *dest_y, *dest_cb, *dest_cr;

    int linesize, uvlinesize /*dct_offset*/;

    int i;

    int *block_offset = &h->block_offset[0];

    const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);

    /* is_h264 should always be true if SVQ3 is disabled. */

    const int is_h264 = !CONFIG_SVQ3_DECODER || simple || s->codec_id == CODEC_ID_H264;

    void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);

    void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);

    dest_y  = s->current_picture.data[0] + (mb_x + mb_y * s->linesize  ) * 16;

    dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8;

    dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8;

    s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4);

    s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2);

    h->list_counts[mb_xy]= h->list_count;

    if (!simple && MB_FIELD) {

        linesize   = h->mb_linesize   = s->linesize * 2;

        uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;

        block_offset = &h->block_offset[24];

        if(mb_y&1){ //FIXME move out of this function?

            dest_y -= s->linesize*15;

            dest_cb-= s->uvlinesize*7;

            dest_cr-= s->uvlinesize*7;

        }

        if(FRAME_MBAFF) {

            int list;

            for(list=0; list<h->list_count; list++){

                if(!USES_LIST(mb_type, list))

                    continue;

                if(IS_16X16(mb_type)){

                    int8_t *ref = &h->ref_cache[list][scan8[0]];

                    fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1);

                }else{

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

                        int ref = h->ref_cache[list][scan8[i]];

                        if(ref >= 0)

                            fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1);

                    }

                }

            }

        }

    } else {

        linesize   = h->mb_linesize   = s->linesize;

        uvlinesize = h->mb_uvlinesize = s->uvlinesize;

//        dct_offset = s->linesize * 16;

    }

    if (!simple && IS_INTRA_PCM(mb_type)) {

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

            memcpy(dest_y + i*  linesize, h->mb       + i*8, 16);

        }

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

            memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4,  8);

            memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4,  8);

        }

    } else {

        if(IS_INTRA(mb_type)){

            if(h->deblocking_filter)

                xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, simple);

            if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){

                h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);

                h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);

            }

            if(IS_INTRA4x4(mb_type)){

                if(simple || !s->encoding){

                    if(IS_8x8DCT(mb_type)){

                        if(transform_bypass){

                            idct_dc_add =

                            idct_add    = s->dsp.add_pixels8;

                        }else{

                            idct_dc_add = h->h264dsp.h264_idct8_dc_add;

                            idct_add    = h->h264dsp.h264_idct8_add;

                        }

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

                            uint8_t * const ptr= dest_y + block_offset[i];

                            const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];

                            if(transform_bypass && h->sps.profile_idc==244 && dir<=1){

                                h->hpc.pred8x8l_add[dir](ptr, h->mb + i*16, linesize);

                            }else{

                                const int nnz = h->non_zero_count_cache[ scan8[i] ];

                                h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,

                                                            (h->topright_samples_available<<i)&0x4000, linesize);

                                if(nnz){

                                    if(nnz == 1 && h->mb[i*16])

                                        idct_dc_add(ptr, h->mb + i*16, linesize);

                                    else

                                        idct_add   (ptr, h->mb + i*16, linesize);

                                }

                            }

                        }

                    }else{

                        if(transform_bypass){

                            idct_dc_add =

                            idct_add    = s->dsp.add_pixels4;

                        }else{

                            idct_dc_add = h->h264dsp.h264_idct_dc_add;

                            idct_add    = h->h264dsp.h264_idct_add;

                        }

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

                            uint8_t * const ptr= dest_y + block_offset[i];

                            const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];

                            if(transform_bypass && h->sps.profile_idc==244 && dir<=1){

                                h->hpc.pred4x4_add[dir](ptr, h->mb + i*16, linesize);

                            }else{

                                uint8_t *topright;

                                int nnz, tr;

                                if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){

                                    const int topright_avail= (h->topright_samples_available<<i)&0x8000;

                                    assert(mb_y || linesize <= block_offset[i]);

                                    if(!topright_avail){

                                        tr= ptr[3 - linesize]*0x01010101;

                                        topright= (uint8_t*) &tr;

                                    }else

                                        topright= ptr + 4 - linesize;

                                }else

                                    topright= NULL;

                                h->hpc.pred4x4[ dir ](ptr, topright, linesize);

                                nnz = h->non_zero_count_cache[ scan8[i] ];

                                if(nnz){

                                    if(is_h264){

                                        if(nnz == 1 && h->mb[i*16])

                                            idct_dc_add(ptr, h->mb + i*16, linesize);

                                        else

                                            idct_add   (ptr, h->mb + i*16, linesize);

                                    }else

                                        ff_svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);

                                }

                            }

                        }

                    }

                }

            }else{

                h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);

                if(is_h264){

                    if(h->non_zero_count_cache[ scan8[LUMA_DC_BLOCK_INDEX] ]){

                        if(!transform_bypass)

                            h->h264dsp.h264_luma_dc_dequant_idct(h->mb, h->mb_luma_dc, h->dequant4_coeff[0][s->qscale][0]);

                        else{

                            static const uint8_t dc_mapping[16] = { 0*16, 1*16, 4*16, 5*16, 2*16, 3*16, 6*16, 7*16,

                                                                    8*16, 9*16,12*16,13*16,10*16,11*16,14*16,15*16};

                            for(i = 0; i < 16; i++)

                                h->mb[dc_mapping[i]] = h->mb_luma_dc[i];

                        }

                    }

                }else

                    ff_svq3_luma_dc_dequant_idct_c(h->mb, h->mb_luma_dc, s->qscale);

            }

            if(h->deblocking_filter)

                xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, simple);

        }else if(is_h264){

            hl_motion(h, dest_y, dest_cb, dest_cr,

                      s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,

                      s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,

                      h->h264dsp.weight_h264_pixels_tab, h->h264dsp.biweight_h264_pixels_tab);

        }

        if(!IS_INTRA4x4(mb_type)){