/src/libhevc/encoder/ihevce_mv_pred_merge.c

Source (jump to first uncovered line)
/******************************************************************************
 *
 * Copyright (C) 2018 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
 *  ihevcd_mv_pred_merge.c
 *
 * @brief
 *  Contains functions for motion vector merge candidates derivation
 *
 * @author
 *  Ittiam
 *
 * @par List of Functions:
 * - ihevce_compare_pu_mv_t()
 * - ihevce_mv_pred_merge()
 *
 * @remarks
 *  None
 *
 *******************************************************************************
 */
/*****************************************************************************/
/* File Includes                                                             */
/*****************************************************************************/
/* System include files */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <stdarg.h>
#include <math.h>

/* User include files */
#include "ihevc_typedefs.h"
#include "itt_video_api.h"
#include "ihevce_api.h"

#include "rc_cntrl_param.h"
#include "rc_frame_info_collector.h"
#include "rc_look_ahead_params.h"

#include "ihevc_defs.h"
#include "ihevc_macros.h"
#include "ihevc_debug.h"
#include "ihevc_structs.h"
#include "ihevc_platform_macros.h"
#include "ihevc_deblk.h"
#include "ihevc_itrans_recon.h"
#include "ihevc_chroma_itrans_recon.h"
#include "ihevc_chroma_intra_pred.h"
#include "ihevc_intra_pred.h"
#include "ihevc_inter_pred.h"
#include "ihevc_mem_fns.h"
#include "ihevc_padding.h"
#include "ihevc_weighted_pred.h"
#include "ihevc_sao.h"
#include "ihevc_resi_trans.h"
#include "ihevc_quant_iquant_ssd.h"
#include "ihevc_cabac_tables.h"
#include "ihevc_common_tables.h"

#include "ihevce_defs.h"
#include "ihevce_hle_interface.h"
#include "ihevce_lap_enc_structs.h"
#include "ihevce_multi_thrd_structs.h"
#include "ihevce_me_common_defs.h"
#include "ihevce_had_satd.h"
#include "ihevce_error_codes.h"
#include "ihevce_bitstream.h"
#include "ihevce_cabac.h"
#include "ihevce_rdoq_macros.h"
#include "ihevce_function_selector.h"
#include "ihevce_enc_structs.h"
#include "ihevce_entropy_structs.h"
#include "ihevce_cmn_utils_instr_set_router.h"
#include "ihevce_enc_loop_structs.h"
#include "hme_datatype.h"
#include "hme_interface.h"
#include "hme_common_defs.h"
#include "hme_defs.h"
#include "ihevce_mv_pred.h"
#include "ihevce_mv_pred_merge.h"
#include "ihevce_common_utils.h"

/*****************************************************************************/
/* Function Definitions                                                      */
/*****************************************************************************/

/**
 *******************************************************************************
 *
 * @brief Function scaling temporal motion vector
 *
 *
 * @par Description:
 *   Scales mv based on difference between current POC and current
 *   reference POC and neighbour reference poc
 *
 * @param[inout] mv
 *   motion vector to be scaled
 *
 * @param[in] cur_ref_poc
 *   Current PU refernce pic poc
 *
 * @param[in] nbr_ref_poc
 *   Neighbor PU reference pic poc
 *
 * @param[in] cur_poc
 *   Picture order count of current pic
 *
 * @returns
 *  None
 *
 * @remarks
 *
 *******************************************************************************
 */
void ihevce_scale_collocated_mv(
    mv_t *ps_mv, WORD32 cur_ref_poc, WORD32 col_ref_poc, WORD32 col_poc, WORD32 cur_poc)
{
    WORD32 td, tb, tx;
    WORD32 dist_scale_factor;
    WORD32 mvx, mvy;

    td = CLIP_S8(col_poc - col_ref_poc);
    tb = CLIP_S8(cur_poc - cur_ref_poc);

    tx = (16384 + (abs(td) >> 1)) / td;

    dist_scale_factor = (tb * tx + 32) >> 6;
    dist_scale_factor = CLIP3(dist_scale_factor, -4096, 4095);

    mvx = ps_mv->i2_mvx;
    mvy = ps_mv->i2_mvy;

    mvx = SIGN(dist_scale_factor * mvx) * ((abs(dist_scale_factor * mvx) + 127) >> 8);
    mvy = SIGN(dist_scale_factor * mvy) * ((abs(dist_scale_factor * mvy) + 127) >> 8);

    ps_mv->i2_mvx = CLIP_S16(mvx);
    ps_mv->i2_mvy = CLIP_S16(mvy);

} /* End of ihevce_scale_collocated_mv */

void ihevce_collocated_mvp(
    mv_pred_ctxt_t *ps_mv_ctxt,
    pu_t *ps_pu,
    mv_t *ps_mv_col,
    WORD32 *pu4_avail_col_flag,
    WORD32 use_pu_ref_idx,
    WORD32 x_col,
    WORD32 y_col)
{
    sps_t *ps_sps = ps_mv_ctxt->ps_sps;
    slice_header_t *ps_slice_hdr = ps_mv_ctxt->ps_slice_hdr;
    recon_pic_buf_t *ps_col_ref_buf;
    WORD32 xp_col, yp_col;  //In pixel unit
    WORD32 col_ctb_x, col_ctb_y;  //In CTB unit
    mv_t as_mv_col[2];
    WORD32 log2_ctb_size;
    WORD32 ctb_size;
    WORD32 avail_col;
    WORD32 col_ctb_idx, pu_cnt;
    WORD32 au4_list_col[2];
    WORD32 num_minpu_in_ctb;
    UWORD8 *pu1_pic_pu_map_ctb;
    pu_col_mv_t *ps_col_mv;
    WORD32 part_pos_y;

    part_pos_y = ps_pu->b4_pos_y << 2;

    log2_ctb_size = ps_sps->i1_log2_ctb_size;
    ctb_size = (1 << log2_ctb_size);

    avail_col = 1;

    /* Initializing reference list */
    if((ps_slice_hdr->i1_slice_type == BSLICE) && (ps_slice_hdr->i1_collocated_from_l0_flag == 0))
    {
        /* L1 */
        ps_col_ref_buf = ps_mv_ctxt->ps_ref_list[1][ps_slice_hdr->i1_collocated_ref_idx];
    }
    else
    {
        /* L0 */
        ps_col_ref_buf = ps_mv_ctxt->ps_ref_list[0][ps_slice_hdr->i1_collocated_ref_idx];
    }
    num_minpu_in_ctb = (ctb_size / MIN_PU_SIZE) * (ctb_size / MIN_PU_SIZE);

    if(((part_pos_y >> log2_ctb_size) == (y_col >> log2_ctb_size)) &&
       (((x_col + (ps_mv_ctxt->i4_ctb_x << log2_ctb_size)) < ps_sps->i2_pic_width_in_luma_samples) ||
        ps_mv_ctxt->ai4_tile_xtra_ctb[2]) &&
       ((((y_col + (ps_mv_ctxt->i4_ctb_y << log2_ctb_size)) <
          ps_sps->i2_pic_height_in_luma_samples) ||
         ps_mv_ctxt->ai4_tile_xtra_ctb[3])))
    {
        xp_col = ((x_col >> 4) << 4);
        yp_col = ((y_col >> 4) << 4);
        col_ctb_x = ps_mv_ctxt->i4_ctb_x + (xp_col >> log2_ctb_size);
        col_ctb_y = ps_mv_ctxt->i4_ctb_y + (yp_col >> log2_ctb_size);

        /* pu1_frm_pu_map has (i2_pic_wd_in_ctb + 1) CTBs for stride */
        col_ctb_idx = col_ctb_x + (col_ctb_y) * (ps_sps->i2_pic_wd_in_ctb + 1);

        if(xp_col == ctb_size)
            xp_col = 0;

        pu1_pic_pu_map_ctb = ps_col_ref_buf->pu1_frm_pu_map + col_ctb_idx * num_minpu_in_ctb;

        pu_cnt = pu1_pic_pu_map_ctb[(yp_col >> 2) * (ctb_size / MIN_PU_SIZE) + (xp_col >> 2)];

        /* ps_frm_col_mv has (i2_pic_wd_in_ctb + 1) CTBs for stride */
        ps_col_mv = ps_col_ref_buf->ps_frm_col_mv +
                    (col_ctb_y * (ps_sps->i2_pic_wd_in_ctb + 1) + col_ctb_x) * num_minpu_in_ctb +
                    pu_cnt;
    }
    else
        avail_col = 0;

    if((avail_col == 0) || (ps_col_mv->b1_intra_flag == 1) ||
       (ps_slice_hdr->i1_slice_temporal_mvp_enable_flag == 0))
    {
        pu4_avail_col_flag[0] = 0;
        pu4_avail_col_flag[1] = 0;
        ps_mv_col[0].i2_mvx = 0;
        ps_mv_col[0].i2_mvy = 0;
        ps_mv_col[1].i2_mvx = 0;
        ps_mv_col[1].i2_mvy = 0;
    }
    else
    {
        WORD32 au4_ref_idx_col[2];
        WORD32 pred_flag_l0, pred_flag_l1;
        pred_flag_l0 = (ps_col_mv->b2_pred_mode != PRED_L1);
        pred_flag_l1 = (ps_col_mv->b2_pred_mode != PRED_L0);

        if(pred_flag_l0 == 0)
        {
            as_mv_col[0] = ps_col_mv->s_l1_mv;
            au4_ref_idx_col[0] = ps_col_mv->i1_l1_ref_idx;
            au4_list_col[0] = 1; /* L1 */

            as_mv_col[1] = ps_col_mv->s_l1_mv;
            au4_ref_idx_col[1] = ps_col_mv->i1_l1_ref_idx;
            au4_list_col[1] = 1; /* L1 */
        }
        else
        {
            if(pred_flag_l1 == 0)
            {
                as_mv_col[0] = ps_col_mv->s_l0_mv;
                au4_ref_idx_col[0] = ps_col_mv->i1_l0_ref_idx;
                au4_list_col[0] = 0; /* L1 */

                as_mv_col[1] = ps_col_mv->s_l0_mv;
                au4_ref_idx_col[1] = ps_col_mv->i1_l0_ref_idx;
                au4_list_col[1] = 0; /* L1 */
            }
            else
            {
                if(1 == ps_slice_hdr->i1_low_delay_flag)
                {
                    as_mv_col[0] = ps_col_mv->s_l0_mv;
                    au4_ref_idx_col[0] = ps_col_mv->i1_l0_ref_idx;
                    au4_list_col[0] = 0; /* L0 */

                    as_mv_col[1] = ps_col_mv->s_l1_mv;
                    au4_ref_idx_col[1] = ps_col_mv->i1_l1_ref_idx;
                    au4_list_col[1] = 1; /* L1 */
                }
                else
                {
                    if(0 == ps_slice_hdr->i1_collocated_from_l0_flag)
                    {
                        as_mv_col[0] = ps_col_mv->s_l0_mv;
                        au4_ref_idx_col[0] = ps_col_mv->i1_l0_ref_idx;

                        as_mv_col[1] = ps_col_mv->s_l0_mv;
                        au4_ref_idx_col[1] = ps_col_mv->i1_l0_ref_idx;
                    }
                    else
                    {
                        as_mv_col[0] = ps_col_mv->s_l1_mv;
                        au4_ref_idx_col[0] = ps_col_mv->i1_l1_ref_idx;

                        as_mv_col[1] = ps_col_mv->s_l1_mv;
                        au4_ref_idx_col[1] = ps_col_mv->i1_l1_ref_idx;
                    }

                    au4_list_col[0] =
                        ps_slice_hdr->i1_collocated_from_l0_flag; /* L"collocated_from_l0_flag" */
                    au4_list_col[1] =
                        ps_slice_hdr->i1_collocated_from_l0_flag; /* L"collocated_from_l0_flag" */
                }
            }
        }
        avail_col = 1;
        {
            WORD32 cur_poc, col_poc, col_ref_poc_l0, cur_ref_poc;
            WORD32 col_ref_poc_l0_lt, cur_ref_poc_lt;
            WORD32 ref_idx_l0, ref_idx_l1;

            if(use_pu_ref_idx)
            {
                ref_idx_l0 = ps_pu->mv.i1_l0_ref_idx;
                ref_idx_l1 = ps_pu->mv.i1_l1_ref_idx;
            }
            else
            {
                ref_idx_l0 = 0;
                ref_idx_l1 = 0;
            }

            col_poc = ps_col_ref_buf->i4_poc;
            cur_poc = ps_slice_hdr->i4_abs_pic_order_cnt;

            if(-1 != ref_idx_l0)
            {
                if(au4_list_col[0] == 0)
                {
                    col_ref_poc_l0 = ps_col_ref_buf->ai4_col_l0_poc[au4_ref_idx_col[0]];
                    col_ref_poc_l0_lt = 0; /* Encoder has only short term references */
                }
                else
                {
                    col_ref_poc_l0 = ps_col_ref_buf->ai4_col_l1_poc[au4_ref_idx_col[0]];
                    col_ref_poc_l0_lt = 0;
                }
                /* L0 collocated mv */
                cur_ref_poc = ps_mv_ctxt->ps_ref_list[0][ref_idx_l0]->i4_poc;
                cur_ref_poc_lt = 0;

                {
                    pu4_avail_col_flag[0] = 1;

                    /*if(cur_ref_poc_lt || ((col_poc - col_ref_poc_l0) == (cur_poc - cur_ref_poc)))*/
                    if((col_poc - col_ref_poc_l0) == (cur_poc - cur_ref_poc))
                    {
                        ps_mv_col[0] = as_mv_col[0];
                    }
                    else
                    {
                        ps_mv_col[0] = as_mv_col[0];
                        if(col_ref_poc_l0 != col_poc)
                        {
                            ihevce_scale_collocated_mv(
                                (mv_t *)(&ps_mv_col[0]),
                                cur_ref_poc,
                                col_ref_poc_l0,
                                col_poc,
                                cur_poc);
                        }
                    }
                }
            }
            else
            {
                pu4_avail_col_flag[0] = 0;
                ps_mv_col[0].i2_mvx = 0;
                ps_mv_col[0].i2_mvy = 0;
            }
            if((BSLICE == ps_slice_hdr->i1_slice_type) && (-1 != ref_idx_l1))
            {
                WORD32 col_ref_poc_l1_lt, col_ref_poc_l1;

                if(au4_list_col[1] == 0)
                {
                    col_ref_poc_l1 = ps_col_ref_buf->ai4_col_l0_poc[au4_ref_idx_col[0]];
                    col_ref_poc_l1_lt = 0;
                }
                else
                {
                    col_ref_poc_l1 = ps_col_ref_buf->ai4_col_l1_poc[au4_ref_idx_col[0]];
                    col_ref_poc_l1_lt = 0;
                }

                /* L1 collocated mv */
                cur_ref_poc = ps_mv_ctxt->ps_ref_list[1][ref_idx_l1]->i4_poc;
                cur_ref_poc_lt = 0;

                {
                    pu4_avail_col_flag[1] = 1;

                    /*if(cur_ref_poc_lt || ((col_poc - col_ref_poc_l1) == (cur_poc - cur_ref_poc)))*/
                    if((col_poc - col_ref_poc_l1) == (cur_poc - cur_ref_poc))
                    {
                        ps_mv_col[1] = as_mv_col[1];
                    }
                    else
                    {
                        ps_mv_col[1] = as_mv_col[1];
                        if(col_ref_poc_l1 != col_poc)
                        {
                            ihevce_scale_collocated_mv(
                                (mv_t *)&ps_mv_col[1],
                                cur_ref_poc,
                                col_ref_poc_l1,
                                col_poc,
                                cur_poc);
                        }
                    }
                }
            } /* End of if BSLICE */
            else
            {
                pu4_avail_col_flag[1] = 0;
            }
        }

    } /* End of collocated MV calculation */

} /* End of ihevce_collocated_mvp */

/**
 *******************************************************************************
 *
 * @brief Compare Motion vectors function
 *
 *
 * @par Description:
 *   Checks if MVs and Reference idx are excatly matching.
 *
 * @param[inout] ps_1
 *   motion vector 1 to be compared
 *
 * @param[in] ps_2
 *   motion vector 2 to be compared
 *
 * @returns
 *  0 : if not matching 1 : if matching
 *
 * @remarks
 *
 *******************************************************************************
 */

/**
 *******************************************************************************
 *
 * @brief
 * This function performs Motion Vector Merge candidates derivation
 *
 * @par Description:
 *  MV merge list is computed using neighbor mvs and colocated mv
 *
 * @param[in] ps_ctxt
 * pointer to mv predictor context
 *
 * @param[in] ps_top_nbr_4x4
 * pointer to top 4x4 nbr structure
 *
 * @param[in] ps_left_nbr_4x4
 * pointer to left 4x4 nbr structure
 *
 * @param[in] ps_top_left_nbr_4x4
 * pointer to top left 4x4 nbr structure
 *
 * @param[in] left_nbr_4x4_strd
 * left nbr buffer stride in terms of 4x4 units
 *
 * @param[in] ps_avail_flags
 * Neighbor availability flags container
 *
 * @param[in] ps_col_mv
 * Colocated MV pointer
 *
 * @param[in] ps_pu
 * Current Partition PU strucrture pointer
 *
 * @param[in] part_mode
 * Partition mode @sa PART_SIZE_E
 *
 * @param[in] part_idx
 * Partition idx of current partition inside CU
 *
 * @param[in] single_mcl_flag
 * Single MCL flag based on 8x8 CU and Parallel merge value
 *
 * @param[out] ps_merge_cand_list
 * pointer to store MV merge candidates list
 *
 * @returns
 * Number of merge candidates
 * @remarks
 *
 *
 *******************************************************************************
 */
WORD32 ihevce_mv_pred_merge(
    mv_pred_ctxt_t *ps_ctxt,
    nbr_4x4_t *ps_top_nbr_4x4,
    nbr_4x4_t *ps_left_nbr_4x4,
    nbr_4x4_t *ps_top_left_nbr_4x4,
    WORD32 left_nbr_4x4_strd,
    nbr_avail_flags_t *ps_avail_flags,
    pu_mv_t *ps_col_mv,
    pu_t *ps_pu,
    PART_SIZE_E part_mode,
    WORD32 part_idx,
    WORD32 single_mcl_flag,
    merge_cand_list_t *ps_merge_cand_list,
    UWORD8 *pu1_is_top_used)
{
    /******************************************************/
    /*      Spatial Merge Candidates                      */
    /******************************************************/
    WORD32 part_pos_x;
    WORD32 part_pos_y;
    WORD32 part_wd;
    WORD32 part_ht;
    WORD32 slice_type;
    WORD32 num_ref_idx_l0_active;
    WORD32 num_ref_idx_l1_active;
    WORD32 num_merge_cand;
    WORD32 log2_parallel_merge_level_minus2;
    WORD32 n;
    WORD8 i1_spatial_avail_flag_n[MAX_NUM_MV_NBR]; /*[A0/A1/B0/B1/B2]*/
    WORD32 nbr_x[MAX_NUM_MV_NBR], nbr_y[MAX_NUM_MV_NBR];
    UWORD8 u1_nbr_avail[MAX_NUM_MV_NBR];
    WORD32 merge_shift;
    nbr_4x4_t *ps_nbr_mv[MAX_NUM_MV_NBR];

    /*******************************************/
    /* Neighbor location: Graphical indication */
    /*                                         */
    /*          B2 _____________B1 B0          */
    /*            |               |            */
    /*            |               |            */
    /*            |               |            */
    /*            |      PU     ht|            */
    /*            |               |            */
    /*            |               |            */
    /*          A1|______wd_______|            */
    /*          A0                             */
    /*                                         */
    /*******************************************/

    part_pos_x = ps_pu->b4_pos_x << 2;
    part_pos_y = ps_pu->b4_pos_y << 2;
    part_ht = (ps_pu->b4_ht + 1) << 2;
    part_wd = (ps_pu->b4_wd + 1) << 2;

    slice_type = ps_ctxt->ps_slice_hdr->i1_slice_type;
    num_ref_idx_l0_active = ps_ctxt->ps_slice_hdr->i1_num_ref_idx_l0_active;
    num_ref_idx_l1_active = ps_ctxt->ps_slice_hdr->i1_num_ref_idx_l1_active;
    log2_parallel_merge_level_minus2 = ps_ctxt->i4_log2_parallel_merge_level_minus2;

    /* Assigning co-ordinates to neighbors */
    nbr_x[NBR_A0] = part_pos_x - 1;
    nbr_y[NBR_A0] = part_pos_y + part_ht; /* A0 */

    nbr_x[NBR_A1] = part_pos_x - 1;
    nbr_y[NBR_A1] = part_pos_y + part_ht - 1; /* A1 */

    nbr_x[NBR_B0] = part_pos_x + part_wd;
    nbr_y[NBR_B0] = part_pos_y - 1; /* B0 */

    nbr_x[NBR_B1] = part_pos_x + part_wd - 1;
    nbr_y[NBR_B1] = part_pos_y - 1; /* B1 */

    nbr_x[NBR_B2] = part_pos_x - 1;
    nbr_y[NBR_B2] = part_pos_y - 1; /* B2 */

    /* Assigning mv's */
    ps_nbr_mv[NBR_A0] = ps_left_nbr_4x4 + ((nbr_y[NBR_A0] - part_pos_y) >> 2) * left_nbr_4x4_strd;
    ps_nbr_mv[NBR_A1] = ps_left_nbr_4x4 + ((nbr_y[NBR_A1] - part_pos_y) >> 2) * left_nbr_4x4_strd;
    ps_nbr_mv[NBR_B0] = ps_top_nbr_4x4 + ((nbr_x[NBR_B0] - part_pos_x) >> 2);
    ps_nbr_mv[NBR_B1] = ps_top_nbr_4x4 + ((nbr_x[NBR_B1] - part_pos_x) >> 2);

    if(part_pos_y == 0) /* AT vertical CTB boundary */
        ps_nbr_mv[NBR_B2] = ps_top_nbr_4x4 + ((nbr_x[NBR_B2] - part_pos_x) >> 2);
    else
        ps_nbr_mv[NBR_B2] = ps_top_left_nbr_4x4;

    /* Assigning nbr availability */
    u1_nbr_avail[NBR_A0] = ps_avail_flags->u1_bot_lt_avail &&
                           (!ps_nbr_mv[NBR_A0]->b1_intra_flag); /* A0 */
    u1_nbr_avail[NBR_A1] = ps_avail_flags->u1_left_avail &&
                           (!ps_nbr_mv[NBR_A1]->b1_intra_flag); /* A1 */
    u1_nbr_avail[NBR_B0] = ps_avail_flags->u1_top_rt_avail &&
                           (!ps_nbr_mv[NBR_B0]->b1_intra_flag); /* B0 */
    u1_nbr_avail[NBR_B1] = ps_avail_flags->u1_top_avail &&
                           (!ps_nbr_mv[NBR_B1]->b1_intra_flag); /* B1 */
    u1_nbr_avail[NBR_B2] = ps_avail_flags->u1_top_lt_avail &&
                           (!ps_nbr_mv[NBR_B2]->b1_intra_flag); /* B2 */

    merge_shift = log2_parallel_merge_level_minus2 + 2;

    /* Availability check */
    /* A1 */
    {
        WORD32 avail_flag;
        avail_flag = 1;
        n = NBR_A1;

        /* if at same merge level */
        if((part_pos_x >> merge_shift) == (nbr_x[n] >> merge_shift) &&
           ((part_pos_y >> merge_shift) == (nbr_y[n] >> merge_shift)))
        {
            u1_nbr_avail[n] = 0;
        }

        /* SPEC JCTVC-K1003_v9 version has a different way using not available       */
        /* candidates compared to software. for non square part and seconf part case */
        /* ideally nothing from the 1st partition should be used as per spec but     */
        /* HM 8.2 dev verison does not adhere to this. currenlty code fllows HM      */

        /* if single MCL is 0 , second part of 2 part in CU */
        if((single_mcl_flag == 0) && (part_idx == 1) &&
           ((part_mode == PART_Nx2N) || (part_mode == PART_nLx2N) || (part_mode == PART_nRx2N)))
        {
            u1_nbr_avail[n] = 0;
        }

        if(u1_nbr_avail[n] == 0)
        {
            avail_flag = 0;
        }
        i1_spatial_avail_flag_n[n] = avail_flag;
    }
    /* B1 */
    {
        WORD32 avail_flag;
        avail_flag = 1;
        n = NBR_B1;

        /* if at same merge level */
        if((part_pos_x >> merge_shift) == (nbr_x[n] >> merge_shift) &&
           ((part_pos_y >> merge_shift) == (nbr_y[n] >> merge_shift)))
        {
            u1_nbr_avail[n] = 0;
        }

        /* if single MCL is 0 , second part of 2 part in CU */
        if((single_mcl_flag == 0) && (part_idx == 1) &&
           ((part_mode == PART_2NxN) || (part_mode == PART_2NxnU) || (part_mode == PART_2NxnD)))
        {
            u1_nbr_avail[n] = 0;
        }

        if(u1_nbr_avail[n] == 0)
        {
            avail_flag = 0;
        }

        if((avail_flag == 1) && (u1_nbr_avail[NBR_A1] == 1))
        {
            /* TODO: Assumption: mvs and ref indicies in both l0 and l1*/
            /* should match for non availability                       */
            WORD32 i4_pred_1, i4_pred_2;
            i4_pred_1 =
                (ps_nbr_mv[NBR_A1]->b1_pred_l0_flag | (ps_nbr_mv[NBR_A1]->b1_pred_l1_flag << 1)) -
                1;
            i4_pred_2 = (ps_nbr_mv[n]->b1_pred_l0_flag | (ps_nbr_mv[n]->b1_pred_l1_flag << 1)) - 1;
            if(ihevce_compare_pu_mv_t(
                   &ps_nbr_mv[NBR_A1]->mv, &ps_nbr_mv[n]->mv, i4_pred_1, i4_pred_2))
            {
                avail_flag = 0;
            }
        }
        i1_spatial_avail_flag_n[n] = avail_flag;
    }

    /* B0 */
    {
        WORD32 avail_flag;
        avail_flag = 1;
        n = NBR_B0;

        /* if at same merge level */
        if((part_pos_x >> merge_shift) == (nbr_x[n] >> merge_shift) &&
           ((part_pos_y >> merge_shift) == (nbr_y[n] >> merge_shift)))
        {
            u1_nbr_avail[n] = 0;
        }

        if(u1_nbr_avail[n] == 0)
        {
            avail_flag = 0;
        }

        if((avail_flag == 1) && (u1_nbr_avail[NBR_B1] == 1))
        {
            WORD32 i4_pred_1, i4_pred_2;
            i4_pred_1 =
                (ps_nbr_mv[NBR_B1]->b1_pred_l0_flag | (ps_nbr_mv[NBR_B1]->b1_pred_l1_flag << 1)) -
                1;
            i4_pred_2 = (ps_nbr_mv[n]->b1_pred_l0_flag | (ps_nbr_mv[n]->b1_pred_l1_flag << 1)) - 1;
            if(ihevce_compare_pu_mv_t(
                   &ps_nbr_mv[NBR_B1]->mv, &ps_nbr_mv[n]->mv, i4_pred_1, i4_pred_2))
            {
                avail_flag = 0;
            }
        }
        i1_spatial_avail_flag_n[n] = avail_flag;
    }

    /* A0 */
    {
        WORD32 avail_flag;
        avail_flag = 1;
        n = NBR_A0;

        /* if at same merge level */
        if((part_pos_x >> merge_shift) == (nbr_x[n] >> merge_shift) &&
           ((part_pos_y >> merge_shift) == (nbr_y[n] >> merge_shift)))
        {
            u1_nbr_avail[n] = 0;
        }

        if(u1_nbr_avail[n] == 0)
        {
            avail_flag = 0;
        }

        if((avail_flag == 1) && (u1_nbr_avail[NBR_A1] == 1))
        {
            WORD32 i4_pred_1, i4_pred_2;
            i4_pred_1 =
                (ps_nbr_mv[NBR_A1]->b1_pred_l0_flag | (ps_nbr_mv[NBR_A1]->b1_pred_l1_flag << 1)) -
                1;
            i4_pred_2 = (ps_nbr_mv[n]->b1_pred_l0_flag | (ps_nbr_mv[n]->b1_pred_l1_flag << 1)) - 1;
            if(ihevce_compare_pu_mv_t(
                   &ps_nbr_mv[NBR_A1]->mv, &ps_nbr_mv[n]->mv, i4_pred_1, i4_pred_2))
            {
                avail_flag = 0;
            }
        }
        i1_spatial_avail_flag_n[n] = avail_flag;
    }
    /* B2 */
    {
        WORD32 avail_flag;
        avail_flag = 1;
        n = NBR_B2;

        /* if at same merge level */
        if((part_pos_x >> merge_shift) == (nbr_x[n] >> merge_shift) &&
           ((part_pos_y >> merge_shift) == (nbr_y[n] >> merge_shift)))
        {
            u1_nbr_avail[n] = 0;
        }

        if(u1_nbr_avail[n] == 0)
        {
            avail_flag = 0;
        }

        if((i1_spatial_avail_flag_n[NBR_A0] + i1_spatial_avail_flag_n[NBR_A1] +
            i1_spatial_avail_flag_n[NBR_B0] + i1_spatial_avail_flag_n[NBR_B1]) == 4)
        {
            avail_flag = 0;
        }

        if(avail_flag == 1)
        {
            if(u1_nbr_avail[NBR_A1] == 1)
            {
                WORD32 i4_pred_1, i4_pred_2;
                i4_pred_1 = (ps_nbr_mv[NBR_A1]->b1_pred_l0_flag |
                             (ps_nbr_mv[NBR_A1]->b1_pred_l1_flag << 1)) -
                            1;
                i4_pred_2 =
                    (ps_nbr_mv[n]->b1_pred_l0_flag | (ps_nbr_mv[n]->b1_pred_l1_flag << 1)) - 1;
                if(ihevce_compare_pu_mv_t(
                       &ps_nbr_mv[NBR_A1]->mv, &ps_nbr_mv[n]->mv, i4_pred_1, i4_pred_2))
                {
                    avail_flag = 0;
                }
            }
            if(u1_nbr_avail[NBR_B1] == 1)
            {
                WORD32 i4_pred_1, i4_pred_2;
                i4_pred_1 = (ps_nbr_mv[NBR_B1]->b1_pred_l0_flag |
                             (ps_nbr_mv[NBR_B1]->b1_pred_l1_flag << 1)) -
                            1;
                i4_pred_2 =
                    (ps_nbr_mv[n]->b1_pred_l0_flag | (ps_nbr_mv[n]->b1_pred_l1_flag << 1)) - 1;
                if(ihevce_compare_pu_mv_t(
                       &ps_nbr_mv[NBR_B1]->mv, &ps_nbr_mv[n]->mv, i4_pred_1, i4_pred_2))
                {
                    avail_flag = 0;
                }
            }
        }
        i1_spatial_avail_flag_n[n] = avail_flag;
    }

    /******************************************************/
    /*          Merge Candidates List                     */
    /******************************************************/
    /* Preparing MV merge candidate list */
    {
        WORD32 merge_list_priority[MAX_NUM_MERGE_CAND] = { NBR_A1, NBR_B1, NBR_B0, NBR_A0, NBR_B2 };

        num_merge_cand = 0;
        for(n = 0; n < MAX_NUM_MERGE_CAND; n++)
        {
            WORD32 merge_idx;
            merge_idx = merge_list_priority[n];
            if(i1_spatial_avail_flag_n[merge_idx] == 1)
            {
                ps_merge_cand_list[num_merge_cand].mv = ps_nbr_mv[merge_idx]->mv;
                ps_merge_cand_list[num_merge_cand].u1_pred_flag_l0 =
                    (UWORD8)ps_nbr_mv[merge_idx]->b1_pred_l0_flag;
                ps_merge_cand_list[num_merge_cand].u1_pred_flag_l1 =
                    (UWORD8)ps_nbr_mv[merge_idx]->b1_pred_l1_flag;

                switch(merge_list_priority[n])
                {
                case NBR_A1:
                case NBR_A0:
                {
                    pu1_is_top_used[num_merge_cand] = 0;

                    break;
                }
                default:
                {
                    pu1_is_top_used[num_merge_cand] = 1;

                    break;
                }
                }

                num_merge_cand++;
            }
        }

        /******************************************************/
        /*           Temporal Merge Candidates                */
        /******************************************************/
        if(num_merge_cand < MAX_NUM_MERGE_CAND)
        {
            mv_t as_mv_col[2];
            WORD32 avail_col_flag[2] = { 0 }, x_col, y_col;
            WORD32 avail_col_l0, avail_col_l1;

            /* Checking Collocated MV availability at Bottom right of PU*/
            x_col = part_pos_x + part_wd;
            y_col = part_pos_y + part_ht;
            ihevce_collocated_mvp(ps_ctxt, ps_pu, as_mv_col, avail_col_flag, 0, x_col, y_col);

            avail_col_l0 = avail_col_flag[0];
            avail_col_l1 = avail_col_flag[1];

            if(avail_col_l0 || avail_col_l1)
            {
                ps_merge_cand_list[num_merge_cand].mv.s_l0_mv = as_mv_col[0];
                ps_merge_cand_list[num_merge_cand].mv.s_l1_mv = as_mv_col[1];
            }

            if(avail_col_l0 == 0 || avail_col_l1 == 0)
            {
                /* Checking Collocated MV availability at Center of PU */
                x_col = part_pos_x + (part_wd >> 1);
                y_col = part_pos_y + (part_ht >> 1);
                ihevce_collocated_mvp(ps_ctxt, ps_pu, as_mv_col, avail_col_flag, 0, x_col, y_col);

                if(avail_col_l0 == 0)
                {
                    ps_merge_cand_list[num_merge_cand].mv.s_l0_mv = as_mv_col[0];
                }
                if(avail_col_l1 == 0)
                {
                    ps_merge_cand_list[num_merge_cand].mv.s_l1_mv = as_mv_col[1];
                }

                avail_col_l0 |= avail_col_flag[0];
                avail_col_l1 |= avail_col_flag[1];
            }

            ps_merge_cand_list[num_merge_cand].mv.i1_l0_ref_idx = 0;
            ps_merge_cand_list[num_merge_cand].mv.i1_l1_ref_idx = 0;
            ps_merge_cand_list[num_merge_cand].u1_pred_flag_l0 = avail_col_l0 ? 1 : 0;
            ps_merge_cand_list[num_merge_cand].u1_pred_flag_l1 = avail_col_l1 ? 1 : 0;

            if(avail_col_l0 || avail_col_l1)
            {
                pu1_is_top_used[num_merge_cand] = 0;
                num_merge_cand++;
            }
        }

        /******************************************************/
        /*      Bi pred merge candidates                      */
        /******************************************************/
        if(slice_type == BSLICE)
        {
            if((num_merge_cand > 1) && (num_merge_cand < MAX_NUM_MERGE_CAND))
            {
                WORD32 priority_list0[12] = { 0, 1, 0, 2, 1, 2, 0, 3, 1, 3, 2, 3 };
                WORD32 priority_list1[12] = { 1, 0, 2, 0, 2, 1, 3, 0, 3, 1, 3, 2 };
                WORD32 l0_cand, l1_cand;
                WORD32 bi_pred_idx = 0;
                WORD32 total_bi_pred_cand = num_merge_cand * (num_merge_cand - 1);

                while(bi_pred_idx < total_bi_pred_cand)
                {
                    l0_cand = priority_list0[bi_pred_idx];
                    l1_cand = priority_list1[bi_pred_idx];

                    if((ps_merge_cand_list[l0_cand].u1_pred_flag_l0 == 1) &&
                       (ps_merge_cand_list[l1_cand].u1_pred_flag_l1 == 1))
                    {
                        WORD8 i1_l0_ref_idx, i1_l1_ref_idx;
                        WORD32 l0_poc, l1_poc;
                        mv_t s_l0_mv, s_l1_mv;

                        i1_l0_ref_idx = ps_merge_cand_list[l0_cand].mv.i1_l0_ref_idx;
                        i1_l1_ref_idx = ps_merge_cand_list[l1_cand].mv.i1_l1_ref_idx;
                        l0_poc = ps_ctxt->ps_ref_list[0][i1_l0_ref_idx]->i4_poc;
                        l1_poc = ps_ctxt->ps_ref_list[1][i1_l1_ref_idx]->i4_poc;
                        s_l0_mv = ps_merge_cand_list[l0_cand].mv.s_l0_mv;
                        s_l1_mv = ps_merge_cand_list[l1_cand].mv.s_l1_mv;

                        if((l0_poc != l1_poc) || (s_l0_mv.i2_mvx != s_l1_mv.i2_mvx) ||
                           (s_l0_mv.i2_mvy != s_l1_mv.i2_mvy))
                        {
                            ps_merge_cand_list[num_merge_cand].mv.s_l0_mv = s_l0_mv;
                            ps_merge_cand_list[num_merge_cand].mv.s_l1_mv = s_l1_mv;
                            ps_merge_cand_list[num_merge_cand].mv.i1_l0_ref_idx = i1_l0_ref_idx;
                            ps_merge_cand_list[num_merge_cand].mv.i1_l1_ref_idx = i1_l1_ref_idx;
                            ps_merge_cand_list[num_merge_cand].u1_pred_flag_l0 = 1;
                            ps_merge_cand_list[num_merge_cand].u1_pred_flag_l1 = 1;

                            if(pu1_is_top_used[l0_cand] || pu1_is_top_used[l1_cand])
                            {
                                pu1_is_top_used[num_merge_cand] = 1;
                            }
                            else
                            {
                                pu1_is_top_used[num_merge_cand] = 0;
                            }

                            num_merge_cand++;
                        }
                    }

                    bi_pred_idx++;

                    if((bi_pred_idx == total_bi_pred_cand) ||
                       (num_merge_cand == MAX_NUM_MERGE_CAND))
                    {
                        break;
                    }
                }
            }
        } /* End of Bipred merge candidates */

        /******************************************************/
        /*      Zero merge candidates                         */
        /******************************************************/
        if(num_merge_cand < MAX_NUM_MERGE_CAND)
        {
            WORD32 num_ref_idx;
            WORD32 zero_idx;

            zero_idx = 0;

            if(slice_type == PSLICE)
                num_ref_idx = num_ref_idx_l0_active;
            else
                /* Slice type B */
                num_ref_idx = MIN(num_ref_idx_l0_active, num_ref_idx_l1_active);

            while(num_merge_cand < MAX_NUM_MERGE_CAND)
            {
                if(slice_type == PSLICE)
                {
                    ps_merge_cand_list[num_merge_cand].mv.i1_l0_ref_idx = zero_idx;
                    ps_merge_cand_list[num_merge_cand].mv.i1_l1_ref_idx = -1;
                    ps_merge_cand_list[num_merge_cand].u1_pred_flag_l0 = 1;
                    ps_merge_cand_list[num_merge_cand].u1_pred_flag_l1 = 0;
                }
                else /* Slice type B */
                {
                    ps_merge_cand_list[num_merge_cand].mv.i1_l0_ref_idx = zero_idx;
                    ps_merge_cand_list[num_merge_cand].mv.i1_l1_ref_idx = zero_idx;
                    ps_merge_cand_list[num_merge_cand].u1_pred_flag_l0 = 1;
                    ps_merge_cand_list[num_merge_cand].u1_pred_flag_l1 = 1;
                }

                ps_merge_cand_list[num_merge_cand].mv.s_l0_mv.i2_mvx = 0;
                ps_merge_cand_list[num_merge_cand].mv.s_l0_mv.i2_mvy = 0;
                ps_merge_cand_list[num_merge_cand].mv.s_l1_mv.i2_mvx = 0;
                ps_merge_cand_list[num_merge_cand].mv.s_l1_mv.i2_mvy = 0;

                pu1_is_top_used[num_merge_cand] = 0;

                num_merge_cand++;
                zero_idx++;

                /* if all the reference pics have been added as candidates      */
                /* the the loop shoudl break since it would add same cand again */
                if(zero_idx == num_ref_idx)
                {
                    break;
                }
            }
        } /* End of zero merge candidates */

    } /* End of merge candidate list population */

    return (num_merge_cand);
}

Coverage Report

Created: 2025-07-18 07:02