path: root/encoder/hme_subpel.c

/******************************************************************************
 *
 * 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;

                i4_noise_term *= ps_inter_ctb_prms->i4_alpha_stim_multiplier;

                ASSERT(i4_noise_term >= 0);

                u8_temp_var = i4_sad_grid;
                u8_temp_var *= ((1 << (i4_q_level)) - (i4_noise_term));
                u8_temp_var += (1 << ((i4_q_level)-1));
                i4_sad_grid = (UWORD32)(u8_temp_var >> (i4_q_level));
            }
#endif

            cur_iter_best_cost = i4_sad_grid;
            cur_iter_best_cost += ps_pu_node1->i4_mv_cost;
            cur_iter_best_cost += ps_pu_node2[i].i4_mv_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 = 0;
            }
        }

        uni_cost = ps_pu_node1->i4_tot_cost;

#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;

            S08 i1_ref_idx =
                (PRED_L0 == ps_pu_node1->pu.b2_pred_mode)
                    ? ps_inter_ctb_prms->pi1_past_list[ps_pu_node1->pu.mv.i1_l0_ref_idx]
                    : ps_inter_ctb_prms->pi1_future_list[ps_pu_node1->pu.mv.i1_l1_ref_idx];
            S32 i4_sad = ps_pu_node1->i4_tot_cost - ps_pu_node1->i4_mv_cost;

            u8_pred_sigmaSquareX = (au8_sigmaX[0][j] * au8_sigmaX[0][j]);
            u8_pred_variance = au8_sigmaXSquared[0][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,
                    ps_inter_ctb_prms->pi4_inv_wt[i1_ref_idx],
                    ps_inter_ctb_prms->pi4_inv_wt_shift_val[i1_ref_idx],
                    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,
                    ps_inter_ctb_prms->pi4_inv_wt[i1_ref_idx],
                    ps_inter_ctb_prms->pi4_inv_wt_shift_val[i1_ref_idx],
                    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;

            i4_noise_term *= ps_inter_ctb_prms->i4_alpha_stim_multiplier;

            ASSERT(i4_noise_term >= 0);

            u8_temp_var = i4_sad;
            u8_temp_var *= ((1 << (i4_q_level)) - (i4_noise_term));
            u8_temp_var += (1 << ((i4_q_level)-1));
            i4_sad = (UWORD32)(u8_temp_var >> (i4_q_level));

            uni_cost = i4_sad + ps_pu_node1->i4_mv_cost;

            pu8_winning_pred_sigmaX[j] = au8_sigmaX[0][j];
            pu8_winning_pred_sigmaXSquare[j] = au8_sigmaXSquared[0][j];
        }
#endif

        if((bi_cost < uni_cost) && (!is_best_cand_an_intra))
        {
            if(u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)
            {
                pu8_winning_pred_sigmaX[j] = au8_sigmaX[1][j];
                pu8_winning_pred_sigmaXSquare[j] = au8_sigmaXSquared[1][j];
            }

            if(PRED_L0 == ps_pu_node1->pu.b2_pred_mode)
            {
                ps_pu_node1->pu.b2_pred_mode = PRED_BI;

                if(PRED_L0 == ps_pu_node2[best_cand_in_opp_dir_idx].pu.b2_pred_mode)
                {
                    ps_pu_node1->pu.mv.i1_l1_ref_idx =
                        ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.i1_l0_ref_idx;
                    ps_pu_node1->pu.mv.s_l1_mv.i2_mvx =
                        ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l0_mv.i2_mvx;
                    ps_pu_node1->pu.mv.s_l1_mv.i2_mvy =
                        ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l0_mv.i2_mvy;
                }
                else
                {
                    ps_pu_node1->pu.mv.i1_l1_ref_idx =
                        ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.i1_l1_ref_idx;
                    ps_pu_node1->pu.mv.s_l1_mv.i2_mvx =
                        ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l1_mv.i2_mvx;
                    ps_pu_node1->pu.mv.s_l1_mv.i2_mvy =
                        ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l1_mv.i2_mvy;
                }
            }
            else
            {
                ps_pu_node1->pu.b2_pred_mode = PRED_BI;

                if(PRED_L0 == ps_pu_node2[best_cand_in_opp_dir_idx].pu.b2_pred_mode)
                {
                    ps_pu_node1->pu.mv.i1_l0_ref_idx =
                        ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.i1_l0_ref_idx;
                    ps_pu_node1->pu.mv.s_l0_mv.i2_mvx =
                        ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l0_mv.i2_mvx;
                    ps_pu_node1->pu.mv.s_l0_mv.i2_mvy =
                        ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l0_mv.i2_mvy;
                }
                else
                {
                    ps_pu_node1->pu.mv.i1_l0_ref_idx =
                        ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.i1_l1_ref_idx;
                    ps_pu_node1->pu.mv.s_l0_mv.i2_mvx =
                        ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l1_mv.i2_mvx;
                    ps_pu_node1->pu.mv.s_l0_mv.i2_mvy =
                        ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l1_mv.i2_mvy;
                }
            }

            ps_part_type_result->as_pu_results[j].i4_tot_cost = bi_cost;
        }

        best_cost = MIN(uni_cost, bi_cost);
        tot_cost += best_cost;
    }

    hme_debrief_bipred_eval(
        ps_part_type_result,
        as_pred_buf_data,
        &ps_inter_ctb_prms->s_pred_buf_mngr,
        au1_pred_buf_array_indixes,
        ps_cmn_utils_optimised_function_list);

    ps_part_type_result->i4_tot_cost = tot_cost;
}

WORD32 hme_evalsatd_pt_pu_8x8_tu_rec(
    err_prms_t *ps_prms,
    WORD32 lambda,
    WORD32 lambda_q_shift,
    WORD32 i4_frm_qstep,
    me_func_selector_t *ps_func_selector)
{
    S32 ai4_satd_4x4[4]; /* num 4x4s in a 8x8 */
    S32 i4_satd_8x8;
    S16 *pi2_had_out;
    S32 i4_tu_split_flag = 0;
    S32 i4_tu_early_cbf = 0;

    S32 i4_early_cbf = 1;
    //  S32 i4_i, i4_k;
    S32 i4_total_satd_cost = 0;
    S32 best_cost_tu_split;

    /* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
    S32 *api4_satd_pu[HAD_32x32 + 1];
    S32 *api4_tu_split[HAD_32x32 + 1];
    S32 *api4_tu_early_cbf[HAD_32x32 + 1];

    S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;
    S32 *pi4_tu_split = ps_prms->pi4_tu_split_flags;
    S32 *pi4_early_cbf = ps_prms->pi4_tu_early_cbf;

    U08 *pu1_inp = ps_prms->pu1_inp;
    U08 *pu1_ref = ps_prms->pu1_ref;

    S32 inp_stride = ps_prms->i4_inp_stride;
    S32 ref_stride = ps_prms->i4_ref_stride;

    /* Initialize tu_split_cost to "0" */
    ps_prms->i4_tu_split_cost = 0;
    pi2_had_out = (S16 *)ps_prms->pu1_wkg_mem;

    api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
    api4_satd_pu[HAD_8x8] = &i4_satd_8x8;
    api4_satd_pu[HAD_16x16] = NULL;
    api4_satd_pu[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */

    api4_tu_split[HAD_4x4] = NULL;
    api4_tu_split[HAD_8x8] = &i4_tu_split_flag;
    api4_tu_split[HAD_16x16] = NULL;
    api4_tu_split[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */

    api4_tu_early_cbf[HAD_4x4] = NULL;
    api4_tu_early_cbf[HAD_8x8] = &i4_tu_early_cbf;
    api4_tu_early_cbf[HAD_16x16] = NULL;
    api4_tu_early_cbf[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */

    /* Call recursive 16x16 HAD module; updates satds for 4x4, 8x8 and 16x16 */

    /* Return value is merge of both best_stad_cost and tu_split_flags */
    best_cost_tu_split = ps_func_selector->pf_had_8x8_using_4_4x4_r(
        pu1_inp,
        inp_stride,
        pu1_ref,
        ref_stride,
        pi2_had_out,
        8,
        api4_satd_pu,
        api4_tu_split,
        api4_tu_early_cbf,
        0,
        2,
        0,
        0,
        i4_frm_qstep,
        0,
        ps_prms->u1_max_tr_depth,
        ps_prms->u1_max_tr_size,
        &(ps_prms->i4_tu_split_cost),
        NULL);

    /* For SATD computation following TU size are assumed for a 8x8 CU */
    /* 8 for 2Nx2N, 4 for Nx2N,2NxN                                    */

    i4_total_satd_cost = best_cost_tu_split >> 2;

    /* Second last bit has the tu pslit flag */
    i4_tu_split_flag = (best_cost_tu_split & 0x3) >> 1;

    /* Last bit corrsponds to the Early CBF flag */
    i4_early_cbf = (best_cost_tu_split & 0x1);

    /* Update 8x8 SATDs */
    pi4_sad_grid[PART_ID_2Nx2N] = i4_satd_8x8;
    pi4_tu_split[PART_ID_2Nx2N] = i4_tu_split_flag;
    pi4_early_cbf[PART_ID_2Nx2N] = i4_early_cbf;

    return i4_total_satd_cost;
}
//#endif
/**
********************************************************************************
*  @fn     S32 hme_evalsatd_update_1_best_result_pt_pu_16x16
*
*  @brief  Evaluates the SATD with partial updates for all the best partitions
*          of a 16x16 CU based on recursive Hadamard 16x16, 8x8 and 4x4 satds
*
*  @param[inout]  ps_prms: error prms containg current and ref ptr, strides,
*                 pointer to sad grid of each partitions
*
*  @return     None
********************************************************************************
*/

void hme_evalsatd_update_2_best_results_pt_pu_16x16(
    err_prms_t *ps_prms, result_upd_prms_t *ps_result_prms)
{
    S32 ai4_satd_4x4[16]; /* num 4x4s in a 16x16 */
    S32 ai4_satd_8x8[4]; /* num 8x8s in a 16x16 */
    S32 i4_satd_16x16; /* 16x16 satd cost     */
    S32 i;
    S16 ai2_8x8_had[256];
    S16 *pi2_y0;
    U08 *pu1_src, *pu1_pred;
    S32 pos_x_y_4x4_0, pos_x_y_4x4 = 0;
    S32 *ppi4_hsad;

    /* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
    S32 *api4_satd_pu[HAD_32x32 + 1];
    S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;

    U08 *pu1_inp = ps_prms->pu1_inp;
    U08 *pu1_ref = ps_prms->pu1_ref;

    S32 inp_stride = ps_prms->i4_inp_stride;
    S32 ref_stride = ps_prms->i4_ref_stride;

    api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
    api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[0];
    api4_satd_pu[HAD_16x16] = &i4_satd_16x16;
    api4_satd_pu[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */

    ppi4_hsad = api4_satd_pu[HAD_16x16];

    /* Call recursive 16x16 HAD module; updates satds for 4x4, 8x8 and 16x16 */
    for(i = 0; i < 4; i++)
    {
        pu1_src = pu1_inp + (i & 0x01) * 8 + (i >> 1) * inp_stride * 8;
        pu1_pred = pu1_ref + (i & 0x01) * 8 + (i >> 1) * ref_stride * 8;
        pi2_y0 = ai2_8x8_had + (i & 0x01) * 8 + (i >> 1) * 16 * 8;
        pos_x_y_4x4_0 = pos_x_y_4x4 + (i & 0x01) * 2 + (i >> 1) * (2 << 16);

        ihevce_had_8x8_using_4_4x4(
            pu1_src, inp_stride, pu1_pred, ref_stride, pi2_y0, 16, api4_satd_pu, pos_x_y_4x4_0, 4);
    }

    /* For SATD computation following TU size are assumed for a 16x16 CU */
    /* 16 for 2Nx2N, 8 for NxN/Nx2N,2NxN and mix of 4 and 8 for AMPs     */

    /* Update 8x8 SATDs */
    /* Modified to cost calculation using only 4x4 SATD */

    //  ai4_satd_8x8[0] = ai4_satd_4x4[0] + ai4_satd_4x4[1] + ai4_satd_4x4[4] + ai4_satd_4x4[5];
    //  ai4_satd_8x8[1] = ai4_satd_4x4[2] + ai4_satd_4x4[3] + ai4_satd_4x4[6] + ai4_satd_4x4[7];
    //  ai4_satd_8x8[2] = ai4_satd_4x4[8] + ai4_satd_4x4[9] + ai4_satd_4x4[12] + ai4_satd_4x4[13];
    //  ai4_satd_8x8[3] = ai4_satd_4x4[10] + ai4_satd_4x4[11] + ai4_satd_4x4[14] + ai4_satd_4x4[15];

    /* Update 16x16 SATDs */
    pi4_sad_grid[PART_ID_2Nx2N] =
        ai4_satd_8x8[0] + ai4_satd_8x8[1] + ai4_satd_8x8[2] + ai4_satd_8x8[3];

    pi4_sad_grid[PART_ID_NxN_TL] = ai4_satd_8x8[0];
    pi4_sad_grid[PART_ID_NxN_TR] = ai4_satd_8x8[1];
    pi4_sad_grid[PART_ID_NxN_BL] = ai4_satd_8x8[2];
    pi4_sad_grid[PART_ID_NxN_BR] = ai4_satd_8x8[3];

    /* Update 8x16 / 16x8 SATDs */
    pi4_sad_grid[PART_ID_Nx2N_L] = ai4_satd_8x8[0] + ai4_satd_8x8[2];
    pi4_sad_grid[PART_ID_Nx2N_R] = ai4_satd_8x8[1] + ai4_satd_8x8[3];
    pi4_sad_grid[PART_ID_2NxN_T] = ai4_satd_8x8[0] + ai4_satd_8x8[1];
    pi4_sad_grid[PART_ID_2NxN_B] = ai4_satd_8x8[2] + ai4_satd_8x8[3];

    /* Update AMP SATDs 16x12,16x4, 12x16,4x16  */
    pi4_sad_grid[PART_ID_nLx2N_L] =
        ai4_satd_4x4[0] + ai4_satd_4x4[4] + ai4_satd_4x4[8] + ai4_satd_4x4[12];

    pi4_sad_grid[PART_ID_nLx2N_R] = ai4_satd_4x4[1] + ai4_satd_4x4[5] + ai4_satd_4x4[9] +
                                    ai4_satd_4x4[13] + pi4_sad_grid[PART_ID_Nx2N_R];

    pi4_sad_grid[PART_ID_nRx2N_L] = ai4_satd_4x4[2] + ai4_satd_4x4[6] + ai4_satd_4x4[10] +
                                    ai4_satd_4x4[14] + pi4_sad_grid[PART_ID_Nx2N_L];

    pi4_sad_grid[PART_ID_nRx2N_R] =
        ai4_satd_4x4[3] + ai4_satd_4x4[7] + ai4_satd_4x4[11] + ai4_satd_4x4[15];

    pi4_sad_grid[PART_ID_2NxnU_T] =
        ai4_satd_4x4[0] + ai4_satd_4x4[1] + ai4_satd_4x4[2] + ai4_satd_4x4[3];

    pi4_sad_grid[PART_ID_2NxnU_B] = ai4_satd_4x4[4] + ai4_satd_4x4[5] + ai4_satd_4x4[6] +
                                    ai4_satd_4x4[7] + pi4_sad_grid[PART_ID_2NxN_B];

    pi4_sad_grid[PART_ID_2NxnD_T] = ai4_satd_4x4[8] + ai4_satd_4x4[9] + ai4_satd_4x4[10] +
                                    ai4_satd_4x4[11] + pi4_sad_grid[PART_ID_2NxN_T];

    pi4_sad_grid[PART_ID_2NxnD_B] =
        ai4_satd_4x4[12] + ai4_satd_4x4[13] + ai4_satd_4x4[14] + ai4_satd_4x4[15];

    /* Call the update results function */
    {
        S32 i4_count = 0, i4_sad, i4_mv_cost, i4_tot_cost;
        mv_refine_ctxt_t *ps_subpel_refine_ctxt = ps_result_prms->ps_subpel_refine_ctxt;
        S32 *pi4_valid_part_ids = &ps_subpel_refine_ctxt->ai4_part_id[0];
        S32 best_node_cost;
        S32 second_best_node_cost;

        /*For each valid partition, update the refine_prm structure to reflect the best and second
        best candidates for that partition*/

        for(i4_count = 0; i4_count < ps_subpel_refine_ctxt->i4_num_valid_parts; i4_count++)
        {
            S32 update_required = 0;
            S32 part_id = pi4_valid_part_ids[i4_count];
            S32 index = (ps_subpel_refine_ctxt->i4_num_valid_parts > 8) ? part_id : i4_count;

            /* Use a pre-computed cost instead of freshly evaluating subpel cost */
            i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];

            /*Calculate total cost*/
            i4_sad = CLIP3(pi4_sad_grid[part_id], 0, 0x7fff);
            i4_tot_cost = CLIP_S16(i4_sad + i4_mv_cost);

            /*****************************************************************/
            /* We do not labor through the results if the total cost worse   */
            /* than the last of the results.                                 */
            /*****************************************************************/
            best_node_cost = CLIP_S16(ps_subpel_refine_ctxt->i2_tot_cost[0][index]);
            second_best_node_cost = CLIP_S16(ps_subpel_refine_ctxt->i2_tot_cost[1][index]);

            if(i4_tot_cost < second_best_node_cost)
            {
                update_required = 2;

                /*************************************************************/
                /* Identify where the current result isto be placed.Basically*/
                /* find the node which has cost just higher thannodeundertest*/
                /*************************************************************/
                if(i4_tot_cost < best_node_cost)
                {
                    update_required = 1;
                }
                else if(i4_tot_cost == ps_subpel_refine_ctxt->i2_tot_cost[0][index])
                {
                    update_required = 0;
                }
                if(update_required == 2)
                {
                    ps_subpel_refine_ctxt->i2_tot_cost[1][index] = i4_tot_cost;
                    ps_subpel_refine_ctxt->i2_mv_cost[1][index] = i4_mv_cost;
                    ps_subpel_refine_ctxt->i2_mv_x[1][index] = ps_result_prms->i2_mv_x;
                    ps_subpel_refine_ctxt->i2_mv_y[1][index] = ps_result_prms->i2_mv_y;
                    ps_subpel_refine_ctxt->i2_ref_idx[1][index] = ps_result_prms->i1_ref_idx;
                }
                else if(update_required == 1)
                {
                    ps_subpel_refine_ctxt->i2_tot_cost[1][index] =
                        ps_subpel_refine_ctxt->i2_tot_cost[0][index];
                    ps_subpel_refine_ctxt->i2_mv_cost[1][index] =
                        ps_subpel_refine_ctxt->i2_mv_cost[0][index];
                    ps_subpel_refine_ctxt->i2_mv_x[1][index] =
                        ps_subpel_refine_ctxt->i2_mv_x[0][index];
                    ps_subpel_refine_ctxt->i2_mv_y[1][index] =
                        ps_subpel_refine_ctxt->i2_mv_y[0][index];
                    ps_subpel_refine_ctxt->i2_ref_idx[1][index] =
                        ps_subpel_refine_ctxt->i2_ref_idx[0][index];

                    ps_subpel_refine_ctxt->i2_tot_cost[0][index] = i4_tot_cost;
                    ps_subpel_refine_ctxt->i2_mv_cost[0][index] = i4_mv_cost;
                    ps_subpel_refine_ctxt->i2_mv_x[0][index] = ps_result_prms->i2_mv_x;
                    ps_subpel_refine_ctxt->i2_mv_y[0][index] = ps_result_prms->i2_mv_y;
                    ps_subpel_refine_ctxt->i2_ref_idx[0][index] = ps_result_prms->i1_ref_idx;
                }
            }
        }
    }
}

//#if COMPUTE_16x16_R == C
void hme_evalsatd_update_1_best_result_pt_pu_16x16(
    err_prms_t *ps_prms, result_upd_prms_t *ps_result_prms)
{
    S32 ai4_satd_4x4[16]; /* num 4x4s in a 16x16 */
    S32 ai4_satd_8x8[4]; /* num 8x8s in a 16x16 */
    S32 i4_satd_16x16; /* 16x16 satd cost     */
    S32 i;
    S16 ai2_8x8_had[256];
    S16 *pi2_y0;
    U08 *pu1_src, *pu1_pred;
    S32 pos_x_y_4x4_0, pos_x_y_4x4 = 0;
    S32 *ppi4_hsad;

    /* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
    S32 *api4_satd_pu[HAD_32x32 + 1];
    S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;

    U08 *pu1_inp = ps_prms->pu1_inp;
    U08 *pu1_ref = ps_prms->pu1_ref;

    S32 inp_stride = ps_prms->i4_inp_stride;
    S32 ref_stride = ps_prms->i4_ref_stride;

    api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
    api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[0];
    api4_satd_pu[HAD_16x16] = &i4_satd_16x16;
    api4_satd_pu[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */

    ppi4_hsad = api4_satd_pu[HAD_16x16];

    /* Call recursive 16x16 HAD module; updates satds for 4x4, 8x8 and 16x16 */
    for(i = 0; i < 4; i++)
    {
        pu1_src = pu1_inp + (i & 0x01) * 8 + (i >> 1) * inp_stride * 8;
        pu1_pred = pu1_ref + (i & 0x01) * 8 + (i >> 1) * ref_stride * 8;
        pi2_y0 = ai2_8x8_had + (i & 0x01) * 8 + (i >> 1) * 16 * 8;
        pos_x_y_4x4_0 = pos_x_y_4x4 + (i & 0x01) * 2 + (i >> 1) * (2 << 16);

        ihevce_had_8x8_using_4_4x4(
            pu1_src, inp_stride, pu1_pred, ref_stride, pi2_y0, 16, api4_satd_pu, pos_x_y_4x4_0, 4);
    }

    /* For SATD computation following TU size are assumed for a 16x16 CU */
    /* 16 for 2Nx2N, 8 for NxN/Nx2N,2NxN and mix of 4 and 8 for AMPs     */

    /* Update 8x8 SATDs */
    /* Modified to cost calculation using only 4x4 SATD */

    //  ai4_satd_8x8[0] = ai4_satd_4x4[0] + ai4_satd_4x4[1] + ai4_satd_4x4[4] + ai4_satd_4x4[5];
    //  ai4_satd_8x8[1] = ai4_satd_4x4[2] + ai4_satd_4x4[3] + ai4_satd_4x4[6] + ai4_satd_4x4[7];
    //  ai4_satd_8x8[2] = ai4_satd_4x4[8] + ai4_satd_4x4[9] + ai4_satd_4x4[12] + ai4_satd_4x4[13];
    //  ai4_satd_8x8[3] = ai4_satd_4x4[10] + ai4_satd_4x4[11] + ai4_satd_4x4[14] + ai4_satd_4x4[15];

    /* Update 16x16 SATDs */
    pi4_sad_grid[PART_ID_2Nx2N] =
        ai4_satd_8x8[0] + ai4_satd_8x8[1] + ai4_satd_8x8[2] + ai4_satd_8x8[3];

    pi4_sad_grid[PART_ID_NxN_TL] = ai4_satd_8x8[0];
    pi4_sad_grid[PART_ID_NxN_TR] = ai4_satd_8x8[1];
    pi4_sad_grid[PART_ID_NxN_BL] = ai4_satd_8x8[2];
    pi4_sad_grid[PART_ID_NxN_BR] = ai4_satd_8x8[3];

    /* Update 8x16 / 16x8 SATDs */
    pi4_sad_grid[PART_ID_Nx2N_L] = ai4_satd_8x8[0] + ai4_satd_8x8[2];
    pi4_sad_grid[PART_ID_Nx2N_R] = ai4_satd_8x8[1] + ai4_satd_8x8[3];
    pi4_sad_grid[PART_ID_2NxN_T] = ai4_satd_8x8[0] + ai4_satd_8x8[1];
    pi4_sad_grid[PART_ID_2NxN_B] = ai4_satd_8x8[2] + ai4_satd_8x8[3];

    /* Update AMP SATDs 16x12,16x4, 12x16,4x16  */
    pi4_sad_grid[PART_ID_nLx2N_L] =
        ai4_satd_4x4[0] + ai4_satd_4x4[2] + ai4_satd_4x4[8] + ai4_satd_4x4[10];
    pi4_sad_grid[PART_ID_nRx2N_R] =
        ai4_satd_4x4[5] + ai4_satd_4x4[7] + ai4_satd_4x4[13] + ai4_satd_4x4[15];
    pi4_sad_grid[PART_ID_2NxnU_T] =
        ai4_satd_4x4[0] + ai4_satd_4x4[1] + ai4_satd_4x4[4] + ai4_satd_4x4[5];
    pi4_sad_grid[PART_ID_2NxnD_B] =
        ai4_satd_4x4[10] + ai4_satd_4x4[11] + ai4_satd_4x4[14] + ai4_satd_4x4[15];

    pi4_sad_grid[PART_ID_nLx2N_R] = pi4_sad_grid[PART_ID_2Nx2N] - pi4_sad_grid[PART_ID_nLx2N_L];
    pi4_sad_grid[PART_ID_nRx2N_L] = pi4_sad_grid[PART_ID_2Nx2N] - pi4_sad_grid[PART_ID_nRx2N_R];
    pi4_sad_grid[PART_ID_2NxnU_B] = pi4_sad_grid[PART_ID_2Nx2N] - pi4_sad_grid[PART_ID_2NxnU_T];
    pi4_sad_grid[PART_ID_2NxnD_T] = pi4_sad_grid[PART_ID_2Nx2N] - pi4_sad_grid[PART_ID_2NxnD_B];

    /* Call the update results function */
    {
        S32 i4_count = 0, i4_sad, i4_mv_cost, i4_tot_cost;
        mv_refine_ctxt_t *ps_subpel_refine_ctxt = ps_result_prms->ps_subpel_refine_ctxt;
        S32 *pi4_valid_part_ids = &ps_subpel_refine_ctxt->ai4_part_id[0];
        S32 best_node_cost;
        S32 second_best_node_cost;

        /*For each valid partition, update the refine_prm structure to reflect the best and second
        best candidates for that partition*/

        for(i4_count = 0; i4_count < ps_subpel_refine_ctxt->i4_num_valid_parts; i4_count++)
        {
            S32 update_required = 0;
            S32 part_id = pi4_valid_part_ids[i4_count];
            S32 index = (ps_subpel_refine_ctxt->i4_num_valid_parts > 8) ? part_id : i4_count;

            /* Use a pre-computed cost instead of freshly evaluating subpel cost */
            i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];

            /*Calculate total cost*/
            i4_sad = CLIP3(pi4_sad_grid[part_id], 0, 0x7fff);
            i4_tot_cost = CLIP_S16(i4_sad + i4_mv_cost);

            /*****************************************************************/
            /* We do not labor through the results if the total cost worse   */
            /* than the last of the results.                                 */
            /*****************************************************************/
            best_node_cost = CLIP_S16(ps_subpel_refine_ctxt->i2_tot_cost[0][index]);
            second_best_node_cost = SHRT_MAX;

            if(i4_tot_cost < second_best_node_cost)
            {
                update_required = 0;

                /*************************************************************/
                /* Identify where the current result isto be placed.Basically*/
                /* find the node which has cost just higher thannodeundertest*/
                /*************************************************************/
                if(i4_tot_cost < best_node_cost)
                {
                    update_required = 1;
                }
                else if(i4_tot_cost == ps_subpel_refine_ctxt->i2_tot_cost[0][index])
                {
                    update_required = 0;
                }
                if(update_required == 2)
                {
                    ps_subpel_refine_ctxt->i2_tot_cost[1][index] = i4_tot_cost;
                    ps_subpel_refine_ctxt->i2_mv_cost[1][index] = i4_mv_cost;
                    ps_subpel_refine_ctxt->i2_mv_x[1][index] = ps_result_prms->i2_mv_x;
                    ps_subpel_refine_ctxt->i2_mv_y[1][index] = ps_result_prms->i2_mv_y;
                    ps_subpel_refine_ctxt->i2_ref_idx[1][index] = ps_result_prms->i1_ref_idx;
                }
                else if(update_required == 1)
                {
                    ps_subpel_refine_ctxt->i2_tot_cost[0][index] = i4_tot_cost;
                    ps_subpel_refine_ctxt->i2_mv_cost[0][index] = i4_mv_cost;
                    ps_subpel_refine_ctxt->i2_mv_x[0][index] = ps_result_prms->i2_mv_x;
                    ps_subpel_refine_ctxt->i2_mv_y[0][index] = ps_result_prms->i2_mv_y;
                    ps_subpel_refine_ctxt->i2_ref_idx[0][index] = ps_result_prms->i1_ref_idx;
                }
            }
        }
    }
}

WORD32 hme_evalsatd_pt_pu_16x16_tu_rec(
    err_prms_t *ps_prms,
    WORD32 lambda,
    WORD32 lambda_q_shift,
    WORD32 i4_frm_qstep,
    me_func_selector_t *ps_func_selector)
{
    S32 ai4_satd_4x4[16]; /* num 4x4s in a 16x16 */
    S32 ai4_satd_8x8[4]; /* num 8x8s in a 16x16 */
    S32 ai4_tu_split_8x8[16];
    S32 i4_satd_16x16; /* 16x16 satd cost     */

    S32 ai4_tu_early_cbf_8x8[16];

    //S16 ai2_had_out[256];
    S16 *pi2_had_out;
    S32 tu_split_flag = 0;
    S32 early_cbf_flag = 0;
    S32 total_satd_cost = 0;

    /* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
    S32 *api4_satd_pu[HAD_32x32 + 1];
    S32 *api4_tu_split[HAD_32x32 + 1];
    S32 *api4_tu_early_cbf[HAD_32x32 + 1];

    U08 *pu1_inp = ps_prms->pu1_inp;
    U08 *pu1_ref = ps_prms->pu1_ref;

    S32 inp_stride = ps_prms->i4_inp_stride;
    S32 ref_stride = ps_prms->i4_ref_stride;

    /* Initialize tu_split_cost to "0" */
    ps_prms->i4_tu_split_cost = 0;

    pi2_had_out = (S16 *)ps_prms->pu1_wkg_mem;

    api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
    api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[0];
    api4_satd_pu[HAD_16x16] = &i4_satd_16x16;
    api4_satd_pu[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */

    api4_tu_split[HAD_4x4] = NULL;
    api4_tu_split[HAD_8x8] = &ai4_tu_split_8x8[0];
    api4_tu_split[HAD_16x16] = &tu_split_flag;
    api4_tu_split[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */

    api4_tu_early_cbf[HAD_4x4] = NULL;
    api4_tu_early_cbf[HAD_8x8] = &ai4_tu_early_cbf_8x8[0];
    api4_tu_early_cbf[HAD_16x16] = &early_cbf_flag;
    api4_tu_early_cbf[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */

    /* Call recursive 16x16 HAD module; updates satds for 4x4, 8x8 and 16x16 */
    ps_func_selector->pf_had_16x16_r(
        pu1_inp,
        inp_stride,
        pu1_ref,
        ref_stride,
        pi2_had_out,
        16,
        api4_satd_pu,
        api4_tu_split,
        api4_tu_early_cbf,
        0,
        4,
        lambda,
        lambda_q_shift,
        i4_frm_qstep,
        0,
        ps_prms->u1_max_tr_depth,
        ps_prms->u1_max_tr_size,
        &(ps_prms->i4_tu_split_cost),
        NULL);

    total_satd_cost = i4_satd_16x16;

    ps_prms->pi4_tu_split_flags[0] = tu_split_flag;

    ps_prms->pi4_tu_early_cbf[0] = early_cbf_flag;

    return total_satd_cost;
}

/**
********************************************************************************
*  @fn     S32 hme_evalsatd_pt_pu_32x32
*
*  @brief  Evaluates the SATD with partial updates for all the best partitions
*          of a 32x32 CU based on recursive Hadamard 16x16, 8x8 and 4x4 satds
*
*  @param[inout]  ps_prms: error prms containg current and ref ptr, strides,
*                 pointer to sad grid of each partitions
*
*  @return     None
********************************************************************************
*/
void hme_evalsatd_pt_pu_32x32(err_prms_t *ps_prms)
{
    //S32 ai4_satd_4x4[64];   /* num 4x4s in a 32x32 */
    S32 ai4_satd_8x8[16]; /* num 8x8s in a 32x32 */
    S32 ai4_satd_16x16[4]; /* num 16x16 in a 32x32 */
    S32 i4_satd_32x32;
    //    S16 ai2_had_out[32*32];
    U08 *pu1_src;
    U08 *pu1_pred;
    S32 i;

    /* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
    S32 *api4_satd_pu[HAD_32x32 + 1];
    S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;

    U08 *pu1_inp = ps_prms->pu1_inp;
    U08 *pu1_ref = ps_prms->pu1_ref;

    S32 inp_stride = ps_prms->i4_inp_stride;
    S32 ref_stride = ps_prms->i4_ref_stride;

    //api4_satd_pu[HAD_4x4]   = &ai4_satd_4x4[0];
    api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[0];
    api4_satd_pu[HAD_16x16] = &ai4_satd_16x16[0];
    api4_satd_pu[HAD_32x32] = &i4_satd_32x32;

    /* 32x32 SATD is calculates as the sum of the 4 8x8's in the block */
    for(i = 0; i < 16; i++)
    {
        pu1_src = pu1_inp + ((i & 0x3) << 3) + ((i >> 2) * inp_stride * 8);

        pu1_pred = pu1_ref + ((i & 0x3) << 3) + ((i >> 2) * ref_stride * 8);

        ai4_satd_8x8[i] = ps_prms->ps_cmn_utils_optimised_function_list->pf_HAD_8x8_8bit(
            pu1_src, inp_stride, pu1_pred, ref_stride, NULL, 1);
    }

    /* Modified to cost calculation using only 8x8 SATD for 32x32*/
    ai4_satd_16x16[0] = ai4_satd_8x8[0] + ai4_satd_8x8[1] + ai4_satd_8x8[4] + ai4_satd_8x8[5];
    ai4_satd_16x16[1] = ai4_satd_8x8[2] + ai4_satd_8x8[3] + ai4_satd_8x8[6] + ai4_satd_8x8[7];
    ai4_satd_16x16[2] = ai4_satd_8x8[8] + ai4_satd_8x8[9] + ai4_satd_8x8[12] + ai4_satd_8x8[13];
    ai4_satd_16x16[3] = ai4_satd_8x8[10] + ai4_satd_8x8[11] + ai4_satd_8x8[14] + ai4_satd_8x8[15];

    /* Update 32x32 SATD */
    pi4_sad_grid[PART_ID_2Nx2N] =
        ai4_satd_16x16[0] + ai4_satd_16x16[1] + ai4_satd_16x16[2] + ai4_satd_16x16[3];

    /* Update 16x16 SATDs */
    pi4_sad_grid[PART_ID_NxN_TL] = ai4_satd_16x16[0];
    pi4_sad_grid[PART_ID_NxN_TR] = ai4_satd_16x16[1];
    pi4_sad_grid[PART_ID_NxN_BL] = ai4_satd_16x16[2];
    pi4_sad_grid[PART_ID_NxN_BR] = ai4_satd_16x16[3];

    /* Update 16x32 / 32x16 SATDs */
    pi4_sad_grid[PART_ID_Nx2N_L] = ai4_satd_16x16[0] + ai4_satd_16x16[2];
    pi4_sad_grid[PART_ID_Nx2N_R] = ai4_satd_16x16[1] + ai4_satd_16x16[3];
    pi4_sad_grid[PART_ID_2NxN_T] = ai4_satd_16x16[0] + ai4_satd_16x16[1];
    pi4_sad_grid[PART_ID_2NxN_B] = ai4_satd_16x16[2] + ai4_satd_16x16[3];

    /* Update AMP SATDs 32x24,32x8, 24x32,8x32  */
    pi4_sad_grid[PART_ID_nLx2N_L] =
        ai4_satd_8x8[0] + ai4_satd_8x8[4] + ai4_satd_8x8[8] + ai4_satd_8x8[12];

    pi4_sad_grid[PART_ID_nLx2N_R] = ai4_satd_8x8[1] + ai4_satd_8x8[5] + ai4_satd_8x8[9] +
                                    ai4_satd_8x8[13] + pi4_sad_grid[PART_ID_Nx2N_R];

    pi4_sad_grid[PART_ID_nRx2N_L] = ai4_satd_8x8[2] + ai4_satd_8x8[6] + ai4_satd_8x8[10] +
                                    ai4_satd_8x8[14] + pi4_sad_grid[PART_ID_Nx2N_L];

    pi4_sad_grid[PART_ID_nRx2N_R] =
        ai4_satd_8x8[3] + ai4_satd_8x8[7] + ai4_satd_8x8[11] + ai4_satd_8x8[15];

    pi4_sad_grid[PART_ID_2NxnU_T] =
        ai4_satd_8x8[0] + ai4_satd_8x8[1] + ai4_satd_8x8[2] + ai4_satd_8x8[3];

    pi4_sad_grid[PART_ID_2NxnU_B] = ai4_satd_8x8[4] + ai4_satd_8x8[5] + ai4_satd_8x8[6] +
                                    ai4_satd_8x8[7] + pi4_sad_grid[PART_ID_2NxN_B];

    pi4_sad_grid[PART_ID_2NxnD_T] = ai4_satd_8x8[8] + ai4_satd_8x8[9] + ai4_satd_8x8[10] +
                                    ai4_satd_8x8[11] + pi4_sad_grid[PART_ID_2NxN_T];

    pi4_sad_grid[PART_ID_2NxnD_B] =
        ai4_satd_8x8[12] + ai4_satd_8x8[13] + ai4_satd_8x8[14] + ai4_satd_8x8[15];
}

WORD32 hme_evalsatd_pt_pu_32x32_tu_rec(
    err_prms_t *ps_prms,
    WORD32 lambda,
    WORD32 lambda_q_shift,
    WORD32 i4_frm_qstep,
    me_func_selector_t *ps_func_selector)
{
    S32 ai4_satd_4x4[64]; /* num 4x4s in a 32x32 */
    S32 ai4_satd_8x8[16]; /* num 8x8s in a 32x32 */
    S32 ai4_tu_split_8x8[16];
    S32 ai4_satd_16x16[4]; /* num 16x16 in a 32x32 */
    S32 ai4_tu_split_16x16[4];
    S32 i4_satd_32x32;

    S32 ai4_tu_early_cbf_8x8[16];
    S32 ai4_tu_early_cbf_16x16[4];
    S32 early_cbf_flag;

    S16 *pi2_had_out;

    /* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
    S32 *api4_satd_pu[HAD_32x32 + 1];
    S32 *api4_tu_split[HAD_32x32 + 1];
    S32 *api4_tu_early_cbf[HAD_32x32 + 1];

    S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;
    S32 *pi4_tu_split_flag = ps_prms->pi4_tu_split_flags;
    S32 *pi4_tu_early_cbf = ps_prms->pi4_tu_early_cbf;

    S32 tu_split_flag = 0;
    S32 total_satd_cost = 0;

    U08 *pu1_inp = ps_prms->pu1_inp;
    U08 *pu1_ref = ps_prms->pu1_ref;

    S32 inp_stride = ps_prms->i4_inp_stride;
    S32 ref_stride = ps_prms->i4_ref_stride;

    /* Initialize tu_split_cost to "0" */
    ps_prms->i4_tu_split_cost = 0;

    pi2_had_out = (S16 *)ps_prms->pu1_wkg_mem;

    api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
    api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[0];
    api4_satd_pu[HAD_16x16] = &ai4_satd_16x16[0];
    api4_satd_pu[HAD_32x32] = &i4_satd_32x32;

    api4_tu_split[HAD_4x4] = NULL;
    api4_tu_split[HAD_8x8] = &ai4_tu_split_8x8[0];
    api4_tu_split[HAD_16x16] = &ai4_tu_split_16x16[0];
    api4_tu_split[HAD_32x32] = &tu_split_flag;

    api4_tu_early_cbf[HAD_4x4] = NULL;
    api4_tu_early_cbf[HAD_8x8] = &ai4_tu_early_cbf_8x8[0];
    api4_tu_early_cbf[HAD_16x16] = &ai4_tu_early_cbf_16x16[0];
    api4_tu_early_cbf[HAD_32x32] = &early_cbf_flag;

    /* Call recursive 32x32 HAD module; updates satds for 4x4, 8x8, 16x16 and 32x32 */
    ihevce_had_32x32_r(
        pu1_inp,
        inp_stride,
        pu1_ref,
        ref_stride,
        pi2_had_out,
        32,
        api4_satd_pu,
        api4_tu_split,
        api4_tu_early_cbf,
        0,
        8,
        lambda,
        lambda_q_shift,
        i4_frm_qstep,
        0,
        ps_prms->u1_max_tr_depth,
        ps_prms->u1_max_tr_size,
        &(ps_prms->i4_tu_split_cost),
        ps_func_selector);

    total_satd_cost = i4_satd_32x32;

    /*The structure of the TU_SPLIT flag for the current 32x32 is as follows
    TL_16x16 - 5bits (4 for child and LSBit for 16x16 split)
    TR_16x16 - 5bits (4 for child and LSBit for 16x16 split)
    BL_16x16 - 5bits (4 for child and LSBit for 16x16 split)
    BR_16x16 - 5bits (4 for child and LSBit for 16x16 split)
    32x32_split - 1bit (LSBit)

    TU_SPLIT : (TL_16x16)_(TR_16x16)_(BL_16x16)_(BR_16x16)_32x32_split (21bits)*/

    pi4_sad_grid[PART_ID_2Nx2N] = total_satd_cost;
    pi4_tu_split_flag[PART_ID_2Nx2N] = tu_split_flag;
    pi4_tu_early_cbf[PART_ID_2Nx2N] = early_cbf_flag;

    return total_satd_cost;
}

/**
********************************************************************************
*  @fn     S32 hme_evalsatd_pt_pu_64x64
*
*  @brief  Evaluates the SATD with partial updates for all the best partitions
*          of a 64x64 CU based on accumulated Hadamard 32x32 and 16x16 satds
*
*           Note : 64x64 SATD does not do hadamard Transform using 32x32 hadamard
*                  outputs but directly uses four 32x32 SATD and 16 16x16 SATDS as
*                  TU size of 64 is not supported in HEVC
*
*  @param[inout]  ps_prms: error prms containg current and ref ptr, strides,
*                 pointer to sad grid of each partitions
*
*  @return     None
********************************************************************************
*/

void hme_evalsatd_pt_pu_64x64(err_prms_t *ps_prms)
{
    //S32 ai4_satd_4x4[4][64];   /* num 4x4s in a 32x32 * num 32x32 in 64x64 */
    S32 ai4_satd_8x8[4][16]; /* num 8x8s in a 32x32 * num 32x32 in 64x64 */
    S32 ai4_satd_16x16[4][4]; /* num 16x16 in a 32x32* num 32x32 in 64x64 */
    S32 ai4_satd_32x32[4]; /* num 32x32 in 64x64 */
    //    S16 ai2_had_out[32*32];
    S32 i, j;

    //  S32 ai4_tu_split_8x8[4][16];
    //  S32 ai4_tu_split_16x16[4][4];
    //  S32 ai4_tu_split_32x32[4];

    /* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
    S32 *api4_satd_pu[HAD_32x32 + 1];
    //  S32 *api4_tu_split[HAD_32x32 + 1];

    S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;

    U08 *pu1_inp = ps_prms->pu1_inp;
    U08 *pu1_ref = ps_prms->pu1_ref;
    U08 *pu1_src;
    U08 *pu1_pred;

    S32 inp_stride = ps_prms->i4_inp_stride;
    S32 ref_stride = ps_prms->i4_ref_stride;

    for(i = 0; i < 4; i++)
    {
        S32 blkx = (i & 0x1);
        S32 blky = (i >> 1);
        U08 *pu1_pi0, *pu1_pi1;

        //api4_satd_pu[HAD_4x4]   = &ai4_satd_4x4[i][0];
        api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[i][0];
        api4_satd_pu[HAD_16x16] = &ai4_satd_16x16[i][0];
        api4_satd_pu[HAD_32x32] = &ai4_satd_32x32[i];

        pu1_pi0 = pu1_inp + (blkx * 32) + (blky * 32 * inp_stride);
        pu1_pi1 = pu1_ref + (blkx * 32) + (blky * 32 * ref_stride);

        /* 64x64 SATD is calculates as the sum of the 4 16x16's in the block */
        for(j = 0; j < 16; j++)
        {
            pu1_src = pu1_pi0 + ((j & 0x3) << 3) + ((j >> 2) * inp_stride * 8);

            pu1_pred = pu1_pi1 + ((j & 0x3) << 3) + ((j >> 2) * ref_stride * 8);

            ai4_satd_8x8[i][j] = ps_prms->ps_cmn_utils_optimised_function_list->pf_HAD_8x8_8bit(
                pu1_src, inp_stride, pu1_pred, ref_stride, NULL, 1);
        }

        /* Modified to cost calculation using only 8x8 SATD for 32x32*/
        ai4_satd_16x16[i][0] =
            ai4_satd_8x8[i][0] + ai4_satd_8x8[i][1] + ai4_satd_8x8[i][4] + ai4_satd_8x8[i][5];
        ai4_satd_16x16[i][1] =
            ai4_satd_8x8[i][2] + ai4_satd_8x8[i][3] + ai4_satd_8x8[i][6] + ai4_satd_8x8[i][7];
        ai4_satd_16x16[i][2] =
            ai4_satd_8x8[i][8] + ai4_satd_8x8[i][9] + ai4_satd_8x8[i][12] + ai4_satd_8x8[i][13];
        ai4_satd_16x16[i][3] =
            ai4_satd_8x8[i][10] + ai4_satd_8x8[i][11] + ai4_satd_8x8[i][14] + ai4_satd_8x8[i][15];
    }

    /* Modified to cost calculation using only 8x8 SATD for 32x32*/

    ai4_satd_32x32[0] =
        ai4_satd_16x16[0][0] + ai4_satd_16x16[0][1] + ai4_satd_16x16[0][2] + ai4_satd_16x16[0][3];
    ai4_satd_32x32[1] =
        ai4_satd_16x16[1][0] + ai4_satd_16x16[1][1] + ai4_satd_16x16[1][2] + ai4_satd_16x16[1][3];
    ai4_satd_32x32[2] =
        ai4_satd_16x16[2][0] + ai4_satd_16x16[2][1] + ai4_satd_16x16[2][2] + ai4_satd_16x16[2][3];
    ai4_satd_32x32[3] =
        ai4_satd_16x16[3][0] + ai4_satd_16x16[3][1] + ai4_satd_16x16[3][2] + ai4_satd_16x16[3][3];

    /* Update 64x64 SATDs */
    pi4_sad_grid[PART_ID_2Nx2N] =
        ai4_satd_32x32[0] + ai4_satd_32x32[1] + ai4_satd_32x32[2] + ai4_satd_32x32[3];

    /* Update 32x32 SATDs */
    pi4_sad_grid[PART_ID_NxN_TL] = ai4_satd_32x32[0];
    pi4_sad_grid[PART_ID_NxN_TR] = ai4_satd_32x32[1];
    pi4_sad_grid[PART_ID_NxN_BL] = ai4_satd_32x32[2];
    pi4_sad_grid[PART_ID_NxN_BR] = ai4_satd_32x32[3];

    /* Update 32x64 / 64x32 SATDs */
    pi4_sad_grid[PART_ID_Nx2N_L] = ai4_satd_32x32[0] + ai4_satd_32x32[2];
    pi4_sad_grid[PART_ID_Nx2N_R] = ai4_satd_32x32[1] + ai4_satd_32x32[3];
    pi4_sad_grid[PART_ID_2NxN_T] = ai4_satd_32x32[0] + ai4_satd_32x32[1];
    pi4_sad_grid[PART_ID_2NxN_B] = ai4_satd_32x32[2] + ai4_satd_32x32[3];

    /* Update AMP SATDs 64x48,64x16, 48x64,16x64  */
    pi4_sad_grid[PART_ID_nLx2N_L] =
        ai4_satd_16x16[0][0] + ai4_satd_16x16[0][2] + ai4_satd_16x16[2][0] + ai4_satd_16x16[2][2];

    pi4_sad_grid[PART_ID_nLx2N_R] = ai4_satd_16x16[0][1] + ai4_satd_16x16[0][3] +
                                    ai4_satd_16x16[2][1] + ai4_satd_16x16[2][3] +
                                    pi4_sad_grid[PART_ID_Nx2N_R];

    pi4_sad_grid[PART_ID_nRx2N_L] = ai4_satd_16x16[1][0] + ai4_satd_16x16[1][2] +
                                    ai4_satd_16x16[3][0] + ai4_satd_16x16[3][2] +
                                    pi4_sad_grid[PART_ID_Nx2N_L];

    pi4_sad_grid[PART_ID_nRx2N_R] =
        ai4_satd_16x16[1][1] + ai4_satd_16x16[1][3] + ai4_satd_16x16[3][1] + ai4_satd_16x16[3][3];

    pi4_sad_grid[PART_ID_2NxnU_T] =
        ai4_satd_16x16[0][0] + ai4_satd_16x16[0][1] + ai4_satd_16x16[1][0] + ai4_satd_16x16[1][1];

    pi4_sad_grid[PART_ID_2NxnU_B] = ai4_satd_16x16[0][2] + ai4_satd_16x16[0][3] +
                                    ai4_satd_16x16[1][2] + ai4_satd_16x16[1][3] +
                                    pi4_sad_grid[PART_ID_2NxN_B];

    pi4_sad_grid[PART_ID_2NxnD_T] = ai4_satd_16x16[2][0] + ai4_satd_16x16[2][1] +
                                    ai4_satd_16x16[3][0] + ai4_satd_16x16[3][1] +
                                    pi4_sad_grid[PART_ID_2NxN_T];

    pi4_sad_grid[PART_ID_2NxnD_B] =
        ai4_satd_16x16[2][2] + ai4_satd_16x16[2][3] + ai4_satd_16x16[3][2] + ai4_satd_16x16[3][3];
}

WORD32 hme_evalsatd_pt_pu_64x64_tu_rec(
    err_prms_t *ps_prms,
    WORD32 lambda,
    WORD32 lambda_q_shift,
    WORD32 i4_frm_qstep,
    me_func_selector_t *ps_func_selector)
{
    S32 ai4_satd_4x4[64]; /* num 4x4s in a 32x32 * num 32x32 in 64x64 */
    S32 ai4_satd_8x8[16]; /* num 8x8s in a 32x32 * num 32x32 in 64x64 */
    S32 ai4_satd_16x16[4]; /* num 16x16 in a 32x32* num 32x32 in 64x64 */
    S32 ai4_satd_32x32[4]; /* num 32x32 in 64x64 */

    S32 ai4_tu_split_8x8[16];
    S32 ai4_tu_split_16x16[4];

    S32 ai4_tu_early_cbf_8x8[16];
    S32 ai4_tu_early_cbf_16x16[4];

    S16 *pi2_had_out;
    S32 i;

    /* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
    S32 *api4_satd_pu[HAD_32x32 + 1];
    S32 *api4_tu_split[HAD_32x32 + 1];
    S32 *api4_tu_early_cbf[HAD_32x32 + 1];

    S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;

    S32 tu_split_flag = 0;
    S32 total_satd_cost = 0;

    U08 *pu1_inp = ps_prms->pu1_inp;
    U08 *pu1_ref = ps_prms->pu1_ref;

    S32 inp_stride = ps_prms->i4_inp_stride;
    S32 ref_stride = ps_prms->i4_ref_stride;

    /* Initialize tu_split_cost to "0" */
    ps_prms->i4_tu_split_cost = 0;

    pi2_had_out = (S16 *)ps_prms->pu1_wkg_mem;

    for(i = 0; i < 4; i++)
    {
        S32 blkx = (i & 0x1);
        S32 blky = (i >> 1);
        U08 *pu1_pi0, *pu1_pi1;
        tu_split_flag = 0;

        api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
        api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[0];
        api4_satd_pu[HAD_16x16] = &ai4_satd_16x16[0];
        api4_satd_pu[HAD_32x32] = &ai4_satd_32x32[i];

        api4_tu_split[HAD_4x4] = NULL;
        api4_tu_split[HAD_8x8] = &ai4_tu_split_8x8[0];
        api4_tu_split[HAD_16x16] = &ai4_tu_split_16x16[0];
        api4_tu_split[HAD_32x32] = &ps_prms->pi4_tu_split_flags[i];

        api4_tu_early_cbf[HAD_4x4] = NULL;
        api4_tu_early_cbf[HAD_8x8] = &ai4_tu_early_cbf_8x8[0];
        api4_tu_early_cbf[HAD_16x16] = &ai4_tu_early_cbf_16x16[0];
        api4_tu_early_cbf[HAD_32x32] = &ps_prms->pi4_tu_early_cbf[i];

        pu1_pi0 = pu1_inp + (blkx * 32) + (blky * 32 * inp_stride);
        pu1_pi1 = pu1_ref + (blkx * 32) + (blky * 32 * ref_stride);

        /* Call recursive 32x32 HAD module; updates satds for 4x4, 8x8, 16x16 and 32x32 */
        ihevce_had_32x32_r(
            pu1_pi0,
            inp_stride,
            pu1_pi1,
            ref_stride,
            pi2_had_out,
            32,
            api4_satd_pu,
            api4_tu_split,
            api4_tu_early_cbf,
            0,
            8,
            lambda,
            lambda_q_shift,
            i4_frm_qstep,
            1,
            ps_prms->u1_max_tr_depth,
            ps_prms->u1_max_tr_size,
            &(ps_prms->i4_tu_split_cost),
            ps_func_selector);
    }

    total_satd_cost = ai4_satd_32x32[0] + ai4_satd_32x32[1] + ai4_satd_32x32[2] + ai4_satd_32x32[3];

    /* Update 64x64 SATDs */
    pi4_sad_grid[PART_ID_2Nx2N] =
        ai4_satd_32x32[0] + ai4_satd_32x32[1] + ai4_satd_32x32[2] + ai4_satd_32x32[3];

    return total_satd_cost;
}

/**
********************************************************************************
*  @fn     void hme_subpel_refine_search_node(search_node_t *ps_search_node,
*                                   hme_subpel_prms_t *ps_prms,
*                                   layer_ctxt_t *ps_curr_layer,
*                                   BLK_SIZE_T e_blk_size,
*                                   S32 x_off,
*                                   S32 y_off)
*
*  @brief  Refines a given partition within a CU
*
*  @param[in,out]  ps_search_node: supplies starting mv and also ref id.
*                   updated with the accurate subpel mv
*
*  @param[in]  ps_prms: subpel prms input to this function
*
*  @param[in]  ps_curr_layer : layer context
*
*  @param[in]  e_blk_size : Block size enumeration
*
*  @param[in]  x_off : x offset of the partition w.r.t. pic start
*
*  @param[in]  y_off : y offset of the partition w.r.t. pic start
*
*  @return None
********************************************************************************
*/

static __inline PF_SAD_RESULT_FXN_T hme_get_calc_sad_and_result_subpel_fxn(
    me_func_selector_t *ps_func_selector,
    ihevce_me_optimised_function_list_t *ps_me_optimised_function_list,
    S32 i4_part_mask,
    U08 u1_use_satd,
    U08 u1_num_parts,
    U08 u1_num_results)
{
    PF_SAD_RESULT_FXN_T pf_err_compute;

    ASSERT((1 == u1_num_results) || (2 == u1_num_results));

    if(1 == u1_num_results)
    {
        if(u1_use_satd)
        {
            if(u1_num_parts == 1)
            {
                pf_err_compute =
                    ps_func_selector->pf_evalsatd_update_1_best_result_pt_pu_16x16_num_part_eq_1;
            }
            else if((u1_num_parts > 1) && (u1_num_parts <= 8))
            {
                pf_err_compute =
                    ps_func_selector->pf_evalsatd_update_1_best_result_pt_pu_16x16_num_part_lt_9;
            }
            else
            {
                pf_err_compute =
                    ps_func_selector->pf_evalsatd_update_1_best_result_pt_pu_16x16_num_part_lt_17;
            }
        }
        else
        {
            if(u1_num_parts == 1)
            {
                pf_err_compute = ps_me_optimised_function_list
                                     ->pf_calc_sad_and_1_best_result_subpel_num_part_eq_1;
            }
            else if(((i4_part_mask & ENABLE_SQUARE_PARTS) != 0) && (u1_num_parts == 5))
            {
                pf_err_compute =
                    ps_me_optimised_function_list->pf_calc_sad_and_1_best_result_subpel_square_parts;
            }
            else if((u1_num_parts > 1) && (u1_num_parts <= 8))
            {
                pf_err_compute = ps_me_optimised_function_list
                                     ->pf_calc_sad_and_1_best_result_subpel_num_part_lt_9;
            }
            else
            {
                pf_err_compute = ps_me_optimised_function_list
                                     ->pf_calc_sad_and_1_best_result_subpel_num_part_lt_17;
            }
        }
    }
    else
    {
        if(u1_use_satd)
        {
            if(u1_num_parts == 1)
            {
                pf_err_compute =
                    ps_func_selector->pf_evalsatd_update_2_best_results_pt_pu_16x16_num_part_eq_1;
            }
            else if((u1_num_parts > 1) && (u1_num_parts <= 8))
            {
                pf_err_compute =
                    ps_func_selector->pf_evalsatd_update_2_best_results_pt_pu_16x16_num_part_lt_9;
            }
            else
            {
                pf_err_compute =
                    ps_func_selector->pf_evalsatd_update_2_best_results_pt_pu_16x16_num_part_lt_17;
            }
        }
        else
        {
            if(u1_num_parts == 1)
            {
                pf_err_compute = ps_me_optimised_function_list
                                     ->pf_calc_sad_and_2_best_results_subpel_num_part_eq_1;
            }
            else if(((i4_part_mask & ENABLE_SQUARE_PARTS) != 0) && (u1_num_parts == 5))
            {
                pf_err_compute = ps_me_optimised_function_list
                                     ->pf_calc_sad_and_2_best_results_subpel_square_parts;
            }
            else if((u1_num_parts > 1) && (u1_num_parts <= 8))
            {
                pf_err_compute = ps_me_optimised_function_list
                                     ->pf_calc_sad_and_2_best_results_subpel_num_part_lt_9;
            }
            else
            {
                pf_err_compute = ps_me_optimised_function_list
                                     ->pf_calc_sad_and_2_best_results_subpel_num_part_lt_17;
            }
        }
    }

    return pf_err_compute;
}

#if DIAMOND_GRID == 1
S32 hme_subpel_refine_search_node_high_speed(
    search_node_t *ps_search_node,
    hme_subpel_prms_t *ps_prms,
    layer_ctxt_t *ps_curr_layer,
    BLK_SIZE_T e_blk_size,
    S32 x_off,
    S32 y_off,
    search_results_t *ps_search_results,
    S32 pred_lx,
    S32 i4_part_mask,
    S32 *pi4_valid_part_ids,
    S32 search_idx,
    subpel_dedup_enabler_t *ps_dedup_enabler,
    me_func_selector_t *ps_func_selector,
    ihevce_me_optimised_function_list_t *ps_me_optimised_function_list)
{
    S32 i4_num_hpel_refine, i4_num_qpel_refine;
    S32 i4_offset, i4_grid_mask;
    S08 i1_ref_idx;
    S32 i4_blk_wd, i4_blk_ht;
    S32 i4_ref_stride, i4_i;
    pred_ctxt_t *ps_pred_ctxt = &ps_search_results->as_pred_ctxt[pred_lx];
    result_upd_prms_t s_result_prms;
    search_node_t s_temp_search_node;

    /*************************************************************************/
    /* Tracks current MV with the fractional component.                      */
    /*************************************************************************/
    S32 i4_mv_x, i4_mv_y;
    S32 i4_frac_x, i4_frac_y;

    /*************************************************************************/
    /* Function pointer for SAD/SATD, array and prms structure to pass to    */
    /* This function                                                         */
    /*************************************************************************/
    PF_SAD_RESULT_FXN_T pf_err_compute;

    S32 ai4_sad_grid[17], i4_tot_cost;
    err_prms_t s_err_prms;

    /*************************************************************************/
    /* Allowed MV RANGE                                                      */
    /*************************************************************************/
    range_prms_t *ps_range_prms;

    /*************************************************************************/
    /* stores min id in grid with associated min cost.                       */
    /*************************************************************************/
    S32 i4_min_cost, i4_min_sad;
    GRID_PT_T e_min_id;

    PF_INTERP_FXN_T pf_qpel_interp;
    /*************************************************************************/
    /* For hpel and qpel we move in diamonds and hence each point in the     */
    /* diamond will belong to a completely different plane. To simplify the  */
    /* look up of the ref ptr, we declare a 2x2 array of ref ptrs for the    */
    /* hpel planes which are interpolated during recon.                      */
    /*************************************************************************/
    U08 *apu1_hpel_ref[4], *pu1_ref;

    interp_prms_t s_interp_prms;

    /*************************************************************************/
    /* Maintains the minimum id of interpolated buffers, and the pointer that*/
    /* points to the corresponding predicted buf with its stride.            */
    /* Note that the pointer cannot be derived just from the id, since the   */
    /* pointer may also point to the hpel buffer (in case we request interp  */
    /* of a hpel pt, which already exists in the recon hpel planes)          */
    /*************************************************************************/
    U08 *pu1_final_out;
    S32 i4_final_out_stride;
    S32 part_id;
    S32 check_for_duplicate = 0;

    subpel_refine_ctxt_t *ps_subpel_refine_ctxt = ps_prms->ps_subpel_refine_ctxt;

    S32 mvx_qpel;
    S32 mvy_qpel;

    pf_err_compute = hme_get_calc_sad_and_result_subpel_fxn(
        ps_func_selector,
        ps_me_optimised_function_list,
        i4_part_mask,
        ps_prms->i4_use_satd,
        ps_subpel_refine_ctxt->i4_num_valid_parts,
        ps_search_results->u1_num_results_per_part);

    i4_num_hpel_refine = ps_prms->i4_num_steps_hpel_refine;
    i4_num_qpel_refine = ps_prms->i4_num_steps_qpel_refine;

    /* Prediction contet should now deal with qpel units */
    HME_SET_MVPRED_RES(ps_pred_ctxt, MV_RES_QPEL);

    /* Buffer allocation for subpel */
    /* Current design is that there may be many partitions and different mvs */
    /* that attempt subpel refinemnt. While there is possibility of overlap, the */
    /* hashing to detect and avoid overlap may be very complex. So, currently,   */
    /* the only thing done is to store the eventual predicted buffer with every  */
    /* ctb node that holds the result of hte best subpel search */

    /* Compute the base pointer for input, interpolated buffers */
    /* The base pointers point as follows: */
    /* fx fy : 0, 0 :: fx, hy : 0, 0.5, hx, fy: 0.5, 0, hx, fy: 0.5, 0.5 */
    /* To these, we need to add the offset of the current node */
    i4_ref_stride = ps_curr_layer->i4_rec_stride;
    i4_offset = x_off + (y_off * i4_ref_stride);
    i1_ref_idx = ps_search_node->i1_ref_idx;

    apu1_hpel_ref[0] = ps_curr_layer->ppu1_list_rec_fxfy[i1_ref_idx] + i4_offset;
    apu1_hpel_ref[1] = ps_curr_layer->ppu1_list_rec_hxfy[i1_ref_idx] + i4_offset;
    apu1_hpel_ref[2] = ps_curr_layer->ppu1_list_rec_fxhy[i1_ref_idx] + i4_offset;
    apu1_hpel_ref[3] = ps_curr_layer->ppu1_list_rec_hxhy[i1_ref_idx] + i4_offset;

    /* Initialize result params used for partition update */
    s_result_prms.pf_mv_cost_compute = NULL;
    s_result_prms.ps_search_results = ps_search_results;
    s_result_prms.pi4_valid_part_ids = pi4_valid_part_ids;
    s_result_prms.i1_ref_idx = ps_search_node->i1_ref_idx;
    s_result_prms.u1_pred_lx = search_idx;
    s_result_prms.i4_part_mask = i4_part_mask;
    s_result_prms.ps_search_node_base = ps_search_node;
    s_result_prms.pi4_sad_grid = &ai4_sad_grid[0];
    s_result_prms.i4_grid_mask = 1;
    s_result_prms.ps_search_node = &s_temp_search_node;
    s_temp_search_node.i1_ref_idx = ps_search_node->i1_ref_idx;

    /* convert to hpel units */
    i4_mv_x = ps_search_node->s_mv.i2_mvx >> 1;
    i4_mv_y = ps_search_node->s_mv.i2_mvy >> 1;

    /* for first pt, we compute at all locations in the grid, 4 + 1 centre */
    ps_range_prms = ps_prms->aps_mv_range_qpel[i1_ref_idx];
    i4_grid_mask = (GRID_DIAMOND_ENABLE_ALL);
    i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 2, ps_range_prms);

    i4_min_cost = MAX_32BIT_VAL;
    i4_min_sad = MAX_32BIT_VAL;

    /*************************************************************************/
    /* Prepare the input params to SAD/SATD function. Note that input is     */
    /* passed from the calling funcion since it may be I (normal subpel      */
    /* refinement) or 2I - P0 in case of bidirect subpel refinement.         */
    /* Both cases are handled here.                                          */
    /*************************************************************************/
    s_err_prms.pu1_inp = (U08 *)ps_prms->pv_inp;
    s_err_prms.i4_inp_stride = ps_prms->i4_inp_stride;
    s_err_prms.i4_ref_stride = i4_ref_stride;
    s_err_prms.i4_part_mask = (ENABLE_2Nx2N);
    s_err_prms.i4_grid_mask = 1;
    s_err_prms.pi4_sad_grid = &ai4_sad_grid[0];
    s_err_prms.i4_blk_wd = i4_blk_wd = gau1_blk_size_to_wd[e_blk_size];
    s_err_prms.i4_blk_ht = i4_blk_ht = gau1_blk_size_to_ht[e_blk_size];

    s_result_prms.ps_subpel_refine_ctxt = ps_subpel_refine_ctxt;

    part_id = ps_search_node->u1_part_id;
    for(i4_i = 0; i4_i < i4_num_hpel_refine; i4_i++)
    {
        e_min_id = PT_C;

        mvx_qpel = i4_mv_x << 1;
        mvy_qpel = i4_mv_y << 1;

        /* Central pt */
        if(i4_grid_mask & BIT_EN(PT_C))
        {
            //ps_search_node->i2_mv_x = (S16)i4_mv_x;
            //ps_search_node->i2_mv_x = (S16)i4_mv_y;
            /* central pt is i4_mv_x, i4_mv_y */
            CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                ps_dedup_enabler, 1, mvx_qpel, mvy_qpel, check_for_duplicate);

            i4_frac_x = i4_mv_x & 1;
            i4_frac_y = i4_mv_y & 1;
            pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
            s_err_prms.pu1_ref = pu1_ref + (i4_mv_x >> 1) + ((i4_mv_y >> 1) * i4_ref_stride);

            /* Update the mv's with the current candt motion vectors */
            s_result_prms.i2_mv_x = mvx_qpel;
            s_result_prms.i2_mv_y = mvy_qpel;
            s_temp_search_node.s_mv.i2_mvx = mvx_qpel;
            s_temp_search_node.s_mv.i2_mvy = mvy_qpel;

            pf_err_compute(&s_err_prms, &s_result_prms);

            i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
            if(i4_tot_cost < i4_min_cost)
            {
                i4_min_cost = i4_tot_cost;
                i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                e_min_id = PT_C;
                pu1_final_out = s_err_prms.pu1_ref;
            }
        }

        /* left pt */
        if(i4_grid_mask & BIT_EN(PT_L))
        {
            CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                ps_dedup_enabler, 1, mvx_qpel - 2, mvy_qpel, check_for_duplicate);

            if(!check_for_duplicate)
            {
                /* search node mv is stored in qpel units */
                ps_search_node->s_mv.i2_mvx = (S16)((i4_mv_x - 1) << 1);
                ps_search_node->s_mv.i2_mvy = (S16)(i4_mv_y << 1);
                /* central pt is i4_mv_x - 1, i4_mv_y */
                i4_frac_x = (i4_mv_x - 1) & 1;  // same as (x-1)&1
                i4_frac_y = i4_mv_y & 1;
                pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
                s_err_prms.pu1_ref =
                    pu1_ref + ((i4_mv_x - 1) >> 1) + ((i4_mv_y >> 1) * i4_ref_stride);

                /* Update the mv's with the current candt motion vectors */
                s_result_prms.i2_mv_x = mvx_qpel - 2;
                s_result_prms.i2_mv_y = mvy_qpel;
                s_temp_search_node.s_mv.i2_mvx = mvx_qpel - 2;
                s_temp_search_node.s_mv.i2_mvy = mvy_qpel;

                pf_err_compute(&s_err_prms, &s_result_prms);
                //hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
                i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
                if(i4_tot_cost < i4_min_cost)
                {
                    i4_min_cost = i4_tot_cost;
                    i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    e_min_id = PT_L;
                    pu1_final_out = s_err_prms.pu1_ref;
                }
            }
        }
        /* top pt */
        if(i4_grid_mask & BIT_EN(PT_T))
        {
            CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                ps_dedup_enabler, 1, mvx_qpel, mvy_qpel - 2, check_for_duplicate);

            if(!check_for_duplicate)
            {
                /* search node mv is stored in qpel units */
                ps_search_node->s_mv.i2_mvx = (S16)(i4_mv_x << 1);
                ps_search_node->s_mv.i2_mvy = (S16)((i4_mv_y - 1) << 1);
                /* top pt is i4_mv_x, i4_mv_y - 1 */
                i4_frac_x = i4_mv_x & 1;
                i4_frac_y = (i4_mv_y - 1) & 1;
                pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
                s_err_prms.pu1_ref =
                    pu1_ref + (i4_mv_x >> 1) + (((i4_mv_y - 1) >> 1) * i4_ref_stride);

                /* Update the mv's with the current candt motion vectors */
                s_result_prms.i2_mv_x = mvx_qpel;
                s_result_prms.i2_mv_y = mvy_qpel - 2;
                s_temp_search_node.s_mv.i2_mvx = mvx_qpel;
                s_temp_search_node.s_mv.i2_mvy = mvy_qpel - 2;

                pf_err_compute(&s_err_prms, &s_result_prms);
                //hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
                i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
                if(i4_tot_cost < i4_min_cost)
                {
                    i4_min_cost = i4_tot_cost;
                    i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    e_min_id = PT_T;
                    pu1_final_out = s_err_prms.pu1_ref;
                }
            }
        }
        /* right pt */
        if(i4_grid_mask & BIT_EN(PT_R))
        {
            CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                ps_dedup_enabler, num_unique_nodes, mvx_qpel + 2, mvy_qpel, check_for_duplicate);
            if(!check_for_duplicate)
            {
                /* search node mv is stored in qpel units */
                ps_search_node->s_mv.i2_mvx = (S16)((i4_mv_x + 1) << 1);
                ps_search_node->s_mv.i2_mvy = (S16)(i4_mv_y << 1);
                /* right pt is i4_mv_x + 1, i4_mv_y */
                i4_frac_x = (i4_mv_x + 1) & 1;
                i4_frac_y = i4_mv_y & 1;

                pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
                s_err_prms.pu1_ref =
                    pu1_ref + ((i4_mv_x + 1) >> 1) + ((i4_mv_y >> 1) * i4_ref_stride);

                /* Update the mv's with the current candt motion vectors */
                s_result_prms.i2_mv_x = mvx_qpel + 2;
                s_result_prms.i2_mv_y = mvy_qpel;
                s_temp_search_node.s_mv.i2_mvx = mvx_qpel + 2;
                s_temp_search_node.s_mv.i2_mvy = mvy_qpel;

                pf_err_compute(&s_err_prms, &s_result_prms);
                //hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
                i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
                if(i4_tot_cost < i4_min_cost)
                {
                    i4_min_cost = i4_tot_cost;
                    i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    e_min_id = PT_R;
                    pu1_final_out = s_err_prms.pu1_ref;
                }
            }
        }
        /* bottom pt */
        if(i4_grid_mask & BIT_EN(PT_B))
        {
            CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                ps_dedup_enabler, num_unique_nodes, mvx_qpel, mvy_qpel + 2, check_for_duplicate);
            if(!check_for_duplicate)
            {
                /* search node mv is stored in qpel units */
                ps_search_node->s_mv.i2_mvx = ((S16)i4_mv_x << 1);
                ps_search_node->s_mv.i2_mvy = ((S16)(i4_mv_y + 1) << 1);
                i4_frac_x = i4_mv_x & 1;
                i4_frac_y = (i4_mv_y + 1) & 1;
                pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
                s_err_prms.pu1_ref =
                    pu1_ref + (i4_mv_x >> 1) + (((i4_mv_y + 1) >> 1) * i4_ref_stride);

                /* Update the mv's with the current candt motion vectors */
                s_result_prms.i2_mv_x = mvx_qpel;
                s_result_prms.i2_mv_y = mvy_qpel + 2;
                s_temp_search_node.s_mv.i2_mvx = mvx_qpel;
                s_temp_search_node.s_mv.i2_mvy = mvy_qpel + 2;

                pf_err_compute(&s_err_prms, &s_result_prms);
                //hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
                i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
                if(i4_tot_cost < i4_min_cost)
                {
                    i4_min_cost = i4_tot_cost;
                    i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    e_min_id = PT_B;
                    pu1_final_out = s_err_prms.pu1_ref;
                }
            }
        }
        /* Early exit in case of central point */
        if(e_min_id == PT_C)
            break;

        /*********************************************************************/
        /* Depending on the best result location, we may be able to skip     */
        /* atleast two pts, centre pt and one more pt. E.g. if right pt is   */
        /* the best result, the next iteration need not do centre, left pts  */
        /*********************************************************************/
        i4_grid_mask = gai4_opt_grid_mask_diamond[e_min_id];
        i4_mv_x += gai1_grid_id_to_x[e_min_id];
        i4_mv_y += gai1_grid_id_to_y[e_min_id];
        ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
        ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
        i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 2, ps_range_prms);
    }

    /* Convert to QPEL units */
    i4_mv_x <<= 1;
    i4_mv_y <<= 1;

    ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
    ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;

    /* Exact interpolation or averaging chosen here */
    pf_qpel_interp = ps_prms->pf_qpel_interp;

    /* Next QPEL ME */
    /* In this case, we have option of doing exact QPEL interpolation or avg */
    /*************************************************************************/
    /*        x                                                              */
    /*    A b C d                                                            */
    /*    e f g h                                                            */
    /*    I j K l                                                            */
    /*    m n o p                                                            */
    /*    Q r S t                                                            */
    /*                                                                       */
    /*    Approximate QPEL logic                                             */
    /*    b = avg(A,C) f = avg(I,C), g= avg(C,K) j=avg(I,K)                  */
    /*    for any given pt, we can get all the information required about    */
    /*    the surrounding 4 pts. For example, given point C (0.5, 0)         */
    /*     surrounding pts info:                                             */
    /*     b : qpel offset: 1, 0, generated by averaging. buffer1: fpel buf  */
    /*           buffer 2: hxfy, offsets for both are 0, 0                   */
    /*    similarly for other pts the info can be gotten                     */
    /*************************************************************************/
    i4_grid_mask = GRID_DIAMOND_ENABLE_ALL ^ (BIT_EN(PT_C));
    i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 1, ps_range_prms);

    /*************************************************************************/
    /* One time preparation of non changing interpolation params. These      */
    /* include a set of ping pong result buf ptrs, input buf ptrs and some   */
    /* working memory (not used though in case of averaging).                */
    /*************************************************************************/
    s_interp_prms.ppu1_ref = &apu1_hpel_ref[0];
    s_interp_prms.i4_ref_stride = i4_ref_stride;
    s_interp_prms.i4_blk_wd = i4_blk_wd;
    s_interp_prms.i4_blk_ht = i4_blk_ht;

    i4_final_out_stride = i4_ref_stride;

    {
        U08 *pu1_mem;
        /*********************************************************************/
        /* Allocation of working memory for interpolated buffers. We maintain*/
        /* an intermediate working buffer, and 2 ping pong interpolated out  */
        /* buffers, purpose of ping pong explained later below               */
        /*********************************************************************/
        pu1_mem = ps_prms->pu1_wkg_mem;
        s_interp_prms.pu1_wkg_mem = pu1_mem;

        //pu1_mem += (INTERP_INTERMED_BUF_SIZE);
        s_interp_prms.apu1_interp_out[0] = pu1_mem;

        pu1_mem += (INTERP_OUT_BUF_SIZE);
        s_interp_prms.apu1_interp_out[1] = pu1_mem;

        pu1_mem += (INTERP_OUT_BUF_SIZE);
        s_interp_prms.apu1_interp_out[2] = pu1_mem;

        pu1_mem += (INTERP_OUT_BUF_SIZE);
        s_interp_prms.apu1_interp_out[3] = pu1_mem;

        pu1_mem += (INTERP_OUT_BUF_SIZE);
        s_interp_prms.apu1_interp_out[4] = pu1_mem;

        /*********************************************************************/
        /* Stride of interpolated output is just a function of blk width of  */
        /* this partition and hence remains constant for this partition      */
        /*********************************************************************/
        s_interp_prms.i4_out_stride = (i4_blk_wd);
    }

    {
        UWORD8 *apu1_final[4];
        WORD32 ai4_ref_stride[4];
        /*************************************************************************/
        /* Ping pong design for interpolated buffers. We use a min id, which     */
        /* tracks the id of the ppu1_interp_out that stores the best result.     */
        /* When new interp to be done, it uses 1 - bes result id to do the interp*/
        /* min id is toggled when any new result becomes the best result.        */
        /*************************************************************************/

        for(i4_i = 0; i4_i < i4_num_qpel_refine; i4_i++)
        {
            e_min_id = PT_C;

            mvx_qpel = i4_mv_x;
            mvy_qpel = i4_mv_y;
            hme_qpel_interp_comprehensive(
                &s_interp_prms,
                apu1_final,
                ai4_ref_stride,
                i4_mv_x,
                i4_mv_y,
                i4_grid_mask,
                ps_me_optimised_function_list);
            if(i4_grid_mask & BIT_EN(PT_L))
            {
                CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                    ps_dedup_enabler,
                    num_unique_nodes,
                    mvx_qpel - 1,
                    mvy_qpel - 0,
                    check_for_duplicate);

                if(!check_for_duplicate)
                {
                    ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x - 1;
                    ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;

                    s_err_prms.pu1_ref = apu1_final[0];
                    s_err_prms.i4_ref_stride = ai4_ref_stride[0];

                    /* Update the mv's with the current candt motion vectors */
                    s_result_prms.i2_mv_x = mvx_qpel - 1;
                    s_result_prms.i2_mv_y = mvy_qpel;
                    s_temp_search_node.s_mv.i2_mvx = mvx_qpel - 1;
                    s_temp_search_node.s_mv.i2_mvy = mvy_qpel;

                    pf_err_compute(&s_err_prms, &s_result_prms);
                    //hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                    i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
                    if(i4_tot_cost < i4_min_cost)
                    {
                        e_min_id = PT_L;
                        i4_min_cost = i4_tot_cost;
                        i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    }
                }
            }
            if(i4_grid_mask & BIT_EN(PT_T))
            {
                CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                    ps_dedup_enabler,
                    num_unique_nodes,
                    mvx_qpel - 0,
                    mvy_qpel - 1,
                    check_for_duplicate);

                if(!check_for_duplicate)
                {
                    ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
                    ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y - 1;

                    s_err_prms.pu1_ref = apu1_final[1];
                    s_err_prms.i4_ref_stride = ai4_ref_stride[1];

                    /* Update the mv's with the current candt motion vectors */
                    s_result_prms.i2_mv_x = mvx_qpel;
                    s_result_prms.i2_mv_y = mvy_qpel - 1;

                    s_temp_search_node.s_mv.i2_mvx = mvx_qpel;
                    s_temp_search_node.s_mv.i2_mvy = mvy_qpel - 1;

                    pf_err_compute(&s_err_prms, &s_result_prms);

                    //hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
                    i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
                    if(i4_tot_cost < i4_min_cost)
                    {
                        e_min_id = PT_T;
                        i4_min_cost = i4_tot_cost;
                        i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    }
                }
            }
            if(i4_grid_mask & BIT_EN(PT_R))
            {
                CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                    ps_dedup_enabler, num_unique_nodes, mvx_qpel + 1, mvy_qpel, check_for_duplicate);

                if(!check_for_duplicate)
                {
                    ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x + 1;
                    ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;

                    s_err_prms.pu1_ref = apu1_final[2];
                    s_err_prms.i4_ref_stride = ai4_ref_stride[2];

                    /* Update the mv's with the current candt motion vectors */
                    s_result_prms.i2_mv_x = mvx_qpel + 1;
                    s_result_prms.i2_mv_y = mvy_qpel;

                    s_temp_search_node.s_mv.i2_mvx = mvx_qpel + 1;
                    s_temp_search_node.s_mv.i2_mvy = mvy_qpel;

                    pf_err_compute(&s_err_prms, &s_result_prms);

                    //hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                    i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
                    if(i4_tot_cost < i4_min_cost)
                    {
                        e_min_id = PT_R;
                        i4_min_cost = i4_tot_cost;
                        i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    }
                }
            }
            /* i4_mv_x and i4_mv_y will always be the centre pt */
            /* for qpel we  start with least hpel, and hence compute of center pt never reqd */
            if(i4_grid_mask & BIT_EN(PT_B))
            {
                CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                    ps_dedup_enabler, num_unique_nodes, mvx_qpel, mvy_qpel + 1, check_for_duplicate);

                if(!check_for_duplicate)
                {
                    ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
                    ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y + 1;

                    s_err_prms.pu1_ref = apu1_final[3];
                    s_err_prms.i4_ref_stride = ai4_ref_stride[3];

                    /* Update the mv's with the current candt motion vectors */
                    s_result_prms.i2_mv_x = mvx_qpel;
                    s_result_prms.i2_mv_y = mvy_qpel + 1;

                    s_temp_search_node.s_mv.i2_mvx = mvx_qpel;
                    s_temp_search_node.s_mv.i2_mvy = mvy_qpel + 1;

                    pf_err_compute(&s_err_prms, &s_result_prms);

                    //hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
                    i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
                    if(i4_tot_cost < i4_min_cost)
                    {
                        e_min_id = PT_B;
                        i4_min_cost = i4_tot_cost;
                        i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    }
                }
            }

            /* New QPEL mv x and y */
            if(e_min_id == PT_C)
                break;
            i4_grid_mask = gai4_opt_grid_mask_diamond[e_min_id];
            i4_mv_x += gai1_grid_id_to_x[e_min_id];
            i4_mv_y += gai1_grid_id_to_y[e_min_id];
            ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
            ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
            i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 1, ps_range_prms);
        }
    }

    /* update modified motion vectors and cost at end of subpel */
    ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
    ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
    ps_search_node->i4_tot_cost = i4_min_cost;
    ps_search_node->i4_sad = i4_min_sad;

    /********************************************************************************/
    /* TODO: Restoring back Sad lambda from Hadamard lambda                         */
    /* Need to pass the had/satd lambda in more cleaner way for subpel cost compute */
    /********************************************************************************/
    //ps_pred_ctxt->lambda >>= 1;

    return (i4_min_cost);
}
#elif DIAMOND_GRID == 0
S32 hme_subpel_refine_search_node_high_speed(
    search_node_t *ps_search_node,
    hme_subpel_prms_t *ps_prms,
    layer_ctxt_t *ps_curr_layer,
    BLK_SIZE_T e_blk_size,
    S32 x_off,
    S32 y_off,
    search_results_t *ps_search_results,
    S32 pred_lx,
    S32 i4_part_mask,
    S32 *pi4_valid_part_ids,
    S32 search_idx,
    subpel_dedup_enabler_t *ps_dedup_enabler,
    me_func_selector_t *ps_func_selector)
{
    S32 i4_num_hpel_refine, i4_num_qpel_refine;
    S32 i4_offset, i4_grid_mask;
    S08 i1_ref_idx;
    S32 i4_blk_wd, i4_blk_ht;
    S32 i4_ref_stride, i4_i;
    pred_ctxt_t *ps_pred_ctxt = &ps_search_results->as_pred_ctxt[pred_lx];
    result_upd_prms_t s_result_prms;

    /*************************************************************************/
    /* Tracks current MV with the fractional component.                      */
    /*************************************************************************/
    S32 i4_mv_x, i4_mv_y;
    S32 i4_frac_x, i4_frac_y;

    /*************************************************************************/
    /* Function pointer for SAD/SATD, array and prms structure to pass to    */
    /* This function                                                         */
    /*************************************************************************/
    PF_SAD_FXN_T pf_err_compute;
    S32 ai4_sad_grid[9][17], i4_tot_cost;
    err_prms_t s_err_prms;

    /*************************************************************************/
    /* Allowed MV RANGE                                                      */
    /*************************************************************************/
    range_prms_t *ps_range_prms;

    /*************************************************************************/
    /* stores min id in grid with associated min cost.                       */
    /*************************************************************************/
    S32 i4_min_cost, i4_min_sad;
    GRID_PT_T e_min_id;

    PF_INTERP_FXN_T pf_qpel_interp;
    /*************************************************************************/
    /* For hpel and qpel we move in diamonds and hence each point in the     */
    /* diamond will belong to a completely different plane. To simplify the  */
    /* look up of the ref ptr, we declare a 2x2 array of ref ptrs for the    */
    /* hpel planes which are interpolated during recon.                      */
    /*************************************************************************/
    U08 *apu1_hpel_ref[4], *pu1_ref;

    interp_prms_t s_interp_prms;

    /*************************************************************************/
    /* Maintains the minimum id of interpolated buffers, and the pointer that*/
    /* points to the corresponding predicted buf with its stride.            */
    /* Note that the pointer cannot be derived just from the id, since the   */
    /* pointer may also point to the hpel buffer (in case we request interp  */
    /* of a hpel pt, which already exists in the recon hpel planes)          */
    /*************************************************************************/
    U08 *pu1_final_out;
    S32 i4_final_out_stride;
    S32 part_id;
    S32 check_for_duplicate = 0;

    S32 mvx_qpel;
    S32 mvy_qpel;

    /*************************************************************************/
    /* Appropriate Err compute fxn, depends on SAD/SATD, blk size and remains*/
    /* fixed through this subpel refinement for this partition.              */
    /* Note, we do not enable grid sads since each pt is different buffers.  */
    /* Hence, part mask is also nearly dont care and we use 2Nx2N enabled.   */
    /*************************************************************************/
    if(ps_prms->i4_use_satd)
    {
        pf_err_compute = hme_evalsatd_update_1_best_result_pt_pu_16x16;
    }
    else
    {
        pf_err_compute = hme_evalsad_grid_pu_16x16; /* hme_evalsad_pt_pu_16x16; */
    }

    i4_num_hpel_refine = ps_prms->i4_num_steps_hpel_refine;
    i4_num_qpel_refine = ps_prms->i4_num_steps_qpel_refine;

    /* Prediction contet should now deal with qpel units */
    HME_SET_MVPRED_RES(ps_pred_ctxt, MV_RES_QPEL);

    /* Buffer allocation for subpel */
    /* Current design is that there may be many partitions and different mvs */
    /* that attempt subpel refinemnt. While there is possibility of overlap, the */
    /* hashing to detect and avoid overlap may be very complex. So, currently,   */
    /* the only thing done is to store the eventual predicted buffer with every  */
    /* ctb node that holds the result of hte best subpel search */

    /* Compute the base pointer for input, interpolated buffers */
    /* The base pointers point as follows:
    /* fx fy : 0, 0 :: fx, hy : 0, 0.5, hx, fy: 0.5, 0, hx, fy: 0.5, 0.5 */
    /* To these, we need to add the offset of the current node */
    i4_ref_stride = ps_curr_layer->i4_rec_stride;
    i4_offset = x_off + (y_off * i4_ref_stride);
    i1_ref_idx = ps_search_node->i1_ref_idx;

    apu1_hpel_ref[0] = ps_curr_layer->ppu1_list_rec_fxfy[i1_ref_idx] + i4_offset;
    apu1_hpel_ref[1] = ps_curr_layer->ppu1_list_rec_hxfy[i1_ref_idx] + i4_offset;
    apu1_hpel_ref[2] = ps_curr_layer->ppu1_list_rec_fxhy[i1_ref_idx] + i4_offset;
    apu1_hpel_ref[3] = ps_curr_layer->ppu1_list_rec_hxhy[i1_ref_idx] + i4_offset;

    /* Initialize result params used for partition update */
    s_result_prms.pf_mv_cost_compute = NULL;
    s_result_prms.ps_search_results = ps_search_results;
    s_result_prms.pi4_valid_part_ids = pi4_valid_part_ids;
    s_result_prms.i1_ref_idx = search_idx;
    s_result_prms.i4_part_mask = i4_part_mask;
    s_result_prms.ps_search_node_base = ps_search_node;
    s_result_prms.pi4_sad_grid = &ai4_sad_grid[0][0];
    s_result_prms.i4_grid_mask = 1;

    /* convert to hpel units */
    i4_mv_x = ps_search_node->s_mv.i2_mvx >> 1;
    i4_mv_y = ps_search_node->s_mv.i2_mvy >> 1;

    /* for first pt, we compute at all locations in the grid, 4 + 1 centre */
    ps_range_prms = ps_prms->ps_mv_range_qpel;
    i4_grid_mask = (GRID_ALL_PTS_VALID);
    i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 2, ps_range_prms);

    i4_min_cost = MAX_32BIT_VAL;
    i4_min_sad = MAX_32BIT_VAL;

    /*************************************************************************/
    /* Prepare the input params to SAD/SATD function. Note that input is     */
    /* passed from the calling funcion since it may be I (normal subpel      */
    /* refinement) or 2I - P0 in case of bidirect subpel refinement.         */
    /* Both cases are handled here.                                          */
    /*************************************************************************/
    s_err_prms.pu1_inp = (U08 *)ps_prms->pv_inp;
    s_err_prms.i4_inp_stride = ps_prms->i4_inp_stride;
    s_err_prms.i4_ref_stride = i4_ref_stride;
    s_err_prms.i4_part_mask = (ENABLE_2Nx2N);
    s_err_prms.i4_grid_mask = 1;
    s_err_prms.pi4_sad_grid = &ai4_sad_grid[0][0];
    s_err_prms.i4_blk_wd = i4_blk_wd = gau1_blk_size_to_wd[e_blk_size];
    s_err_prms.i4_blk_ht = i4_blk_ht = gau1_blk_size_to_ht[e_blk_size];

    /* TODO: Currently doubling lambda for Hadamard Sad instead of 1.9*sadlambda */
    //ps_pred_ctxt->lambda <<= 1;
    part_id = ps_search_node->u1_part_id;
    for(i4_i = 0; i4_i < i4_num_hpel_refine; i4_i++)
    {
        e_min_id = PT_C;

        mvx_qpel = i4_mv_x << 1;
        mvy_qpel = i4_mv_y << 1;

        /* Central pt */
        if(i4_grid_mask & BIT_EN(PT_C))
        {
            //ps_search_node->i2_mv_x = (S16)i4_mv_x;
            //ps_search_node->i2_mv_x = (S16)i4_mv_y;
            /* central pt is i4_mv_x, i4_mv_y */
            CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                ps_dedup_enabler, 1, mvx_qpel, mvy_qpel, check_for_duplicate);

            i4_frac_x = i4_mv_x & 1;
            i4_frac_y = i4_mv_y & 1;
            pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
            s_err_prms.pu1_ref = pu1_ref + (i4_mv_x >> 1) + ((i4_mv_y >> 1) * i4_ref_stride);
            pf_err_compute(&s_err_prms);
            /* Update the mv's with the current candt motion vectors */
            s_result_prms.i2_mv_x = mvx_qpel;
            s_result_prms.i2_mv_y = mvy_qpel;
            hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
            i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
            if(i4_tot_cost < i4_min_cost)
            {
                i4_min_cost = i4_tot_cost;
                i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                e_min_id = PT_C;
                pu1_final_out = s_err_prms.pu1_ref;
            }
        }

        /* left pt */
        if(i4_grid_mask & BIT_EN(PT_L))
        {
            CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                ps_dedup_enabler, 1, mvx_qpel - 2, mvy_qpel, check_for_duplicate);

            if(!check_for_duplicate)
            {
                /* search node mv is stored in qpel units */
                ps_search_node->s_mv.i2_mvx = (S16)((i4_mv_x - 1) << 1);
                ps_search_node->s_mv.i2_mvy = (S16)(i4_mv_y << 1);
                /* central pt is i4_mv_x - 1, i4_mv_y */
                i4_frac_x = (i4_mv_x - 1) & 1;  // same as (x-1)&1
                i4_frac_y = i4_mv_y & 1;
                pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
                s_err_prms.pu1_ref =
                    pu1_ref + ((i4_mv_x - 1) >> 1) + ((i4_mv_y >> 1) * i4_ref_stride);

                pf_err_compute(&s_err_prms);
                /* Update the mv's with the current candt motion vectors */
                s_result_prms.i2_mv_x = mvx_qpel;
                s_result_prms.i2_mv_y = mvy_qpel;
                hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];

                if(i4_tot_cost < i4_min_cost)
                {
                    i4_min_cost = i4_tot_cost;
                    i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    e_min_id = PT_L;
                    pu1_final_out = s_err_prms.pu1_ref;
                }
            }
        }
        /* top pt */
        if(i4_grid_mask & BIT_EN(PT_T))
        {
            CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                ps_dedup_enabler, 1, mvx_qpel, mvy_qpel - 2, check_for_duplicate);

            if(!check_for_duplicate)
            {
                /* search node mv is stored in qpel units */
                ps_search_node->s_mv.i2_mvx = (S16)(i4_mv_x << 1);
                ps_search_node->s_mv.i2_mvy = (S16)((i4_mv_y - 1) << 1);
                /* top pt is i4_mv_x, i4_mv_y - 1 */
                i4_frac_x = i4_mv_x & 1;
                i4_frac_y = (i4_mv_y - 1) & 1;
                pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
                s_err_prms.pu1_ref =
                    pu1_ref + (i4_mv_x >> 1) + (((i4_mv_y - 1) >> 1) * i4_ref_stride);
                pf_err_compute(&s_err_prms);
                /* Update the mv's with the current candt motion vectors */
                s_result_prms.i2_mv_x = mvx_qpel;
                s_result_prms.i2_mv_y = mvy_qpel - 2;
                hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];

                if(i4_tot_cost < i4_min_cost)
                {
                    i4_min_cost = i4_tot_cost;
                    i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    e_min_id = PT_T;
                    pu1_final_out = s_err_prms.pu1_ref;
                }
            }
        }
        /* right pt */
        if(i4_grid_mask & BIT_EN(PT_R))
        {
            CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                ps_dedup_enabler, 1, mvx_qpel + 2, mvy_qpel, check_for_duplicate);

            if(!check_for_duplicate)
            {
                /* search node mv is stored in qpel units */
                ps_search_node->s_mv.i2_mvx = (S16)((i4_mv_x + 1) << 1);
                ps_search_node->s_mv.i2_mvy = (S16)(i4_mv_y << 1);
                /* right pt is i4_mv_x + 1, i4_mv_y */
                i4_frac_x = (i4_mv_x + 1) & 1;
                i4_frac_y = i4_mv_y & 1;

                pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
                s_err_prms.pu1_ref =
                    pu1_ref + ((i4_mv_x + 1) >> 1) + ((i4_mv_y >> 1) * i4_ref_stride);
                pf_err_compute(&s_err_prms);
                /* Update the mv's with the current candt motion vectors */
                s_result_prms.i2_mv_x = mvx_qpel + 2;
                s_result_prms.i2_mv_y = mvy_qpel;
                hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];

                if(i4_tot_cost < i4_min_cost)
                {
                    i4_min_cost = i4_tot_cost;
                    i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    e_min_id = PT_R;
                    pu1_final_out = s_err_prms.pu1_ref;
                }
            }
        }
        /* bottom pt */
        if(i4_grid_mask & BIT_EN(PT_B))
        {
            CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                ps_dedup_enabler, 1, mvx_qpel, mvy_qpel + 2, check_for_duplicate);

            if(!check_for_duplicate)
            {
                /* search node mv is stored in qpel units */
                ps_search_node->s_mv.i2_mvx = ((S16)i4_mv_x << 1);
                ps_search_node->s_mv.i2_mvy = ((S16)(i4_mv_y + 1) << 1);
                i4_frac_x = i4_mv_x & 1;
                i4_frac_y = (i4_mv_y + 1) & 1;
                pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
                s_err_prms.pu1_ref =
                    pu1_ref + (i4_mv_x >> 1) + (((i4_mv_y + 1) >> 1) * i4_ref_stride);

                pf_err_compute(&s_err_prms);
                /* Update the mv's with the current candt motion vectors */
                s_result_prms.i2_mv_x = mvx_qpel;
                s_result_prms.i2_mv_y = mvy_qpel + 2;
                hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];

                if(i4_tot_cost < i4_min_cost)
                {
                    i4_min_cost = i4_tot_cost;
                    i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    e_min_id = PT_B;
                    pu1_final_out = s_err_prms.pu1_ref;
                }
            }
        }
        if(e_min_id == PT_C)
        {
            if(!i4_i)
            {
                /* TL pt */
                if(i4_grid_mask & BIT_EN(PT_TL))
                {
                    S32 mvx_minus_1 = (i4_mv_x - 1);
                    S32 mvy_minus_1 = (i4_mv_y - 1);

                    CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                        ps_dedup_enabler, 1, mvx_qpel - 2, mvy_qpel - 2, check_for_duplicate);

                    if(!check_for_duplicate)
                    {
                        /* search node mv is stored in qpel units */
                        ps_search_node->s_mv.i2_mvx = ((S16)mvx_minus_1 << 1);
                        ps_search_node->s_mv.i2_mvy = ((S16)mvy_minus_1 << 1);
                        i4_frac_x = mvx_minus_1 & 1;
                        i4_frac_y = mvy_minus_1 & 1;
                        pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
                        s_err_prms.pu1_ref =
                            pu1_ref + (mvx_minus_1 >> 1) + ((mvy_minus_1 >> 1) * i4_ref_stride);

                        pf_err_compute(&s_err_prms);
                        /* Update the mv's with the current candt motion vectors */
                        s_result_prms.i2_mv_x = mvx_qpel - 2;
                        s_result_prms.i2_mv_y = mvy_qpel - 2;
                        hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                        i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];

                        if(i4_tot_cost < i4_min_cost)
                        {
                            i4_min_cost = i4_tot_cost;
                            i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                            e_min_id = PT_TL;
                            pu1_final_out = s_err_prms.pu1_ref;
                        }
                    }
                }
                /* TR pt */
                if(i4_grid_mask & BIT_EN(PT_TR))
                {
                    S32 mvx_plus_1 = (i4_mv_x + 1);
                    S32 mvy_minus_1 = (i4_mv_y - 1);

                    CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                        ps_dedup_enabler, 1, mvx_qpel + 2, mvy_qpel - 2, check_for_duplicate);

                    if(!check_for_duplicate)
                    {
                        /* search node mv is stored in qpel units */
                        ps_search_node->s_mv.i2_mvx = ((S16)mvx_plus_1 << 1);
                        ps_search_node->s_mv.i2_mvy = ((S16)mvy_minus_1 << 1);
                        i4_frac_x = mvx_plus_1 & 1;
                        i4_frac_y = mvy_minus_1 & 1;
                        pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
                        s_err_prms.pu1_ref =
                            pu1_ref + (mvx_plus_1 >> 1) + ((mvy_minus_1 >> 1) * i4_ref_stride);

                        pf_err_compute(&s_err_prms);
                        /* Update the mv's with the current candt motion vectors */
                        s_result_prms.i2_mv_x = mvx_qpel + 2;
                        s_result_prms.i2_mv_y = mvy_qpel - 2;
                        hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                        i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];

                        if(i4_tot_cost < i4_min_cost)
                        {
                            i4_min_cost = i4_tot_cost;
                            i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                            e_min_id = PT_TR;
                            pu1_final_out = s_err_prms.pu1_ref;
                        }
                    }
                }
                /* BL pt */
                if(i4_grid_mask & BIT_EN(PT_BL))
                {
                    S32 mvx_minus_1 = (i4_mv_x - 1);
                    S32 mvy_plus_1 = (i4_mv_y + 1);

                    CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                        ps_dedup_enabler, 1, mvx_qpel - 2, mvy_qpel + 2, check_for_duplicate);

                    if(!check_for_duplicate)
                    {
                        /* search node mv is stored in qpel units */
                        ps_search_node->s_mv.i2_mvx = ((S16)mvx_minus_1 << 1);
                        ps_search_node->s_mv.i2_mvy = ((S16)mvy_plus_1 << 1);
                        i4_frac_x = mvx_minus_1 & 1;
                        i4_frac_y = mvy_plus_1 & 1;
                        pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
                        s_err_prms.pu1_ref =
                            pu1_ref + (mvx_minus_1 >> 1) + ((mvy_plus_1 >> 1) * i4_ref_stride);

                        pf_err_compute(&s_err_prms);
                        /* Update the mv's with the current candt motion vectors */
                        s_result_prms.i2_mv_x = mvx_qpel - 2;
                        s_result_prms.i2_mv_y = mvy_qpel + 2;
                        hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                        i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];

                        if(i4_tot_cost < i4_min_cost)
                        {
                            i4_min_cost = i4_tot_cost;
                            i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                            e_min_id = PT_BL;
                            pu1_final_out = s_err_prms.pu1_ref;
                        }
                    }
                }
                /* BR pt */
                if(i4_grid_mask & BIT_EN(PT_BR))
                {
                    S32 mvx_plus_1 = (i4_mv_x + 1);
                    S32 mvy_plus_1 = (i4_mv_y + 1);
                    CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                        ps_dedup_enabler, 1, mvx_qpel + 2, mvy_qpel + 2, check_for_duplicate);

                    if(!check_for_duplicate)
                    {
                        /* search node mv is stored in qpel units */
                        ps_search_node->s_mv.i2_mvx = ((S16)mvx_plus_1 << 1);
                        ps_search_node->s_mv.i2_mvy = ((S16)mvy_plus_1 << 1);
                        i4_frac_x = mvx_plus_1 & 1;
                        i4_frac_y = mvy_plus_1 & 1;
                        pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
                        s_err_prms.pu1_ref =
                            pu1_ref + (mvx_plus_1 >> 1) + ((mvy_plus_1 >> 1) * i4_ref_stride);

                        pf_err_compute(&s_err_prms);
                        /* Update the mv's with the current candt motion vectors */
                        s_result_prms.i2_mv_x = mvx_qpel + 2;
                        s_result_prms.i2_mv_y = mvy_qpel + 2;
                        hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                        i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];

                        if(i4_tot_cost < i4_min_cost)
                        {
                            i4_min_cost = i4_tot_cost;
                            i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                            e_min_id = PT_BR;
                            pu1_final_out = s_err_prms.pu1_ref;
                        }
                    }
                }
                if(e_min_id == PT_C)
                {
                    break;
                }
            }
            else
            {
                break;
            }
        }

        /*********************************************************************/
        /* Depending on the best result location, we may be able to skip     */
        /* atleast two pts, centre pt and one more pt. E.g. if right pt is   */
        /* the best result, the next iteration need not do centre, left pts  */
        /*********************************************************************/
        if(i4_i)
        {
            i4_grid_mask = gai4_opt_grid_mask_diamond[e_min_id];
        }
        else
        {
            i4_grid_mask = gai4_opt_grid_mask_conventional[e_min_id];
        }
        i4_mv_x += gai1_grid_id_to_x[e_min_id];
        i4_mv_y += gai1_grid_id_to_y[e_min_id];
        ps_search_node->s_mv.i2_mvx = (S16)(i4_mv_x << 1);
        ps_search_node->s_mv.i2_mvy = (S16)(i4_mv_y << 1);
        i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 2, ps_range_prms);
    }

    /* Convert to QPEL units */
    i4_mv_x <<= 1;
    i4_mv_y <<= 1;

    ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
    ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;

    /* Early exit if this partition is visiting same hpel mv again */
    /* Assumption : Checkin for early exit in best result of partition */
    if((ps_search_results->aps_part_results[search_idx][part_id][0].i2_best_hpel_mv_x ==
        ps_search_node->s_mv.i2_mvx) &&
       (ps_search_results->aps_part_results[search_idx][part_id][0].i2_best_hpel_mv_y ==
        ps_search_node->s_mv.i2_mvy))
    {
        return (ps_search_results->aps_part_results[search_idx][part_id][0].i4_tot_cost);
    }
    else
    {
        /* Store the best hpel mv for future early exit checks */
        ps_search_results->aps_part_results[search_idx][part_id][0].i2_best_hpel_mv_x =
            (S16)i4_mv_x;
        ps_search_results->aps_part_results[search_idx][part_id][0].i2_best_hpel_mv_y =
            (S16)i4_mv_y;
    }

    /* Early exit if this partition is visiting same hpel mv again */
    /* Assumption : Checkin for early exit in second best result of partition */
    if((ps_search_results->aps_part_results[search_idx][part_id][1].i2_best_hpel_mv_x ==
        ps_search_node->s_mv.i2_mvx) &&
       (ps_search_results->aps_part_results[search_idx][part_id][1].i2_best_hpel_mv_y ==
        ps_search_node->s_mv.i2_mvy))
    {
        return (ps_search_results->aps_part_results[search_idx][part_id][1].i4_tot_cost);
    }
    else
    {
        /* Store the best hpel mv for future early exit checks */
        ps_search_results->aps_part_results[search_idx][part_id][1].i2_best_hpel_mv_x =
            (S16)i4_mv_x;
        ps_search_results->aps_part_results[search_idx][part_id][1].i2_best_hpel_mv_y =
            (S16)i4_mv_y;
    }

    /* Exact interpolation or averaging chosen here */
    pf_qpel_interp = ps_prms->pf_qpel_interp;

    /* Next QPEL ME */
    /* In this case, we have option of doing exact QPEL interpolation or avg */
    /*************************************************************************/
    /*        x                                                              */
    /*    A b C d                                                            */
    /*    e f g h                                                            */
    /*    I j K l                                                            */
    /*    m n o p                                                            */
    /*    Q r S t                                                            */
    /*                                                                       */
    /*    Approximate QPEL logic                                             */
    /*    b = avg(A,C) f = avg(I,C), g= avg(C,K) j=avg(I,K)                  */
    /*    for any given pt, we can get all the information required about    */
    /*    the surrounding 4 pts. For example, given point C (0.5, 0)         */
    /*     surrounding pts info:                                             */
    /*     b : qpel offset: 1, 0, generated by averaging. buffer1: fpel buf  */
    /*           buffer 2: hxfy, offsets for both are 0, 0                   */
    /*    similarly for other pts the info can be gotten                     */
    /*************************************************************************/
    i4_grid_mask = GRID_ALL_PTS_VALID ^ (BIT_EN(PT_C));
    i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 1, ps_range_prms);

    /*************************************************************************/
    /* One time preparation of non changing interpolation params. These      */
    /* include a set of ping pong result buf ptrs, input buf ptrs and some   */
    /* working memory (not used though in case of averaging).                */
    /*************************************************************************/
    s_interp_prms.ppu1_ref = &apu1_hpel_ref[0];
    s_interp_prms.i4_ref_stride = i4_ref_stride;
    s_interp_prms.i4_blk_wd = i4_blk_wd;
    s_interp_prms.i4_blk_ht = i4_blk_ht;

    i4_final_out_stride = i4_ref_stride;

    {
        U08 *pu1_mem;
        /*********************************************************************/
        /* Allocation of working memory for interpolated buffers. We maintain*/
        /* an intermediate working buffer, and 2 ping pong interpolated out  */
        /* buffers, purpose of ping pong explained later below               */
        /*********************************************************************/
        pu1_mem = ps_prms->pu1_wkg_mem;
        s_interp_prms.pu1_wkg_mem = pu1_mem;

        //pu1_mem += (INTERP_INTERMED_BUF_SIZE);
        s_interp_prms.apu1_interp_out[0] = pu1_mem;

        pu1_mem += (INTERP_OUT_BUF_SIZE);
        s_interp_prms.apu1_interp_out[1] = pu1_mem;

        pu1_mem += (INTERP_OUT_BUF_SIZE);
        s_interp_prms.apu1_interp_out[2] = pu1_mem;

        pu1_mem += (INTERP_OUT_BUF_SIZE);
        s_interp_prms.apu1_interp_out[3] = pu1_mem;

        pu1_mem += (INTERP_OUT_BUF_SIZE);
        s_interp_prms.apu1_interp_out[4] = pu1_mem;

        /*********************************************************************/
        /* Stride of interpolated output is just a function of blk width of  */
        /* this partition and hence remains constant for this partition      */
        /*********************************************************************/
        s_interp_prms.i4_out_stride = (i4_blk_wd);
    }

    {
        UWORD8 *apu1_final[4];
        WORD32 ai4_ref_stride[4];
        /*************************************************************************/
        /* Ping pong design for interpolated buffers. We use a min id, which     */
        /* tracks the id of the ppu1_interp_out that stores the best result.     */
        /* When new interp to be done, it uses 1 - bes result id to do the interp*/
        /* min id is toggled when any new result becomes the best result.        */
        /*************************************************************************/

        for(i4_i = 0; i4_i < i4_num_qpel_refine; i4_i++)
        {
            e_min_id = PT_C;

            hme_qpel_interp_comprehensive(
                &s_interp_prms, apu1_final, ai4_ref_stride, i4_mv_x, i4_mv_y, i4_grid_mask);

            mvx_qpel = i4_mv_x;
            mvy_qpel = i4_mv_y;

            if(i4_grid_mask & BIT_EN(PT_L))
            {
                CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                    ps_dedup_enabler, 1, mvx_qpel - 1, mvy_qpel - 0, check_for_duplicate);

                if(!check_for_duplicate)
                {
                    ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x - 1;
                    ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;

                    s_err_prms.pu1_ref = apu1_final[0];
                    s_err_prms.i4_ref_stride = ai4_ref_stride[0];

                    pf_err_compute(&s_err_prms);
                    /* Update the mv's with the current candt motion vectors */
                    s_result_prms.i2_mv_x = mvx_qpel - 1;
                    s_result_prms.i2_mv_y = mvy_qpel;
                    hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                    i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
                    if(i4_tot_cost < i4_min_cost)
                    {
                        e_min_id = PT_L;
                        i4_min_cost = i4_tot_cost;
                        i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    }
                }
            }
            if(i4_grid_mask & BIT_EN(PT_T))
            {
                CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                    ps_dedup_enabler, 1, mvx_qpel - 0, mvy_qpel - 1, check_for_duplicate);

                if(!check_for_duplicate)
                {
                    ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
                    ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y - 1;

                    s_err_prms.pu1_ref = apu1_final[1];
                    s_err_prms.i4_ref_stride = ai4_ref_stride[1];

                    pf_err_compute(&s_err_prms);
                    /* Update the mv's with the current candt motion vectors */
                    s_result_prms.i2_mv_x = mvx_qpel;
                    s_result_prms.i2_mv_y = mvy_qpel - 1;
                    hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
                    i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
                    if(i4_tot_cost < i4_min_cost)
                    {
                        e_min_id = PT_T;
                        i4_min_cost = i4_tot_cost;
                        i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    }
                }
            }
            if(i4_grid_mask & BIT_EN(PT_R))
            {
                CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                    ps_dedup_enabler, 1, mvx_qpel + 1, mvy_qpel, check_for_duplicate);

                if(!check_for_duplicate)
                {
                    ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x + 1;
                    ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;

                    s_err_prms.pu1_ref = apu1_final[2];
                    s_err_prms.i4_ref_stride = ai4_ref_stride[2];

                    pf_err_compute(&s_err_prms);
                    /* Update the mv's with the current candt motion vectors */
                    s_result_prms.i2_mv_x = mvx_qpel + 1;
                    s_result_prms.i2_mv_y = mvy_qpel;
                    hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                    i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
                    if(i4_tot_cost < i4_min_cost)
                    {
                        e_min_id = PT_R;
                        i4_min_cost = i4_tot_cost;
                        i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    }
                }
            }
            /* i4_mv_x and i4_mv_y will always be the centre pt */
            /* for qpel we  start with least hpel, and hence compute of center pt never reqd */
            if(i4_grid_mask & BIT_EN(PT_B))
            {
                CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                    ps_dedup_enabler, 1, mvx_qpel, mvy_qpel + 1, check_for_duplicate);

                if(!check_for_duplicate)
                {
                    ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
                    ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y + 1;

                    s_err_prms.pu1_ref = apu1_final[3];
                    s_err_prms.i4_ref_stride = ai4_ref_stride[3];

                    pf_err_compute(&s_err_prms);
                    /* Update the mv's with the current candt motion vectors */
                    s_result_prms.i2_mv_x = mvx_qpel;
                    s_result_prms.i2_mv_y = mvy_qpel + 1;
                    hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
                    i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
                    if(i4_tot_cost < i4_min_cost)
                    {
                        e_min_id = PT_B;
                        i4_min_cost = i4_tot_cost;
                        i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                    }
                }
            }

            if(e_min_id == PT_C)
            {
                if(!i4_i)
                {
                    S32 i4_interp_buf_id = 0;

                    if(i4_grid_mask & BIT_EN(PT_TL))
                    {
                        CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                            ps_dedup_enabler, 1, mvx_qpel - 1, mvy_qpel - 1, check_for_duplicate);

                        if(!check_for_duplicate)
                        {
                            ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x - 1;
                            ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y - 1;

                            /* Carry out the interpolation */
                            pf_qpel_interp(
                                &s_interp_prms, i4_mv_x - 1, i4_mv_y - 1, i4_interp_buf_id);

                            s_err_prms.pu1_ref = s_interp_prms.pu1_final_out;
                            s_err_prms.i4_ref_stride = s_interp_prms.i4_final_out_stride;

                            pf_err_compute(&s_err_prms);
                            /* Update the mv's with the current candt motion vectors */
                            s_result_prms.i2_mv_x = mvx_qpel - 1;
                            s_result_prms.i2_mv_y = mvy_qpel - 1;
                            hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                            i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];

                            if(i4_tot_cost < i4_min_cost)
                            {
                                e_min_id = PT_TL;
                                i4_min_cost = i4_tot_cost;
                                i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                            }
                        }
                    }
                    if(i4_grid_mask & BIT_EN(PT_TR))
                    {
                        CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                            ps_dedup_enabler, 1, mvx_qpel + 1, mvy_qpel - 1, check_for_duplicate);

                        if(!check_for_duplicate)
                        {
                            ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x + 1;
                            ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y - 1;

                            /* Carry out the interpolation */
                            pf_qpel_interp(
                                &s_interp_prms, i4_mv_x + 1, i4_mv_y - 1, i4_interp_buf_id);

                            s_err_prms.pu1_ref = s_interp_prms.pu1_final_out;
                            s_err_prms.i4_ref_stride = s_interp_prms.i4_final_out_stride;

                            pf_err_compute(&s_err_prms);
                            /* Update the mv's with the current candt motion vectors */
                            s_result_prms.i2_mv_x = mvx_qpel + 1;
                            s_result_prms.i2_mv_y = mvy_qpel - 1;
                            hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                            i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];

                            if(i4_tot_cost < i4_min_cost)
                            {
                                e_min_id = PT_TR;
                                i4_min_cost = i4_tot_cost;
                                i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                            }
                        }
                    }
                    if(i4_grid_mask & BIT_EN(PT_BL))
                    {
                        CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                            ps_dedup_enabler, 1, mvx_qpel - 1, mvy_qpel + 1, check_for_duplicate);

                        if(!check_for_duplicate)
                        {
                            ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x - 1;
                            ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y + 1;

                            /* Carry out the interpolation */
                            pf_qpel_interp(
                                &s_interp_prms, i4_mv_x - 1, i4_mv_y + 1, i4_interp_buf_id);

                            s_err_prms.pu1_ref = s_interp_prms.pu1_final_out;
                            s_err_prms.i4_ref_stride = s_interp_prms.i4_final_out_stride;

                            pf_err_compute(&s_err_prms);
                            /* Update the mv's with the current candt motion vectors */
                            s_result_prms.i2_mv_x = mvx_qpel - 1;
                            s_result_prms.i2_mv_y = mvy_qpel + 1;
                            hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                            i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];

                            if(i4_tot_cost < i4_min_cost)
                            {
                                e_min_id = PT_BL;
                                i4_min_cost = i4_tot_cost;
                                i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                            }
                        }
                    }
                    /* i4_mv_x and i4_mv_y will always be the centre pt */
                    /* for qpel we  start with least hpel, and hence compute of center pt never reqd */
                    if(i4_grid_mask & BIT_EN(PT_BR))
                    {
                        CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
                            ps_dedup_enabler, 1, mvx_qpel + 1, mvy_qpel + 1, check_for_duplicate);

                        if(!check_for_duplicate)
                        {
                            ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x + 1;
                            ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y + 1;

                            /* Carry out the interpolation */
                            pf_qpel_interp(
                                &s_interp_prms, i4_mv_x + 1, i4_mv_y + 1, i4_interp_buf_id);

                            s_err_prms.pu1_ref = s_interp_prms.pu1_final_out;
                            s_err_prms.i4_ref_stride = s_interp_prms.i4_final_out_stride;

                            pf_err_compute(&s_err_prms);
                            /* Update the mv's with the current candt motion vectors */
                            s_result_prms.i2_mv_x = mvx_qpel + 1;
                            s_result_prms.i2_mv_y = mvy_qpel + 1;
                            hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);

                            i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];

                            if(i4_tot_cost < i4_min_cost)
                            {
                                e_min_id = PT_BR;
                                i4_min_cost = i4_tot_cost;
                                i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
                            }
                        }
                    }
                    if(e_min_id == PT_C)
                    {
                        break;
                    }
                }
                else
                {
                    break;
                }
            }

            if(i4_i)
            {
                i4_grid_mask = gai4_opt_grid_mask_diamond[e_min_id];
            }
            else
            {
                i4_grid_mask = gai4_opt_grid_mask_conventional[e_min_id];
            }
            i4_mv_x += gai1_grid_id_to_x[e_min_id];
            i4_mv_y += gai1_grid_id_to_y[e_min_id];
            ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
            ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
            i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 1, ps_range_prms);
        }
    }

    /* update modified motion vectors and cost at end of subpel */
    ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
    ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
    ps_search_node->i4_tot_cost = i4_min_cost;
    ps_search_node->i4_sad = i4_min_sad;

    /********************************************************************************/
    /* TODO: Restoring back Sad lambda from Hadamard lambda                         */
    /* Need to pass the had/satd lambda in more cleaner way for subpel cost compute */
    /********************************************************************************/
    //ps_pred_ctxt->lambda >>= 1;

    return (i4_min_cost);
}
#endif

static void hme_subpel_refine_struct_to_search_results_struct_converter(
    subpel_refine_ctxt_t *ps_subpel_refine_ctxt,
    search_results_t *ps_search_results,
    U08 u1_pred_dir,
    ME_QUALITY_PRESETS_T e_quality_preset)
{
    U08 i;

    U08 u1_num_results_per_part = ps_search_results->u1_num_results_per_part;

    for(i = 0; i < ps_subpel_refine_ctxt->i4_num_valid_parts; i++)
    {
        S32 index;
        S32 i4_sad;

        S32 part_id = ps_subpel_refine_ctxt->ai4_part_id[i];

        search_node_t *ps_best_node = ps_search_results->aps_part_results[u1_pred_dir][part_id];

        if(ps_subpel_refine_ctxt->i4_num_valid_parts > 8)
        {
            index = part_id;
        }
        else
        {
            index = i;
        }

        if(!ps_best_node->u1_subpel_done)
        {
            i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[0][index] -
                     ps_subpel_refine_ctxt->i2_mv_cost[0][index];
            ps_best_node[0].i4_sdi = 0;
            ASSERT((e_quality_preset == ME_PRISTINE_QUALITY) ? (ps_best_node[0].i4_sdi >= 0) : 1);
            ps_best_node[0].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[0][index];

            if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] == MAX_SIGNED_16BIT_VAL)
            {
                i4_sad = MAX_SIGNED_16BIT_VAL;
            }

            ps_best_node[0].i4_sad = i4_sad;
            ps_best_node[0].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];
            ps_best_node[0].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
            ps_best_node[0].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
            ps_best_node[0].i1_ref_idx = (WORD8)ps_subpel_refine_ctxt->i2_ref_idx[0][index];
            ps_best_node->u1_subpel_done = 1;

            if(2 == u1_num_results_per_part)
            {
                i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[1][index] -
                         ps_subpel_refine_ctxt->i2_mv_cost[1][index];
                ps_best_node[1].i4_sdi = 0;
                ps_best_node[1].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[1][index];

                if(ps_subpel_refine_ctxt->i2_tot_cost[1][index] == MAX_SIGNED_16BIT_VAL)
                {
                    i4_sad = MAX_SIGNED_16BIT_VAL;
                }

                ps_best_node[1].i4_sad = i4_sad;
                ps_best_node[1].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[1][index];
                ps_best_node[1].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[1][index];
                ps_best_node[1].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[1][index];
                ps_best_node[1].i1_ref_idx = (WORD8)ps_subpel_refine_ctxt->i2_ref_idx[1][index];
                ps_best_node[1].u1_subpel_done = 1;
            }
        }
        else if(
            (2 == u1_num_results_per_part) &&
            (ps_subpel_refine_ctxt->i2_tot_cost[0][index] < ps_best_node[1].i4_tot_cost))
        {
            if(ps_subpel_refine_ctxt->i2_tot_cost[1][index] < ps_best_node[0].i4_tot_cost)
            {
                i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[0][index] -
                         ps_subpel_refine_ctxt->i2_mv_cost[0][index];
                ps_best_node[0].i4_sdi = 0;
                ps_best_node[0].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[0][index];

                if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] == MAX_SIGNED_16BIT_VAL)
                {
                    i4_sad = MAX_SIGNED_16BIT_VAL;
                }

                ps_best_node[0].i4_sad = i4_sad;
                ps_best_node[0].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];
                ps_best_node[0].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
                ps_best_node[0].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
                ps_best_node[0].i1_ref_idx = (S08)ps_subpel_refine_ctxt->i2_ref_idx[0][index];

                i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[1][index] -
                         ps_subpel_refine_ctxt->i2_mv_cost[1][index];
                ps_best_node[1].i4_sdi = 0;
                ps_best_node[1].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[1][index];

                if(ps_subpel_refine_ctxt->i2_tot_cost[1][index] == MAX_SIGNED_16BIT_VAL)
                {
                    i4_sad = MAX_SIGNED_16BIT_VAL;
                }

                ps_best_node[1].i4_sad = i4_sad;
                ps_best_node[1].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[1][index];
                ps_best_node[1].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[1][index];
                ps_best_node[1].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[1][index];
                ps_best_node[1].i1_ref_idx = (S08)ps_subpel_refine_ctxt->i2_ref_idx[1][index];
            }
            else if(ps_subpel_refine_ctxt->i2_tot_cost[1][index] > ps_best_node[0].i4_tot_cost)
            {
                if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] >= ps_best_node[0].i4_tot_cost)
                {
                    i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[0][index] -
                             ps_subpel_refine_ctxt->i2_mv_cost[0][index];
                    ps_best_node[1].i4_sdi = 0;
                    ps_best_node[1].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[0][index];

                    if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] == MAX_SIGNED_16BIT_VAL)
                    {
                        i4_sad = MAX_SIGNED_16BIT_VAL;
                    }

                    ps_best_node[1].i4_sad = i4_sad;
                    ps_best_node[1].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];
                    ps_best_node[1].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
                    ps_best_node[1].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
                    ps_best_node[1].i1_ref_idx = (S08)ps_subpel_refine_ctxt->i2_ref_idx[0][index];
                }
                else if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] < ps_best_node[0].i4_tot_cost)
                {
                    memmove(&ps_best_node[1], &ps_best_node[0], sizeof(search_node_t));

                    i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[0][index] -
                             ps_subpel_refine_ctxt->i2_mv_cost[0][index];
                    ps_best_node[0].i4_sdi = 0;
                    ps_best_node[0].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[0][index];

                    if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] == MAX_SIGNED_16BIT_VAL)
                    {
                        i4_sad = MAX_SIGNED_16BIT_VAL;
                    }

                    ps_best_node[0].i4_sad = i4_sad;
                    ps_best_node[0].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];
                    ps_best_node[0].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
                    ps_best_node[0].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
                    ps_best_node[0].i1_ref_idx = (S08)ps_subpel_refine_ctxt->i2_ref_idx[0][index];
                }
            }
        }
        else if(
            (1 == u1_num_results_per_part) &&
            (ps_subpel_refine_ctxt->i2_tot_cost[0][index] < ps_best_node[0].i4_tot_cost))
        {
            i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[0][index] -
                     ps_subpel_refine_ctxt->i2_mv_cost[0][index];
            ps_best_node[0].i4_sdi = 0;
            ps_best_node[0].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[0][index];

            if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] == MAX_SIGNED_16BIT_VAL)
            {
                i4_sad = MAX_SIGNED_16BIT_VAL;
            }

            ps_best_node[0].i4_sad = i4_sad;
            ps_best_node[0].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];
            ps_best_node[0].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
            ps_best_node[0].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
            ps_best_node[0].i1_ref_idx = (S08)ps_subpel_refine_ctxt->i2_ref_idx[0][index];
        }
    }
}

/**
********************************************************************************
*  @fn     S32 hme_subpel_refine_cu_hs
*
*  @brief  Evaluates the best subpel mvs for active partitions of an MB in L0
*          layer for the high speed preset. Recursive hadamard SATD / SAD
*          and mv cost is used for 2NxN and NxN partitions with active partition
*          update
*
*  @param[in]  ps_prms: subpel prms input to this function
*
*  @param[in]  ps_curr_layer: points to the current layer ctxt
*
*  @param[out] ps_search_results: points to the search resutls that get updated
*              with best results
*
*  @param[in]  search_idx:  ref id of the frame for which results get updated
*
*  @param[in]  ps_wt_inp_prms:  current frame input params
*
*  @return     None
********************************************************************************
*/
void hme_subpel_refine_cu_hs(
    hme_subpel_prms_t *ps_prms,
    layer_ctxt_t *ps_curr_layer,
    search_results_t *ps_search_results,
    S32 search_idx,
    wgt_pred_ctxt_t *ps_wt_inp_prms,
    WORD32 blk_8x8_mask,
    me_func_selector_t *ps_func_selector,
    ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list,
    ihevce_me_optimised_function_list_t *ps_me_optimised_function_list)
{
    /* Unique search node list for 2nx2n and nxn partitions */
    search_node_t as_nodes_2nx2n[MAX_RESULTS_PER_PART * 5];
    subpel_dedup_enabler_t as_subpel_dedup_enabler[MAX_NUM_REF];
    search_node_t *ps_search_node;

    S32 i, i4_part_mask, j;
    S32 i4_sad_grid;
    S32 max_subpel_cand;
    WORD32 index;
    S32 num_unique_nodes_2nx2n;
    S32 part_id;
    S32 x_off, y_off;
    S32 i4_inp_off;

    CU_SIZE_T e_cu_size;
    BLK_SIZE_T e_blk_size;

    subpel_refine_ctxt_t *ps_subpel_refine_ctxt = ps_prms->ps_subpel_refine_ctxt;

    S32 i4_use_satd = ps_prms->i4_use_satd;
    S32 i4_num_act_refs = ps_prms->i4_num_act_ref_l0 + ps_prms->i4_num_act_ref_l1;

    ASSERT(ps_search_results->u1_num_results_per_part <= MAX_RESULTS_PER_PART);

    if(!DISABLE_SUBPEL_REFINEMENT_WHEN_SRC_IS_NOISY || !ps_prms->u1_is_cu_noisy)
    {
        e_cu_size = ps_search_results->e_cu_size;
        i4_part_mask = ps_search_results->i4_part_mask;

        ps_prms->i4_inp_type = sizeof(U08);

        num_unique_nodes_2nx2n = 0;

        for(i = 0; i < i4_num_act_refs; i++)
        {
            as_subpel_dedup_enabler[i].u1_ref_idx = MAX_NUM_REF;
        }

        /************************************************************************/
        /*                                                                      */
        /*  Initialize SATD cost for each valid partition id.one time before    */
        /*  doing full pel time. This is because of the following reasons:      */
        /*   1. Full pel cost was done in  SAD while subpel is in SATD mode     */
        /*   2. Partitions like AMP, Nx2N and 2NxN are refined on the fly while */
        /*      doing Diamond search for 2Nx2N and NxN. This partitions are     */
        /*      not explicitly refine in high speed mode                        */
        /*                                                                      */
        /************************************************************************/
        for(i = 0; i < ps_subpel_refine_ctxt->i4_num_valid_parts; i++)
        {
            S32 enable_subpel = 0;
            S32 part_type;

            /* Derive the x and y offsets of this part id */
            part_id = ps_subpel_refine_ctxt->ai4_part_id[i];
            if(ps_subpel_refine_ctxt->i4_num_valid_parts > 8)
            {
                index = part_id;
            }
            else
            {
                index = i;
            }

            part_type = ge_part_id_to_part_type[part_id];
            x_off = gas_part_attr_in_cu[part_id].u1_x_start << e_cu_size;
            y_off = gas_part_attr_in_cu[part_id].u1_y_start << e_cu_size;
            x_off += ps_search_results->u1_x_off;
            y_off += ps_search_results->u1_y_off;
            i4_inp_off = x_off + y_off * ps_prms->i4_inp_stride;
            e_blk_size = ge_part_id_to_blk_size[e_cu_size][part_id];

            x_off += ps_prms->i4_ctb_x_off;
            y_off += ps_prms->i4_ctb_y_off;

            max_subpel_cand = 0;

            /* Choose the minimum number of candidates to be used for Sub pel refinement */
            if(PART_ID_2Nx2N == part_type)
            {
                max_subpel_cand =
                    MIN(ps_prms->u1_max_subpel_candts_2Nx2N,
                        ps_search_results->u1_num_results_per_part);
            }
            else if(PRT_NxN == part_type)
            {
                max_subpel_cand = MIN(
                    ps_prms->u1_max_subpel_candts_NxN, ps_search_results->u1_num_results_per_part);
            }

            /* If incomplete CTB, NxN num candidates should be forced to min 1 */
            if((0 == max_subpel_cand) && (blk_8x8_mask != 15))
            {
                max_subpel_cand = 1;
            }

            if((PART_ID_2Nx2N == part_type) || (PRT_NxN == part_type))
            {
                enable_subpel = 1;
            }

            /* Compute full pel SATD for each result per partition before subpel */
            /* refinement starts.                                                */
            /* Also prepare unique candidate list for 2Nx2N and NxN partitions   */
            for(j = 0; j < ps_search_results->u1_num_results_per_part; j++)
            {
                err_prms_t s_err_prms;
                S32 i4_satd = 0;
                S32 i1_ref_idx;
                U08 *pu1_ref_base;
                S32 i4_ref_stride = ps_curr_layer->i4_rec_stride;
                S32 i4_mv_x, i4_mv_y;

                ps_search_node = ps_search_results->aps_part_results[search_idx][part_id] + j;

                if(ps_subpel_refine_ctxt->i2_mv_x[j][index] == INTRA_MV)
                {
                    ps_search_node->u1_subpel_done = 1;
                    continue;
                }

                i1_ref_idx = ps_subpel_refine_ctxt->i2_ref_idx[j][index];
                ps_prms->pv_inp = (void *)(ps_wt_inp_prms->apu1_wt_inp[i1_ref_idx] + i4_inp_off);
                pu1_ref_base = ps_curr_layer->ppu1_list_rec_fxfy[i1_ref_idx];

                i4_mv_x = ps_subpel_refine_ctxt->i2_mv_x[j][index];
                i4_mv_y = ps_subpel_refine_ctxt->i2_mv_y[j][index];

                if(i4_use_satd)
                {
                    s_err_prms.pu1_inp = (U08 *)ps_prms->pv_inp;
                    s_err_prms.i4_inp_stride = ps_prms->i4_inp_stride;
                    s_err_prms.pu1_ref = pu1_ref_base + x_off + (y_off * i4_ref_stride) + i4_mv_x +
                                         (i4_mv_y * i4_ref_stride);

                    s_err_prms.i4_ref_stride = i4_ref_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 = gau1_blk_size_to_wd[e_blk_size];
                    s_err_prms.i4_blk_ht = gau1_blk_size_to_ht[e_blk_size];

                    s_err_prms.ps_cmn_utils_optimised_function_list =
                        ps_cmn_utils_optimised_function_list;

                    compute_satd_8bit(&s_err_prms);

                    i4_satd = s_err_prms.pi4_sad_grid[0];

                    ps_subpel_refine_ctxt->i2_tot_cost[j][index] =
                        CLIP_S16(ps_subpel_refine_ctxt->i2_mv_cost[j][index] + i4_satd);
                    ps_subpel_refine_ctxt->ai2_fullpel_satd[j][index] = i4_satd;
                }

                /* Sub-pel candidate filtration */
                if(j)
                {
                    S16 i2_best_sad;
                    S32 i4_best_mvx;
                    S32 i4_best_mvy;

                    search_node_t *ps_node =
                        ps_search_results->aps_part_results[search_idx][part_id];

                    U08 u1_is_subpel_done = ps_node->u1_subpel_done;
                    S16 i2_curr_sad = ps_subpel_refine_ctxt->ai2_fullpel_satd[j][index];
                    S32 i4_curr_mvx = i4_mv_x << 2;
                    S32 i4_curr_mvy = i4_mv_y << 2;

                    if(u1_is_subpel_done)
                    {
                        i2_best_sad = ps_node->i4_sad;

                        if(ps_node->i1_ref_idx == i1_ref_idx)
                        {
                            i4_best_mvx = ps_node->s_mv.i2_mvx;
                            i4_best_mvy = ps_node->s_mv.i2_mvy;
                        }
                        else if(i1_ref_idx == ps_subpel_refine_ctxt->i2_ref_idx[0][index])
                        {
                            i4_best_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
                            i4_best_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
                        }
                        else
                        {
                            i4_best_mvx = INTRA_MV;
                            i4_best_mvy = INTRA_MV;
                        }
                    }
                    else
                    {
                        i2_best_sad = ps_subpel_refine_ctxt->i2_tot_cost[0][index] -
                                      ps_subpel_refine_ctxt->i2_mv_cost[0][index];

                        if(i1_ref_idx == ps_subpel_refine_ctxt->i2_ref_idx[0][index])
                        {
                            i4_best_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
                            i4_best_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
                        }
                        else
                        {
                            i4_best_mvx = INTRA_MV;
                            i4_best_mvy = INTRA_MV;
                        }
                    }

                    i2_best_sad += (i2_best_sad >> ps_prms->u1_subpel_candt_threshold);

                    if(((ABS(i4_curr_mvx - i4_best_mvx) < 2) &&
                        (ABS(i4_curr_mvy - i4_best_mvy) < 2)) ||
                       (i2_curr_sad > i2_best_sad))
                    {
                        enable_subpel = 0;
                    }
                }

                ps_search_node->u1_part_id = part_id;

                /* Convert mvs in part results from FPEL to QPEL units */
                ps_subpel_refine_ctxt->i2_mv_x[j][index] <<= 2;
                ps_subpel_refine_ctxt->i2_mv_y[j][index] <<= 2;

                /* If the candidate number is more than the number of candts
                set initally, do not add those candts for refinement */
                if(j >= max_subpel_cand)
                {
                    enable_subpel = 0;
                }

                if(enable_subpel)
                {
                    if(num_unique_nodes_2nx2n == 0)
                    {
                        S32 i4_index = ps_subpel_refine_ctxt->i2_ref_idx[j][index];

                        as_subpel_dedup_enabler[i4_index].i2_mv_x =
                            ps_subpel_refine_ctxt->i2_mv_x[j][index];
                        as_subpel_dedup_enabler[i4_index].i2_mv_y =
                            ps_subpel_refine_ctxt->i2_mv_y[j][index];
                        as_subpel_dedup_enabler[i4_index].u1_ref_idx =
                            (U08)ps_subpel_refine_ctxt->i2_ref_idx[j][index];
                        memset(
                            as_subpel_dedup_enabler[i4_index].au4_node_map,
                            0,
                            sizeof(U32) * 2 * MAP_X_MAX);
                    }
                    INSERT_NEW_NODE_NOMAP_ALTERNATE(
                        as_nodes_2nx2n, num_unique_nodes_2nx2n, ps_subpel_refine_ctxt, j, i);
                }
            }

            /*********************************************************************************************/
            /* If sad_1 < sad_2, then satd_1 need not be lesser than satd_2. Therefore, after conversion */
            /* to satd, tot_cost_1 may not be lesser than tot_cost_2. So we need to sort the search nodes*/
            /* for each partition again, based on the new costs                                          */
            /*********************************************************************************************/
            /*********************************************************************************************/
            /* Because right now, we store only the two best candidates for each partition, the sort will*/
            /* converge to a simple swap.                                                                */
            /* ASSUMPTION : We store only two best results per partition                                 */
            /*********************************************************************************************/
            if(ps_search_results->u1_num_results_per_part == 2)
            {
                if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] >
                   ps_subpel_refine_ctxt->i2_tot_cost[1][index])
                {
                    SWAP(
                        ps_subpel_refine_ctxt->i2_tot_cost[0][index],
                        ps_subpel_refine_ctxt->i2_tot_cost[1][index]);

                    SWAP(
                        ps_subpel_refine_ctxt->i2_mv_cost[0][index],
                        ps_subpel_refine_ctxt->i2_mv_cost[1][index]);

                    SWAP(
                        ps_subpel_refine_ctxt->i2_mv_x[0][index],
                        ps_subpel_refine_ctxt->i2_mv_x[1][index]);

                    SWAP(
                        ps_subpel_refine_ctxt->i2_mv_y[0][index],
                        ps_subpel_refine_ctxt->i2_mv_y[1][index]);

                    SWAP(
                        ps_subpel_refine_ctxt->i2_ref_idx[0][index],
                        ps_subpel_refine_ctxt->i2_ref_idx[1][index]);

                    SWAP(
                        ps_subpel_refine_ctxt->ai2_fullpel_satd[0][index],
                        ps_subpel_refine_ctxt->ai2_fullpel_satd[1][index]);
                }
            }
        }

        if(blk_8x8_mask == 0xf)
        {
            num_unique_nodes_2nx2n =
                MIN(num_unique_nodes_2nx2n, ps_prms->u1_max_num_subpel_refine_centers);
        }
        {
            x_off = gas_part_attr_in_cu[0].u1_x_start << e_cu_size;
            y_off = gas_part_attr_in_cu[0].u1_y_start << e_cu_size;
            x_off += ps_search_results->u1_x_off;
            y_off += ps_search_results->u1_y_off;
            i4_inp_off = x_off + y_off * ps_prms->i4_inp_stride;
            e_blk_size = ge_part_id_to_blk_size[e_cu_size][0];

            for(j = 0; j < num_unique_nodes_2nx2n; j++)
            {
                S32 pred_lx;
                ps_search_node = &as_nodes_2nx2n[j];

                if(ps_search_node->s_mv.i2_mvx == INTRA_MV)
                {
                    continue;
                }

                {
                    S08 i1_ref_idx = ps_search_node->i1_ref_idx;
                    subpel_dedup_enabler_t *ps_dedup_enabler =
                        &(as_subpel_dedup_enabler[i1_ref_idx]);

                    if(ps_dedup_enabler->u1_ref_idx == MAX_NUM_REF)
                    {
                        as_subpel_dedup_enabler[i1_ref_idx].i2_mv_x = ps_search_node->s_mv.i2_mvx;
                        as_subpel_dedup_enabler[i1_ref_idx].i2_mv_y = ps_search_node->s_mv.i2_mvy;
                        as_subpel_dedup_enabler[i1_ref_idx].u1_ref_idx = i1_ref_idx;
                        memset(
                            as_subpel_dedup_enabler[i1_ref_idx].au4_node_map,
                            0,
                            sizeof(U32) * 2 * MAP_X_MAX);
                    }
                }

                pred_lx = search_idx;
                ps_prms->pv_inp =
                    (void *)(ps_wt_inp_prms->apu1_wt_inp[ps_search_node->i1_ref_idx] + i4_inp_off);

                hme_subpel_refine_search_node_high_speed(
                    ps_search_node,
                    ps_prms,
                    ps_curr_layer,
                    e_blk_size,
                    x_off + ps_prms->i4_ctb_x_off,
                    y_off + ps_prms->i4_ctb_y_off,
                    ps_search_results,
                    pred_lx,
                    i4_part_mask,
                    &ps_subpel_refine_ctxt->ai4_part_id[0],
                    search_idx,
                    &(as_subpel_dedup_enabler[ps_search_node->i1_ref_idx]),
                    ps_func_selector,
                    ps_me_optimised_function_list);
            }
        }
    }
    else
    {
        for(i = 0; i < ps_subpel_refine_ctxt->i4_num_valid_parts; i++)
        {
            S32 i4_index;

            S32 i4_part_id = ps_subpel_refine_ctxt->ai4_part_id[i];

            if(ps_subpel_refine_ctxt->i4_num_valid_parts > 8)
            {
                i4_index = i4_part_id;
            }
            else
            {
                i4_index = i;
            }

            for(j = 0; j < ps_search_results->u1_num_results_per_part; j++)
            {
                ps_subpel_refine_ctxt->i2_mv_x[j][i4_index] <<= 2;
                ps_subpel_refine_ctxt->i2_mv_y[j][i4_index] <<= 2;
            }
        }
    }

    hme_subpel_refine_struct_to_search_results_struct_converter(
        ps_subpel_refine_ctxt, ps_search_results, search_idx, ps_prms->e_me_quality_presets);
}