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

 *

 * 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 hme_subpel.c

*

* @brief

*    Subpel refinement modules for ME algo

*

* @author

*    Ittiam

*

*

* List of Functions

* hme_qpel_interp_avg()

* hme_subpel_refine_ctblist_bck()

* hme_subpel_refine_ctblist_fwd()

* hme_refine_bidirect()

* hme_subpel_refinement()

* hme_subpel_refine_ctb_fwd()

* hme_subpel_refine_ctb_bck()

* hme_create_bck_inp()

* hme_subpel_refine_search_node()

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

*/

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

/* File Includes                                                             */

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

/* System include files */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include <stdarg.h>

#include <math.h>

#include <limits.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_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 "ihevce_defs.h"

#include "ihevce_lap_enc_structs.h"

#include "ihevce_multi_thrd_structs.h"

#include "ihevce_multi_thrd_funcs.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 "ihevce_bs_compute_ctb.h"

#include "ihevce_global_tables.h"

#include "ihevce_dep_mngr_interface.h"

#include "hme_datatype.h"

#include "hme_interface.h"

#include "hme_common_defs.h"

#include "hme_defs.h"

#include "ihevce_me_instr_set_router.h"

#include "hme_globals.h"

#include "hme_utils.h"

#include "hme_coarse.h"

#include "hme_fullpel.h"

#include "hme_subpel.h"

#include "hme_refine.h"

#include "hme_err_compute.h"

#include "hme_common_utils.h"

#include "hme_search_algo.h"

#include "ihevce_stasino_helpers.h"

#include "ihevce_common_utils.h"

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

/* Function Definitions                                                      */

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

void hme_qpel_interp_avg(interp_prms_t *ps_prms, S32 i4_mv_x, S32 i4_mv_y, S32 i4_buf_id)

{

    U08 *pu1_src1, *pu1_src2, *pu1_dst;

    qpel_input_buf_cfg_t *ps_inp_cfg;

    S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;

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

    /* For a given QPEL pt, we need to determine the 2 source pts that are   */

    /* needed to do the QPEL averaging. The logic to do this is as follows   */

    /* i4_mv_x and i4_mv_y are the motion vectors in QPEL units that are     */

    /* pointing to the pt of interest. Obviously, they are w.r.t. the 0,0    */

    /* pt of th reference blk that is colocated to the inp blk.              */

    /*    A j E k B                                                          */

    /*    l m n o p                                                          */

    /*    F q G r H                                                          */

    /*    s t u v w                                                          */

    /*    C x I y D                                                          */

    /* In above diagram, A. B, C, D are full pts at offsets (0,0),(1,0),(0,1)*/

    /* and (1,1) respectively in the fpel buffer (id = 0)                    */

    /* E and I are hxfy pts in offsets (0,0),(0,1) respectively in hxfy buf  */

    /* F and H are fxhy pts in offsets (0,0),(1,0) respectively in fxhy buf  */

    /* G is hxhy pt in offset 0,0 in hxhy buf                                */

    /* All above offsets are computed w.r.t. motion displaced pt in          */

    /* respective bufs. This means that A corresponds to (i4_mv_x >> 2) and  */

    /* (i4_mv_y >> 2) in fxfy buf. Ditto with E, F and G                     */

    /* fxfy buf is buf id 0, hxfy is buf id 1, fxhy is buf id 2, hxhy is 3   */

    /* If we consider pt v to be derived. v has a fractional comp of 3, 3    */

    /* v is avg of H and I. So the table look up of v should give following  */

    /* buf 1 (H) : offset = (1, 0) buf id = 2.                               */

    /* buf 2 (I) : offset = 0 , 1) buf id = 1.                               */

    /* NOTE: For pts that are fxfy/hxfy/fxhy/hxhy, bufid 1 will be -1.       */

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

    i4_mv_x_frac = i4_mv_x & 3;

    i4_mv_y_frac = i4_mv_y & 3;

    i4_offset = (i4_mv_x >> 2) + (i4_mv_y >> 2) * ps_prms->i4_ref_stride;

    /* Derive the descriptor that has all offset and size info */

    ps_inp_cfg = &gas_qpel_inp_buf_cfg[i4_mv_y_frac][i4_mv_x_frac];

    if(ps_inp_cfg->i1_buf_id1 == ps_inp_cfg->i1_buf_id2)

    {

        /* This is case for fxfy/hxfy/fxhy/hxhy */

        ps_prms->pu1_final_out = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];

        ps_prms->pu1_final_out += ps_inp_cfg->i1_buf_xoff1 + i4_offset;

        ps_prms->pu1_final_out += (ps_inp_cfg->i1_buf_yoff1 * ps_prms->i4_ref_stride);

        ps_prms->i4_final_out_stride = ps_prms->i4_ref_stride;

        return;

    }

    pu1_src1 = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];

    pu1_src1 += ps_inp_cfg->i1_buf_xoff1 + i4_offset;

    pu1_src1 += (ps_inp_cfg->i1_buf_yoff1 * ps_prms->i4_ref_stride);

    pu1_src2 = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id2];

    pu1_src2 += ps_inp_cfg->i1_buf_xoff2 + i4_offset;

    pu1_src2 += (ps_inp_cfg->i1_buf_yoff2 * ps_prms->i4_ref_stride);

    pu1_dst = ps_prms->apu1_interp_out[i4_buf_id];

    hevc_avg_2d(

        pu1_src1,

        pu1_src2,

        ps_prms->i4_ref_stride,

        ps_prms->i4_ref_stride,

        ps_prms->i4_blk_wd,

        ps_prms->i4_blk_ht,

        pu1_dst,

        ps_prms->i4_out_stride);

    ps_prms->pu1_final_out = pu1_dst;

    ps_prms->i4_final_out_stride = ps_prms->i4_out_stride;

}

static __inline void hme_qpel_interp_avg_2pt_vert_no_reuse(

    interp_prms_t *ps_prms,

    S32 i4_mv_x,

    S32 i4_mv_y,

    U08 **ppu1_final,

    S32 *pi4_final_stride,

    FT_QPEL_INTERP_AVG_1PT *pf_qpel_interp_avg_1pt)

{

    pf_qpel_interp_avg_1pt(ps_prms, i4_mv_x, i4_mv_y + 1, 3, ppu1_final, pi4_final_stride);

    pf_qpel_interp_avg_1pt(ps_prms, i4_mv_x, i4_mv_y - 1, 1, ppu1_final, pi4_final_stride);

}

static __inline void hme_qpel_interp_avg_2pt_horz_no_reuse(

    interp_prms_t *ps_prms,

    S32 i4_mv_x,

    S32 i4_mv_y,

    U08 **ppu1_final,

    S32 *pi4_final_stride,

    FT_QPEL_INTERP_AVG_1PT *pf_qpel_interp_avg_1pt)

{

    pf_qpel_interp_avg_1pt(ps_prms, i4_mv_x + 1, i4_mv_y, 2, ppu1_final, pi4_final_stride);

    pf_qpel_interp_avg_1pt(ps_prms, i4_mv_x - 1, i4_mv_y, 0, ppu1_final, pi4_final_stride);

}

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

*  @fn     hme_qpel_interp_comprehensive

*

*  @brief  Interpolates 2 qpel points by hpel averaging

*

*  @param[in,out]  ps_prms: Both input buffer ptrs and location of output

*

*  @param[in]  i4_mv_x : x component of motion vector in QPEL units

*

*  @param[in]  i4_mv_y : y component of motion vector in QPEL units

*

*  @param[in]  i4_grid_mask : mask which determines qpels to be computed

*

*  @param[out]  ppu1_final : storage for final buffer pointers

*

*  @param[out]  pi4_final_stride : storage for final buffer strides

*

*  @return None

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

*/

static __inline void hme_qpel_interp_comprehensive(

    interp_prms_t *ps_prms,

    U08 **ppu1_final,

    S32 *pi4_final_stride,

    S32 i4_mv_x,

    S32 i4_mv_y,

    S32 i4_grid_mask,

    ihevce_me_optimised_function_list_t *ps_me_optimised_function_list)

{

    S32 pt_select_for_TB, pt_select_for_LR;

    S32 dx, dy, dydx;

    S32 vert_func_selector, horz_func_selector;

    S32 i4_ref_stride = ps_prms->i4_ref_stride;

    pt_select_for_TB =

        ((i4_grid_mask & (1 << PT_B)) >> PT_B) + ((i4_grid_mask & (1 << PT_T)) >> (PT_T - 1));

    pt_select_for_LR =

        ((i4_grid_mask & (1 << PT_R)) >> PT_R) + ((i4_grid_mask & (1 << PT_L)) >> (PT_L - 1));

    dx = (i4_mv_x & 3);

    dy = (i4_mv_y & 3);

    dydx = (dx + (dy << 2));

    vert_func_selector = gai4_select_qpel_function_vert[pt_select_for_TB][dydx];

    horz_func_selector = gai4_select_qpel_function_horz[pt_select_for_LR][dydx];

    /* case descriptions */

    /* Let T = (gridmask & T) & B = (gridmask & B) */

    /* & hp = pt is an hpel or an fpel */

    /* & r = reuse possible */

    /* 0 => T || B = 0 */

    /* 1 => (!T) && (B) && hp */

    /* 2 => (T) && (!B) && hp */

    /* 3 => (!T) && (B) && !hp */

    /* 4 => (T) && (!B) && !hp */

    /* 5 => (T) && (B) && !hp && r */

    /* 6 => (T) && (B) && !hp && !r */

    /* 7 => (T) && (B) && hp */

    switch(vert_func_selector)

    {

    case 0:

    {

        break;

    }

    case 1:

    {

        S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;

        qpel_input_buf_cfg_t *ps_inp_cfg;

        S32 i4_mvyp1 = (i4_mv_y + 1);

        i4_mv_x_frac = dx;

        i4_mv_y_frac = i4_mvyp1 & 3;

        i4_offset = (i4_mv_x >> 2) + (i4_mvyp1 >> 2) * i4_ref_stride;

        /* Derive the descriptor that has all offset and size info */

        ps_inp_cfg = &gas_qpel_inp_buf_cfg[i4_mv_y_frac][i4_mv_x_frac];

        ppu1_final[3] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];

        ppu1_final[3] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;

        ppu1_final[3] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);

        pi4_final_stride[3] = i4_ref_stride;

        break;

    }

    case 2:

    {

        S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;

        qpel_input_buf_cfg_t *ps_inp_cfg;

        S32 i4_mvym1 = (i4_mv_y - 1);

        i4_mv_x_frac = dx;

        i4_mv_y_frac = i4_mvym1 & 3;

        i4_offset = (i4_mv_x >> 2) + (i4_mvym1 >> 2) * i4_ref_stride;

        /* Derive the descriptor that has all offset and size info */

        ps_inp_cfg = &gas_qpel_inp_buf_cfg[i4_mv_y_frac][i4_mv_x_frac];

        ppu1_final[1] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];

        ppu1_final[1] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;

        ppu1_final[1] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);

        pi4_final_stride[1] = i4_ref_stride;

        break;

    }

    case 3:

    {

        ps_me_optimised_function_list->pf_qpel_interp_avg_1pt(

            ps_prms, i4_mv_x, i4_mv_y + 1, 3, ppu1_final, pi4_final_stride);

        break;

    }

    case 4:

    {

        ps_me_optimised_function_list->pf_qpel_interp_avg_1pt(

            ps_prms, i4_mv_x, i4_mv_y - 1, 1, ppu1_final, pi4_final_stride);

        break;

    }

    case 5:

    {

        ps_me_optimised_function_list->pf_qpel_interp_avg_2pt_vert_with_reuse(

            ps_prms, i4_mv_x, i4_mv_y, ppu1_final, pi4_final_stride);

        break;

    }

    case 6:

    {

        hme_qpel_interp_avg_2pt_vert_no_reuse(

            ps_prms,

            i4_mv_x,

            i4_mv_y,

            ppu1_final,

            pi4_final_stride,

            ps_me_optimised_function_list->pf_qpel_interp_avg_1pt);

        break;

    }

    case 7:

    {

        S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;

        qpel_input_buf_cfg_t *ps_inp_cfg;

        S32 i4_mvyp1 = (i4_mv_y + 1);

        S32 i4_mvym1 = (i4_mv_y - 1);

        i4_mv_x_frac = dx;

        i4_mv_y_frac = i4_mvyp1 & 3;

        i4_offset = (i4_mv_x >> 2) + (i4_mvyp1 >> 2) * i4_ref_stride;

        /* Derive the descriptor that has all offset and size info */

        ps_inp_cfg = &gas_qpel_inp_buf_cfg[i4_mv_y_frac][i4_mv_x_frac];

        ppu1_final[3] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];

        ppu1_final[3] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;

        ppu1_final[3] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);

        pi4_final_stride[3] = i4_ref_stride;

        i4_mv_y_frac = i4_mvym1 & 3;

        i4_offset = (i4_mv_x >> 2) + (i4_mvym1 >> 2) * i4_ref_stride;

        /* Derive the descriptor that has all offset and size info */

        ps_inp_cfg = &gas_qpel_inp_buf_cfg[i4_mv_y_frac][i4_mv_x_frac];

        ppu1_final[1] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];

        ppu1_final[1] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;

        ppu1_final[1] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);

        pi4_final_stride[1] = i4_ref_stride;

        break;

    }

    }

    /* case descriptions */

    /* Let L = (gridmask & L) & R = (gridmask & R) */

    /* & hp = pt is an hpel or an fpel */

    /* & r = reuse possible */

    /* 0 => L || R = 0 */

    /* 1 => (!L) && (R) && hp */

    /* 2 => (L) && (!R) && hp */

    /* 3 => (!L) && (R) && !hp */

    /* 4 => (L) && (!R) && !hp */

    /* 5 => (L) && (R) && !hp && r */

    /* 6 => (L) && (R) && !hp && !r */

    /* 7 => (L) && (R) && hp */

    switch(horz_func_selector)

    {

    case 0:

    {

        break;

    }

    case 1:

    {

        S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;

        qpel_input_buf_cfg_t *ps_inp_cfg;

        S32 i4_mvxp1 = (i4_mv_x + 1);

        i4_mv_x_frac = i4_mvxp1 & 3;

        i4_mv_y_frac = dy;

        i4_offset = (i4_mvxp1 >> 2) + (i4_mv_y >> 2) * i4_ref_stride;

        /* Derive the descriptor that has all offset and size info */

        ps_inp_cfg = &gas_qpel_inp_buf_cfg[i4_mv_y_frac][i4_mv_x_frac];

        ppu1_final[2] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];

        ppu1_final[2] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;

        ppu1_final[2] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);

        pi4_final_stride[2] = i4_ref_stride;

        break;

    }

    case 2:

    {

        S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;

        qpel_input_buf_cfg_t *ps_inp_cfg;

        S32 i4_mvxm1 = (i4_mv_x - 1);

        i4_mv_x_frac = i4_mvxm1 & 3;

        i4_mv_y_frac = dy;

        i4_offset = (i4_mvxm1 >> 2) + (i4_mv_y >> 2) * i4_ref_stride;

        /* Derive the descriptor that has all offset and size info */

        ps_inp_cfg = &gas_qpel_inp_buf_cfg[i4_mv_y_frac][i4_mv_x_frac];

        ppu1_final[0] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];

        ppu1_final[0] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;

        ppu1_final[0] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);

        pi4_final_stride[0] = i4_ref_stride;

        break;

    }

    case 3:

    {

        ps_me_optimised_function_list->pf_qpel_interp_avg_1pt(

            ps_prms, i4_mv_x + 1, i4_mv_y, 2, ppu1_final, pi4_final_stride);

        break;

    }

    case 4:

    {

        ps_me_optimised_function_list->pf_qpel_interp_avg_1pt(

            ps_prms, i4_mv_x - 1, i4_mv_y, 0, ppu1_final, pi4_final_stride);

        break;

    }

    case 5:

    {

        ps_me_optimised_function_list->pf_qpel_interp_avg_2pt_horz_with_reuse(

            ps_prms, i4_mv_x, i4_mv_y, ppu1_final, pi4_final_stride);

        break;

    }

    case 6:

    {

        hme_qpel_interp_avg_2pt_horz_no_reuse(

            ps_prms,

            i4_mv_x,

            i4_mv_y,

            ppu1_final,

            pi4_final_stride,

            ps_me_optimised_function_list->pf_qpel_interp_avg_1pt);

        break;

    }

    case 7:

    {

        S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;

        qpel_input_buf_cfg_t *ps_inp_cfg;

        S32 i4_mvxp1 = (i4_mv_x + 1);

        S32 i4_mvxm1 = (i4_mv_x - 1);

        i4_mv_x_frac = i4_mvxp1 & 3;

        i4_mv_y_frac = dy;

        i4_offset = (i4_mvxp1 >> 2) + (i4_mv_y >> 2) * i4_ref_stride;

        /* Derive the descriptor that has all offset and size info */

        ps_inp_cfg = &gas_qpel_inp_buf_cfg[i4_mv_y_frac][i4_mv_x_frac];

        ppu1_final[2] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];

        ppu1_final[2] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;

        ppu1_final[2] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);

        pi4_final_stride[2] = i4_ref_stride;

        i4_mv_x_frac = i4_mvxm1 & 3;

        i4_offset = (i4_mvxm1 >> 2) + (i4_mv_y >> 2) * i4_ref_stride;

        /* Derive the descriptor that has all offset and size info */

        ps_inp_cfg = &gas_qpel_inp_buf_cfg[i4_mv_y_frac][i4_mv_x_frac];

        ppu1_final[0] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];

        ppu1_final[0] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;

        ppu1_final[0] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);

        pi4_final_stride[0] = i4_ref_stride;

        break;

    }

    }

}

/**

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

*  @fn     S32 hme_compute_pred_and_evaluate_bi(hme_subpel_prms_t *ps_prms,

*                                   search_results_t *ps_search_results,

*                                   layer_ctxt_t *ps_curr_layer,

*                                   U08 **ppu1_pred)

*

*

*  @brief  Evaluates the best bipred cost as avg(P0, P1) where P0 and P1 are

*          best L0 and L1 bufs respectively for the entire CU

*

*  @param[in]  ps_prms: subpel prms input to this function

*

*  @param[in] ps_curr_layer: points to the current layer ctxt

*

*  @return The best BI cost of best uni cost, whichever better

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

*/

void hme_compute_pred_and_evaluate_bi(

    inter_cu_results_t *ps_cu_results,

    inter_pu_results_t *ps_pu_results,

    inter_ctb_prms_t *ps_inter_ctb_prms,

    part_type_results_t *ps_part_type_result,

    ULWORD64 *pu8_winning_pred_sigmaXSquare,

    ULWORD64 *pu8_winning_pred_sigmaX,

    ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list,

    ihevce_me_optimised_function_list_t *ps_me_optimised_function_list)

{

    /* Idx0 - Uni winner */

    /* Idx1 - Uni runner-up */

    /* Idx2 - Bi winner */

    hme_pred_buf_info_t as_pred_buf_data[3][NUM_INTER_PU_PARTS];

    err_prms_t s_err_prms;

    interp_prms_t s_interp_prms;

    PF_SAD_FXN_T pf_err_compute;

    S32 i, j;

    S32 x_off, y_off, x_pic, y_pic;

    S32 i4_sad_grid;

    U08 e_cu_size;

    S32 i4_part_type;

    U08 u1_cu_size;

    S32 shift;

    S32 x_part, y_part, num_parts;

    S32 inp_stride, ref_stride;

    U08 au1_pred_buf_array_indixes[3];

    S32 cur_iter_best_cost;

    S32 uni_cost, bi_cost, best_cost, tot_cost;

    /* Idx0 - Uni winner */

    /* Idx1 - Bi winner */

    ULWORD64 au8_sigmaX[2][NUM_INTER_PU_PARTS];

    ULWORD64 au8_sigmaXSquared[2][NUM_INTER_PU_PARTS];

#if USE_NOISE_TERM_DURING_BICAND_SEARCH

    S32 i4_noise_term;

#endif

    interp_prms_t *ps_interp_prms = &s_interp_prms;

    S32 best_cand_in_opp_dir_idx = 0;

    S32 is_best_cand_an_intra = 0;

    U08 u1_is_cu_noisy = ps_inter_ctb_prms->u1_is_cu_noisy;

#if USE_NOISE_TERM_DURING_BICAND_SEARCH

    const S32 i4_default_src_wt = ((1 << 15) + (WGHT_DEFAULT >> 1)) / WGHT_DEFAULT;

#endif

    tot_cost = 0;

    /* Start of the CU w.r.t. CTB */

    x_off = ps_cu_results->u1_x_off;

    y_off = ps_cu_results->u1_y_off;

    inp_stride = ps_inter_ctb_prms->i4_inp_stride;

    ref_stride = ps_inter_ctb_prms->i4_rec_stride;

    ps_interp_prms->i4_ref_stride = ref_stride;

    /* Start of the CU w.r.t. Pic 0,0 */

    x_pic = x_off + ps_inter_ctb_prms->i4_ctb_x_off;

    y_pic = y_off + ps_inter_ctb_prms->i4_ctb_y_off;

    u1_cu_size = ps_cu_results->u1_cu_size;

    e_cu_size = u1_cu_size;

    shift = (S32)e_cu_size;

    i4_part_type = ps_part_type_result->u1_part_type;

    num_parts = gau1_num_parts_in_part_type[i4_part_type];

    for(i = 0; i < 3; i++)

    {

        hme_init_pred_buf_info(

            &as_pred_buf_data[i],

            &ps_inter_ctb_prms->s_pred_buf_mngr,

            (ps_part_type_result->as_pu_results->pu.b4_wd + 1) << 2,

            (ps_part_type_result->as_pu_results->pu.b4_ht + 1) << 2,

            (PART_TYPE_T)i4_part_type);

        au1_pred_buf_array_indixes[i] = as_pred_buf_data[i][0].u1_pred_buf_array_id;

    }

    for(j = 0; j < num_parts; j++)

    {

        UWORD8 *apu1_hpel_ref[2][4];

        PART_ID_T e_part_id;

        BLK_SIZE_T e_blk_size;

        WORD8 i1_ref_idx;

        UWORD8 pred_dir;

        WORD32 ref_offset, inp_offset, wd, ht;

        pu_result_t *ps_pu_node1, *ps_pu_node2, *ps_pu_result;

        mv_t *aps_mv[2];

        UWORD8 num_active_ref_opp;

        UWORD8 num_results_per_part;

        WORD32 luma_weight_ref1, luma_offset_ref1;

        WORD32 luma_weight_ref2, luma_offset_ref2;

        WORD32 pu_node2_found = 0;

        e_part_id = ge_part_type_to_part_id[i4_part_type][j];

        e_blk_size = ge_part_id_to_blk_size[e_cu_size][e_part_id];

        x_part = gas_part_attr_in_cu[e_part_id].u1_x_start << shift;

        y_part = gas_part_attr_in_cu[e_part_id].u1_y_start << shift;

        ref_offset = (x_part + x_pic) + (y_pic + y_part) * ref_stride;

        inp_offset = (x_part + y_part * inp_stride) + ps_cu_results->i4_inp_offset;

        pred_dir = ps_part_type_result->as_pu_results[j].pu.b2_pred_mode;

        ps_pu_node1 = &(ps_part_type_result->as_pu_results[j]);

        if(PRED_L0 == pred_dir)

        {

            i1_ref_idx = ps_pu_node1->pu.mv.i1_l0_ref_idx;

            aps_mv[0] = &(ps_pu_node1->pu.mv.s_l0_mv);

            num_active_ref_opp =

                ps_inter_ctb_prms->u1_num_active_ref_l1 * (ps_inter_ctb_prms->i4_bidir_enabled);

            num_results_per_part = ps_pu_results->u1_num_results_per_part_l0[e_part_id];

            ps_pu_result = ps_pu_results->aps_pu_results[PRED_L0][e_part_id];

            ASSERT(i1_ref_idx >= 0);

            apu1_hpel_ref[0][0] =

                (UWORD8 *)(ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->s_yuv_buf_desc.pv_y_buf) +

                ref_offset;

            apu1_hpel_ref[0][1] =

                ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->apu1_y_sub_pel_planes[0] +

                ref_offset;

            apu1_hpel_ref[0][2] =

                ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->apu1_y_sub_pel_planes[1] +

                ref_offset;

            apu1_hpel_ref[0][3] =

                ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->apu1_y_sub_pel_planes[2] +

                ref_offset;

            luma_weight_ref1 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]

                                   ->s_weight_offset.i2_luma_weight;

            luma_offset_ref1 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]

                                   ->s_weight_offset.i2_luma_offset;

        }

        else

        {

            i1_ref_idx = ps_pu_node1->pu.mv.i1_l1_ref_idx;

            aps_mv[0] = &(ps_pu_node1->pu.mv.s_l1_mv);

            ASSERT(i1_ref_idx >= 0);

            num_active_ref_opp =

                ps_inter_ctb_prms->u1_num_active_ref_l0 * (ps_inter_ctb_prms->i4_bidir_enabled);

            num_results_per_part = ps_pu_results->u1_num_results_per_part_l1[e_part_id];

            ps_pu_result = ps_pu_results->aps_pu_results[PRED_L1][e_part_id];

            apu1_hpel_ref[0][0] =

                (UWORD8 *)(ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->s_yuv_buf_desc.pv_y_buf) +

                ref_offset;

            apu1_hpel_ref[0][1] =

                ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->apu1_y_sub_pel_planes[0] +

                ref_offset;

            apu1_hpel_ref[0][2] =

                ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->apu1_y_sub_pel_planes[1] +

                ref_offset;

            apu1_hpel_ref[0][3] =

                ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->apu1_y_sub_pel_planes[2] +

                ref_offset;

            luma_weight_ref1 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]

                                   ->s_weight_offset.i2_luma_weight;

            luma_offset_ref1 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]

                                   ->s_weight_offset.i2_luma_offset;

        }

        if(aps_mv[0]->i2_mvx == INTRA_MV)

        {

            uni_cost = ps_pu_node1->i4_tot_cost;

            cur_iter_best_cost = ps_pu_node1->i4_tot_cost;

            best_cost = MIN(uni_cost, cur_iter_best_cost);

            tot_cost += best_cost;

            continue;

        }

        ps_interp_prms->i4_blk_wd = wd = gau1_blk_size_to_wd[e_blk_size];

        ps_interp_prms->i4_blk_ht = ht = gau1_blk_size_to_ht[e_blk_size];

        ps_interp_prms->i4_out_stride = MAX_CU_SIZE;

        if(num_active_ref_opp)

        {

            if(PRED_L0 == pred_dir)

            {

                if(ps_pu_results->u1_num_results_per_part_l1[e_part_id])

                {

                    ps_pu_node2 = ps_pu_results->aps_pu_results[1][e_part_id];

                    pu_node2_found = 1;

                }

            }

            else

            {

                if(ps_pu_results->u1_num_results_per_part_l0[e_part_id])

                {

                    ps_pu_node2 = ps_pu_results->aps_pu_results[0][e_part_id];

                    pu_node2_found = 1;

                }

            }

        }

        if(!pu_node2_found)

        {

            bi_cost = INT_MAX >> 1;

            s_interp_prms.apu1_interp_out[0] = as_pred_buf_data[0][j].pu1_pred;

            ps_interp_prms->ppu1_ref = &apu1_hpel_ref[0][0];

            ps_me_optimised_function_list->pf_qpel_interp_avg_generic(

                ps_interp_prms, aps_mv[0]->i2_mvx, aps_mv[0]->i2_mvy, 0);

            if(ps_interp_prms->pu1_final_out != s_interp_prms.apu1_interp_out[0])

            {

                as_pred_buf_data[0][j].u1_pred_buf_array_id = UCHAR_MAX;

                as_pred_buf_data[0][j].pu1_pred = ps_interp_prms->pu1_final_out;

                as_pred_buf_data[0][j].i4_pred_stride = ps_interp_prms->i4_final_out_stride;

            }

            if(u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)

            {

                hme_compute_sigmaX_and_sigmaXSquared(

                    as_pred_buf_data[0][j].pu1_pred,

                    as_pred_buf_data[0][j].i4_pred_stride,

                    &au8_sigmaX[0][j],

                    &au8_sigmaXSquared[0][j],

                    ps_interp_prms->i4_blk_wd,

                    ps_interp_prms->i4_blk_ht,

                    ps_interp_prms->i4_blk_wd,

                    ps_interp_prms->i4_blk_ht,

                    0,

                    1);

            }

        }

        else

        {

            i = 0;

            bi_cost = MAX_32BIT_VAL;

            is_best_cand_an_intra = 0;

            best_cand_in_opp_dir_idx = 0;

            pred_dir = ps_pu_node2[i].pu.b2_pred_mode;

            if(PRED_L0 == pred_dir)

            {

                i1_ref_idx = ps_pu_node2[i].pu.mv.i1_l0_ref_idx;

                aps_mv[1] = &(ps_pu_node2[i].pu.mv.s_l0_mv);

                ASSERT(i1_ref_idx >= 0);

                apu1_hpel_ref[1][0] =

                    (UWORD8 *)(ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]

                                   ->s_yuv_buf_desc.pv_y_buf) +

                    ref_offset;  //>ppu1_list_rec_fxfy[0][i1_ref_idx] + ref_offset;

                apu1_hpel_ref[1][1] =

                    ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->apu1_y_sub_pel_planes[0] +

                    ref_offset;

                apu1_hpel_ref[1][2] =

                    ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->apu1_y_sub_pel_planes[1] +

                    ref_offset;

                apu1_hpel_ref[1][3] =

                    ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->apu1_y_sub_pel_planes[2] +

                    ref_offset;

                luma_weight_ref2 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]

                                       ->s_weight_offset.i2_luma_weight;

                luma_offset_ref2 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]

                                       ->s_weight_offset.i2_luma_offset;

            }

            else

            {

                i1_ref_idx = ps_pu_node2[i].pu.mv.i1_l1_ref_idx;

                aps_mv[1] = &(ps_pu_node2[i].pu.mv.s_l1_mv);

                ASSERT(i1_ref_idx >= 0);

                apu1_hpel_ref[1][0] =

                    (UWORD8 *)(ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]

                                   ->s_yuv_buf_desc.pv_y_buf) +

                    ref_offset;  //>ppu1_list_rec_fxfy[0][i1_ref_idx] + ref_offset;

                apu1_hpel_ref[1][1] =

                    ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->apu1_y_sub_pel_planes[0] +

                    ref_offset;

                apu1_hpel_ref[1][2] =

                    ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->apu1_y_sub_pel_planes[1] +

                    ref_offset;

                apu1_hpel_ref[1][3] =

                    ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->apu1_y_sub_pel_planes[2] +

                    ref_offset;

                luma_weight_ref2 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]

                                       ->s_weight_offset.i2_luma_weight;

                luma_offset_ref2 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]

                                       ->s_weight_offset.i2_luma_offset;

            }

            if(aps_mv[1]->i2_mvx == INTRA_MV)

            {

                uni_cost = ps_pu_node1->i4_tot_cost;

                cur_iter_best_cost = ps_pu_node2[i].i4_tot_cost;

                if(cur_iter_best_cost < bi_cost)

                {

                    bi_cost = cur_iter_best_cost;

                    best_cand_in_opp_dir_idx = i;

                    is_best_cand_an_intra = 1;

                }

                best_cost = MIN(uni_cost, bi_cost);

                tot_cost += best_cost;

                continue;

            }

            s_interp_prms.apu1_interp_out[0] = as_pred_buf_data[0][j].pu1_pred;

            ps_interp_prms->ppu1_ref = &apu1_hpel_ref[0][0];

            ps_me_optimised_function_list->pf_qpel_interp_avg_generic(

                ps_interp_prms, aps_mv[0]->i2_mvx, aps_mv[0]->i2_mvy, 0);

            if(ps_interp_prms->pu1_final_out != s_interp_prms.apu1_interp_out[0])

            {

                as_pred_buf_data[0][j].u1_pred_buf_array_id = UCHAR_MAX;

                as_pred_buf_data[0][j].pu1_pred = ps_interp_prms->pu1_final_out;

                as_pred_buf_data[0][j].i4_pred_stride = ps_interp_prms->i4_final_out_stride;

            }

            if(u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)

            {

                hme_compute_sigmaX_and_sigmaXSquared(

                    as_pred_buf_data[0][j].pu1_pred,

                    as_pred_buf_data[0][j].i4_pred_stride,

                    &au8_sigmaX[0][j],

                    &au8_sigmaXSquared[0][j],

                    ps_interp_prms->i4_blk_wd,

                    ps_interp_prms->i4_blk_ht,

                    ps_interp_prms->i4_blk_wd,

                    ps_interp_prms->i4_blk_ht,

                    0,

                    1);

            }

            s_interp_prms.apu1_interp_out[0] = as_pred_buf_data[1][j].pu1_pred;

            ps_interp_prms->ppu1_ref = &apu1_hpel_ref[1][0];

            ps_me_optimised_function_list->pf_qpel_interp_avg_generic(

                ps_interp_prms, aps_mv[1]->i2_mvx, aps_mv[1]->i2_mvy, 0);

            if(ps_interp_prms->pu1_final_out != s_interp_prms.apu1_interp_out[0])

            {

                as_pred_buf_data[1][j].u1_pred_buf_array_id = UCHAR_MAX;

                as_pred_buf_data[1][j].pu1_pred = ps_interp_prms->pu1_final_out;

                as_pred_buf_data[1][j].i4_pred_stride = ps_interp_prms->i4_final_out_stride;

            }

            ps_cmn_utils_optimised_function_list->pf_wt_avg_2d(

                as_pred_buf_data[0][j].pu1_pred,

                as_pred_buf_data[1][j].pu1_pred,

                as_pred_buf_data[0][j].i4_pred_stride,

                as_pred_buf_data[1][j].i4_pred_stride,

                wd,

                ht,

                as_pred_buf_data[2][j].pu1_pred,

                as_pred_buf_data[2][j].i4_pred_stride,

                luma_weight_ref1,

                luma_weight_ref2,

                luma_offset_ref1,

                luma_offset_ref2,

                ps_inter_ctb_prms->wpred_log_wdc);

            if(u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)

            {

                hme_compute_sigmaX_and_sigmaXSquared(

                    as_pred_buf_data[2][j].pu1_pred,

                    as_pred_buf_data[2][j].i4_pred_stride,

                    &au8_sigmaX[1][j],

                    &au8_sigmaXSquared[1][j],

                    ps_interp_prms->i4_blk_wd,

                    ps_interp_prms->i4_blk_ht,

                    ps_interp_prms->i4_blk_wd,

                    ps_interp_prms->i4_blk_ht,

                    0,

                    1);

            }

            s_err_prms.pu1_inp = (U08 *)ps_inter_ctb_prms->pu1_non_wt_inp + inp_offset;

            s_err_prms.i4_inp_stride = inp_stride;

            s_err_prms.i4_ref_stride = as_pred_buf_data[2][j].i4_pred_stride;

            s_err_prms.i4_part_mask = (ENABLE_2Nx2N);

            s_err_prms.i4_grid_mask = 1;

            s_err_prms.pi4_sad_grid = &i4_sad_grid;

            s_err_prms.i4_blk_wd = wd;

            s_err_prms.i4_blk_ht = ht;

            s_err_prms.pu1_ref = as_pred_buf_data[2][j].pu1_pred;

            s_err_prms.ps_cmn_utils_optimised_function_list = ps_cmn_utils_optimised_function_list;

            if(ps_inter_ctb_prms->u1_use_satd)

            {

                pf_err_compute = compute_satd_8bit;

            }

            else

            {

                pf_err_compute = ps_me_optimised_function_list->pf_evalsad_pt_npu_mxn_8bit;

            }

            pf_err_compute(&s_err_prms);

#if USE_NOISE_TERM_DURING_BICAND_SEARCH

            if(u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)

            {

                unsigned long u4_shift_val;

                ULWORD64 u8_src_variance, u8_pred_variance, u8_pred_sigmaSquareX;

                ULWORD64 u8_temp_var, u8_temp_var1;

                S32 i4_bits_req;

                S32 i4_q_level = STIM_Q_FORMAT + ALPHA_Q_FORMAT;

                u8_pred_sigmaSquareX = (au8_sigmaX[1][j] * au8_sigmaX[1][j]);

                u8_pred_variance = au8_sigmaXSquared[1][j] - u8_pred_sigmaSquareX;

                if(e_cu_size == CU_8x8)

                {

                    PART_ID_T e_part_id =

                        (PART_ID_T)((PART_ID_NxN_TL) + (x_off & 1) + ((y_off & 1) << 1));

                    u4_shift_val = ihevce_calc_stim_injected_variance(

                        ps_inter_ctb_prms->pu8_part_src_sigmaX,

                        ps_inter_ctb_prms->pu8_part_src_sigmaXSquared,

                        &u8_src_variance,

                        i4_default_src_wt,

                        0,

                        ps_inter_ctb_prms->wpred_log_wdc,

                        e_part_id);

                }

                else

                {

                    u4_shift_val = ihevce_calc_stim_injected_variance(

                        ps_inter_ctb_prms->pu8_part_src_sigmaX,

                        ps_inter_ctb_prms->pu8_part_src_sigmaXSquared,

                        &u8_src_variance,

                        i4_default_src_wt,

                        0,

                        ps_inter_ctb_prms->wpred_log_wdc,

                        e_part_id);

                }

                u8_pred_variance = u8_pred_variance >> u4_shift_val;

                GETRANGE64(i4_bits_req, u8_pred_variance);

                if(i4_bits_req > 27)

                {

                    u8_pred_variance = u8_pred_variance >> (i4_bits_req - 27);

                    u8_src_variance = u8_src_variance >> (i4_bits_req - 27);

                }

                if(u8_src_variance == u8_pred_variance)

                {

                    u8_temp_var = (1 << STIM_Q_FORMAT);

                }

                else

                {

                    u8_temp_var = (2 * u8_src_variance * u8_pred_variance);

                    u8_temp_var = (u8_temp_var * (1 << STIM_Q_FORMAT));

                    u8_temp_var1 =

                        (u8_src_variance * u8_src_variance) + (u8_pred_variance * u8_pred_variance);

                    u8_temp_var = (u8_temp_var + (u8_temp_var1 / 2));

                    u8_temp_var = (u8_temp_var / u8_temp_var1);

                }

                i4_noise_term = (UWORD32)u8_temp_var;