/src/libavc/decoder/ih264d_mvpred.c

Source
/******************************************************************************
 *
 * 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_mvpred.c
 *
 * \brief
 *    This file contains function specific to decoding Motion vector.
 *
 * Detailed_description
 *
 * \date
 *    10-12-2002
 *
 * \author  Arvind Raman
 **************************************************************************
 */
#include <string.h>
#include "ih264d_parse_cavlc.h"
#include "ih264d_error_handler.h"
#include "ih264d_structs.h"
#include "ih264d_defs.h"
#include "ih264_typedefs.h"
#include "ih264_macros.h"
#include "ih264_platform_macros.h"
#include "ih264d_mb_utils.h"
#include "ih264d_defs.h"
#include "ih264d_debug.h"
#include "ih264d_tables.h"
#include "ih264d_process_bslice.h"
#include "ih264d_mvpred.h"
#include "ih264d_inter_pred.h"
#include "ih264d_tables.h"

/*!
 **************************************************************************
 * \if ih264d_get_motion_vector_predictor name : Name \endif
 *
 * \brief
 *    The routine calculates the motion vector predictor for a given block,
 *    given the candidate MV predictors.
 *
 * \param ps_mv_pred: Candidate predictors for the current block
 * \param ps_currMv: Pointer to the left top edge of the current block in
 *     the MV bank
 *
 * \return
 *    _mvPred: The x & y components of the MV predictor.
 *
 * \note
 *    The code implements the logic as described in sec 8.4.1.2.1. Given
 *    the candidate predictors and the pointer to the top left edge of the
 *    block in the MV bank.
 *
 **************************************************************************
 */

void ih264d_get_motion_vector_predictor(mv_pred_t * ps_result,
                                        mv_pred_t **ps_mv_pred,
                                        UWORD8 u1_ref_idx,
                                        UWORD8 u1_B,
                                        const UWORD8 *pu1_mv_pred_condition)
{
    WORD8 c_temp;
    UWORD8 uc_B2 = (u1_B << 1);

    /* If only one of the candidate blocks has a reference frame equal to
     the current block then use the same block as the final predictor */
    c_temp =
                    (ps_mv_pred[LEFT]->i1_ref_frame[u1_B] == u1_ref_idx)
                                    | ((ps_mv_pred[TOP]->i1_ref_frame[u1_B]
                                                    == u1_ref_idx) << 1)
                                    | ((ps_mv_pred[TOP_R]->i1_ref_frame[u1_B]
                                                    == u1_ref_idx) << 2);
    c_temp = pu1_mv_pred_condition[c_temp];

    if(c_temp != -1)
    {
        /* Case when only when one of the cadidate block has the same
         reference frame as the current block */
        ps_result->i2_mv[uc_B2 + 0] = ps_mv_pred[c_temp]->i2_mv[uc_B2 + 0];
        ps_result->i2_mv[uc_B2 + 1] = ps_mv_pred[c_temp]->i2_mv[uc_B2 + 1];
    }
    else
    {
        WORD32 D0, D1;
        D0 = MIN(ps_mv_pred[0]->i2_mv[uc_B2 + 0],
                 ps_mv_pred[1]->i2_mv[uc_B2 + 0]);
        D1 = MAX(ps_mv_pred[0]->i2_mv[uc_B2 + 0],
                 ps_mv_pred[1]->i2_mv[uc_B2 + 0]);
        D1 = MIN(D1, ps_mv_pred[2]->i2_mv[uc_B2 + 0]);
        ps_result->i2_mv[uc_B2 + 0] = (WORD16)(MAX(D0, D1));

        D0 = MIN(ps_mv_pred[0]->i2_mv[uc_B2 + 1],
                 ps_mv_pred[1]->i2_mv[uc_B2 + 1]);
        D1 = MAX(ps_mv_pred[0]->i2_mv[uc_B2 + 1],
                 ps_mv_pred[1]->i2_mv[uc_B2 + 1]);
        D1 = MIN(D1, ps_mv_pred[2]->i2_mv[uc_B2 + 1]);
        ps_result->i2_mv[uc_B2 + 1] = (WORD16)(MAX(D0, D1));

    }
}

/*!
 **************************************************************************
 * \if ih264d_mbaff_mv_pred name : Name \endif
 *
 * \brief
 *    The routine calculates the motion vector predictor for a given block,
 *    given the candidate MV predictors.
 *
 * \param ps_mv_pred: Candidate predictors for the current block
 * \param ps_currMv: Pointer to the left top edge of the current block in
 *     the MV bank
 *
 * \return
 *    _mvPred: The x & y components of the MV predictor.
 *
 * \note
 *    The code implements the logic as described in sec 8.4.1.2.1. Given
 *    the candidate predictors and the pointer to the top left edge of the
 *    block in the MV bank.
 *
 **************************************************************************
 */

void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
                          UWORD32 u4_sub_mb_num,
                          mv_pred_t *ps_mv_nmb,
                          mv_pred_t *ps_mv_ntop,
                          dec_struct_t *ps_dec,
                          UWORD8 uc_mb_part_width,
                          dec_mb_info_t *ps_cur_mb_info,
                          UWORD8* pu0_scale)
{
    UWORD16 u2_a_in = 0, u2_b_in = 0, u2_c_in = 0, u2_d_in = 0;
    mv_pred_t *ps_mvpred_l, *ps_mvpred_tmp;
    UWORD32 u4_sub_mb_x = (u4_sub_mb_num & 3), uc_sub_mb_y = (u4_sub_mb_num >> 2);
    UWORD8 u1_is_cur_mb_fld, u1_is_left_mb_fld, u1_is_top_mb_fld;
    UWORD8 u1_is_cur_mb_top;

    u1_is_cur_mb_fld = ps_cur_mb_info->u1_mb_field_decodingflag;
    u1_is_cur_mb_top = ps_cur_mb_info->u1_topmb;

    u1_is_left_mb_fld = ps_cur_mb_info->ps_left_mb->u1_mb_fld;
    u1_is_top_mb_fld = ps_cur_mb_info->ps_top_mb->u1_mb_fld;

    /* Checking in the subMB exists, calculating their motion vectors to be
     used as predictors and the reference frames of those subMBs */
    ps_mv_pred[LEFT] = &ps_dec->s_default_mv_pred;
    ps_mv_pred[TOP] = &(ps_dec->s_default_mv_pred);
    ps_mv_pred[TOP_R] = &(ps_dec->s_default_mv_pred);

    /* Check if the left subMb is available */
    if(u4_sub_mb_x)
    {
        u2_a_in = 1;
        ps_mv_pred[LEFT] = (ps_mv_nmb - 1);
    }
    else
    {
        UWORD8 uc_temp;
        u2_a_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & LEFT_MB_AVAILABLE_MASK);
        if(u2_a_in)
        {
            ps_mvpred_l = (ps_dec->u4_num_pmbair) ?
                            ps_mv_nmb :
                            (ps_dec->ps_mv_left + (uc_sub_mb_y << 2) + 48
                                            - (u1_is_cur_mb_top << 4));
            uc_temp = 29;
            if(u1_is_cur_mb_fld ^ u1_is_left_mb_fld)
            {
                if(u1_is_left_mb_fld)
                {
                    uc_temp +=
                                    (((uc_sub_mb_y & 1) << 2)
                                                    + ((uc_sub_mb_y & 2) << 1));
                    uc_temp += ((u1_is_cur_mb_top) ? 0 : 8);
                }
                else
                {
                    uc_temp = uc_temp - (uc_sub_mb_y << 2);
                    uc_temp += ((u1_is_cur_mb_top) ? 0 : 16);
                }
            }
            ps_mv_pred[LEFT] = (ps_mvpred_l - uc_temp);
            pu0_scale[LEFT] = u1_is_cur_mb_fld - u1_is_left_mb_fld;
        }
    }

    /* Check if the top subMB is available */
    if((uc_sub_mb_y > 0) || ((u1_is_cur_mb_top | u1_is_cur_mb_fld) == 0))
    {
        u2_b_in = 1;
        ps_mv_pred[TOP] = ps_mv_nmb - 4;
    }
    else
    {
        u2_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & TOP_MB_AVAILABLE_MASK);
        if(u2_b_in)
        {
            /* CHANGED CODE */

            if(u1_is_top_mb_fld && u1_is_cur_mb_fld)
                ps_mvpred_tmp = ps_mv_ntop;
            else
            {
                ps_mvpred_tmp = ps_mv_ntop;
                if(u1_is_cur_mb_top)
                    ps_mvpred_tmp += 16;
            }

            ps_mv_pred[TOP] = ps_mvpred_tmp;
            pu0_scale[TOP] = u1_is_cur_mb_fld - u1_is_top_mb_fld;
        }
    }

    /* Check if the top right subMb is available. The top right subMb is
     defined as the top right subMb at the top right corner of the MB
     partition. The top right subMb index starting from the top left
     corner of the MB partition is given by
     TopRightSubMbIndx = TopLeftSubMbIndx + (WidthOfMbPartition - 6) / 2
     */
    u2_c_in = CHECKBIT(ps_cur_mb_info->u2_top_right_avail_mask,
                        (u4_sub_mb_num + uc_mb_part_width - 1));
    if(u2_c_in)
    {
        ps_mv_pred[TOP_R] = ps_mv_pred[TOP] + uc_mb_part_width;
        pu0_scale[TOP_R] = pu0_scale[TOP];
        if((uc_sub_mb_y == 0) && ((u4_sub_mb_x + uc_mb_part_width) > 3))
        {
            UWORD8 uc_isTopRtMbFld;
            uc_isTopRtMbFld = ps_cur_mb_info->ps_top_right_mb->u1_mb_fld;
            /* CHANGED CODE */
            ps_mvpred_tmp = ps_mv_ntop + uc_mb_part_width + 12;
            ps_mvpred_tmp += (u1_is_cur_mb_top) ? 16 : 0;
            ps_mvpred_tmp += (u1_is_cur_mb_fld && u1_is_cur_mb_top && uc_isTopRtMbFld) ?
                            0 : 16;
            ps_mv_pred[TOP_R] = ps_mvpred_tmp;
            pu0_scale[TOP_R] = u1_is_cur_mb_fld - uc_isTopRtMbFld;
        }
    }
    else
    {
        u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u4_sub_mb_num);

        /* Check if the the top left subMB is available */
        if(u2_d_in)
        {
            UWORD8 uc_isTopLtMbFld;

            ps_mv_pred[TOP_R] = ps_mv_pred[TOP] - 1;
            pu0_scale[TOP_R] = pu0_scale[TOP];

            if(u4_sub_mb_x == 0)
            {
                if((uc_sub_mb_y > 0) || ((u1_is_cur_mb_top | u1_is_cur_mb_fld) == 0))
                {
                    uc_isTopLtMbFld = u1_is_left_mb_fld;
                    ps_mvpred_tmp = ps_mv_pred[LEFT] - 4;

                    if((u1_is_cur_mb_fld == 0) && uc_isTopLtMbFld)
                    {
                        ps_mvpred_tmp = ps_mv_pred[LEFT] + 16;
                        ps_mvpred_tmp -= (uc_sub_mb_y & 1) ? 0 : 4;
                    }
                }
                else
                {
                    UWORD32 u4_cond = ps_dec->u4_num_pmbair;
                    uc_isTopLtMbFld = ps_cur_mb_info->u1_topleft_mb_fld;

                    /* CHANGED CODE */
                    ps_mvpred_tmp = ps_mv_ntop - 29;
                    ps_mvpred_tmp += (u1_is_cur_mb_top) ? 16 : 0;
                    if(u1_is_cur_mb_fld && u1_is_cur_mb_top)
                        ps_mvpred_tmp -= (uc_isTopLtMbFld) ? 16 : 0;
                }
                ps_mv_pred[TOP_R] = ps_mvpred_tmp;
                pu0_scale[TOP_R] = u1_is_cur_mb_fld - uc_isTopLtMbFld;
            }
        }
        else if(u2_b_in == 0)
        {
            /* If all the subMBs B, C, D are all out of the frame then their MV
             and their reference picture is equal to that of A */
            ps_mv_pred[TOP] = ps_mv_pred[LEFT];
            ps_mv_pred[TOP_R] = ps_mv_pred[LEFT];
            pu0_scale[TOP] = pu0_scale[LEFT];
            pu0_scale[TOP_R] = pu0_scale[LEFT];
        }
    }
}

/*!
 **************************************************************************
 * \if ih264d_non_mbaff_mv_pred name : Name \endif
 *
 * \brief
 *    The routine calculates the motion vector predictor for a given block,
 *    given the candidate MV predictors.
 *
 * \param ps_mv_pred: Candidate predictors for the current block
 * \param ps_currMv: Pointer to the left top edge of the current block in
 *     the MV bank
 *
 * \return
 *    _mvPred: The x & y components of the MV predictor.
 *
 * \note
 *    The code implements the logic as described in sec 8.4.1.2.1. Given
 *    the candidate predictors and the pointer to the top left edge of the
 *    block in the MV bank.
 *
 **************************************************************************
 */
#if(!MVPRED_NONMBAFF)
void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
                              UWORD32 u4_sub_mb_num,
                              mv_pred_t *ps_mv_nmb,
                              mv_pred_t *ps_mv_ntop,
                              dec_struct_t *ps_dec,
                              UWORD8 uc_mb_part_width,
                              dec_mb_info_t *ps_cur_mb_info)
{
    UWORD16 u2_b_in = 0, u2_c_in = 0, u2_d_in = 0;
    UWORD32 u4_sub_mb_x = (u4_sub_mb_num & 3), uc_sub_mb_y = (u4_sub_mb_num >> 2);

    /* Checking in the subMB exists, calculating their motion vectors to be
     used as predictors and the reference frames of those subMBs */

    ps_mv_pred[LEFT] = &ps_dec->s_default_mv_pred;
    ps_mv_pred[TOP] = &(ps_dec->s_default_mv_pred);
    ps_mv_pred[TOP_R] = &(ps_dec->s_default_mv_pred);
    /* Check if the left subMb is available */

    if(u4_sub_mb_x)
    {
        ps_mv_pred[LEFT] = (ps_mv_nmb - 1);
    }
    else
    {
        if(ps_cur_mb_info->u1_mb_ngbr_availablity & LEFT_MB_AVAILABLE_MASK)
        {
            ps_mv_pred[LEFT] = (ps_mv_nmb - 13);
        }
    }

    /* Check if the top subMB is available */
    if(uc_sub_mb_y)
    {
        u2_b_in = 1;
        ps_mv_ntop = ps_mv_nmb - 4;
        ps_mv_pred[TOP] = ps_mv_ntop;

    }
    else
    {
        u2_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity & TOP_MB_AVAILABLE_MASK);
        if(u2_b_in)
        {
            ps_mv_pred[TOP] = ps_mv_ntop;
        }
    }

    /* Check if the top right subMb is available. The top right subMb is
     defined as the top right subMb at the top right corner of the MB
     partition. The top right subMb index starting from the top left
     corner of the MB partition is given by
     TopRightSubMbIndx = TopLeftSubMbIndx + (WidthOfMbPartition - 6) / 2
     */
    u2_c_in = CHECKBIT(ps_cur_mb_info->u2_top_right_avail_mask,
                        (u4_sub_mb_num + uc_mb_part_width - 1));
    if(u2_c_in)
    {
        ps_mv_pred[TOP_R] = (ps_mv_ntop + uc_mb_part_width);

        if(uc_sub_mb_y == 0)
        {
            /* CHANGED CODE */
            if((u4_sub_mb_x + uc_mb_part_width) > 3)
                ps_mv_pred[TOP_R] += 12;
        }
    }
    else
    {
        u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u4_sub_mb_num);
        /* Check if the the top left subMB is available */
        if(u2_d_in)
        {
            /* CHANGED CODE */
            ps_mv_pred[TOP_R] = (ps_mv_ntop - 1);
            if(u4_sub_mb_x == 0)
            {
                if(uc_sub_mb_y)
                {
                    ps_mv_pred[TOP_R] = (ps_mv_nmb - 17);
                }
                else
                {
                    /* CHANGED CODE */
                    ps_mv_pred[TOP_R] -= 12;
                }
            }
        }
        else if(u2_b_in == 0)
        {
            /* If all the subMBs B, C, D are all out of the frame then their MV
             and their reference picture is equal to that of A */
            ps_mv_pred[TOP] = ps_mv_pred[LEFT];
            ps_mv_pred[TOP_R] = ps_mv_pred[LEFT];
        }
    }
}
#endif

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_mvpred_nonmbaffB                                         */
/*                                                                           */
/*  Description   : This function calculates the motion vector predictor,    */
/*                  for B-Slices                                             */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : None                                                     */
/*  Processing    : The neighbours A(Left),B(Top),C(TopRight) are calculated */
/*                  and based on the type of Mb the prediction is            */
/*                  appropriately done                                       */
/*  Outputs       : populates ps_mv_final_pred structure                       */
/*  Returns       : u1_direct_zero_pred_flag which is used only in              */
/*                    decodeSpatialdirect()                                  */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         03 05 2005   TA              First Draft                          */
/*                                                                           */
/*****************************************************************************/
#if(!MVPRED_NONMBAFF)
UWORD8 ih264d_mvpred_nonmbaffB(dec_struct_t *ps_dec,
                               dec_mb_info_t *ps_cur_mb_info,
                               mv_pred_t *ps_mv_nmb,
                               mv_pred_t *ps_mv_ntop,
                               mv_pred_t *ps_mv_final_pred,
                               UWORD32 u4_sub_mb_num,
                               UWORD8 uc_mb_part_width,
                               UWORD8 u1_lx_start,
                               UWORD8 u1_lxend,
                               UWORD8 u1_mb_mc_mode)
{
    UWORD8 u1_a_in, u1_b_in, uc_temp1, uc_temp2, uc_temp3;
    mv_pred_t *ps_mv_pred[3];
    UWORD8 uc_B2, uc_lx, u1_ref_idx;
    UWORD8 u1_direct_zero_pred_flag = 0;

    ih264d_non_mbaff_mv_pred(ps_mv_pred, u4_sub_mb_num, ps_mv_nmb, ps_mv_ntop,
                             ps_dec, uc_mb_part_width, ps_cur_mb_info);

    for(uc_lx = u1_lx_start; uc_lx < u1_lxend; uc_lx++)
    {
        u1_ref_idx = ps_mv_final_pred->i1_ref_frame[uc_lx];
        uc_B2 = (uc_lx << 1);
        switch(u1_mb_mc_mode)
        {
            case PRED_16x8:
                /* Directional prediction for a 16x8 MB partition */
                if(u4_sub_mb_num == 0)
                {
                    /* Calculating the MV pred for the top 16x8 block */
                    if(ps_mv_pred[TOP]->i1_ref_frame[uc_lx] == u1_ref_idx)
                    {
                        /* If the reference frame used by the top subMB is same as the
                         reference frame used by the current block then MV predictor to
                         be used for the current block is same as the MV of the top
                         subMB */
                        ps_mv_final_pred->i2_mv[uc_B2 + 0] =
                                        ps_mv_pred[TOP]->i2_mv[uc_B2 + 0];
                        ps_mv_final_pred->i2_mv[uc_B2 + 1] =
                                        ps_mv_pred[TOP]->i2_mv[uc_B2 + 1];
                    }
                    else
                    {
                        /* The MV predictor is calculated according to the process
                         defined in 8.4.1.2.1 */
                        ih264d_get_motion_vector_predictor(
                                        ps_mv_final_pred,
                                        ps_mv_pred,
                                        u1_ref_idx,
                                        uc_lx,
                                        (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                    }
                }
                else
                {
                    if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx)
                    {
                        /* If the reference frame used by the left subMB is same as the
                         reference frame used by the current block then MV predictor to
                         be used for the current block is same as the MV of the left
                         subMB */
                        ps_mv_final_pred->i2_mv[uc_B2 + 0] =
                                        ps_mv_pred[LEFT]->i2_mv[uc_B2 + 0];
                        ps_mv_final_pred->i2_mv[uc_B2 + 1] =
                                        ps_mv_pred[LEFT]->i2_mv[uc_B2 + 1];
                    }
                    else
                    {
                        /* The MV predictor is calculated according to the process
                         defined in 8.4.1.2.1 */
                        ih264d_get_motion_vector_predictor(
                                        ps_mv_final_pred,
                                        ps_mv_pred,
                                        u1_ref_idx,
                                        uc_lx,
                                        (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                    }
                }
                break;
            case PRED_8x16:
                /* Directional prediction for a 8x16 MB partition */
                if(u4_sub_mb_num == 0)
                {
                    if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx)
                    {
                        /* If the reference frame used by the left subMB is same as the
                         reference frame used by the current block then MV predictor to
                         be used for the current block is same as the MV of the left
                         subMB */
                        ps_mv_final_pred->i2_mv[uc_B2 + 0] =
                                        ps_mv_pred[LEFT]->i2_mv[uc_B2 + 0];
                        ps_mv_final_pred->i2_mv[uc_B2 + 1] =
                                        ps_mv_pred[LEFT]->i2_mv[uc_B2 + 1];
                    }
                    else
                    {
                        /* The MV predictor is calculated according to the process
                         defined in 8.4.1.2.1 */
                        ih264d_get_motion_vector_predictor(
                                        ps_mv_final_pred,
                                        ps_mv_pred,
                                        u1_ref_idx,
                                        uc_lx,
                                        (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                    }
                }
                else
                {
                    if(ps_mv_pred[TOP_R]->i1_ref_frame[uc_lx] == u1_ref_idx)
                    {
                        /* If the reference frame used by the top right subMB is same as
                         the reference frame used by the current block then MV
                         predictor to be used for the current block is same as the MV
                         of the left subMB */
                        ps_mv_final_pred->i2_mv[uc_B2 + 0] =
                                        ps_mv_pred[TOP_R]->i2_mv[uc_B2 + 0];
                        ps_mv_final_pred->i2_mv[uc_B2 + 1] =
                                        ps_mv_pred[TOP_R]->i2_mv[uc_B2 + 1];
                    }
                    else
                    {
                        /* The MV predictor is calculated according to the process
                         defined in 8.4.1.2.1 */
                        ih264d_get_motion_vector_predictor(
                                        ps_mv_final_pred,
                                        ps_mv_pred,
                                        u1_ref_idx,
                                        uc_lx,
                                        (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                    }
                }
                break;
            case B_DIRECT_SPATIAL:
                /* Case when the MB has been skipped */
                /* If either of left or the top subMB is not present
                 OR
                 If both the MV components of either the left or the top subMB are
                 zero and their reference frame pointer pointing to 0
                 then MV for the skipped MB is zero
                 else the Median of the mv_pred_t is used */
                uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[0];
                uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[0];
                uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[0];

                ps_mv_final_pred->i1_ref_frame[0] = MIN(uc_temp1,
                                                      MIN(uc_temp2, uc_temp3));

                uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[1];
                uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[1];
                uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[1];

                ps_mv_final_pred->i1_ref_frame[1] = MIN(uc_temp1,
                                                      MIN(uc_temp2, uc_temp3));

                if((ps_mv_final_pred->i1_ref_frame[0] < 0)
                                && (ps_mv_final_pred->i1_ref_frame[1] < 0))
                {
                    u1_direct_zero_pred_flag = 1;
                    ps_mv_final_pred->i1_ref_frame[0] = 0;
                    ps_mv_final_pred->i1_ref_frame[1] = 0;
                }
                ih264d_get_motion_vector_predictor(
                                ps_mv_final_pred, ps_mv_pred,
                                ps_mv_final_pred->i1_ref_frame[0], 0,
                                (const UWORD8 *)gau1_ih264d_mv_pred_condition);

                ih264d_get_motion_vector_predictor(
                                ps_mv_final_pred, ps_mv_pred,
                                ps_mv_final_pred->i1_ref_frame[1], 1,
                                (const UWORD8 *)gau1_ih264d_mv_pred_condition);

                break;
            case MB_SKIP:
                /* Case when the MB has been skipped */
                /* If either of left or the top subMB is not present
                 OR
                 If both the MV components of either the left or the top subMB are
                 zero and their reference frame pointer pointing to 0
                 then MV for the skipped MB is zero
                 else the Median of the mv_pred_t is used */
                u1_a_in = (ps_cur_mb_info->u1_mb_ngbr_availablity &
                LEFT_MB_AVAILABLE_MASK);
                u1_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity &
                TOP_MB_AVAILABLE_MASK);
                if(((u1_a_in * u1_b_in) == 0)
                                || ((ps_mv_pred[LEFT]->i2_mv[0]
                                                | ps_mv_pred[LEFT]->i2_mv[1]
                                                | ps_mv_pred[LEFT]->i1_ref_frame[0])
                                                == 0)
                                || ((ps_mv_pred[TOP]->i2_mv[0]
                                                | ps_mv_pred[TOP]->i2_mv[1]
                                                | ps_mv_pred[TOP]->i1_ref_frame[0])
                                                == 0))
                {
                    ps_mv_final_pred->i2_mv[0] = 0;
                    ps_mv_final_pred->i2_mv[1] = 0;
                    break;
                }
                /* If the condition above is not true calculate the MV predictor
                 according to the process defined in sec 8.4.1.2.1 */
            default:
                ih264d_get_motion_vector_predictor(
                                ps_mv_final_pred, ps_mv_pred, u1_ref_idx, uc_lx,
                                (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                break;
        }
    }
    return (u1_direct_zero_pred_flag);
}
#endif

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_mvpred_nonmbaff                                          */
/*                                                                           */
/*  Description   : This function calculates the motion vector predictor,    */
/*                  for all the slice types other than B_SLICE               */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : None                                                     */
/*  Processing    : The neighbours A(Left),B(Top),C(TopRight) are calculated */
/*                  and based on the type of Mb the prediction is            */
/*                  appropriately done                                       */
/*  Outputs       : populates ps_mv_final_pred structure                       */
/*  Returns       : u1_direct_zero_pred_flag which is used only in              */
/*                    decodeSpatialdirect()                                  */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         03 05 2005   TA              First Draft                          */
/*                                                                           */
/*****************************************************************************/
#if(!MVPRED_NONMBAFF)
UWORD8 ih264d_mvpred_nonmbaff(dec_struct_t *ps_dec,
                              dec_mb_info_t *ps_cur_mb_info,
                              mv_pred_t *ps_mv_nmb,
                              mv_pred_t *ps_mv_ntop,
                              mv_pred_t *ps_mv_final_pred,
                              UWORD32 u4_sub_mb_num,
                              UWORD8 uc_mb_part_width,
                              UWORD8 u1_lx_start,
                              UWORD8 u1_lxend,
                              UWORD8 u1_mb_mc_mode)
{
    UWORD8 u1_a_in, u1_b_in, uc_temp1, uc_temp2, uc_temp3;
    mv_pred_t *ps_mv_pred[3];
    UWORD8 u1_ref_idx;
    UWORD8 u1_direct_zero_pred_flag = 0;
    UNUSED(u1_lx_start);
    UNUSED(u1_lxend);
    ih264d_non_mbaff_mv_pred(ps_mv_pred, u4_sub_mb_num, ps_mv_nmb, ps_mv_ntop,
                             ps_dec, uc_mb_part_width, ps_cur_mb_info);

    u1_ref_idx = ps_mv_final_pred->i1_ref_frame[0];

    switch(u1_mb_mc_mode)
    {
        case PRED_16x8:
            /* Directional prediction for a 16x8 MB partition */
            if(u4_sub_mb_num == 0)
            {
                /* Calculating the MV pred for the top 16x8 block */
                if(ps_mv_pred[TOP]->i1_ref_frame[0] == u1_ref_idx)
                {
                    /* If the reference frame used by the top subMB is same as the
                     reference frame used by the current block then MV predictor to
                     be used for the current block is same as the MV of the top
                     subMB */

                    ps_mv_final_pred->i2_mv[0] = ps_mv_pred[TOP]->i2_mv[0];
                    ps_mv_final_pred->i2_mv[1] = ps_mv_pred[TOP]->i2_mv[1];
                }
                else
                {
                    /* The MV predictor is calculated according to the process
                     defined in 8.4.1.2.1 */
                    ih264d_get_motion_vector_predictor(
                                    ps_mv_final_pred,
                                    ps_mv_pred,
                                    u1_ref_idx,
                                    0,
                                    (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                }
            }
            else
            {
                if(ps_mv_pred[LEFT]->i1_ref_frame[0] == u1_ref_idx)
                {
                    /* If the reference frame used by the left subMB is same as the
                     reference frame used by the current block then MV predictor to
                     be used for the current block is same as the MV of the left
                     subMB */

                    ps_mv_final_pred->i2_mv[0] = ps_mv_pred[LEFT]->i2_mv[0];
                    ps_mv_final_pred->i2_mv[1] = ps_mv_pred[LEFT]->i2_mv[1];
                }
                else
                {
                    /* The MV predictor is calculated according to the process
                     defined in 8.4.1.2.1 */
                    ih264d_get_motion_vector_predictor(
                                    ps_mv_final_pred,
                                    ps_mv_pred,
                                    u1_ref_idx,
                                    0,
                                    (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                }
            }
            break;
        case PRED_8x16:
            /* Directional prediction for a 8x16 MB partition */
            if(u4_sub_mb_num == 0)
            {
                if(ps_mv_pred[LEFT]->i1_ref_frame[0] == u1_ref_idx)
                {
                    /* If the reference frame used by the left subMB is same as the
                     reference frame used by the current block then MV predictor to
                     be used for the current block is same as the MV of the left
                     subMB */

                    ps_mv_final_pred->i2_mv[0] = ps_mv_pred[LEFT]->i2_mv[0];
                    ps_mv_final_pred->i2_mv[1] = ps_mv_pred[LEFT]->i2_mv[1];
                }
                else
                {
                    /* The MV predictor is calculated according to the process
                     defined in 8.4.1.2.1 */
                    ih264d_get_motion_vector_predictor(
                                    ps_mv_final_pred,
                                    ps_mv_pred,
                                    u1_ref_idx,
                                    0,
                                    (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                }
            }
            else
            {
                if(ps_mv_pred[TOP_R]->i1_ref_frame[0] == u1_ref_idx)
                {
                    /* If the reference frame used by the top right subMB is same as
                     the reference frame used by the current block then MV
                     predictor to be used for the current block is same as the MV
                     of the left subMB */

                    ps_mv_final_pred->i2_mv[0] = ps_mv_pred[TOP_R]->i2_mv[0];
                    ps_mv_final_pred->i2_mv[1] = ps_mv_pred[TOP_R]->i2_mv[1];
                }
                else
                {
                    /* The MV predictor is calculated according to the process
                     defined in 8.4.1.2.1 */
                    ih264d_get_motion_vector_predictor(
                                    ps_mv_final_pred,
                                    ps_mv_pred,
                                    u1_ref_idx,
                                    0,
                                    (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                }
            }
            break;
        case B_DIRECT_SPATIAL:
            /* Case when the MB has been skipped */
            /* If either of left or the top subMB is not present
             OR
             If both the MV components of either the left or the top subMB are
             zero and their reference frame pointer pointing to 0
             then MV for the skipped MB is zero
             else the Median of the mv_pred_t is used */
            uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[0];
            uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[0];
            uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[0];

            ps_mv_final_pred->i1_ref_frame[0] = MIN(uc_temp1,
                                                  MIN(uc_temp2, uc_temp3));

            uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[1];
            uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[1];
            uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[1];

            ps_mv_final_pred->i1_ref_frame[1] = MIN(uc_temp1,
                                                  MIN(uc_temp2, uc_temp3));

            if((ps_mv_final_pred->i1_ref_frame[0] < 0)
                            && (ps_mv_final_pred->i1_ref_frame[1] < 0))
            {
                u1_direct_zero_pred_flag = 1;
                ps_mv_final_pred->i1_ref_frame[0] = 0;
                ps_mv_final_pred->i1_ref_frame[1] = 0;
            }
            ih264d_get_motion_vector_predictor(
                            ps_mv_final_pred, ps_mv_pred,
                            ps_mv_final_pred->i1_ref_frame[0], 0,
                            (const UWORD8 *)gau1_ih264d_mv_pred_condition);

            ih264d_get_motion_vector_predictor(
                            ps_mv_final_pred, ps_mv_pred,
                            ps_mv_final_pred->i1_ref_frame[1], 1,
                            (const UWORD8 *)gau1_ih264d_mv_pred_condition);

            break;
        case MB_SKIP:
            /* Case when the MB has been skipped */
            /* If either of left or the top subMB is not present
             OR
             If both the MV components of either the left or the top subMB are
             zero and their reference frame pointer pointing to 0
             then MV for the skipped MB is zero
             else the Median of the mv_pred_t is used */
            u1_a_in = (ps_cur_mb_info->u1_mb_ngbr_availablity &
            LEFT_MB_AVAILABLE_MASK);
            u1_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity &
            TOP_MB_AVAILABLE_MASK);
            if(((u1_a_in * u1_b_in) == 0)
                            || ((ps_mv_pred[LEFT]->i2_mv[0]
                                            | ps_mv_pred[LEFT]->i2_mv[1]
                                            | ps_mv_pred[LEFT]->i1_ref_frame[0])
                                            == 0)
                            || ((ps_mv_pred[TOP]->i2_mv[0]
                                            | ps_mv_pred[TOP]->i2_mv[1]
                                            | ps_mv_pred[TOP]->i1_ref_frame[0])
                                            == 0))
            {

                ps_mv_final_pred->i2_mv[0] = 0;
                ps_mv_final_pred->i2_mv[1] = 0;
                break;
            }
            /* If the condition above is not true calculate the MV predictor
             according to the process defined in sec 8.4.1.2.1 */
        default:
            ih264d_get_motion_vector_predictor(
                            ps_mv_final_pred, ps_mv_pred, u1_ref_idx, 0,
                            (const UWORD8 *)gau1_ih264d_mv_pred_condition);
            break;
    }

    return (u1_direct_zero_pred_flag);
}
#endif

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_mvpred_mbaff                                             */
/*                                                                           */
/*  Description   : This function calculates the motion vector predictor,    */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : None                                                     */
/*  Processing    : The neighbours A(Left),B(Top),C(TopRight) are calculated */
/*                  and based on the type of Mb the prediction is            */
/*                  appropriately done                                       */
/*  Outputs       : populates ps_mv_final_pred structure                       */
/*  Returns       : u1_direct_zero_pred_flag which is used only in              */
/*                    decodeSpatialdirect()                                  */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         03 05 2005   TA              First Draft                          */
/*                                                                           */
/*****************************************************************************/

UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
                           dec_mb_info_t *ps_cur_mb_info,
                           mv_pred_t *ps_mv_nmb,
                           mv_pred_t *ps_mv_ntop,
                           mv_pred_t *ps_mv_final_pred,
                           UWORD32 u4_sub_mb_num,
                           UWORD8 uc_mb_part_width,
                           UWORD8 u1_lx_start,
                           UWORD8 u1_lxend,
                           UWORD8 u1_mb_mc_mode)
{
    UWORD8 u1_a_in, u1_b_in, uc_temp1, uc_temp2, uc_temp3;
    mv_pred_t *ps_mv_pred[3], s_mvPred[3];
    UWORD8 uc_B2, pu0_scale[3], i, uc_lx, u1_ref_idx;
    UWORD8 u1_direct_zero_pred_flag = 0;

    pu0_scale[0] = pu0_scale[1] = pu0_scale[2] = 0;
    ih264d_mbaff_mv_pred(ps_mv_pred, u4_sub_mb_num, ps_mv_nmb, ps_mv_ntop, ps_dec,
                         uc_mb_part_width, ps_cur_mb_info, pu0_scale);
    for(i = 0; i < 3; i++)
    {
        if(pu0_scale[i] != 0)
        {
            memcpy(&s_mvPred[i], ps_mv_pred[i], sizeof(mv_pred_t));
            if(pu0_scale[i] == 1)
            {
                s_mvPred[i].i1_ref_frame[0] = s_mvPred[i].i1_ref_frame[0] << 1;
                s_mvPred[i].i1_ref_frame[1] = s_mvPred[i].i1_ref_frame[1] << 1;
                s_mvPred[i].i2_mv[1] = SIGN_POW2_DIV(s_mvPred[i].i2_mv[1], 1);
                s_mvPred[i].i2_mv[3] = SIGN_POW2_DIV(s_mvPred[i].i2_mv[3], 1);
            }
            else
            {
                s_mvPred[i].i1_ref_frame[0] = s_mvPred[i].i1_ref_frame[0] >> 1;
                s_mvPred[i].i1_ref_frame[1] = s_mvPred[i].i1_ref_frame[1] >> 1;
                s_mvPred[i].i2_mv[1] = s_mvPred[i].i2_mv[1] << 1;
                s_mvPred[i].i2_mv[3] = s_mvPred[i].i2_mv[3] << 1;
            }
            ps_mv_pred[i] = &s_mvPred[i];
        }
    }

    for(uc_lx = u1_lx_start; uc_lx < u1_lxend; uc_lx++)
    {
        u1_ref_idx = ps_mv_final_pred->i1_ref_frame[uc_lx];
        uc_B2 = (uc_lx << 1);
        switch(u1_mb_mc_mode)
        {
            case PRED_16x8:
                /* Directional prediction for a 16x8 MB partition */
                if(u4_sub_mb_num == 0)
                {
                    /* Calculating the MV pred for the top 16x8 block */
                    if(ps_mv_pred[TOP]->i1_ref_frame[uc_lx] == u1_ref_idx)
                    {
                        /* If the reference frame used by the top subMB is same as the
                         reference frame used by the current block then MV predictor to
                         be used for the current block is same as the MV of the top
                         subMB */
                        ps_mv_final_pred->i2_mv[uc_B2 + 0] =
                                        ps_mv_pred[TOP]->i2_mv[uc_B2 + 0];
                        ps_mv_final_pred->i2_mv[uc_B2 + 1] =
                                        ps_mv_pred[TOP]->i2_mv[uc_B2 + 1];
                    }
                    else
                    {
                        /* The MV predictor is calculated according to the process
                         defined in 8.4.1.2.1 */
                        ih264d_get_motion_vector_predictor(
                                        ps_mv_final_pred,
                                        ps_mv_pred,
                                        u1_ref_idx,
                                        uc_lx,
                                        (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                    }
                }
                else
                {
                    if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx)
                    {
                        /* If the reference frame used by the left subMB is same as the
                         reference frame used by the current block then MV predictor to
                         be used for the current block is same as the MV of the left
                         subMB */
                        ps_mv_final_pred->i2_mv[uc_B2 + 0] =
                                        ps_mv_pred[LEFT]->i2_mv[uc_B2 + 0];
                        ps_mv_final_pred->i2_mv[uc_B2 + 1] =
                                        ps_mv_pred[LEFT]->i2_mv[uc_B2 + 1];
                    }
                    else
                    {
                        /* The MV predictor is calculated according to the process
                         defined in 8.4.1.2.1 */
                        ih264d_get_motion_vector_predictor(
                                        ps_mv_final_pred,
                                        ps_mv_pred,
                                        u1_ref_idx,
                                        uc_lx,
                                        (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                    }
                }
                break;
            case PRED_8x16:
                /* Directional prediction for a 8x16 MB partition */
                if(u4_sub_mb_num == 0)
                {
                    if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx)
                    {
                        /* If the reference frame used by the left subMB is same as the
                         reference frame used by the current block then MV predictor to
                         be used for the current block is same as the MV of the left
                         subMB */
                        ps_mv_final_pred->i2_mv[uc_B2 + 0] =
                                        ps_mv_pred[LEFT]->i2_mv[uc_B2 + 0];
                        ps_mv_final_pred->i2_mv[uc_B2 + 1] =
                                        ps_mv_pred[LEFT]->i2_mv[uc_B2 + 1];
                    }
                    else
                    {
                        /* The MV predictor is calculated according to the process
                         defined in 8.4.1.2.1 */
                        ih264d_get_motion_vector_predictor(
                                        ps_mv_final_pred,
                                        ps_mv_pred,
                                        u1_ref_idx,
                                        uc_lx,
                                        (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                    }
                }
                else
                {
                    if(ps_mv_pred[TOP_R]->i1_ref_frame[uc_lx] == u1_ref_idx)
                    {
                        /* If the reference frame used by the top right subMB is same as
                         the reference frame used by the current block then MV
                         predictor to be used for the current block is same as the MV
                         of the left subMB */
                        ps_mv_final_pred->i2_mv[uc_B2 + 0] =
                                        ps_mv_pred[TOP_R]->i2_mv[uc_B2 + 0];
                        ps_mv_final_pred->i2_mv[uc_B2 + 1] =
                                        ps_mv_pred[TOP_R]->i2_mv[uc_B2 + 1];
                    }
                    else
                    {
                        /* The MV predictor is calculated according to the process
                         defined in 8.4.1.2.1 */
                        ih264d_get_motion_vector_predictor(
                                        ps_mv_final_pred,
                                        ps_mv_pred,
                                        u1_ref_idx,
                                        uc_lx,
                                        (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                    }
                }
                break;
            case B_DIRECT_SPATIAL:
                /* Case when the MB has been skipped */
                /* If either of left or the top subMB is not present
                 OR
                 If both the MV components of either the left or the top subMB are
                 zero and their reference frame pointer pointing to 0
                 then MV for the skipped MB is zero
                 else the Median of the mv_pred_t is used */
                uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[0];
                uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[0];
                uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[0];

                ps_mv_final_pred->i1_ref_frame[0] = MIN(uc_temp1,
                                                      MIN(uc_temp2, uc_temp3));

                uc_temp1 = (UWORD8)ps_mv_pred[LEFT]->i1_ref_frame[1];
                uc_temp2 = (UWORD8)ps_mv_pred[TOP]->i1_ref_frame[1];
                uc_temp3 = (UWORD8)ps_mv_pred[TOP_R]->i1_ref_frame[1];

                ps_mv_final_pred->i1_ref_frame[1] = MIN(uc_temp1,
                                                      MIN(uc_temp2, uc_temp3));

                /* If the reference indices are negative clip the scaled reference indices to -1 */
                /* i.e invalid reference index */

                /*if(ps_mv_final_pred->i1_ref_frame[0] < 0)
                 ps_mv_final_pred->i1_ref_frame[0] = -1;

                 if(ps_mv_final_pred->i1_ref_frame[1] < 0)
                 ps_mv_final_pred->i1_ref_frame[1] = -1; */

                if((ps_mv_final_pred->i1_ref_frame[0] < 0)
                                && (ps_mv_final_pred->i1_ref_frame[1] < 0))
                {
                    u1_direct_zero_pred_flag = 1;
                    ps_mv_final_pred->i1_ref_frame[0] = 0;
                    ps_mv_final_pred->i1_ref_frame[1] = 0;
                }
                ih264d_get_motion_vector_predictor(
                                ps_mv_final_pred, ps_mv_pred,
                                ps_mv_final_pred->i1_ref_frame[0], 0,
                                (const UWORD8 *)gau1_ih264d_mv_pred_condition);

                ih264d_get_motion_vector_predictor(
                                ps_mv_final_pred, ps_mv_pred,
                                ps_mv_final_pred->i1_ref_frame[1], 1,
                                (const UWORD8 *)gau1_ih264d_mv_pred_condition);

                break;
            case MB_SKIP:
                /* Case when the MB has been skipped */
                /* If either of left or the top subMB is not present
                 OR
                 If both the MV components of either the left or the top subMB are
                 zero and their reference frame pointer pointing to 0
                 then MV for the skipped MB is zero
                 else the Median of the mv_pred_t is used */
                u1_a_in = (ps_cur_mb_info->u1_mb_ngbr_availablity &
                LEFT_MB_AVAILABLE_MASK);
                u1_b_in = (ps_cur_mb_info->u1_mb_ngbr_availablity &
                TOP_MB_AVAILABLE_MASK);
                if(((u1_a_in * u1_b_in) == 0)
                                || ((ps_mv_pred[LEFT]->i2_mv[0]
                                                | ps_mv_pred[LEFT]->i2_mv[1]
                                                | ps_mv_pred[LEFT]->i1_ref_frame[0])
                                                == 0)
                                || ((ps_mv_pred[TOP]->i2_mv[0]
                                                | ps_mv_pred[TOP]->i2_mv[1]
                                                | ps_mv_pred[TOP]->i1_ref_frame[0])
                                                == 0))
                {
                    ps_mv_final_pred->i2_mv[0] = 0;
                    ps_mv_final_pred->i2_mv[1] = 0;
                    break;
                }
                /* If the condition above is not true calculate the MV predictor
                 according to the process defined in sec 8.4.1.2.1 */
            default:
                ih264d_get_motion_vector_predictor(
                                ps_mv_final_pred, ps_mv_pred, u1_ref_idx, uc_lx,
                                (const UWORD8 *)gau1_ih264d_mv_pred_condition);
                break;
        }
    }
    return (u1_direct_zero_pred_flag);
}




void ih264d_rep_mv_colz(dec_struct_t *ps_dec,
                        mv_pred_t *ps_mv_pred_src,
                        mv_pred_t *ps_mv_pred_dst,
                        UWORD32 u4_sub_mb_num,
                        UWORD8 u1_colz,
                        UWORD8 u1_ht,
                        UWORD8 u1_wd)
{

    UWORD8 k, m;
    UWORD8 *pu1_colz = ps_dec->pu1_col_zero_flag + ps_dec->i4_submb_ofst
                    + u4_sub_mb_num;

    for(k = 0; k < u1_ht; k++)
    {
        for(m = 0; m < u1_wd; m++)
        {
            *(ps_mv_pred_dst + m) = *(ps_mv_pred_src);
            *(pu1_colz + m) = u1_colz;

        }
        pu1_colz += SUB_BLK_WIDTH;
        ps_mv_pred_dst += SUB_BLK_WIDTH;
    }
}


Coverage Report

Created: 2026-10-17 07:17