/******************************************************************************

 *

 * Copyright (C) 2022 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at:

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 *

 *****************************************************************************

 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore

 */

/**

 *******************************************************************************

 * @file

 *  isvcd_process_bslice.c

 *

 * @brief

 *  Contains routines that decode B slice type

 *

 * @author

 *  Kishore

 *

 * @remarks

 *  None

 *

 *******************************************************************************

 */

#include <string.h>

#include "ih264_typedefs.h"

#include "ih264_macros.h"

#include "ih264_platform_macros.h"

#include "isvcd_structs.h"

#include "ih264d_bitstrm.h"

#include "ih264d_parse_cavlc.h"

#include "ih264d_mb_utils.h"

#include "ih264d_mvpred.h"

#include "ih264d_inter_pred.h"

#include "ih264d_process_pslice.h"

#include "ih264d_error_handler.h"

#include "ih264d_tables.h"

#include "ih264d_parse_slice.h"

#include "ih264d_process_pslice.h"

#include "ih264d_process_bslice.h"

#include "ih264d_tables.h"

#include "ih264d_parse_islice.h"

#include "ih264d_mvpred.h"

/*!

**************************************************************************

* \if Function name : isvcd_one_to_one \endif

*

* \brief

*    Initializes forward and backward refernce lists for B slice decoding.

*

*

* \return

*    0 on Success and Error code otherwise

**************************************************************************

*/

void isvcd_one_to_one(svc_dec_lyr_struct_t *ps_svc_lyr_dec, struct pic_buffer_t *ps_col_pic,

                      directmv_t *ps_direct, UWORD8 u1_wd_x, WORD32 u2_sub_mb_ofst,

                      dec_mb_info_t *ps_cur_mb_info)

{

    dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;

    UWORD8 *pu1_col_zero_flag_start, u1_col_mb_pred_mode, u1_num_blks, u1_sub_mb_num;

    UWORD8 u1_init_colzero_flag;

    UNUSED(ps_cur_mb_info);

    pu1_col_zero_flag_start = ps_col_pic->pu1_col_zero_flag + u2_sub_mb_ofst;

    u1_col_mb_pred_mode = pu1_col_zero_flag_start[ps_dec->u1_sub_mb_num];

    u1_init_colzero_flag = u1_col_mb_pred_mode & 1;

    u1_col_mb_pred_mode >>= 6;

    ps_direct->u1_vert_mv_scale = ONE_TO_ONE;

    ps_direct->u1_col_zeroflag_change = (ps_svc_lyr_dec->u1_base_res_flag) ? 0 : 1;

    if(u1_wd_x == MB_SIZE)

    {

        ps_dec->u1_currB_type = (!!u1_col_mb_pred_mode);

        if(u1_col_mb_pred_mode == PRED_16x16)

        {

            ps_direct->i1_num_partitions = 1;

            ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;

            ps_direct->i1_submb_num[0] = 0;

            ps_direct->i1_partitionsize[0] = PRED_16x16;

            return;

        }

        else if(u1_col_mb_pred_mode < PRED_8x8)

        {

            ps_direct->i1_num_partitions = 2;

            ps_direct->i4_mv_indices[0] = u2_sub_mb_ofst;

            ps_direct->i1_submb_num[0] = 0;

            ps_direct->i1_partitionsize[0] = u1_col_mb_pred_mode;

            u1_sub_mb_num = (u1_col_mb_pred_mode == PRED_16x8) ? 8 : 2;

            ps_direct->i1_submb_num[1] = u1_sub_mb_num;

            ps_direct->i4_mv_indices[1] = u2_sub_mb_ofst + ps_direct->i1_submb_num[1];

            ps_direct->i1_partitionsize[1] = u1_col_mb_pred_mode;

            if((pu1_col_zero_flag_start[u1_sub_mb_num] & 1) != u1_init_colzero_flag)

                ps_direct->u1_col_zeroflag_change = 1;

            return;

        }

        else

        {

            u1_num_blks = 4;

        }

    }

    else

    {

        u1_num_blks = 1;

    }

    {

        const UWORD8 *pu1_top_lt_mb_part_idx;

        UWORD8 u1_col_sub_mb_pred_mode, uc_blk, u1_sub_blk, u1_submb_col = 0;

        UWORD8 u1_num_sub_blks, uc_direct8x8inf, *pu1_col_zero_flag, u1_sub_mb_num;

        const UWORD8 *pu1_num_sub_mb_part = (const UWORD8 *) gau1_ih264d_num_submb_part;

        UWORD8 i1_num_partitions = 0, partition_size;

        WORD32 mv_index;

        const UWORD8 *pu1_top_lt_sub_mb_idx = gau1_ih264d_submb_indx_mod_sp_drct;

        u1_sub_mb_num = ps_dec->u1_sub_mb_num;

        uc_direct8x8inf = ps_dec->ps_cur_slice->u1_direct_8x8_inference_flag;

        pu1_top_lt_mb_part_idx = gau1_ih264d_top_left_mb_part_indx_mod + (PRED_8x8 << 1) + 1;

        for(uc_blk = 0; uc_blk < u1_num_blks; uc_blk++)

        {

            partition_size = PRED_8x8;

            pu1_top_lt_sub_mb_idx = gau1_ih264d_submb_indx_mod_sp_drct;

            if(uc_direct8x8inf == 1)

            {

                u1_submb_col = u1_sub_mb_num | (u1_sub_mb_num >> 1);

                mv_index = u2_sub_mb_ofst + u1_submb_col;

                u1_num_sub_blks = 1;

            }

            else

            {

                /* colMbPart is either 8x8, 8x4, 4x8, 4x4 */

                pu1_col_zero_flag = pu1_col_zero_flag_start + u1_sub_mb_num;

                u1_col_sub_mb_pred_mode = *pu1_col_zero_flag;

                u1_col_sub_mb_pred_mode = (u1_col_sub_mb_pred_mode & 0x30) >> 4;

                partition_size = (UWORD8) ((u1_col_sub_mb_pred_mode) | (PRED_8x8 << 2));

                mv_index = u2_sub_mb_ofst + u1_sub_mb_num;

                pu1_top_lt_sub_mb_idx += (u1_col_sub_mb_pred_mode << 1);

                u1_num_sub_blks = pu1_num_sub_mb_part[u1_col_sub_mb_pred_mode];

            }

            for(u1_sub_blk = 0; u1_sub_blk < u1_num_sub_blks; u1_sub_blk++, pu1_top_lt_sub_mb_idx++)

            {

                u1_sub_mb_num += *pu1_top_lt_sub_mb_idx;

                mv_index += *pu1_top_lt_sub_mb_idx;

                ps_direct->i4_mv_indices[i1_num_partitions] = mv_index;

                ps_direct->i1_submb_num[i1_num_partitions] = u1_sub_mb_num;

                ps_direct->i1_partitionsize[i1_num_partitions] = partition_size;

                i1_num_partitions++;

                if(!uc_direct8x8inf) u1_submb_col = u1_sub_mb_num;

                if((pu1_col_zero_flag_start[u1_submb_col] & 1) != u1_init_colzero_flag)

                    ps_direct->u1_col_zeroflag_change = 1;

            }

            u1_sub_mb_num = *pu1_top_lt_mb_part_idx++;

        }

        ps_direct->i1_num_partitions = i1_num_partitions;

    }

}

/*!

 **************************************************************************

 * \if Function name : isvcd_decode_spatial_direct \endif

 *

 * \brief

 *    Decodes spatial direct mode.

 *

 * \return

 *    None.

 *    Vijay

 **************************************************************************

 */

WORD32 isvcd_decode_spatial_direct(dec_struct_t *ps_dec, UWORD8 u1_wd_x,

                                   dec_mb_info_t *ps_cur_mb_info, UWORD8 u1_mb_num)

{

    svc_dec_lyr_struct_t *ps_svc_lyr_dec = (svc_dec_lyr_struct_t *) ps_dec;

    mv_pred_t s_mv_pred = {0};

    mv_pred_t *ps_mv;

    UWORD8 u1_col_zero_flag, u1_sub_mb_num, u1_direct_zero_pred_flag = 0;

    UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;

    mv_pred_t *ps_mv_ntop_start;

    mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);

    UWORD8 partition_size, sub_partition, u1_mb_partw, u1_mb_parth;

    UWORD8 i;

    WORD8 i1_pred, i1_ref_frame0, i1_ref_frame1;

    struct pic_buffer_t *ps_ref_frame = NULL, *ps_col_pic, *ps_pic_buff0 = NULL,

                        *ps_pic_buff1 = NULL;

    UWORD8 u1_zero_pred_cond_f, u1_zero_pred_cond_b;

    WORD16 i2_spat_pred_mv[4] = {0};

    WORD16 *pi2_final_mv0, *pi2_final_mv1;

    UWORD16 ui2_mask_fwd = 0, ui2_mask_bwd = 0;

    UWORD32 *pui32_weight_ofsts = NULL;

    directmv_t s_mvdirect = {0};

    UWORD8 u1_colz;

    UWORD8 u1_final_ref_idx = 0;

    const UWORD8 *pu1_mb_parth = (const UWORD8 *) gau1_ih264d_mb_parth;

    const UWORD8 *pu1_mb_partw = (const UWORD8 *) gau1_ih264d_mb_partw;

    mv_pred_t s_temp_mv_pred = {0};

    ps_mv_ntop_start =

        ps_dec->ps_mv_cur + (u1_mb_num << 4) - (ps_dec->u2_frm_wd_in_mbs << (4 + u1_mbaff)) + 12;

    u1_direct_zero_pred_flag =

        ps_dec->pf_mvpred(ps_dec, ps_cur_mb_info, (ps_mv_nmb_start + ps_dec->u1_sub_mb_num),

                          ps_mv_ntop_start + (ps_dec->u1_sub_mb_num & 0x03), &s_mv_pred,

                          ps_dec->u1_sub_mb_num, (u1_wd_x >> 2), 0, 1, B_DIRECT_SPATIAL);

    i2_spat_pred_mv[0] = s_mv_pred.i2_mv[0];

    i2_spat_pred_mv[1] = s_mv_pred.i2_mv[1];

    i2_spat_pred_mv[2] = s_mv_pred.i2_mv[2];

    i2_spat_pred_mv[3] = s_mv_pred.i2_mv[3];

    i1_ref_frame0 = s_mv_pred.i1_ref_frame[0];

    i1_ref_frame1 = s_mv_pred.i1_ref_frame[1];

    i1_ref_frame0 = (i1_ref_frame0 < 0) ? -1 : i1_ref_frame0;

    i1_ref_frame1 = (i1_ref_frame1 < 0) ? -1 : i1_ref_frame1;

    i1_pred = 0;

    {

        WORD8 u1_ref_idx, u1_ref_idx1;

        UWORD32 uc_Idx, uc_Idx1;

        UWORD8 u1_scale_ref =

            (ps_dec->ps_cur_slice->u1_mbaff_frame_flag && ps_cur_mb_info->u1_mb_field_decodingflag);

        u1_final_ref_idx = i1_ref_frame0;

        if(i1_ref_frame0 >= 0)

        {

            /* convert RefIdx if it is MbAff */

            u1_ref_idx = i1_ref_frame0;

            u1_ref_idx1 = i1_ref_frame0;

            if(u1_scale_ref)

            {

                u1_ref_idx1 = u1_ref_idx >> 1;

                if((u1_ref_idx & 0x01) != (1 - ps_cur_mb_info->u1_topmb))

                    u1_ref_idx1 += MAX_REF_BUFS;

            }

            /* If i1_ref_frame0 < 0 then refIdxCol is obtained from ps_pic_buff1 */

            ps_pic_buff0 = ps_dec->ps_ref_pic_buf_lx[0][u1_ref_idx1];

            ps_ref_frame = ps_pic_buff0;

            i1_pred = PRED_L0;

        }

        if(i1_ref_frame1 >= 0)

        {

            /* convert RefIdx if it is MbAff */

            u1_ref_idx = i1_ref_frame1;

            u1_ref_idx1 = i1_ref_frame1;

            if(u1_scale_ref)

            {

                u1_ref_idx1 = u1_ref_idx >> 1;

                if((u1_ref_idx & 0x01) != (1 - ps_cur_mb_info->u1_topmb))

                    u1_ref_idx1 += MAX_REF_BUFS;

            }

            ps_pic_buff1 = ps_dec->ps_ref_pic_buf_lx[1][u1_ref_idx1];

            i1_pred = i1_pred | PRED_L1;

        }

        if(i1_ref_frame0 < 0)

        {

            ps_ref_frame = ps_pic_buff1;

            u1_final_ref_idx = i1_ref_frame1;

        }

        u1_zero_pred_cond_f = (u1_direct_zero_pred_flag) || (i1_ref_frame0 < 0);

        u1_zero_pred_cond_b = (u1_direct_zero_pred_flag) || (i1_ref_frame1 < 0);

        if(ps_dec->ps_cur_pps->u1_wted_bipred_idc)

        {

            uc_Idx = ((i1_ref_frame0 < 1) ? 0 : i1_ref_frame0) *

                     ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1];

            if(u1_scale_ref) uc_Idx >>= 1;

            uc_Idx1 = (i1_ref_frame1 < 0) ? 0 : i1_ref_frame1;

            uc_Idx += (u1_scale_ref) ? (uc_Idx1 >> 1) : uc_Idx1;

            pui32_weight_ofsts = (UWORD32 *) &ps_dec->pu4_wt_ofsts[2 * X3(uc_Idx)];

            if(i1_ref_frame0 < 0) pui32_weight_ofsts += 1;

            if(u1_scale_ref && (ps_dec->ps_cur_pps->u1_wted_bipred_idc == 2))

            {

                WORD16 i2_ref_idx;

                i2_ref_idx = MAX(i1_ref_frame0, 0);

                i2_ref_idx *= (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1] << 1);

                i2_ref_idx += MAX(i1_ref_frame1, 0);

                if(!ps_cur_mb_info->u1_topmb)

                    i2_ref_idx += (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0] << 1) *

                                  (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[1] << 1);

                pui32_weight_ofsts = (UWORD32 *) &ps_dec->pu4_mbaff_wt_mat[2 * X3(i2_ref_idx)];

            }

        }

    }

    s_temp_mv_pred.i1_ref_frame[0] = i1_ref_frame0;

    s_temp_mv_pred.i1_ref_frame[1] = i1_ref_frame1;

    s_temp_mv_pred.u1_col_ref_pic_idx = ps_ref_frame->u1_mv_buf_id;

    s_temp_mv_pred.u1_pic_type = ps_ref_frame->u1_pic_type;

    /**********************************************************************/

    /* Call the function which gets the number of partitions and          */

    /* partition info of colocated Mb                                     */

    /**********************************************************************/

    isvcd_one_to_one(ps_svc_lyr_dec, ps_dec->ps_col_pic, &s_mvdirect, u1_wd_x,

                     ps_dec->i4_submb_ofst, ps_cur_mb_info);

    ps_col_pic = ps_dec->ps_col_pic;

    if((s_mvdirect.u1_col_zeroflag_change == 0) || u1_direct_zero_pred_flag)

    {

        WORD16 i2_mv_x, i2_mv_y, i2_mvX1, i2_mvY1;

        /* Most probable case */

        u1_col_zero_flag = *(ps_col_pic->pu1_col_zero_flag + s_mvdirect.i4_mv_indices[0]);

        u1_col_zero_flag = u1_col_zero_flag & 0x01;

        if(u1_zero_pred_cond_f || ((i1_ref_frame0 == 0) && (u1_col_zero_flag == 1)))

        {

            i2_mv_x = 0;

            i2_mv_y = 0;

        }

        else

        {

            i2_mv_x = i2_spat_pred_mv[0];

            i2_mv_y = i2_spat_pred_mv[1];

        }

        if(u1_zero_pred_cond_b || ((i1_ref_frame1 == 0) && (u1_col_zero_flag == 1)))

        {

            i2_mvX1 = 0;

            i2_mvY1 = 0;

        }

        else

        {

            i2_mvX1 = i2_spat_pred_mv[2];

            i2_mvY1 = i2_spat_pred_mv[3];

        }

        u1_sub_mb_num = ps_dec->u1_sub_mb_num;

        u1_mb_partw = (u1_wd_x >> 2);

        if(i1_ref_frame0 >= 0)

        {

            {

                pred_info_pkd_t *ps_pred_pkd;

                WORD16 i2_mv[2];

                WORD8 i1_ref_idx = 0;

                i2_mv[0] = i2_mv_x;

                i2_mv[1] = i2_mv_y;

                ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;

                ih264d_fill_pred_info(i2_mv, u1_mb_partw, u1_mb_partw, u1_sub_mb_num, i1_pred,

                                      ps_pred_pkd, ps_pic_buff0->u1_pic_buf_id, i1_ref_idx,

                                      pui32_weight_ofsts, ps_pic_buff0->u1_pic_type);

                ps_dec->u4_pred_info_pkd_idx++;

                ps_cur_mb_info->u1_num_pred_parts++;

            }

        }

        if(i1_ref_frame1 >= 0)

        {

            {

                pred_info_pkd_t *ps_pred_pkd;

                WORD16 i2_mv[2];

                WORD8 i1_ref_idx = 0;

                i2_mv[0] = i2_mvX1;

                i2_mv[1] = i2_mvY1;

                ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;

                ih264d_fill_pred_info(i2_mv, u1_mb_partw, u1_mb_partw, u1_sub_mb_num, i1_pred,

                                      ps_pred_pkd, ps_pic_buff1->u1_pic_buf_id, i1_ref_idx,

                                      pui32_weight_ofsts, ps_pic_buff1->u1_pic_type);

                ps_dec->u4_pred_info_pkd_idx++;

                ps_cur_mb_info->u1_num_pred_parts++;

            }

        }

        /* Replication optimisation */

        s_temp_mv_pred.i2_mv[0] = i2_mv_x;

        s_temp_mv_pred.i2_mv[1] = i2_mv_y;

        s_temp_mv_pred.i2_mv[2] = i2_mvX1;

        s_temp_mv_pred.i2_mv[3] = i2_mvY1;

        /* Calculating colocated zero information */

        {

            /*************************************/

            /* If(bit2 and bit3 set)             */

            /* then                              */

            /*  (bit0 and bit1) => submmbmode    */

            /*  (bit2 and bit3) => mbmode        */

            /* else                              */

            /*  (bit0 and bit1) => mbmode        */

            /*************************************/

            /*UWORD8 u1_packed_mb_sub_mb_mode = sub_partition ?

             (s_mvdirect.i1_partitionsize[0]) : ((s_mvdirect.i1_partitionsize[0]) <<

             2);*/

            UWORD8 u1_packed_mb_sub_mb_mode = (u1_mb_partw == 2) ? 0x03 : 0;

            if(i1_ref_frame0 < 0)

            {

                i2_mv_x = i2_mvX1;

                i2_mv_y = i2_mvY1;

            }

            /* Change from left shift 4 to 6 - Varun */

            u1_colz = (ps_cur_mb_info->u1_mb_field_decodingflag << 1) |

                      ((u1_final_ref_idx == 0) && (ABS(i2_mv_x) <= 1) && (ABS(i2_mv_y) <= 1));

            u1_colz |= (u1_packed_mb_sub_mb_mode << 6);

        }

        ps_mv = ps_mv_nmb_start + u1_sub_mb_num;

        if(ps_mv)

        {

            ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num, u1_colz, u1_mb_partw,

                               u1_mb_partw);

        }

        else

        {

            return NOT_OK;

        }

        if(u1_wd_x == MB_SIZE) ps_dec->u1_currB_type = 0;

        return OK;

    }

    /***************************************************************************/

    /* If present MB is 16x16 and the partition of colocated Mb is >= PRED_8x8 */

    /* i.e 8x8 or less than 8x8 partitions then set up DMA for (0,0) and       */

    /* spatially predicted motion vector and do the multiplexing after         */

    /* motion compensation                                                     */

    /***************************************************************************/

    if((u1_wd_x == MB_SIZE) && (s_mvdirect.i1_num_partitions > 2))

    {

        ps_cur_mb_info->u1_Mux = 1;

        if(i1_ref_frame0 >= 0)

        {

            {

                pred_info_pkd_t *ps_pred_pkd;

                WORD8 i1_ref_idx = 0;

                ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;

                ih264d_fill_pred_info(&(i2_spat_pred_mv[0]), 4, 4, 0, i1_pred, ps_pred_pkd,

                                      ps_pic_buff0->u1_pic_buf_id, i1_ref_idx, pui32_weight_ofsts,

                                      ps_pic_buff0->u1_pic_type);

                ps_dec->u4_pred_info_pkd_idx++;

                ps_cur_mb_info->u1_num_pred_parts++;

            }

            /******    (0,0) Motion vectors DMA     *****/

            {

                pred_info_pkd_t *ps_pred_pkd;

                WORD16 i2_mv[2];

                WORD8 i1_ref_idx = 0;

                i2_mv[0] = 0;

                i2_mv[1] = 0;

                ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;

                ih264d_fill_pred_info(i2_mv, 4, 4, 0, i1_pred, ps_pred_pkd,

                                      ps_pic_buff0->u1_pic_buf_id, i1_ref_idx, pui32_weight_ofsts,

                                      ps_pic_buff0->u1_pic_type);

                ps_dec->u4_pred_info_pkd_idx++;

                ps_cur_mb_info->u1_num_pred_parts++;

            }

        }

        if(i1_ref_frame1 >= 0)

        {

            {

                pred_info_pkd_t *ps_pred_pkd;

                WORD8 i1_ref_idx = 0;

                ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;

                ih264d_fill_pred_info(&(i2_spat_pred_mv[2]), 4, 4, 0, i1_pred, ps_pred_pkd,

                                      ps_pic_buff1->u1_pic_buf_id, i1_ref_idx, pui32_weight_ofsts,

                                      ps_pic_buff1->u1_pic_type);

                ps_dec->u4_pred_info_pkd_idx++;

                ps_cur_mb_info->u1_num_pred_parts++;

            }

            /******    (0,0) Motion vectors DMA     *****/

            {

                pred_info_pkd_t *ps_pred_pkd;

                WORD16 i2_mv[2];

                WORD8 i1_ref_idx = 0;

                i2_mv[0] = 0;

                i2_mv[1] = 0;

                ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;

                ih264d_fill_pred_info(i2_mv, 4, 4, 0, i1_pred, ps_pred_pkd,

                                      ps_pic_buff1->u1_pic_buf_id, i1_ref_idx, pui32_weight_ofsts,

                                      ps_pic_buff1->u1_pic_type);

                ps_dec->u4_pred_info_pkd_idx++;

                ps_cur_mb_info->u1_num_pred_parts++;

            }

        }

    }

    for(i = 0; i < s_mvdirect.i1_num_partitions; i++)

    {

        partition_size = s_mvdirect.i1_partitionsize[i];

        u1_sub_mb_num = s_mvdirect.i1_submb_num[i];

        sub_partition = partition_size >> 2;

        partition_size &= 0x3;

        u1_mb_partw = pu1_mb_partw[partition_size];

        u1_mb_parth = pu1_mb_parth[partition_size];

        if(sub_partition != 0)

        {

            u1_mb_partw >>= 1;

            u1_mb_parth >>= 1;

        }

        u1_col_zero_flag = *(ps_col_pic->pu1_col_zero_flag + s_mvdirect.i4_mv_indices[i]);

        u1_col_zero_flag = u1_col_zero_flag & 0x01;

        /*if(u1_col != u1_col_zero_flag)

         u1_init = 1;*/

        pi2_final_mv0 = &i2_spat_pred_mv[0];

        pi2_final_mv1 = &i2_spat_pred_mv[2];

        if(ps_cur_mb_info->u1_Mux != 1)

        {

            if(i1_ref_frame0 >= 0)

            {

                {

                    pred_info_pkd_t *ps_pred_pkd;

                    WORD8 i1_ref_idx = 0;

                    ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;

                    ih264d_fill_pred_info(pi2_final_mv0, u1_mb_partw, u1_mb_parth, u1_sub_mb_num,

                                          i1_pred, ps_pred_pkd, ps_pic_buff0->u1_pic_buf_id,

                                          i1_ref_idx, pui32_weight_ofsts,

                                          ps_pic_buff0->u1_pic_type);

                    ps_dec->u4_pred_info_pkd_idx++;

                    ps_cur_mb_info->u1_num_pred_parts++;

                }

            }

            if(i1_ref_frame1 >= 0)

            {

                pred_info_pkd_t *ps_pred_pkd;

                WORD8 i1_ref_idx = 0;

                ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;

                ih264d_fill_pred_info(pi2_final_mv1, u1_mb_partw, u1_mb_parth, u1_sub_mb_num,

                                      i1_pred, ps_pred_pkd, ps_pic_buff1->u1_pic_buf_id, i1_ref_idx,

                                      pui32_weight_ofsts, ps_pic_buff1->u1_pic_type);

                ps_dec->u4_pred_info_pkd_idx++;

                ps_cur_mb_info->u1_num_pred_parts++;

            }

        }

        /* Replication optimisation */

        s_temp_mv_pred.i2_mv[0] = pi2_final_mv0[0];

        s_temp_mv_pred.i2_mv[1] = pi2_final_mv0[1];

        s_temp_mv_pred.i2_mv[2] = pi2_final_mv1[0];

        s_temp_mv_pred.i2_mv[3] = pi2_final_mv1[1];

        /* Calculating colocated zero information */

        {

            WORD16 i2_mv_x = 0, i2_mv_y = 0;

            /*************************************/

            /* If(bit2 and bit3 set)             */

            /* then                              */

            /*  (bit0 and bit1) => submmbmode    */

            /*  (bit2 and bit3) => mbmode        */

            /* else                              */

            /*  (bit0 and bit1) => mbmode        */

            /*************************************/

            UWORD8 u1_packed_mb_sub_mb_mode = sub_partition

                                                  ? (s_mvdirect.i1_partitionsize[i])

                                                  : ((s_mvdirect.i1_partitionsize[i]) << 2);

            if(i1_ref_frame0 >= 0)

            {

                i2_mv_x = pi2_final_mv0[0];

                i2_mv_y = pi2_final_mv0[1];

            }

            else

            {

                i2_mv_x = pi2_final_mv1[0];

                i2_mv_y = pi2_final_mv1[1];

            }

            u1_colz = (ps_cur_mb_info->u1_mb_field_decodingflag << 1) |

                      ((u1_final_ref_idx == 0) && (ABS(i2_mv_x) <= 1) && (ABS(i2_mv_y) <= 1));

            u1_colz |= (u1_packed_mb_sub_mb_mode << 4);

        }

        ps_mv = ps_mv_nmb_start + u1_sub_mb_num;

        if(ps_mv)

        {

            ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num, u1_colz, u1_mb_parth,

                               u1_mb_partw);

        }

        else

        {

            return NOT_OK;

        }

    }

    i = 0;

    if(i1_ref_frame0 >= 0) ps_cur_mb_info->u2_mask[i++] = ui2_mask_fwd;

    if(i1_ref_frame1 >= 0) ps_cur_mb_info->u2_mask[i] = ui2_mask_bwd;

    return OK;

}