PeerStreamer

/*

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

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

 *

 * This file is part of FFmpeg.

 *

 * FFmpeg 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.

 *

 * FFmpeg 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 FFmpeg; if not, write to the Free Software

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

 */

/**

 * @file h264.c

 * H.264 / AVC / MPEG4 part10 codec.

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

 */

#include "dsputil.h"

#include "avcodec.h"

#include "mpegvideo.h"

#include "h264.h"

#include "h264data.h"

#include "h264_parser.h"

#include "golomb.h"

#include "rectangle.h"

#include "vdpau_internal.h"

#include "cabac.h"

#if ARCH_X86

#include "x86/h264_i386.h"

#endif

//#undef NDEBUG

#include <assert.h>

/**

 * Value of Picture.reference when Picture is not a reference picture, but

 * is held for delayed output.

 */

#define DELAYED_PIC_REF 4

static VLC coeff_token_vlc[4];

static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];

static const int coeff_token_vlc_tables_size[4]={520,332,280,256};

static VLC chroma_dc_coeff_token_vlc;

static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];

static const int chroma_dc_coeff_token_vlc_table_size = 256;

static VLC total_zeros_vlc[15];

static VLC_TYPE total_zeros_vlc_tables[15][512][2];

static const int total_zeros_vlc_tables_size = 512;

static VLC chroma_dc_total_zeros_vlc[3];

static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];

static const int chroma_dc_total_zeros_vlc_tables_size = 8;

static VLC run_vlc[6];

static VLC_TYPE run_vlc_tables[6][8][2];

static const int run_vlc_tables_size = 8;

static VLC run7_vlc;

static VLC_TYPE run7_vlc_table[96][2];

static const int run7_vlc_table_size = 96;

static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp);

static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);

static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize);

static void filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize);

static Picture * remove_long(H264Context *h, int i, int ref_mask);

static av_always_inline uint32_t pack16to32(int a, int b){

#ifdef WORDS_BIGENDIAN

   return (b&0xFFFF) + (a<<16);

#else

   return (a&0xFFFF) + (b<<16);

#endif

}

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 int left_block_options[4][8]={

    {0,1,2,3,7,10,8,11},

    {2,2,3,3,8,11,8,11},

    {0,0,1,1,7,10,7,10},

    {0,2,0,2,7,10,7,10}

};

#define LEVEL_TAB_BITS 8

static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];

static void fill_caches(H264Context *h, int mb_type, int for_deblock){

    MpegEncContext * const s = &h->s;

    const int mb_xy= h->mb_xy;

    int topleft_xy, top_xy, topright_xy, left_xy[2];

    int topleft_type, top_type, topright_type, left_type[2];

    const int * left_block;

    int topleft_partition= -1;

    int i;

    top_xy     = mb_xy  - (s->mb_stride << FIELD_PICTURE);

    //FIXME deblocking could skip the intra and nnz parts.

    if(for_deblock && (h->slice_num == 1 || h->slice_table[mb_xy] == h->slice_table[top_xy]) && !FRAME_MBAFF)

        return;

    /* Wow, what a mess, why didn't they simplify the interlacing & intra

     * stuff, I can't imagine that these complex rules are worth it. */

    topleft_xy = top_xy - 1;

    topright_xy= top_xy + 1;

    left_xy[1] = left_xy[0] = mb_xy-1;

    left_block = left_block_options[0];

    if(FRAME_MBAFF){

        const int pair_xy          = s->mb_x     + (s->mb_y & ~1)*s->mb_stride;

        const int top_pair_xy      = pair_xy     - s->mb_stride;

        const int topleft_pair_xy  = top_pair_xy - 1;

        const int topright_pair_xy = top_pair_xy + 1;

        const int topleft_mb_field_flag  = IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]);

        const int top_mb_field_flag      = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);

        const int topright_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]);

        const int left_mb_field_flag     = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);

        const int curr_mb_field_flag     = IS_INTERLACED(mb_type);

        const int bottom = (s->mb_y & 1);

        tprintf(s->avctx, "fill_caches: curr_mb_field_flag:%d, left_mb_field_flag:%d, topleft_mb_field_flag:%d, top_mb_field_flag:%d, topright_mb_field_flag:%d\n", curr_mb_field_flag, left_mb_field_flag, topleft_mb_field_flag, top_mb_field_flag, topright_mb_field_flag);

        if (curr_mb_field_flag && (bottom || top_mb_field_flag)){

            top_xy -= s->mb_stride;

        }

        if (curr_mb_field_flag && (bottom || topleft_mb_field_flag)){

            topleft_xy -= s->mb_stride;

        } else if(bottom && !curr_mb_field_flag && left_mb_field_flag) {

            topleft_xy += s->mb_stride;

            // take top left mv from the middle of the mb, as opposed to all other modes which use the bottom right partition

            topleft_partition = 0;

        }

        if (curr_mb_field_flag && (bottom || topright_mb_field_flag)){

            topright_xy -= s->mb_stride;

        }

        if (left_mb_field_flag != curr_mb_field_flag) {

            left_xy[1] = left_xy[0] = pair_xy - 1;

            if (curr_mb_field_flag) {

                left_xy[1] += s->mb_stride;

                left_block = left_block_options[3];

            } else {

                left_block= left_block_options[2 - bottom];

            }

        }

    }

    h->top_mb_xy = top_xy;

    h->left_mb_xy[0] = left_xy[0];

    h->left_mb_xy[1] = left_xy[1];

    if(for_deblock){

        topleft_type = 0;

        topright_type = 0;

        top_type     = h->slice_table[top_xy     ] < 0xFFFF ? s->current_picture.mb_type[top_xy]     : 0;

        left_type[0] = h->slice_table[left_xy[0] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[0]] : 0;

        left_type[1] = h->slice_table[left_xy[1] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[1]] : 0;

        if(MB_MBAFF && !IS_INTRA(mb_type)){

            int list;

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

                //These values where changed for ease of performing MC, we need to change them back

                //FIXME maybe we can make MC and loop filter use the same values or prevent

                //the MC code from changing ref_cache and rather use a temporary array.

                if(USES_LIST(mb_type,list)){

                    int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]];

                    *(uint32_t*)&h->ref_cache[list][scan8[ 0]] =

                    *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = (pack16to32(ref[0],ref[1])&0x00FF00FF)*0x0101;

                    ref += h->b8_stride;

                    *(uint32_t*)&h->ref_cache[list][scan8[ 8]] =

                    *(uint32_t*)&h->ref_cache[list][scan8[10]] = (pack16to32(ref[0],ref[1])&0x00FF00FF)*0x0101;

                }

            }

        }

    }else{

        topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;

        top_type     = h->slice_table[top_xy     ] == h->slice_num ? s->current_picture.mb_type[top_xy]     : 0;

        topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;

        left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;

        left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;

    if(IS_INTRA(mb_type)){

        int type_mask= h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1;

        h->topleft_samples_available=

        h->top_samples_available=

        h->left_samples_available= 0xFFFF;

        h->topright_samples_available= 0xEEEA;

        if(!(top_type & type_mask)){

            h->topleft_samples_available= 0xB3FF;

            h->top_samples_available= 0x33FF;

            h->topright_samples_available= 0x26EA;

        }

        if(IS_INTERLACED(mb_type) != IS_INTERLACED(left_type[0])){

            if(IS_INTERLACED(mb_type)){

                if(!(left_type[0] & type_mask)){

                    h->topleft_samples_available&= 0xDFFF;

                    h->left_samples_available&= 0x5FFF;

                }

                if(!(left_type[1] & type_mask)){

                    h->topleft_samples_available&= 0xFF5F;

                    h->left_samples_available&= 0xFF5F;

                }

            }else{

                int left_typei = h->slice_table[left_xy[0] + s->mb_stride ] == h->slice_num

                                ? s->current_picture.mb_type[left_xy[0] + s->mb_stride] : 0;

                assert(left_xy[0] == left_xy[1]);

                if(!((left_typei & type_mask) && (left_type[0] & type_mask))){

                    h->topleft_samples_available&= 0xDF5F;

                    h->left_samples_available&= 0x5F5F;

                }

            }

        }else{

            if(!(left_type[0] & type_mask)){

                h->topleft_samples_available&= 0xDF5F;

                h->left_samples_available&= 0x5F5F;

            }

        }

        if(!(topleft_type & type_mask))

            h->topleft_samples_available&= 0x7FFF;

        if(!(topright_type & type_mask))

            h->topright_samples_available&= 0xFBFF;

        if(IS_INTRA4x4(mb_type)){

            if(IS_INTRA4x4(top_type)){

                h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4];

                h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5];

                h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6];

                h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3];

            }else{

                int pred;

                if(!(top_type & type_mask))

                    pred= -1;

                else{

                    pred= 2;

                }

                h->intra4x4_pred_mode_cache[4+8*0]=

                h->intra4x4_pred_mode_cache[5+8*0]=

                h->intra4x4_pred_mode_cache[6+8*0]=

                h->intra4x4_pred_mode_cache[7+8*0]= pred;

            }

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

                if(IS_INTRA4x4(left_type[i])){

                    h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]];

                    h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]];

                }else{

                    int pred;

                    if(!(left_type[i] & type_mask))

                        pred= -1;

                    else{

                        pred= 2;

                    }

                    h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=

                    h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred;

                }

            }

        }

    }

    }

/*

0 . T T. T T T T

1 L . .L . . . .

2 L . .L . . . .

3 . T TL . . . .

4 L . .L . . . .

5 L . .. . . . .

*/

//FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)

    if(top_type){

        h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4];

        h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5];

        h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6];

        h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3];

        h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9];

        h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8];

        h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12];

        h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11];

    }else{

        h->non_zero_count_cache[4+8*0]=

        h->non_zero_count_cache[5+8*0]=

        h->non_zero_count_cache[6+8*0]=

        h->non_zero_count_cache[7+8*0]=

        h->non_zero_count_cache[1+8*0]=

        h->non_zero_count_cache[2+8*0]=

        h->non_zero_count_cache[1+8*3]=

        h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;

    }

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

        if(left_type[i]){

            h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]];

            h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]];

            h->non_zero_count_cache[0+8*1 +   8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]];

            h->non_zero_count_cache[0+8*4 +   8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]];

        }else{

            h->non_zero_count_cache[3+8*1 + 2*8*i]=

            h->non_zero_count_cache[3+8*2 + 2*8*i]=

            h->non_zero_count_cache[0+8*1 +   8*i]=

            h->non_zero_count_cache[0+8*4 +   8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;

        }

    }

    if( h->pps.cabac ) {

        // top_cbp

        if(top_type) {

            h->top_cbp = h->cbp_table[top_xy];

        } else if(IS_INTRA(mb_type)) {

            h->top_cbp = 0x1C0;

        } else {

            h->top_cbp = 0;

        }

        // left_cbp

        if (left_type[0]) {

            h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0;

        } else if(IS_INTRA(mb_type)) {

            h->left_cbp = 0x1C0;

        } else {

            h->left_cbp = 0;

        }

        if (left_type[0]) {

            h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1;

        }

        if (left_type[1]) {

            h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3;

        }

    }

#if 1

    if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){

        int list;

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

            if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){

                /*if(!h->mv_cache_clean[list]){

                    memset(h->mv_cache [list],  0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all?

                    memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t));

                    h->mv_cache_clean[list]= 1;

                }*/

                continue;

            }

            h->mv_cache_clean[list]= 0;

            if(USES_LIST(top_type, list)){

                const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;

                const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;

                *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0];

                *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1];

                *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2];

                *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3];

                h->ref_cache[list][scan8[0] + 0 - 1*8]=

                h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0];

                h->ref_cache[list][scan8[0] + 2 - 1*8]=

                h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1];

            }else{

                *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]=

                *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]=

                *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]=

                *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0;

                *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;

            }

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

                int cache_idx = scan8[0] - 1 + i*2*8;

                if(USES_LIST(left_type[i], list)){

                    const int b_xy= h->mb2b_xy[left_xy[i]] + 3;

                    const int b8_xy= h->mb2b8_xy[left_xy[i]] + 1;

                    *(uint32_t*)h->mv_cache[list][cache_idx  ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0+i*2]];

                    *(uint32_t*)h->mv_cache[list][cache_idx+8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1+i*2]];

                    h->ref_cache[list][cache_idx  ]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0+i*2]>>1)];

                    h->ref_cache[list][cache_idx+8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1+i*2]>>1)];

                }else{

                    *(uint32_t*)h->mv_cache [list][cache_idx  ]=

                    *(uint32_t*)h->mv_cache [list][cache_idx+8]= 0;

                    h->ref_cache[list][cache_idx  ]=

                    h->ref_cache[list][cache_idx+8]= left_type[i] ? LIST_NOT_USED : PART_NOT_AVAILABLE;

                }

            }

            if(for_deblock || ((IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred) && !FRAME_MBAFF))

                continue;

            if(USES_LIST(topleft_type, list)){

                const int b_xy = h->mb2b_xy[topleft_xy] + 3 + h->b_stride + (topleft_partition & 2*h->b_stride);

                const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + (topleft_partition & h->b8_stride);

                *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];

                h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy];

            }else{

                *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0;

                h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;

            }

            if(USES_LIST(topright_type, list)){

                const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride;

                const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride;

                *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];

                h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy];

            }else{

                *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0;

                h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;

            }

            if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF)

                continue;

            h->ref_cache[list][scan8[5 ]+1] =

            h->ref_cache[list][scan8[7 ]+1] =

            h->ref_cache[list][scan8[13]+1] =  //FIXME remove past 3 (init somewhere else)

            h->ref_cache[list][scan8[4 ]] =

            h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE;

            *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]=

            *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]=

            *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)

            *(uint32_t*)h->mv_cache [list][scan8[4 ]]=

            *(uint32_t*)h->mv_cache [list][scan8[12]]= 0;

            if( h->pps.cabac ) {

                /* XXX beurk, Load mvd */

                if(USES_LIST(top_type, list)){

                    const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;

                    *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0];

                    *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1];

                    *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2];

                    *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3];

                }else{

                    *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]=

                    *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]=

                    *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]=

                    *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0;

                }

                if(USES_LIST(left_type[0], list)){

                    const int b_xy= h->mb2b_xy[left_xy[0]] + 3;

                    *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[0]];

                    *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[1]];

                }else{

                    *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]=

                    *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0;

                }

                if(USES_LIST(left_type[1], list)){

                    const int b_xy= h->mb2b_xy[left_xy[1]] + 3;

                    *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[2]];

                    *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[3]];

                }else{

                    *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]=

                    *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0;

                }

                *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]=

                *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]=

                *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)

                *(uint32_t*)h->mvd_cache [list][scan8[4 ]]=

                *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0;

                if(h->slice_type_nos == FF_B_TYPE){

                    fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1);

                    if(IS_DIRECT(top_type)){

                        *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101;

                    }else if(IS_8X8(top_type)){

                        int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride;

                        h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy];

                        h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1];

                    }else{

                        *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0;

                    }

                    if(IS_DIRECT(left_type[0]))

                        h->direct_cache[scan8[0] - 1 + 0*8]= 1;

                    else if(IS_8X8(left_type[0]))

                        h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[h->mb2b8_xy[left_xy[0]] + 1 + h->b8_stride*(left_block[0]>>1)];

                    else

                        h->direct_cache[scan8[0] - 1 + 0*8]= 0;

                    if(IS_DIRECT(left_type[1]))

                        h->direct_cache[scan8[0] - 1 + 2*8]= 1;

                    else if(IS_8X8(left_type[1]))

                        h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[h->mb2b8_xy[left_xy[1]] + 1 + h->b8_stride*(left_block[2]>>1)];

                    else

                        h->direct_cache[scan8[0] - 1 + 2*8]= 0;

                }

            }

            if(FRAME_MBAFF){

#define MAP_MVS\

                    MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\

                    MAP_F2F(scan8[0] + 0 - 1*8, top_type)\

                    MAP_F2F(scan8[0] + 1 - 1*8, top_type)\

                    MAP_F2F(scan8[0] + 2 - 1*8, top_type)\

                    MAP_F2F(scan8[0] + 3 - 1*8, top_type)\

                    MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\

                    MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\

                    MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\

                    MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\

                    MAP_F2F(scan8[0] - 1 + 3*8, left_type[1])

                if(MB_FIELD){

#define MAP_F2F(idx, mb_type)\

                    if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\

                        h->ref_cache[list][idx] <<= 1;\

                        h->mv_cache[list][idx][1] /= 2;\

                        h->mvd_cache[list][idx][1] /= 2;\

                    }

                    MAP_MVS

#undef MAP_F2F

                }else{

#define MAP_F2F(idx, mb_type)\

                    if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\

                        h->ref_cache[list][idx] >>= 1;\

                        h->mv_cache[list][idx][1] <<= 1;\

                        h->mvd_cache[list][idx][1] <<= 1;\

                    }

                    MAP_MVS

#undef MAP_F2F

                }

            }

        }

    }

#endif

    h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]);

}

static inline void write_back_intra_pred_mode(H264Context *h){

    const int mb_xy= h->mb_xy;

    h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1];

    h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2];

    h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3];

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

    h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4];

    h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4];

    h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4];

}

/**

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

 */

static inline int 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 next

/**

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

 */

static inline int 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;

}

/**

 * gets the predicted intra4x4 prediction mode.

 */

static inline int pred_intra_mode(H264Context *h, int n){

    const int index8= scan8[n];

    const int left= h->intra4x4_pred_mode_cache[index8 - 1];

    const int top = h->intra4x4_pred_mode_cache[index8 - 8];

    const int min= FFMIN(left, top);

    tprintf(h->s.avctx, "mode:%d %d min:%d\n", left ,top, min);

    if(min<0) return DC_PRED;

    else      return min;

}

static inline void write_back_non_zero_count(H264Context *h){

    const int mb_xy= h->mb_xy;

    h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[7+8*1];

    h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[7+8*2];

    h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[7+8*3];

    h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4];

    h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[4+8*4];

    h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[5+8*4];

    h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4];

    h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[1+8*2];

    h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2];

    h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[2+8*1];

    h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[1+8*5];

    h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5];

    h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4];

}

/**

 * gets the predicted number of non-zero coefficients.

 * @param n block index

 */

static inline int pred_non_zero_count(H264Context *h, int n){

    const int index8= scan8[n];

    const int left= h->non_zero_count_cache[index8 - 1];

    const int top = h->non_zero_count_cache[index8 - 8];

    int i= left + top;

    if(i<64) i= (i+1)>>1;

    tprintf(h->s.avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);

    return i&31;

}

static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){

    const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];

    MpegEncContext *s = &h->s;

    /* there is no consistent mapping of mvs to neighboring locations that will

     * make mbaff happy, so we can't move all this logic to fill_caches */

    if(FRAME_MBAFF){

        const uint32_t *mb_types = s->current_picture_ptr->mb_type;

        const int16_t *mv;

        *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0;

        *C = h->mv_cache[list][scan8[0]-2];

        if(!MB_FIELD

           && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){

            int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3);

            if(IS_INTERLACED(mb_types[topright_xy])){

#define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\

                const int x4 = X4, y4 = Y4;\

                const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\

                if(!USES_LIST(mb_type,list))\

                    return LIST_NOT_USED;\

                mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\

                h->mv_cache[list][scan8[0]-2][0] = mv[0];\

                h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\

                return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP;

                SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1);

            }

        }

        if(topright_ref == PART_NOT_AVAILABLE

           && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4

           && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){

            if(!MB_FIELD

               && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){

                SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1);

            }

            if(MB_FIELD

               && !IS_INTERLACED(mb_types[h->left_mb_xy[0]])

               && i >= scan8[0]+8){

                // left shift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's OK.

                SET_DIAG_MV(/2, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2);

            }

        }

#undef SET_DIAG_MV

    }

    if(topright_ref != PART_NOT_AVAILABLE){

        *C= h->mv_cache[list][ i - 8 + part_width ];

        return topright_ref;

    }else{

        tprintf(s->avctx, "topright MV not available\n");

        *C= h->mv_cache[list][ i - 8 - 1 ];

        return h->ref_cache[list][ i - 8 - 1 ];

    }

}

/**

 * gets the predicted MV.

 * @param n the block index

 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)

 * @param mx the x component of the predicted motion vector

 * @param my the y component of the predicted motion vector

 */

static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){

    const int index8= scan8[n];

    const int top_ref=      h->ref_cache[list][ index8 - 8 ];

    const int left_ref=     h->ref_cache[list][ index8 - 1 ];

    const int16_t * const A= h->mv_cache[list][ index8 - 1 ];

    const int16_t * const B= h->mv_cache[list][ index8 - 8 ];

    const int16_t * C;

    int diagonal_ref, match_count;

    assert(part_width==1 || part_width==2 || part_width==4);

/* mv_cache

  B . . A T T T T

  U . . L . . , .

  U . . L . . . .

  U . . L . . , .

  . . . L . . . .

*/

    diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width);

    match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref);

    tprintf(h->s.avctx, "pred_motion match_count=%d\n", match_count);

    if(match_count > 1){ //most common

        *mx= mid_pred(A[0], B[0], C[0]);

        *my= mid_pred(A[1], B[1], C[1]);

    }else if(match_count==1){

        if(left_ref==ref){

            *mx= A[0];

            *my= A[1];

        }else if(top_ref==ref){

            *mx= B[0];

            *my= B[1];

        }else{

            *mx= C[0];

            *my= C[1];

        }

    }else{

        if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){

            *mx= A[0];

            *my= A[1];

        }else{

            *mx= mid_pred(A[0], B[0], C[0]);

            *my= mid_pred(A[1], B[1], C[1]);

        }

    }

    tprintf(h->s.avctx, "pred_motion (%2d %2d %2d) (%2d %2d %2d) (%2d %2d %2d) -> (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1],                    diagonal_ref, C[0], C[1], left_ref, A[0], A[1], ref, *mx, *my, h->s.mb_x, h->s.mb_y, n, list);

}

/**

 * gets the directionally predicted 16x8 MV.

 * @param n the block index

 * @param mx the x component of the predicted motion vector

 * @param my the y component of the predicted motion vector

 */

static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){

    if(n==0){

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

        const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ];

        tprintf(h->s.avctx, "pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1], h->s.mb_x, h->s.mb_y, n, list);

        if(top_ref == ref){

            *mx= B[0];

            *my= B[1];

            return;

        }

    }else{

        const int left_ref=     h->ref_cache[list][ scan8[8] - 1 ];

        const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ];

        tprintf(h->s.avctx, "pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list);

        if(left_ref == ref){

            *mx= A[0];

            *my= A[1];

            return;

        }

    }

    //RARE

    pred_motion(h, n, 4, list, ref, mx, my);

}

/**

 * gets the directionally predicted 8x16 MV.

 * @param n the block index

 * @param mx the x component of the predicted motion vector

 * @param my the y component of the predicted motion vector

 */

static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){

    if(n==0){

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

        const int16_t * const A=  h->mv_cache[list][ scan8[0] - 1 ];

        tprintf(h->s.avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list);

        if(left_ref == ref){

            *mx= A[0];

            *my= A[1];

            return;

        }

    }else{

        const int16_t * C;

        int diagonal_ref;

        diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2);

        tprintf(h->s.avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", diagonal_ref, C[0], C[1], h->s.mb_x, h->s.mb_y, n, list);

        if(diagonal_ref == ref){

            *mx= C[0];

            *my= C[1];

            return;

        }

    }

    //RARE

    pred_motion(h, n, 2, list, ref, mx, my);

}

static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){

    const int top_ref = h->ref_cache[0][ scan8[0] - 8 ];

    const int left_ref= h->ref_cache[0][ scan8[0] - 1 ];

    tprintf(h->s.avctx, "pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y);

    if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE

       || !( top_ref | *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ])

       || !(left_ref | *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ])){

        *mx = *my = 0;

        return;

    }

    pred_motion(h, 0, 4, 0, 0, mx, my);

    return;

}

static int get_scale_factor(H264Context * const h, int poc, int poc1, int i){

    int poc0 = h->ref_list[0][i].poc;

    int td = av_clip(poc1 - poc0, -128, 127);

    if(td == 0 || h->ref_list[0][i].long_ref){

        return 256;

    }else{

        int tb = av_clip(poc - poc0, -128, 127);

        int tx = (16384 + (FFABS(td) >> 1)) / td;

        return av_clip((tb*tx + 32) >> 6, -1024, 1023);

    }

}

static inline void direct_dist_scale_factor(H264Context * const h){

    MpegEncContext * const s = &h->s;

    const int poc = h->s.current_picture_ptr->field_poc[ s->picture_structure == PICT_BOTTOM_FIELD ];

    const int poc1 = h->ref_list[1][0].poc;

    int i, field;

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

        const int poc  = h->s.current_picture_ptr->field_poc[field];

        const int poc1 = h->ref_list[1][0].field_poc[field];

        for(i=0; i < 2*h->ref_count[0]; i++)

            h->dist_scale_factor_field[field][i^field] = get_scale_factor(h, poc, poc1, i+16);

    }

    for(i=0; i<h->ref_count[0]; i++){

        h->dist_scale_factor[i] = get_scale_factor(h, poc, poc1, i);

    }

}

static void fill_colmap(H264Context *h, int map[2][16+32], int list, int field, int colfield, int mbafi){

    MpegEncContext * const s = &h->s;

    Picture * const ref1 = &h->ref_list[1][0];

    int j, old_ref, rfield;

    int start= mbafi ? 16                      : 0;

    int end  = mbafi ? 16+2*h->ref_count[list] : h->ref_count[list];

    int interl= mbafi || s->picture_structure != PICT_FRAME;

    /* bogus; fills in for missing frames */

    memset(map[list], 0, sizeof(map[list]));

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

        for(old_ref=0; old_ref<ref1->ref_count[colfield][list]; old_ref++){

            int poc = ref1->ref_poc[colfield][list][old_ref];

            if     (!interl)

                poc |= 3;

            else if( interl && (poc&3) == 3) //FIXME store all MBAFF references so this isnt needed

                poc= (poc&~3) + rfield + 1;

            for(j=start; j<end; j++){

                if(4*h->ref_list[list][j].frame_num + (h->ref_list[list][j].reference&3) == poc){

                    int cur_ref= mbafi ? (j-16)^field : j;

                    map[list][2*old_ref + (rfield^field) + 16] = cur_ref;

                    if(rfield == field)

                        map[list][old_ref] = cur_ref;

                    break;

                }

            }

        }

    }

}

static inline void direct_ref_list_init(H264Context * const h){

    MpegEncContext * const s = &h->s;

    Picture * const ref1 = &h->ref_list[1][0];

    Picture * const cur = s->current_picture_ptr;

    int list, j, field;

    int sidx= (s->picture_structure&1)^1;

    int ref1sidx= (ref1->reference&1)^1;

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

        cur->ref_count[sidx][list] = h->ref_count[list];

        for(j=0; j<h->ref_count[list]; j++)

            cur->ref_poc[sidx][list][j] = 4*h->ref_list[list][j].frame_num + (h->ref_list[list][j].reference&3);

    }

    if(s->picture_structure == PICT_FRAME){

        memcpy(cur->ref_count[1], cur->ref_count[0], sizeof(cur->ref_count[0]));

        memcpy(cur->ref_poc  [1], cur->ref_poc  [0], sizeof(cur->ref_poc  [0]));

    }

    cur->mbaff= FRAME_MBAFF;

    if(cur->pict_type != FF_B_TYPE || h->direct_spatial_mv_pred)

        return;

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

        fill_colmap(h, h->map_col_to_list0, list, sidx, ref1sidx, 0);

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

            fill_colmap(h, h->map_col_to_list0_field[field], list, field, field, 1);

    }

}

static inline void pred_direct_motion(H264Context * const h, int *mb_type){

    MpegEncContext * const s = &h->s;

    int b8_stride = h->b8_stride;

    int b4_stride = h->b_stride;

    int mb_xy = h->mb_xy;

    int mb_type_col[2];

    const int16_t (*l1mv0)[2], (*l1mv1)[2];

    const int8_t *l1ref0, *l1ref1;

    const int is_b8x8 = IS_8X8(*mb_type);

    unsigned int sub_mb_type;

    int i8, i4;

#define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)

    if(IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])){ // AFL/AFR/FR/FL -> AFL/FL

        if(!IS_INTERLACED(*mb_type)){                    //     AFR/FR    -> AFL/FL

            int cur_poc = s->current_picture_ptr->poc;

            int *col_poc = h->ref_list[1]->field_poc;

            int col_parity = FFABS(col_poc[0] - cur_poc) >= FFABS(col_poc[1] - cur_poc);

            mb_xy= s->mb_x + ((s->mb_y&~1) + col_parity)*s->mb_stride;

            b8_stride = 0;

        }else if(!(s->picture_structure & h->ref_list[1][0].reference) && !h->ref_list[1][0].mbaff){// FL -> FL & differ parity

            int fieldoff= 2*(h->ref_list[1][0].reference)-3;

            mb_xy += s->mb_stride*fieldoff;

        }

        goto single_col;

    }else{                                               // AFL/AFR/FR/FL -> AFR/FR

        if(IS_INTERLACED(*mb_type)){                     // AFL       /FL -> AFR/FR

            mb_xy= s->mb_x + (s->mb_y&~1)*s->mb_stride;

            mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy];

            mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + s->mb_stride];

            b8_stride *= 3;

            b4_stride *= 6;

            //FIXME IS_8X8(mb_type_col[0]) && !h->sps.direct_8x8_inference_flag

            if(    (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)

                && (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA)

                && !is_b8x8){

                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */

                *mb_type   |= MB_TYPE_16x8 |MB_TYPE_L0L1|MB_TYPE_DIRECT2; /* B_16x8 */

            }else{

                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */

                *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;

            }

        }else{                                           //     AFR/FR    -> AFR/FR

single_col:

            mb_type_col[0] =

            mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy];

            if(IS_8X8(mb_type_col[0]) && !h->sps.direct_8x8_inference_flag){

                /* FIXME save sub mb types from previous frames (or derive from MVs)

                * so we know exactly what block size to use */

                sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */

                *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;

            }else if(!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)){

                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */

                *mb_type   |= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */

            }else{

                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */

                *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;

            }

        }

    }

    l1mv0  = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]];

    l1mv1  = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]];

    l1ref0 = &h->ref_list[1][0].ref_index [0][h->mb2b8_xy[mb_xy]];

    l1ref1 = &h->ref_list[1][0].ref_index [1][h->mb2b8_xy[mb_xy]];

    if(!b8_stride){

        if(s->mb_y&1){

            l1ref0 += h->b8_stride;

            l1ref1 += h->b8_stride;

            l1mv0  +=  2*b4_stride;

            l1mv1  +=  2*b4_stride;

        }

    }

    if(h->direct_spatial_mv_pred){

        int ref[2];

        int mv[2][2];

        int list;

        /* FIXME interlacing + spatial direct uses wrong colocated block positions */

        /* ref = min(neighbors) */

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

            int refa = h->ref_cache[list][scan8[0] - 1];

            int refb = h->ref_cache[list][scan8[0] - 8];

            int refc = h->ref_cache[list][scan8[0] - 8 + 4];

            if(refc == PART_NOT_AVAILABLE)

                refc = h->ref_cache[list][scan8[0] - 8 - 1];

            ref[list] = FFMIN3((unsigned)refa, (unsigned)refb, (unsigned)refc);

            if(ref[list] < 0)

                ref[list] = -1;

        }

        if(ref[0] < 0 && ref[1] < 0){

            ref[0] = ref[1] = 0;

            mv[0][0] = mv[0][1] =

            mv[1][0] = mv[1][1] = 0;

        }else{

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

                if(ref[list] >= 0)

                    pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]);

                else

                    mv[list][0] = mv[list][1] = 0;

            }

        }

        if(ref[1] < 0){

            if(!is_b8x8)

                *mb_type &= ~MB_TYPE_L1;

            sub_mb_type &= ~MB_TYPE_L1;

        }else if(ref[0] < 0){

            if(!is_b8x8)

                *mb_type &= ~MB_TYPE_L0;

            sub_mb_type &= ~MB_TYPE_L0;

        }

        if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){

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

                int x8 = i8&1;

                int y8 = i8>>1;

                int xy8 = x8+y8*b8_stride;

                int xy4 = 3*x8+y8*b4_stride;

                int a=0, b=0;

                if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))

                    continue;

                h->sub_mb_type[i8] = sub_mb_type;

                fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);

                fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);

                if(!IS_INTRA(mb_type_col[y8])

                   && (   (l1ref0[xy8] == 0 && FFABS(l1mv0[xy4][0]) <= 1 && FFABS(l1mv0[xy4][1]) <= 1)

                       || (l1ref0[xy8]  < 0 && l1ref1[xy8] == 0 && FFABS(l1mv1[xy4][0]) <= 1 && FFABS(l1mv1[xy4][1]) <= 1))){

                    if(ref[0] > 0)

                        a= pack16to32(mv[0][0],mv[0][1]);

                    if(ref[1] > 0)

                        b= pack16to32(mv[1][0],mv[1][1]);

                }else{

                    a= pack16to32(mv[0][0],mv[0][1]);

                    b= pack16to32(mv[1][0],mv[1][1]);

                }

                fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, a, 4);

                fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, b, 4);

            }

        }else if(IS_16X16(*mb_type)){

            int a=0, b=0;

            fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);

            fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);

            if(!IS_INTRA(mb_type_col[0])

               && (   (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1)

                   || (l1ref0[0]  < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1

                       && (h->x264_build>33 || !h->x264_build)))){

                if(ref[0] > 0)

                    a= pack16to32(mv[0][0],mv[0][1]);

                if(ref[1] > 0)