/******************************************************************************
 *
 * Copyright (C) 2015 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 ih264d_inter_pred.c
 *
 * \brief
 *    This file contains routines to perform MotionCompensation tasks
 *
 * Detailed_description
 *
 * \date
 *    20/11/2002
 *
 * \author  Arvind Raman
 **************************************************************************
 */

#include <string.h>
#include "ih264d_defs.h"
#include "ih264d_mvpred.h"
#include "ih264d_error_handler.h"
#include "ih264d_structs.h"
#include "ih264d_defs.h"
#include "ih264d_inter_pred.h"
#include "ih264_typedefs.h"
#include "ih264_macros.h"
#include "ih264_platform_macros.h"
#include "ih264d_debug.h"
#include "ih264d_tables.h"
#include "ih264d_mb_utils.h"


void ih264d_pad_on_demand(pred_info_t *ps_pred, UWORD8 lum_chrom_blk);


void ih264d_copy_multiplex_data(UWORD8 *puc_Source,
                                UWORD8 *puc_To,
                                UWORD32 uc_w,
                                UWORD32 uc_h,
                                UWORD32 ui16_sourceWidth,
                                UWORD32 ui16_toWidth)
{
    UWORD8 uc_i, uc_j;

    for(uc_i = 0; uc_i < uc_h; uc_i++)
    {
        memcpy(puc_To, puc_Source, uc_w);
        puc_To += ui16_toWidth;
        puc_Source += ui16_sourceWidth;
    }
}


/*!
 **************************************************************************
 * \if Function name : dma_2d1d \endif
 *
 * \brief
 *    2D -> 1D linear DMA into the reference buffers
 *
 * \return
 *    None
 **************************************************************************
 */
void ih264d_copy_2d1d(UWORD8 *puc_src,
                      UWORD8 *puc_dest,
                      UWORD16 ui16_srcWidth,
                      UWORD16 ui16_widthToFill,
                      UWORD16 ui16_heightToFill)
{
    UWORD32 uc_w, uc_h;
    for(uc_h = ui16_heightToFill; uc_h != 0; uc_h--)
    {
        memcpy(puc_dest, puc_src, ui16_widthToFill);
        puc_dest += ui16_widthToFill;
        puc_src += ui16_srcWidth;
    }
}

/*!
 **************************************************************************
 * \if Function name : ih264d_fill_pred_info \endif
 *
 * \brief
 *    Fills inter prediction related info
 *
 * \return
 *    None
 **************************************************************************
 */
void ih264d_fill_pred_info(WORD16 *pi2_mv,WORD32 part_width,WORD32 part_height, WORD32 sub_mb_num,
                           WORD32 pred_dir,pred_info_pkd_t *ps_pred_pkd,WORD8 i1_buf_id,
                           WORD8 i1_ref_idx,UWORD32 *pu4_wt_offset,UWORD8 u1_pic_type)
{
    WORD32 insert_bits;

    ps_pred_pkd->i2_mv[0] = pi2_mv[0];
    ps_pred_pkd->i2_mv[1] = pi2_mv[1];

    insert_bits = sub_mb_num & 3; /*sub mb x*/
    ps_pred_pkd->i1_size_pos_info = insert_bits;
    insert_bits = sub_mb_num >> 2;/*sub mb y*/
    ps_pred_pkd->i1_size_pos_info |= insert_bits << 2;
    insert_bits = part_width >> 1;
    ps_pred_pkd->i1_size_pos_info |= insert_bits << 4;
    insert_bits = part_height >> 1;
    ps_pred_pkd->i1_size_pos_info |= insert_bits << 6;

    ps_pred_pkd->i1_ref_idx_info = i1_ref_idx;
    ps_pred_pkd->i1_ref_idx_info |= (pred_dir << 6);
    ps_pred_pkd->i1_buf_id = i1_buf_id;
    ps_pred_pkd->pu4_wt_offst = pu4_wt_offset;
    ps_pred_pkd->u1_pic_type = u1_pic_type;


}


/*****************************************************************************/
/* \if Function name : formMbPartInfo \endif                                 */
/*                                                                           */
/* \brief                                                                    */
/*    Form the Mb partition information structure, to be used by the MC      */
/*    routine                                                                */
/*                                                                           */
/* \return                                                                   */
/*    None                                                                   */
/* \note                                                                     */
/*    c_bufx is used to select PredBuffer,                                   */
/*    if it's only Forward/Backward prediction always buffer used is         */
/*    puc_MbLumaPredBuffer[0 to X1],pu1_mb_cb_pred_buffer[0 to X1] and          */
/*    pu1_mb_cr_pred_buffer[0 to X1]                                            */
/*                                                                           */
/*    if it's bidirect for forward ..PredBuffer[0 to X1] buffer is used and  */
/*    ..PredBuffer[X2 to X3] for backward prediction. and                    */
/*                                                                           */
/*    Final predicted samples values are the average of ..PredBuffer[0 to X1]*/
/*    and ..PredBuffer[X2 to X3]                                             */
/*                                                                           */
/*    X1 is 255 for Luma and 63 for Chroma                                   */
/*    X2 is 256 for Luma and 64 for Chroma                                   */
/*    X3 is 511 for Luma and 127 for Chroma                                  */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         11 05 2005   SWRN            Modified to handle pod               */
/*****************************************************************************/

WORD32 ih264d_form_mb_part_info_bp(pred_info_pkd_t *ps_pred_pkd,
                                 dec_struct_t * ps_dec,
                                 UWORD16 u2_mb_x,
                                 UWORD16 u2_mb_y,
                                 WORD32 mb_index,
                                 dec_mb_info_t *ps_cur_mb_info)
{
    /* The reference buffer pointer */
    WORD32 i2_frm_x, i2_frm_y;
    WORD32 i2_tmp_mv_x, i2_tmp_mv_y;
    WORD32 i2_rec_x, i2_rec_y;

    WORD32 u2_pic_ht;
    WORD32 u2_frm_wd;
    WORD32 u2_rec_wd;
    UWORD8 u1_sub_x = 0,u1_sub_y=0 ;
    UWORD8  u1_part_wd = 0,u1_part_ht = 0;
    WORD16 i2_mv_x,i2_mv_y;

    /********************************************/
    /* i1_mc_wd       width reqd for mcomp      */
    /* u1_dma_ht      height reqd for mcomp     */
    /* u1_dma_wd      width aligned to 4 bytes  */
    /* u1_dx          fractional part of width  */
    /* u1_dx          fractional part of height */
    /********************************************/
    UWORD32 i1_mc_wd;

    WORD32 u1_dma_ht;

    UWORD32 u1_dma_wd;
    UWORD32 u1_dx;
    UWORD32 u1_dy;
    pred_info_t * ps_pred = ps_dec->ps_pred + ps_dec->u4_pred_info_idx;
    dec_slice_params_t * const ps_cur_slice = ps_dec->ps_cur_slice;
    tfr_ctxt_t *ps_frame_buf;
    struct pic_buffer_t *ps_ref_frm;
    UWORD8 u1_scale_ref,u1_mbaff,u1_field;
    pic_buffer_t  **pps_ref_frame;
    WORD8 i1_size_pos_info,i1_buf_id;

    PROFILE_DISABLE_MB_PART_INFO()

     UNUSED(ps_cur_mb_info);
     i1_size_pos_info = ps_pred_pkd->i1_size_pos_info;
     GET_XPOS_PRED(u1_sub_x,i1_size_pos_info);
     GET_YPOS_PRED(u1_sub_y,i1_size_pos_info);
     GET_WIDTH_PRED(u1_part_wd,i1_size_pos_info);
     GET_HEIGHT_PRED(u1_part_ht,i1_size_pos_info);
     i2_mv_x = ps_pred_pkd->i2_mv[0];
     i2_mv_y = ps_pred_pkd->i2_mv[1];
     i1_buf_id = ps_pred_pkd->i1_buf_id;


     ps_ref_frm = ps_dec->apv_buf_id_pic_buf_map[i1_buf_id];


    {
        ps_frame_buf = &ps_dec->s_tran_addrecon;
    }


    /* Transfer Setup Y */
    {
        UWORD8 *pu1_pred, *pu1_rec;

        /* calculating rounded motion vectors and fractional components */
        i2_tmp_mv_x = i2_mv_x;
        i2_tmp_mv_y = i2_mv_y;
        u1_dx = i2_tmp_mv_x & 0x3;
        u1_dy = i2_tmp_mv_y & 0x3;
        i2_tmp_mv_x >>= 2;
        i2_tmp_mv_y >>= 2;
        i1_mc_wd = u1_part_wd << 2;
        u1_dma_ht = u1_part_ht << 2;
        if(u1_dx)
        {
            i2_tmp_mv_x -= 2;
            i1_mc_wd += 5;
        }
        if(u1_dy)
        {
            i2_tmp_mv_y -= 2;
            u1_dma_ht += 5;
        }

        /********************************************************************/
        /* Calulating the horizontal and the vertical u4_ofst from top left  */
        /* edge of the reference frame, and subsequent clipping             */
        /********************************************************************/
        u2_pic_ht = ps_dec->u2_pic_ht;
        u2_frm_wd = ps_dec->u2_frm_wd_y;
        i2_rec_x = u1_sub_x << 2;
        i2_rec_y = u1_sub_y << 2;

        i2_frm_x = (u2_mb_x << 4) + i2_rec_x + i2_tmp_mv_x;
        i2_frm_y = (u2_mb_y << 4) + i2_rec_y + i2_tmp_mv_y;

        i2_frm_x = CLIP3(MAX_OFFSET_OUTSIDE_X_FRM, (ps_dec->u2_pic_wd - 1),
                         i2_frm_x);
        i2_frm_y = CLIP3(((1 - u1_dma_ht)), (u2_pic_ht - (1)), i2_frm_y);

        pu1_pred = ps_ref_frm->pu1_buf1 + i2_frm_y * u2_frm_wd + i2_frm_x;

        u1_dma_wd = (i1_mc_wd + 3) & 0xFC;

        /********************************************************************/
        /* Calulating the horizontal and the vertical u4_ofst from top left  */
        /* edge of the recon buffer                                         */
        /********************************************************************/
        u2_rec_wd = MB_SIZE;
        {
            u2_rec_wd = ps_dec->u2_frm_wd_y;
            i2_rec_x += (mb_index << 4);
            pu1_rec = ps_frame_buf->pu1_dest_y + i2_rec_y * u2_rec_wd
                            + i2_rec_x;
        }

        /* filling the pred and dma structures for Y */
        u2_frm_wd = ps_dec->u2_frm_wd_y;

        ps_pred->u2_u1_ref_buf_wd = u1_dma_wd;
        ps_pred->i1_dma_ht = u1_dma_ht;
        ps_pred->i1_mc_wd = i1_mc_wd;
        ps_pred->u2_frm_wd = u2_frm_wd;
        ps_pred->pu1_rec_y_u = pu1_rec;
        ps_pred->u2_dst_stride = u2_rec_wd;

        ps_pred->i1_mb_partwidth = u1_part_wd << 2;
        ps_pred->i1_mb_partheight = u1_part_ht << 2;
        ps_pred->u1_dydx = (u1_dy << 2) + u1_dx;

        ps_pred->pu1_y_ref = pu1_pred;

    }

    /* Increment ps_pred index */
    ps_pred++;

    /* Transfer Setup U & V */
    {
        WORD32 i4_ref_offset, i4_rec_offset;
        UWORD8 *pu1_pred_u, *pu1_pred_v;


        /* calculating rounded motion vectors and fractional components */
        i2_tmp_mv_x = i2_mv_x;
        i2_tmp_mv_y = i2_mv_y;

        /************************************************************************/
        /* Table 8-9: Derivation of the vertical component of the chroma vector */
        /* in field coding mode                                                 */
        /************************************************************************/

        /* Eighth sample of the chroma MV */
        u1_dx = i2_tmp_mv_x & 0x7;
        u1_dy = i2_tmp_mv_y & 0x7;

        /********************************************************************/
        /* Calculating the full pel MV for chroma which is 1/2 of the Luma  */
        /* MV in full pel units                                             */
        /********************************************************************/
        i2_mv_x = i2_tmp_mv_x;
        i2_mv_y = i2_tmp_mv_y;
        i2_tmp_mv_x = SIGN_POW2_DIV(i2_tmp_mv_x, 3);
        i2_tmp_mv_y = SIGN_POW2_DIV(i2_tmp_mv_y, 3);
        i1_mc_wd = u1_part_wd << 1;
        u1_dma_ht = u1_part_ht << 1;
        if(u1_dx)
        {
            i2_tmp_mv_x -= (i2_mv_x < 0);
            i1_mc_wd++;
        }
        if(u1_dy != 0)
        {
            i2_tmp_mv_y -= (i2_mv_y < 0);
            u1_dma_ht++;
        }

        /********************************************************************/
        /* Calulating the horizontal and the vertical u4_ofst from top left  */
        /* edge of the reference frame, and subsequent clipping             */
        /********************************************************************/
        u2_pic_ht >>= 1;
        u2_frm_wd = ps_dec->u2_frm_wd_uv;
        i2_rec_x = u1_sub_x << 1;
        i2_rec_y = u1_sub_y << 1;

        i2_frm_x = (u2_mb_x << 3) + i2_rec_x + i2_tmp_mv_x;
        i2_frm_y = (u2_mb_y << 3) + i2_rec_y + i2_tmp_mv_y;

        i2_frm_x = CLIP3(MAX_OFFSET_OUTSIDE_UV_FRM,
                         ((ps_dec->u2_pic_wd >> 1) - 1), i2_frm_x);
        i2_frm_y = CLIP3(((1 - u1_dma_ht)), (u2_pic_ht - (1)), i2_frm_y);

        i4_ref_offset = i2_frm_y * u2_frm_wd + i2_frm_x * YUV420SP_FACTOR;
        u1_dma_wd = (i1_mc_wd + 3) & 0xFC;

        /********************************************************************/
        /* Calulating the horizontal and the vertical u4_ofst from top left  */
        /* edge of the recon buffer                                         */
        /********************************************************************/
        /* CHANGED CODE */
        u2_rec_wd = BLK8x8SIZE * YUV420SP_FACTOR;
        i4_rec_offset = i2_rec_y * u2_rec_wd + i2_rec_x * YUV420SP_FACTOR;

        {
            u2_rec_wd = ps_dec->u2_frm_wd_uv;
            i2_rec_x += (mb_index << 3);
            i4_rec_offset = i2_rec_y * u2_rec_wd + i2_rec_x * YUV420SP_FACTOR;
            ps_pred->pu1_rec_y_u = ps_frame_buf->pu1_dest_u + i4_rec_offset;
            ps_pred->u1_pi1_wt_ofst_rec_v = ps_frame_buf->pu1_dest_v
                            + i4_rec_offset;
        }

        /* CHANGED CODE */

        /* filling the common pred structures for U */
        u2_frm_wd = ps_dec->u2_frm_wd_uv;

        ps_pred->u2_u1_ref_buf_wd = u1_dma_wd;
        ps_pred->i1_dma_ht = u1_dma_ht;
        ps_pred->i1_mc_wd = i1_mc_wd;

        ps_pred->u2_frm_wd = u2_frm_wd;
        ps_pred->u2_dst_stride = u2_rec_wd;

        ps_pred->i1_mb_partwidth = u1_part_wd << 1;
        ps_pred->i1_mb_partheight = u1_part_ht << 1;
        ps_pred->u1_dydx = (u1_dy << 3) + u1_dx;

        pu1_pred_u = ps_ref_frm->pu1_buf2 + i4_ref_offset;
        pu1_pred_v = ps_ref_frm->pu1_buf3 + i4_ref_offset;

        /* Copy U & V partitions */
        ps_pred->pu1_u_ref = pu1_pred_u;

        /* Increment the reference buffer Index */
        ps_pred->pu1_v_ref = pu1_pred_v;
    }

    /* Increment ps_pred index */
    ps_dec->u4_pred_info_idx += 2;

    return OK;

}


/*****************************************************************************/
/* \if Function name : formMbPartInfo \endif                                 */
/*                                                                           */
/* \brief                                                                    */
/*    Form the Mb partition information structure, to be used by the MC      */
/*    routine                                                                */
/*                                                                           */
/* \return                                                                   */
/*    None                                                                   */
/* \note                                                                     */
/*    c_bufx is used to select PredBuffer,                                   */
/*    if it's only Forward/Backward prediction always buffer used is         */
/*    puc_MbLumaPredBuffer[0 to X1],pu1_mb_cb_pred_buffer[0 to X1] and          */
/*    pu1_mb_cr_pred_buffer[0 to X1]                                            */
/*                                                                           */
/*    if it's bidirect for forward ..PredBuffer[0 to X1] buffer is used and  */
/*    ..PredBuffer[X2 to X3] for backward prediction. and                    */
/*                                                                           */
/*    Final predicted samples values are the average of ..PredBuffer[0 to X1]*/
/*    and ..PredBuffer[X2 to X3]                                             */
/*                                                                           */
/*    X1 is 255 for Luma and 63 for Chroma                                   */
/*    X2 is 256 for Luma and 64 for Chroma                                   */
/*    X3 is 511 for Luma and 127 for Chroma                                  */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         11 05 2005   SWRN            Modified to handle pod               */
/*****************************************************************************/
WORD32 ih264d_form_mb_part_info_mp(pred_info_pkd_t *ps_pred_pkd,
                                 dec_struct_t * ps_dec,
                                 UWORD16 u2_mb_x,
                                 UWORD16 u2_mb_y,
                                 WORD32 mb_index,
                                 dec_mb_info_t *ps_cur_mb_info)
{
    /* The reference buffer pointer */
    UWORD8 *pu1_ref_buf;
    WORD16 i2_frm_x, i2_frm_y, i2_tmp_mv_x, i2_tmp_mv_y, i2_pod_ht;
    WORD16 i2_rec_x, i2_rec_y;
    UWORD16 u2_pic_ht, u2_frm_wd, u2_rec_wd;
    UWORD8 u1_wght_pred_type, u1_wted_bipred_idc;
    UWORD16 u2_tot_ref_scratch_size;
    UWORD8 u1_sub_x = 0;
    UWORD8 u1_sub_y = 0;
    UWORD8 u1_is_bi_dir = 0;

    /********************************************/
    /* i1_mc_wd       width reqd for mcomp      */
    /* u1_dma_ht      height reqd for mcomp     */
    /* u1_dma_wd      width aligned to 4 bytes  */
    /* u1_dx          fractional part of width  */
    /* u1_dx          fractional part of height */
    /********************************************/
    UWORD8 i1_mc_wd, u1_dma_ht, u1_dma_wd, u1_dx, u1_dy;
    pred_info_t * ps_pred ;
    dec_slice_params_t * const ps_cur_slice = ps_dec->ps_cur_slice;
    const UWORD8 u1_slice_type = ps_dec->ps_decode_cur_slice->slice_type;
    UWORD8 u1_pod_bot, u1_pod_top;

    /* load the pictype for pod u4_flag & chroma motion vector derivation */
    UWORD8 u1_ref_pic_type ;

    /* set default value to flags specifying field nature of picture & mb */
    UWORD32 u1_mb_fld = 0, u1_mb_or_pic_fld;
    UWORD32 u1_mb_bot = 0, u1_pic_bot = 0, u1_mb_or_pic_bot;
    tfr_ctxt_t *ps_frame_buf;
    /* calculate flags specifying field nature of picture & mb */
    const UWORD32 u1_pic_fld = ps_cur_slice->u1_field_pic_flag;
    WORD8 i1_pred;
    WORD8 i1_size_pos_info,i1_buf_id,i1_ref_idx;
    UWORD8 u1_part_wd,u1_part_ht;
    WORD16 i2_mv_x,i2_mv_y;
    struct pic_buffer_t *ps_ref_frm;
    UWORD32 *pu4_wt_offset;
    UWORD8 *pu1_buf1,*pu1_buf2,*pu1_buf3;


    PROFILE_DISABLE_MB_PART_INFO()

    ps_pred = ps_dec->ps_pred + ps_dec->u4_pred_info_idx;


     i1_size_pos_info = ps_pred_pkd->i1_size_pos_info;
     GET_XPOS_PRED(u1_sub_x,i1_size_pos_info);
     GET_YPOS_PRED(u1_sub_y,i1_size_pos_info);
     GET_WIDTH_PRED(u1_part_wd,i1_size_pos_info);
     GET_HEIGHT_PRED(u1_part_ht,i1_size_pos_info);
     i2_mv_x = ps_pred_pkd->i2_mv[0];
     i2_mv_y = ps_pred_pkd->i2_mv[1];
     i1_ref_idx = ps_pred_pkd->i1_ref_idx_info & 0x3f;
     i1_buf_id = ps_pred_pkd->i1_buf_id;
     ps_ref_frm = ps_dec->apv_buf_id_pic_buf_map[i1_buf_id];

     i1_pred = (ps_pred_pkd->i1_ref_idx_info & 0xC0) >> 6;
     u1_is_bi_dir = (i1_pred == BI_PRED);


    u1_ref_pic_type = ps_pred_pkd->u1_pic_type & PIC_MASK;

    pu1_buf1  = ps_ref_frm->pu1_buf1;
    pu1_buf2  = ps_ref_frm->pu1_buf2;
    pu1_buf3  = ps_ref_frm->pu1_buf3;

    if(u1_ref_pic_type == BOT_FLD)
    {
        pu1_buf1 += ps_ref_frm->u2_frm_wd_y;
        pu1_buf2 += ps_ref_frm->u2_frm_wd_uv;
        pu1_buf3 += ps_ref_frm->u2_frm_wd_uv;

    }


    if(ps_dec->ps_cur_pps->u1_wted_pred_flag)
    {
            pu4_wt_offset = (UWORD32*)&ps_dec->pu4_wt_ofsts[2
                            * X3(i1_ref_idx)];
    }


    pu4_wt_offset = ps_pred_pkd->pu4_wt_offst;


    /* Pointer to the frame buffer */
    {
        ps_frame_buf = &ps_dec->s_tran_addrecon;
        /* CHANGED CODE */
    }

    if(!u1_pic_fld)
    {
        u1_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag;
        u1_mb_bot = 1 - ps_cur_mb_info->u1_topmb;
    }
    else
        u1_pic_bot = ps_cur_slice->u1_bottom_field_flag;

    /****************************************************************/
    /* calculating the flags the tell whether to use frame-padding  */
    /* or use software pad-on-demand                                */
    /****************************************************************/
    u1_mb_or_pic_bot = u1_mb_bot | u1_pic_bot;
    u1_mb_or_pic_fld = u1_mb_fld | u1_pic_fld;
    u1_pod_bot = u1_mb_or_pic_fld && (u1_ref_pic_type == TOP_FLD);
    u1_pod_top = u1_mb_or_pic_fld && (u1_ref_pic_type == BOT_FLD);

    /* Weighted Pred additions */
    u1_wted_bipred_idc = ps_dec->ps_cur_pps->u1_wted_bipred_idc;

    if((u1_slice_type == P_SLICE) || (u1_slice_type == SP_SLICE))
    {
        /* P Slice only */
        u1_wght_pred_type = ps_dec->ps_cur_pps->u1_wted_pred_flag;

    }
    else
    {
        /* B Slice only */
        u1_wght_pred_type = 1 + u1_is_bi_dir;
        if(u1_wted_bipred_idc == 0)
            u1_wght_pred_type = 0;
        if((u1_wted_bipred_idc == 2) && (!u1_is_bi_dir))
            u1_wght_pred_type = 0;
    }
    /* load the scratch reference buffer index */
    pu1_ref_buf = ps_dec->pu1_ref_buff + ps_dec->u4_dma_buf_idx;
    u2_tot_ref_scratch_size = 0;


    /* Transfer Setup Y */
    {
        UWORD8 *pu1_pred, *pu1_rec;
        /* calculating rounded motion vectors and fractional components */
        i2_tmp_mv_x = i2_mv_x;
        i2_tmp_mv_y = i2_mv_y;

        u1_dx = i2_tmp_mv_x & 0x3;
        u1_dy = i2_tmp_mv_y & 0x3;
        i2_tmp_mv_x >>= 2;
        i2_tmp_mv_y >>= 2;
        i1_mc_wd = u1_part_wd << 2;
        u1_dma_ht = u1_part_ht << 2;
        if(u1_dx)
        {
            i2_tmp_mv_x -= 2;
            i1_mc_wd += 5;
        }
        if(u1_dy)
        {
            i2_tmp_mv_y -= 2;
            u1_dma_ht += 5;
        }

        /********************************************************************/
        /* Calulating the horizontal and the vertical u4_ofst from top left  */
        /* edge of the reference frame, and subsequent clipping             */
        /********************************************************************/
        u2_pic_ht = ps_dec->u2_pic_ht >> u1_pic_fld;
        u2_frm_wd = ps_dec->u2_frm_wd_y << u1_pic_fld;
        i2_frm_x = (u2_mb_x << 4) + (u1_sub_x << 2) + i2_tmp_mv_x;
        i2_frm_y = ((u2_mb_y + (u1_mb_bot && !u1_mb_fld)) << 4)
                        + (((u1_sub_y << 2) + i2_tmp_mv_y) << u1_mb_fld);

        i2_frm_x = CLIP3(MAX_OFFSET_OUTSIDE_X_FRM, (ps_dec->u2_pic_wd - 1),
                         i2_frm_x);
        i2_frm_y = CLIP3(((1 - u1_dma_ht) << u1_mb_fld),
                         (u2_pic_ht - (1 << u1_mb_fld)), i2_frm_y);

        pu1_pred = pu1_buf1 + i2_frm_y * u2_frm_wd + i2_frm_x;
        u1_dma_wd = (i1_mc_wd + 3) & 0xFC;
        /********************************************************************/
        /* Calulating the horizontal and the vertical u4_ofst from top left  */
        /* edge of the recon buffer                                         */
        /********************************************************************/
        /* CHANGED CODE */
        u2_rec_wd = MB_SIZE;
        i2_rec_x = u1_sub_x << 2;
        i2_rec_y = u1_sub_y << 2;
        {
            u2_rec_wd = ps_dec->u2_frm_wd_y << u1_mb_or_pic_fld;
            i2_rec_x += (mb_index << 4);
            pu1_rec = ps_frame_buf->pu1_dest_y + i2_rec_y * u2_rec_wd
                            + i2_rec_x;
            if(u1_mb_bot)
                pu1_rec += ps_dec->u2_frm_wd_y << ((u1_mb_fld) ? 0 : 4);
        }

        /* CHANGED CODE */

        /* filling the pred and dma structures for Y */
        u2_frm_wd = ps_dec->u2_frm_wd_y << u1_mb_or_pic_fld;

        ps_pred->pu1_dma_dest_addr = pu1_ref_buf;
        ps_pred->u2_u1_ref_buf_wd = u1_dma_wd;
        ps_pred->u2_frm_wd = u2_frm_wd;
        ps_pred->i1_dma_ht = u1_dma_ht;
        ps_pred->i1_mc_wd = i1_mc_wd;
        ps_pred->pu1_rec_y_u = pu1_rec;
        ps_pred->u2_dst_stride = u2_rec_wd;

        ps_pred->i1_mb_partwidth = u1_part_wd << 2;
        ps_pred->i1_mb_partheight = u1_part_ht << 2;
        ps_pred->u1_dydx = (u1_dy << 2) + u1_dx;
        ps_pred->u1_is_bi_direct = u1_is_bi_dir;
        ps_pred->u1_pi1_wt_ofst_rec_v = (UWORD8 *)pu4_wt_offset;
        ps_pred->u1_wght_pred_type = u1_wght_pred_type;
        ps_pred->i1_pod_ht = 0;

        /* Increment the Reference buffer Indices */
        pu1_ref_buf += u1_dma_wd * u1_dma_ht;
        u2_tot_ref_scratch_size += u1_dma_wd * u1_dma_ht;

        /* unrestricted field motion comp for top region outside frame */
        i2_pod_ht = (-i2_frm_y) >> u1_mb_fld;
        if((i2_pod_ht > 0) && u1_pod_top)
        {
            ps_pred->i1_pod_ht = (WORD8)(-i2_pod_ht);
            u1_dma_ht -= i2_pod_ht;
            pu1_pred += i2_pod_ht * u2_frm_wd;
        }
        /* unrestricted field motion comp for bottom region outside frame */
        else if(u1_pod_bot)
        {
            i2_pod_ht = u1_dma_ht + ((i2_frm_y - u2_pic_ht) >> u1_mb_fld);
            if(i2_pod_ht > 0)
            {
                u1_dma_ht -= i2_pod_ht;
                ps_pred->i1_pod_ht = (WORD8)i2_pod_ht;
            }
        }

        /* Copy Y partition */

        /*
         * ps_pred->i1_pod_ht is non zero when MBAFF is present. In case of MBAFF the reference data
         * is copied in the Scrath buffer so that the padding_on_demand doesnot corrupt the frame data
         */
        if(ps_pred->i1_pod_ht)
        {
            ps_pred->pu1_pred = pu1_pred;
            ps_pred->u1_dma_ht_y = u1_dma_ht;
            ps_pred->u1_dma_wd_y = u1_dma_wd;
        }
        ps_pred->pu1_y_ref = pu1_pred;
    }


    /* Increment ps_pred index */
    ps_pred++;

    /* Transfer Setup U & V */
    {
        WORD32 i4_ref_offset, i4_rec_offset;
        UWORD8 *pu1_pred_u, *pu1_pred_v, u1_tmp_dma_ht;
        /* CHANGED CODE */
        UWORD8 u1_chroma_cbp = (UWORD8)(ps_cur_mb_info->u1_cbp >> 4);
        /* CHANGED CODE */

        /* calculating rounded motion vectors and fractional components */
        i2_tmp_mv_x = i2_mv_x;
        i2_tmp_mv_y = i2_mv_y;

        /************************************************************************/
        /* Table 8-9: Derivation of the vertical component of the chroma vector */
        /* in field coding mode                                                 */
        /************************************************************************/
        if(u1_pod_bot && u1_mb_or_pic_bot)
            i2_tmp_mv_y += 2;
        if(u1_pod_top && !u1_mb_or_pic_bot)
            i2_tmp_mv_y -= 2;

        /* Eighth sample of the chroma MV */
        u1_dx = i2_tmp_mv_x & 0x7;
        u1_dy = i2_tmp_mv_y & 0x7;

        /********************************************************************/
        /* Calculating the full pel MV for chroma which is 1/2 of the Luma  */
        /* MV in full pel units                                             */
        /********************************************************************/
        i2_mv_x = i2_tmp_mv_x;
        i2_mv_y = i2_tmp_mv_y;
        i2_tmp_mv_x = SIGN_POW2_DIV(i2_tmp_mv_x, 3);
        i2_tmp_mv_y = SIGN_POW2_DIV(i2_tmp_mv_y, 3);
        i1_mc_wd = u1_part_wd << 1;
        u1_dma_ht = u1_part_ht << 1;
        if(u1_dx)
        {
            if(i2_mv_x < 0)
                i2_tmp_mv_x -= 1;
            i1_mc_wd++;
        }
        if(u1_dy != 0)
        {
            if(i2_mv_y < 0)
                i2_tmp_mv_y -= 1;
            u1_dma_ht++;
        }

        /********************************************************************/
        /* Calulating the horizontal and the vertical u4_ofst from top left  */
        /* edge of the reference frame, and subsequent clipping             */
        /********************************************************************/
        u2_pic_ht >>= 1;
        u2_frm_wd = ps_dec->u2_frm_wd_uv << u1_pic_fld;
        i2_frm_x = (u2_mb_x << 3) + (u1_sub_x << 1) + i2_tmp_mv_x;
        i2_frm_y = ((u2_mb_y + (u1_mb_bot && !u1_mb_fld)) << 3)
                        + (((u1_sub_y << 1) + i2_tmp_mv_y) << u1_mb_fld);

        i2_frm_x = CLIP3(MAX_OFFSET_OUTSIDE_UV_FRM,
                         ((ps_dec->u2_pic_wd >> 1) - 1), i2_frm_x);
        i2_frm_y = CLIP3(((1 - u1_dma_ht) << u1_mb_fld),
                         (u2_pic_ht - (1 << u1_mb_fld)), i2_frm_y);

        i4_ref_offset = i2_frm_y * u2_frm_wd + i2_frm_x * YUV420SP_FACTOR;
        u1_dma_wd = (i1_mc_wd + 3) & 0xFC;

        /********************************************************************/
        /* Calulating the horizontal and the vertical u4_ofst from top left  */
        /* edge of the recon buffer                                         */
        /********************************************************************/
        /* CHANGED CODE */
        u2_rec_wd = BLK8x8SIZE * YUV420SP_FACTOR;
        i2_rec_x = u1_sub_x << 1;
        i2_rec_y = u1_sub_y << 1;
        i4_rec_offset = i2_rec_y * u2_rec_wd + i2_rec_x * YUV420SP_FACTOR;
        {
            u2_rec_wd = ps_dec->u2_frm_wd_uv << u1_mb_or_pic_fld;

            i2_rec_x += (mb_index << 3);
            i4_rec_offset = i2_rec_y * u2_rec_wd + i2_rec_x * YUV420SP_FACTOR;
            if(u1_mb_bot)
                i4_rec_offset += ps_dec->u2_frm_wd_uv << ((u1_mb_fld) ? 0 : 3);
            ps_pred->pu1_rec_y_u = ps_frame_buf->pu1_dest_u + i4_rec_offset;
            ps_pred->u1_pi1_wt_ofst_rec_v = ps_frame_buf->pu1_dest_v
                            + i4_rec_offset;

        }

        /* CHANGED CODE */

        /* filling the common pred structures for U */
        u2_frm_wd = ps_dec->u2_frm_wd_uv << u1_mb_or_pic_fld;
        u1_tmp_dma_ht = u1_dma_ht;
        ps_pred->u2_u1_ref_buf_wd = u1_dma_wd;
        ps_pred->u2_frm_wd = u2_frm_wd;
        ps_pred->i1_dma_ht = u1_dma_ht;
        ps_pred->i1_mc_wd = i1_mc_wd;
        ps_pred->u2_dst_stride = u2_rec_wd;

        ps_pred->i1_mb_partwidth = u1_part_wd << 1;
        ps_pred->i1_mb_partheight = u1_part_ht << 1;
        ps_pred->u1_dydx = (u1_dy << 3) + u1_dx;
        ps_pred->u1_is_bi_direct = u1_is_bi_dir;
        ps_pred->u1_wght_pred_type = u1_wght_pred_type;
        ps_pred->i1_pod_ht = 0;

        ps_pred->pu1_dma_dest_addr = pu1_ref_buf;

        /* unrestricted field motion comp for top region outside frame */
        i2_pod_ht = (-i2_frm_y) >> u1_mb_fld;
        if((i2_pod_ht > 0) && u1_pod_top)
        {
            i4_ref_offset += i2_pod_ht * u2_frm_wd;
            u1_dma_ht -= i2_pod_ht;
            ps_pred->i1_pod_ht = (WORD8)(-i2_pod_ht);
        }
        /* unrestricted field motion comp for bottom region outside frame */
        else if(u1_pod_bot)
        {
            i2_pod_ht = u1_dma_ht + ((i2_frm_y - u2_pic_ht) >> u1_mb_fld);
            if(i2_pod_ht > 0)
            {
                u1_dma_ht -= i2_pod_ht;
                ps_pred->i1_pod_ht = (WORD8)i2_pod_ht;
            }
        }

        pu1_pred_u = pu1_buf2 + i4_ref_offset;
        pu1_pred_v = pu1_buf3 + i4_ref_offset;

        /* Copy U & V partitions */
        if(ps_pred->i1_pod_ht)
        {
            ps_pred->pu1_pred_u = pu1_pred_u;
            ps_pred->u1_dma_ht_uv = u1_dma_ht;
            ps_pred->u1_dma_wd_uv = u1_dma_wd;

        }
        ps_pred->pu1_u_ref = pu1_pred_u;

        /* Increment the reference buffer Index */
        u2_tot_ref_scratch_size += (u1_dma_wd * u1_tmp_dma_ht) << 1;

        if(ps_pred->i1_pod_ht)
        {
            ps_pred->pu1_pred_v = pu1_pred_v;
            ps_pred->u1_dma_ht_uv = u1_dma_ht;
            ps_pred->u1_dma_wd_uv = u1_dma_wd;
        }

        ps_pred->pu1_v_ref = pu1_pred_v;
    }

    /* Increment ps_pred index */
    ps_dec->u4_pred_info_idx += 2;


    /* Increment the reference buffer Index */
    ps_dec->u4_dma_buf_idx += u2_tot_ref_scratch_size;

    if(ps_dec->u4_dma_buf_idx > MAX_REF_BUF_SIZE)
        return ERROR_NUM_MV;

    return OK;


}


/*!
 **************************************************************************
 * \if Function name : MotionCompensate \endif
 *
 * \brief
 *    The routine forms predictor blocks for the entire MB and stores it in
 *    predictor buffers.This function works only for BASELINE profile
 *
 * \param ps_dec: Pointer to the structure decStruct. This is used to get
 *     pointers to the current and the reference frame and to the MbParams
 *     structure.
 *
 * \return
 *    None
 *
 * \note
 *    The routine forms predictors for all the luma and the chroma MB
 *    partitions.
 **************************************************************************
 */

void ih264d_motion_compensate_bp(dec_struct_t * ps_dec, dec_mb_info_t *ps_cur_mb_info)
{
    pred_info_t *ps_pred ;
    UWORD8 *puc_ref, *pu1_dest_y;
    UWORD8 *pu1_dest_u;
    UWORD32 u2_num_pels, u2_ref_wd_y, u2_ref_wd_uv, u2_dst_wd;

    UWORD32 u4_wd_y, u4_ht_y, u4_wd_uv;
    UWORD32 u4_ht_uv;
    UWORD8 *puc_pred0 = (UWORD8 *)(ps_dec->pi2_pred1);


    PROFILE_DISABLE_INTER_PRED()
    UNUSED(ps_cur_mb_info);
    ps_pred = ps_dec->ps_pred ;

    for(u2_num_pels = 0; u2_num_pels < 256;)
    {
        UWORD32 uc_dx, uc_dy;
        /* Pointer to the destination buffer. If the CBPs of all 8x8 blocks in
         the MB partition are zero then it would be better to copy the
         predictor valus directly to the current frame buffer */
        /*
         * ps_pred->i1_pod_ht is non zero when MBAFF is present. In case of MBAFF the reference data
         * is copied in the Scrath buffer so that the padding_on_demand doesnot corrupt the frame data
         */

        u2_ref_wd_y = ps_pred->u2_frm_wd;
        puc_ref = ps_pred->pu1_y_ref;
        if(ps_pred->u1_dydx & 0x3)
            puc_ref += 2;
        if(ps_pred->u1_dydx >> 2)
            puc_ref += 2 * u2_ref_wd_y;

        u4_wd_y = ps_pred->i1_mb_partwidth;
        u4_ht_y = ps_pred->i1_mb_partheight;
        uc_dx = ps_pred->u1_dydx;
        uc_dy = uc_dx >> 2;
        uc_dx &= 0x3;

        pu1_dest_y = ps_pred->pu1_rec_y_u;
        u2_dst_wd = ps_pred->u2_dst_stride;

        ps_dec->apf_inter_pred_luma[ps_pred->u1_dydx](puc_ref, pu1_dest_y,
                                                      u2_ref_wd_y,
                                                      u2_dst_wd,
                                                      u4_ht_y,
                                                      u4_wd_y, puc_pred0,
                                                      ps_pred->u1_dydx);

        ps_pred++;

        /* Interpolate samples for the chroma components */
        {
            UWORD8 *pu1_ref_u;

            u2_ref_wd_uv = ps_pred->u2_frm_wd;
            pu1_ref_u = ps_pred->pu1_u_ref;

            u4_wd_uv = ps_pred->i1_mb_partwidth;
            u4_ht_uv = ps_pred->i1_mb_partheight;
            uc_dx = ps_pred->u1_dydx; /* 8*dy + dx */
            uc_dy = uc_dx >> 3;
            uc_dx &= 0x7;

            pu1_dest_u = ps_pred->pu1_rec_y_u;
            u2_dst_wd = ps_pred->u2_dst_stride;

            ps_pred++;
            ps_dec->pf_inter_pred_chroma(pu1_ref_u, pu1_dest_u, u2_ref_wd_uv,
                                         u2_dst_wd, uc_dx, uc_dy,
                                         u4_ht_uv, u4_wd_uv);

        }

        u2_num_pels += (UWORD8)u4_wd_y * (UWORD8)u4_ht_y;

    }
}


/*
 **************************************************************************
 * \if Function name : MotionCompensateB \endif
 *
 * \brief
 *    The routine forms predictor blocks for the entire MB and stores it in
 *    predictor buffers.
 *
 * \param ps_dec: Pointer to the structure decStruct. This is used to get
 *     pointers to the current and the reference frame and to the MbParams
 *     structure.
 *
 * \return
 *    None
 *
 * \note
 *    The routine forms predictors for all the luma and the chroma MB
 *    partitions.
 **************************************************************************
 */

void ih264d_motion_compensate_mp(dec_struct_t * ps_dec, dec_mb_info_t *ps_cur_mb_info)
{
    pred_info_t *ps_pred ;
    pred_info_t *ps_pred_y_forw, *ps_pred_y_back, *ps_pred_cr_forw;
    UWORD8 *puc_ref, *pu1_dest_y, *puc_pred0, *puc_pred1;
    UWORD8 *pu1_dest_u, *pu1_dest_v;
    WORD16 *pi16_intm;
    UWORD32 u2_num_pels, u2_ref_wd_y, u2_ref_wd_uv, u2_dst_wd;
    UWORD32 u2_dest_wd_y, u2_dest_wd_uv;
    UWORD32 u2_row_buf_wd_y = 0;
    UWORD32 u2_row_buf_wd_uv = 0;
    UWORD32 u2_log2Y_crwd;
    UWORD32 u4_wd_y, u4_ht_y, u1_dir, u4_wd_uv;
    UWORD32 u4_ht_uv;
    UWORD8 *pu1_temp_mc_buffer = ps_dec->pu1_temp_mc_buffer;
    WORD32 i2_pod_ht;
    UWORD32 u2_pic_ht, u2_frm_wd, u2_rec_wd;
    UWORD32 u1_pod_bot, u1_pod_top;
    UWORD8 *pu1_pred, *pu1_dma_dst;
    UWORD32 u1_dma_wd, u1_dma_ht;

    dec_slice_params_t * const ps_cur_slice = ps_dec->ps_cur_slice;

    /* set default value to flags specifying field nature of picture & mb */
    UWORD32 u1_mb_fld = 0, u1_mb_or_pic_fld;
    UWORD32 u1_mb_or_pic_bot;
    /* calculate flags specifying field nature of picture & mb */
    const UWORD8 u1_pic_fld = ps_cur_slice->u1_field_pic_flag;

    PROFILE_DISABLE_INTER_PRED()
    ps_pred = ps_dec->ps_pred ;
    /* Initialize both ps_pred_y_forw, ps_pred_cr_forw and ps_pred_y_back
     * to avoid static analysis warnings */
    ps_pred_y_forw = ps_pred;
    ps_pred_y_back = ps_pred;
    ps_pred_cr_forw = ps_pred;

    u2_log2Y_crwd = ps_dec->ps_decode_cur_slice->u2_log2Y_crwd;

    if(!u1_pic_fld)
    {
        u1_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag;
    }

    u1_mb_or_pic_fld = u1_mb_fld | u1_pic_fld;

    pi16_intm = ps_dec->pi2_pred1;
    puc_pred0 = (UWORD8 *)pi16_intm;
    puc_pred1 = puc_pred0 + PRED_BUFFER_WIDTH * PRED_BUFFER_HEIGHT * sizeof(WORD16);

    for(u2_num_pels = 0; u2_num_pels < 256;)
    {
        UWORD8 uc_dx, uc_dy;
        const UWORD8 u1_is_bi_direct = ps_pred->u1_is_bi_direct;
        for(u1_dir = 0; u1_dir <= u1_is_bi_direct; u1_dir++)
        {
            /* Pointer to the destination buffer. If the CBPs of all 8x8 blocks in
             the MB partition are zero then it would be better to copy the
             predictor valus directly to the current frame buffer */
            /*
             * ps_pred->i1_pod_ht is non zero when MBAFF is present. In case of MBAFF the reference data
             * is copied in the Scrath buffer so that the padding_on_demand doesnot corrupt the frame data
             */

            if(ps_pred->i1_pod_ht)
            {
                u2_ref_wd_y = ps_pred->u2_u1_ref_buf_wd;
                puc_ref = ps_pred->pu1_dma_dest_addr;
            }
            else
            {
                u2_ref_wd_y = ps_pred->u2_frm_wd;
                puc_ref = ps_pred->pu1_y_ref;

            }

            if(ps_pred->u1_dydx & 0x3)
                puc_ref += 2;
            if(ps_pred->u1_dydx >> 2)
                puc_ref += 2 * u2_ref_wd_y;
            u4_wd_y = ps_pred->i1_mb_partwidth;
            u4_ht_y = ps_pred->i1_mb_partheight;

            uc_dx = ps_pred->u1_dydx;
            uc_dy = uc_dx >> 2;
            uc_dx &= 0x3;
            if(u1_dir == 0)
            {
                pu1_dest_y = ps_pred->pu1_rec_y_u;
                u2_row_buf_wd_y = ps_pred->u2_dst_stride;
                u2_dst_wd = ps_pred->u2_dst_stride;
                u2_dest_wd_y = u2_dst_wd;
                ps_pred_y_forw = ps_pred;
            }
            else
            {
                pu1_dest_y = pu1_temp_mc_buffer;
                u2_dst_wd = MB_SIZE;
                u2_dest_wd_y = u2_dst_wd;
                ps_pred_y_back = ps_pred;
                ps_pred_y_back->pu1_rec_y_u = pu1_dest_y;
            }

            /* padding on demand (POD) for y done here */

            if(ps_pred->i1_pod_ht)
            {
                pu1_pred = ps_pred->pu1_pred;
                pu1_dma_dst = ps_pred->pu1_dma_dest_addr;
                u1_dma_wd = ps_pred->u1_dma_wd_y;
                u1_dma_ht = ps_pred->u1_dma_ht_y;
                u2_frm_wd = ps_dec->u2_frm_wd_y << u1_mb_or_pic_fld;
                if(ps_pred->i1_pod_ht < 0)
                {
                    pu1_dma_dst = pu1_dma_dst - (ps_pred->i1_pod_ht * ps_pred->u2_u1_ref_buf_wd);
                }
                ih264d_copy_2d1d(pu1_pred, pu1_dma_dst, u2_frm_wd, u1_dma_wd,
                                 u1_dma_ht);
                ih264d_pad_on_demand(ps_pred, LUM_BLK);
            }
            ps_dec->apf_inter_pred_luma[ps_pred->u1_dydx](puc_ref, pu1_dest_y,
                                                          u2_ref_wd_y,
                                                          u2_dst_wd,
                                                          u4_ht_y,
                                                          u4_wd_y,
                                                          puc_pred0,
                                                          ps_pred->u1_dydx);
            ps_pred++;

            /* Interpolate samples for the chroma components */
            {
                UWORD8 *pu1_ref_u;
                UWORD32 u1_dma_ht;

                /* padding on demand (POD) for U and V done here */
                u1_dma_ht = ps_pred->i1_dma_ht;

                if(ps_pred->i1_pod_ht)
                {
                    pu1_pred = ps_pred->pu1_pred_u;
                    pu1_dma_dst = ps_pred->pu1_dma_dest_addr;
                    u1_dma_ht = ps_pred->u1_dma_ht_uv;
                    u1_dma_wd = ps_pred->u1_dma_wd_uv * YUV420SP_FACTOR;
                    u2_frm_wd = ps_dec->u2_frm_wd_uv << u1_mb_or_pic_fld;
                    if(ps_pred->i1_pod_ht < 0)
                    {
                        /*Top POD*/
                        pu1_dma_dst -= (ps_pred->i1_pod_ht
                                        * ps_pred->u2_u1_ref_buf_wd
                                        * YUV420SP_FACTOR);
                    }

                    ih264d_copy_2d1d(pu1_pred, pu1_dma_dst, u2_frm_wd,
                                     u1_dma_wd, u1_dma_ht);

                    pu1_dma_dst += (ps_pred->i1_dma_ht
                                    * ps_pred->u2_u1_ref_buf_wd);
                    pu1_pred = ps_pred->pu1_pred_v;

                    ih264d_pad_on_demand(ps_pred, CHROM_BLK);
                }

                if(ps_pred->i1_pod_ht)
                {
                    pu1_ref_u = ps_pred->pu1_dma_dest_addr;

                    u2_ref_wd_uv = ps_pred->u2_u1_ref_buf_wd
                                    * YUV420SP_FACTOR;
                }
                else
                {
                    u2_ref_wd_uv = ps_pred->u2_frm_wd;
                    pu1_ref_u = ps_pred->pu1_u_ref;

                }

                u4_wd_uv = ps_pred->i1_mb_partwidth;
                u4_ht_uv = ps_pred->i1_mb_partheight;
                uc_dx = ps_pred->u1_dydx; /* 8*dy + dx */
                uc_dy = uc_dx >> 3;
                uc_dx &= 0x7;
                if(u1_dir == 0)
                {
                    pu1_dest_u = ps_pred->pu1_rec_y_u;

                    pu1_dest_v = ps_pred->u1_pi1_wt_ofst_rec_v;
                    u2_row_buf_wd_uv = ps_pred->u2_dst_stride;
                    u2_dst_wd = ps_pred->u2_dst_stride;
                    u2_dest_wd_uv = u2_dst_wd;
                    ps_pred_cr_forw = ps_pred;
                }
                else
                {
                    pu1_dest_u = puc_pred0;

                    pu1_dest_v = puc_pred1;
                    u2_dest_wd_uv = BUFFER_WIDTH;
                    u2_dst_wd = BUFFER_WIDTH;
                    ps_pred->pu1_rec_y_u = pu1_dest_u;
                    ps_pred->u1_pi1_wt_ofst_rec_v = pu1_dest_v;
                }

                ps_pred++;
                ps_dec->pf_inter_pred_chroma(pu1_ref_u, pu1_dest_u,
                                             u2_ref_wd_uv, u2_dst_wd,
                                             uc_dx, uc_dy, u4_ht_uv,
                                             u4_wd_uv);

                if(ps_cur_mb_info->u1_Mux == 1)
                {
                    /******************************************************************/
                    /* padding on demand (POD) for U and V done here                  */
                    /* ps_pred now points to the Y entry of the 0,0 component         */
                    /* Y need not be checked for POD because Y lies within            */
                    /* the picture((0,0) mv for Y doesnot get changed. But (0,0) for  */
                    /* U and V can need POD beacause of cross-field mv adjustments    */
                    /* (Table 8-9 of standard)                                        */
                    /******************************************************************/
                    if((ps_pred + 1)->i1_pod_ht)
                    {
                        pu1_pred = (ps_pred + 1)->pu1_pred_u;
                        pu1_dma_dst = (ps_pred + 1)->pu1_dma_dest_addr;
                        u1_dma_ht = (ps_pred + 1)->u1_dma_ht_uv;
                        u1_dma_wd = (ps_pred + 1)->u1_dma_wd_uv
                                        * YUV420SP_FACTOR;
                        u2_frm_wd = ps_dec->u2_frm_wd_uv << u1_mb_or_pic_fld;
                        if((ps_pred + 1)->i1_pod_ht < 0)
                        {
                            /*Top POD*/
                            pu1_dma_dst -= ((ps_pred + 1)->i1_pod_ht
                                            * (ps_pred + 1)->u2_u1_ref_buf_wd
                                            * YUV420SP_FACTOR);
                        }
                        ih264d_copy_2d1d(pu1_pred, pu1_dma_dst, u2_frm_wd,
                                         u1_dma_wd, u1_dma_ht);
                        pu1_dma_dst += ((ps_pred + 1)->i1_dma_ht
                                        * (ps_pred + 1)->u2_u1_ref_buf_wd); //(u1_dma_ht * u1_dma_wd);//
                        pu1_pred = (ps_pred + 1)->pu1_pred_v;
                        ih264d_pad_on_demand(ps_pred + 1, CHROM_BLK);

                    }

                    ih264d_multiplex_ref_data(ps_dec, ps_pred, pu1_dest_y,
                                              pu1_dest_u, ps_cur_mb_info,
                                              u2_dest_wd_y, u2_dest_wd_uv,
                                              u1_dir);
                    ps_pred += 2;
                }
            }
        }
        if(u1_dir != 0)
            u2_ref_wd_y = MB_SIZE;

        u2_num_pels += u4_wd_y * u4_ht_y;
        /* if BI_DIRECT, average the two pred's, and put in ..PredBuffer[0] */
        if((u1_is_bi_direct != 0) || (ps_pred_y_forw->u1_wght_pred_type != 0))
        {

            switch(ps_pred_y_forw->u1_wght_pred_type)
            {
                case 0:
                    ps_dec->pf_default_weighted_pred_luma(
                                    ps_pred_y_forw->pu1_rec_y_u, pu1_dest_y,
                                    ps_pred_y_forw->pu1_rec_y_u,
                                    u2_row_buf_wd_y, u2_ref_wd_y,
                                    u2_row_buf_wd_y, u4_ht_uv * 2,
                                    u4_wd_uv * 2);

                    ps_dec->pf_default_weighted_pred_chroma(
                                    ps_pred_cr_forw->pu1_rec_y_u, pu1_dest_u,
                                    ps_pred_cr_forw->pu1_rec_y_u,
                                    u2_row_buf_wd_uv, u2_dst_wd,
                                    u2_row_buf_wd_uv, u4_ht_uv,
                                    u4_wd_uv);

                    break;
                case 1:
                {
                    UWORD32 *pu4_weight_ofst =
                                    (UWORD32*)ps_pred_y_forw->u1_pi1_wt_ofst_rec_v;
                    UWORD32 u4_wt_ofst_u, u4_wt_ofst_v;
                    UWORD32 u4_wt_ofst_y =
                                    (UWORD32)(pu4_weight_ofst[0]);
                    WORD32 weight = (WORD16)(u4_wt_ofst_y & 0xffff);
                    WORD32 ofst = (WORD8)(u4_wt_ofst_y >> 16);

                    ps_dec->pf_weighted_pred_luma(ps_pred_y_forw->pu1_rec_y_u,
                                                  ps_pred_y_forw->pu1_rec_y_u,
                                                  u2_row_buf_wd_y,
                                                  u2_row_buf_wd_y,
                                                  (u2_log2Y_crwd & 0x0ff),
                                                  weight, ofst, u4_ht_y,
                                                  u4_wd_y);

                    u4_wt_ofst_u = (UWORD32)(pu4_weight_ofst[2]);
                    u4_wt_ofst_v = (UWORD32)(pu4_weight_ofst[4]);
                    weight = ((u4_wt_ofst_v & 0xffff) << 16)
                                    | (u4_wt_ofst_u & 0xffff);
                    ofst = ((u4_wt_ofst_v >> 16) << 8)
                                    | ((u4_wt_ofst_u >> 16) & 0xFF);

                    ps_dec->pf_weighted_pred_chroma(
                                    ps_pred_cr_forw->pu1_rec_y_u,
                                    ps_pred_cr_forw->pu1_rec_y_u,
                                    u2_row_buf_wd_uv, u2_row_buf_wd_uv,
                                    (u2_log2Y_crwd >> 8), weight, ofst,
                                    u4_ht_y >> 1, u4_wd_y >> 1);
                }

                    break;
                case 2:
                {
                    UWORD32 *pu4_weight_ofst =
                                    (UWORD32*)ps_pred_y_forw->u1_pi1_wt_ofst_rec_v;
                    UWORD32 u4_wt_ofst_u, u4_wt_ofst_v;
                    UWORD32 u4_wt_ofst_y;
                    WORD32 weight1, weight2;
                    WORD32 ofst1, ofst2;

                    u4_wt_ofst_y = (UWORD32)(pu4_weight_ofst[0]);

                    weight1 = (WORD16)(u4_wt_ofst_y & 0xffff);
                    ofst1 = (WORD8)(u4_wt_ofst_y >> 16);

                    u4_wt_ofst_y = (UWORD32)(pu4_weight_ofst[1]);
                    weight2 = (WORD16)(u4_wt_ofst_y & 0xffff);
                    ofst2 = (WORD8)(u4_wt_ofst_y >> 16);

                    ps_dec->pf_weighted_bi_pred_luma(ps_pred_y_forw->pu1_rec_y_u,
                                                     ps_pred_y_back->pu1_rec_y_u,
                                                     ps_pred_y_forw->pu1_rec_y_u,
                                                     u2_row_buf_wd_y,
                                                     u2_ref_wd_y,
                                                     u2_row_buf_wd_y,
                                                     (u2_log2Y_crwd & 0x0ff),
                                                     weight1, weight2, ofst1,
                                                     ofst2, u4_ht_y,
                                                     u4_wd_y);

                    u4_wt_ofst_u = (UWORD32)(pu4_weight_ofst[2]);
                    u4_wt_ofst_v = (UWORD32)(pu4_weight_ofst[4]);
                    weight1 = ((u4_wt_ofst_v & 0xffff) << 16)
                                    | (u4_wt_ofst_u & 0xffff);
                    ofst1 = ((u4_wt_ofst_v >> 16) << 8)
                                    | ((u4_wt_ofst_u >> 16) & 0xFF);

                    u4_wt_ofst_u = (UWORD32)(pu4_weight_ofst[3]);
                    u4_wt_ofst_v = (UWORD32)(pu4_weight_ofst[5]);
                    weight2 = ((u4_wt_ofst_v & 0xffff) << 16)
                                    | (u4_wt_ofst_u & 0xffff);
                    ofst2 = ((u4_wt_ofst_v >> 16) << 8)
                                    | ((u4_wt_ofst_u >> 16) & 0xFF);

                    ps_dec->pf_weighted_bi_pred_chroma(
                                    (ps_pred_y_forw + 1)->pu1_rec_y_u,
                                    (ps_pred_y_back + 1)->pu1_rec_y_u,
                                    (ps_pred_y_forw + 1)->pu1_rec_y_u,
                                    u2_row_buf_wd_uv, u2_dst_wd,
                                    u2_row_buf_wd_uv, (u2_log2Y_crwd >> 8),
                                    weight1, weight2, ofst1, ofst2,
                                    u4_ht_y >> 1, u4_wd_y >> 1);
                }

                    break;
            }

        }
    }
}


/*!
 **************************************************************************
 * \if Function name : ih264d_multiplex_ref_data \endif
 *
 * \brief
 *    Initializes forward and backward refernce lists for B slice decoding.
 *
 *
 * \return
 *    0 on Success and Error code otherwise
 **************************************************************************
 */

void ih264d_multiplex_ref_data(dec_struct_t * ps_dec,
                               pred_info_t *ps_pred,
                               UWORD8* pu1_dest_y,
                               UWORD8* pu1_dest_u,
                               dec_mb_info_t *ps_cur_mb_info,
                               UWORD16 u2_dest_wd_y,
                               UWORD16 u2_dest_wd_uv,
                               UWORD8 u1_dir)
{
    UWORD16 u2_mask = ps_cur_mb_info->u2_mask[u1_dir];
    UWORD8 *pu1_ref_y, *pu1_ref_u;
    UWORD8 uc_cond, i, j, u1_dydx;
    UWORD16 u2_ref_wd_y, u2_ref_wd_uv;

    PROFILE_DISABLE_INTER_PRED()

    if(ps_pred->i1_pod_ht)
    {
        pu1_ref_y = ps_pred->pu1_dma_dest_addr;

        u2_ref_wd_y = ps_pred->u2_u1_ref_buf_wd;
    }
    else
    {
        pu1_ref_y = ps_pred->pu1_y_ref;
        u2_ref_wd_y = ps_pred->u2_frm_wd;
    }

    ps_pred++;
    if(ps_pred->i1_pod_ht)
    {
        pu1_ref_u = ps_pred->pu1_dma_dest_addr;
        u2_ref_wd_uv = ps_pred->u2_u1_ref_buf_wd * YUV420SP_FACTOR;

    }
    else
    {
        pu1_ref_u = ps_pred->pu1_u_ref;
        u2_ref_wd_uv = ps_pred->u2_frm_wd;

    }

    u1_dydx = ps_pred->u1_dydx;

    {
        UWORD8 uc_dx, uc_dy;
        UWORD8 *pu1_scratch_u;

        uc_dx = u1_dydx & 0x3;
        uc_dy = u1_dydx >> 3;
        if(u1_dydx != 0)
        {
            pred_info_t * ps_prv_pred = ps_pred - 2;
            pu1_scratch_u = ps_prv_pred->pu1_dma_dest_addr;
            ps_dec->pf_inter_pred_chroma(pu1_ref_u, pu1_scratch_u,
                                         u2_ref_wd_uv, 16, uc_dx, uc_dy, 8,
                                         8);

            /* Modify ref pointer and refWidth to point to scratch    */
            /* buffer to be used below in ih264d_copy_multiplex_data functions */
            /* CHANGED CODE */
            pu1_ref_u = pu1_scratch_u;
            u2_ref_wd_uv = 8 * YUV420SP_FACTOR;
        }
    }
    {
        for(i = 0; i < 4; i++)
        {
            for(j = 0; j < 4; j++)
            {
                uc_cond = u2_mask & 1;
                u2_mask >>= 1;
                if(uc_cond)
                {
                    *(UWORD32 *)(pu1_dest_y + u2_dest_wd_y) =
                                    *(UWORD32 *)(pu1_ref_y + u2_ref_wd_y);
                    *(UWORD32 *)(pu1_dest_y + 2 * u2_dest_wd_y) =
                                    *(UWORD32 *)(pu1_ref_y + 2 * u2_ref_wd_y);
                    *(UWORD32 *)(pu1_dest_y + 3 * u2_dest_wd_y) =
                                    *(UWORD32 *)(pu1_ref_y + 3 * u2_ref_wd_y);
                    {
                        UWORD32 *dst, *src;
                        dst = (UWORD32 *)pu1_dest_y;
                        src = (UWORD32 *)pu1_ref_y;
                        *dst = *src;
                        dst++;
                        src++;
                        pu1_dest_y = (UWORD8 *)dst;
                        pu1_ref_y = (UWORD8 *)src;
                    }
                    *(UWORD32 *)(pu1_dest_u + u2_dest_wd_uv) =
                                    *(UWORD32 *)(pu1_ref_u + u2_ref_wd_uv);
                    {
                        UWORD32 *dst, *src;
                        dst = (UWORD32 *)pu1_dest_u;
                        src = (UWORD32 *)pu1_ref_u;
                        *dst = *src;
                        dst++;
                        src++;
                        pu1_dest_u = (UWORD8 *)dst;
                        pu1_ref_u = (UWORD8 *)src;
                    }

                }
                else
                {
                    pu1_dest_y += 4;
                    pu1_ref_y += 4;
                    pu1_dest_u += 2 * YUV420SP_FACTOR;
                    pu1_ref_u += 2 * YUV420SP_FACTOR;
                }
            }
            pu1_ref_y += 4 * (u2_ref_wd_y - 4);
            pu1_ref_u += 2 * (u2_ref_wd_uv - 4 * YUV420SP_FACTOR);
            pu1_dest_y += 4 * (u2_dest_wd_y - 4);
            pu1_dest_u += 2 * (u2_dest_wd_uv - 4 * YUV420SP_FACTOR);
        }
    }
}

void ih264d_pad_on_demand(pred_info_t *ps_pred, UWORD8 lum_chrom_blk)
{
    if(CHROM_BLK == lum_chrom_blk)
    {
        UWORD32 *pu4_pod_src_u, *pu4_pod_dst_u;
        UWORD32 *pu4_pod_src_v, *pu4_pod_dst_v;
        WORD32 j, u1_wd_stride;
        WORD32 i, u1_dma_ht, i1_ht;
        UWORD32 u2_dma_size;
        u1_wd_stride = (ps_pred->u2_u1_ref_buf_wd >> 2) * YUV420SP_FACTOR;
        u1_dma_ht = ps_pred->i1_dma_ht;
        u2_dma_size = u1_wd_stride * u1_dma_ht;
        pu4_pod_src_u = (UWORD32 *)ps_pred->pu1_dma_dest_addr;
        pu4_pod_dst_u = pu4_pod_src_u;

        pu4_pod_src_v = pu4_pod_src_u + u2_dma_size;
        pu4_pod_dst_v = pu4_pod_src_v;

        i1_ht = ps_pred->i1_pod_ht;
        pu4_pod_src_u -= u1_wd_stride * i1_ht;
        pu4_pod_src_v -= u1_wd_stride * i1_ht;
        if(i1_ht < 0)
            /* Top POD */
            i1_ht = -i1_ht;
        else
        {
            /* Bottom POD */
            pu4_pod_src_u += (u1_dma_ht - 1) * u1_wd_stride;
            pu4_pod_dst_u += (u1_dma_ht - i1_ht) * u1_wd_stride;
            pu4_pod_src_v += (u1_dma_ht - 1) * u1_wd_stride;
            pu4_pod_dst_v += (u1_dma_ht - i1_ht) * u1_wd_stride;
        }

        for(i = 0; i < i1_ht; i++)
            for(j = 0; j < u1_wd_stride; j++)
            {
                *pu4_pod_dst_u++ = *(pu4_pod_src_u + j);

            }
    }
    else
    {
        UWORD32 *pu4_pod_src, *pu4_pod_dst;
        WORD32 j, u1_wd_stride;
        WORD32 i, i1_ht;
        pu4_pod_src = (UWORD32 *)ps_pred->pu1_dma_dest_addr;
        pu4_pod_dst = pu4_pod_src;
        u1_wd_stride = ps_pred->u2_u1_ref_buf_wd >> 2;
        i1_ht = ps_pred->i1_pod_ht;
        pu4_pod_src -= u1_wd_stride * i1_ht;
        if(i1_ht < 0)
            /* Top POD */
            i1_ht = -i1_ht;
        else
        {
            /* Bottom POD */
            pu4_pod_src += (ps_pred->i1_dma_ht - 1) * u1_wd_stride;
            pu4_pod_dst += (ps_pred->i1_dma_ht - i1_ht) * u1_wd_stride;
        }

        for(i = 0; i < i1_ht; i++)
            for(j = 0; j < u1_wd_stride; j++)
                *pu4_pod_dst++ = *(pu4_pod_src + j);
    }
}