/******************************************************************************
 *
 * 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 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_inter_pred.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"

/*****************************************************************************/
/* Macros                                                                    */
/*****************************************************************************/
#define UNI_SATD_SCALE 1

/*****************************************************************************/
/* Function Definitions                                                      */
/*****************************************************************************/
void ihevce_open_loop_pred_data(
    me_frm_ctxt_t *ps_ctxt,
    inter_pu_results_t *ps_pu_results,
    U08 *pu1_src,
    U08 *pu1_temp_pred,
    S32 stride,
    S32 src_strd,
    UWORD8 e_part_id)
{
    S32 best_sad_l0 = -1, best_sad_l1 = -1;
    S32 sad_diff, status;
    inter_pred_me_ctxt_t *ps_inter_pred_me_ctxt;
    U08 enable_bi = 0;
    pu_t s_pu;

    ps_inter_pred_me_ctxt = &ps_ctxt->s_mc_ctxt;
    ps_ctxt->i4_count++;
    /* L0*/
    if(ps_pu_results->u1_num_results_per_part_l0[e_part_id])
    {
        pu_result_t *ps_best_l0_pu;
        ps_best_l0_pu = ps_pu_results->aps_pu_results[0][PRT_2Nx2N];
        best_sad_l0 = ps_best_l0_pu->i4_tot_cost - ps_best_l0_pu->i4_mv_cost;
        s_pu.b2_pred_mode = PRED_L0;
        s_pu.b4_ht = ps_best_l0_pu->pu.b4_ht;
        s_pu.b4_wd = ps_best_l0_pu->pu.b4_wd;
        s_pu.b4_pos_x = ps_best_l0_pu->pu.b4_pos_x;
        s_pu.b4_pos_y = ps_best_l0_pu->pu.b4_pos_y;
        s_pu.b1_intra_flag = 0;
        s_pu.mv.s_l0_mv.i2_mvx = ps_best_l0_pu->pu.mv.s_l0_mv.i2_mvx;
        s_pu.mv.s_l0_mv.i2_mvy = ps_best_l0_pu->pu.mv.s_l0_mv.i2_mvy;
        s_pu.mv.i1_l0_ref_idx = ps_best_l0_pu->pu.mv.i1_l0_ref_idx;
    }
    /*L1*/
    if(ps_pu_results->u1_num_results_per_part_l1[e_part_id])
    {
        pu_result_t *ps_best_l1_pu;
        ps_best_l1_pu = ps_pu_results->aps_pu_results[1][PRT_2Nx2N];
        best_sad_l1 = ps_best_l1_pu->i4_tot_cost - ps_best_l1_pu->i4_mv_cost;
        s_pu.b2_pred_mode = PRED_L1;
        s_pu.b4_ht = ps_best_l1_pu->pu.b4_ht;
        s_pu.b4_wd = ps_best_l1_pu->pu.b4_wd;
        s_pu.b4_pos_x = ps_best_l1_pu->pu.b4_pos_x;
        s_pu.b4_pos_y = ps_best_l1_pu->pu.b4_pos_y;
        s_pu.b1_intra_flag = 0;
        s_pu.mv.s_l1_mv.i2_mvx = ps_best_l1_pu->pu.mv.s_l1_mv.i2_mvx;
        s_pu.mv.s_l1_mv.i2_mvy = ps_best_l1_pu->pu.mv.s_l1_mv.i2_mvy;
        s_pu.mv.i1_l1_ref_idx = ps_best_l1_pu->pu.mv.i1_l1_ref_idx;
    }
    ASSERT((best_sad_l0 != -1) || (best_sad_l1 != -1));
    /*bi selection*/
    if((best_sad_l0 != -1) && (best_sad_l1 != -1))
    {
        sad_diff = abs(best_sad_l0 - best_sad_l1);
        if((sad_diff < (best_sad_l0 * 0.15)) && (sad_diff < (best_sad_l1 * 0.15)))
        {
            enable_bi = 1;
            s_pu.b2_pred_mode = PRED_BI;
        }
        if(!enable_bi)
        {
            if(best_sad_l0 < best_sad_l1)
            {
                s_pu.b2_pred_mode = PRED_L0;
            }
            else
            {
                s_pu.b2_pred_mode = PRED_L1;
            }
        }
    }
    status = ihevce_luma_inter_pred_pu(ps_inter_pred_me_ctxt, &s_pu, pu1_temp_pred, stride, 1);
    if(status == -1)
    {
        ASSERT(0);
    }
}

/**
********************************************************************************
*  @fn     void *hme_get_wkg_mem(buf_mgr_t *ps_buf_mgr, S32 i4_size)
*
*  @brief  Allocates a block of size = i4_size from working memory and returns
*
*  @param[in,out] ps_buf_mgr: Buffer manager for wkg memory
*
*  @param[in]  i4_size : size required
*
*  @return void pointer to allocated memory, NULL if failure
********************************************************************************
*/
void *hme_get_wkg_mem(buf_mgr_t *ps_buf_mgr, S32 i4_size)
{
    U08 *pu1_mem;

    if(ps_buf_mgr->i4_used + i4_size > ps_buf_mgr->i4_total)
        return NULL;

    pu1_mem = ps_buf_mgr->pu1_wkg_mem + ps_buf_mgr->i4_used;
    ps_buf_mgr->i4_used += i4_size;

    return ((void *)pu1_mem);
}

/**
********************************************************************************
*  @fn     hme_init_histogram(
*
*  @brief  Top level entry point for Coarse ME. Runs across blocks and does the
*          needful by calling other low level routines.
*
*  @param[in,out]  ps_hist : the histogram structure
*
*  @param[in]  i4_max_mv_x : Maximum mv allowed in x direction (fpel units)
*
*  @param[in]  i4_max_mv_y : Maximum mv allowed in y direction (fpel units)
*
*  @return None
********************************************************************************
*/

void hme_init_histogram(mv_hist_t *ps_hist, S32 i4_max_mv_x, S32 i4_max_mv_y)
{
    S32 i4_num_bins, i4_num_cols, i4_num_rows;
    S32 i4_shift_x, i4_shift_y, i, i4_range, i4_val;

    /*************************************************************************/
    /* Evaluate the shift_x and shift_y. For this, we use the following logic*/
    /* Assuming that we use up all MAX_NUM_BINS. Then the number of bins is  */
    /* given by formula ((max_mv_x * 2) >> shift_x)*((max_mv_y * 2)>>shift_y)*/
    /* or shift_x + shift_y is log ((max_mv_x * max_mv_y * 4) / MAX_NUM_BINS)*/
    /* if above quantity is negative, then we make it zero.                  */
    /* If result is odd, then shift_y is result >> 1, shift_x is shift_y + 1 */
    /*************************************************************************/
    i4_val = i4_max_mv_x * i4_max_mv_y * 4;
    i4_range = (hme_get_range(i4_val - 1)) + 1;
    if(i4_range > LOG_MAX_NUM_BINS)
    {
        i4_shift_y = (i4_range - LOG_MAX_NUM_BINS);
        i4_shift_x = (i4_shift_y + 1) >> 1;
        i4_shift_y >>= 1;
    }
    else
    {
        i4_shift_y = 0;
        i4_shift_x = 0;
    }

    /* we assume the mv range is -max_mv_x to +max_mv_x, ditto for y */
    /* So number of columns is 2*max_mv_x >> i4_shift_x. Ditto for rows */
    /* this helps us compute num bins that are active for this histo session */
    i4_num_cols = (i4_max_mv_x << 1) >> i4_shift_x;
    i4_num_rows = (i4_max_mv_y << 1) >> i4_shift_y;
    i4_num_bins = i4_num_rows * i4_num_cols;

    ASSERT(i4_num_bins <= MAX_NUM_BINS);

    ps_hist->i4_num_rows = i4_num_rows;
    ps_hist->i4_num_cols = i4_num_cols;
    ps_hist->i4_min_x = -i4_max_mv_x;
    ps_hist->i4_min_y = -i4_max_mv_y;
    ps_hist->i4_shift_x = i4_shift_x;
    ps_hist->i4_shift_y = i4_shift_y;
    ps_hist->i4_lobe1_size = 5;
    ps_hist->i4_lobe2_size = 3;

    ps_hist->i4_num_bins = i4_num_bins;

    for(i = 0; i < i4_num_bins; i++)
    {
        ps_hist->ai4_bin_count[i] = 0;
    }
}

/**
********************************************************************************
*  @fn     hme_update_histogram(
*
*  @brief  Updates the histogram given an mv entry
*
*  @param[in,out]  ps_hist : the histogram structure
*
*  @param[in]  i4_mv_x : x component of the mv (fpel units)
*
*  @param[in]  i4_mv_y : y component of the mv (fpel units)
*
*  @return None
********************************************************************************
*/
void hme_update_histogram(mv_hist_t *ps_hist, S32 i4_mv_x, S32 i4_mv_y)
{
    S32 i4_bin_index, i4_col, i4_row;

    i4_col = (i4_mv_x - ps_hist->i4_min_x) >> ps_hist->i4_shift_x;
    i4_row = (i4_mv_y - ps_hist->i4_min_y) >> ps_hist->i4_shift_y;

    i4_bin_index = i4_col + (i4_row * ps_hist->i4_num_cols);
    /* Sanity Check */
    ASSERT(i4_bin_index < MAX_NUM_BINS);

    ps_hist->ai4_bin_count[i4_bin_index]++;
}

/**
********************************************************************************
*  @fn     hme_get_global_mv(
*
*  @brief  returns the global mv of a previous picture. Accounts for the fact
*          that the delta poc of the previous picture may have been different
*          from delta poc of current picture. Delta poc is POC difference
*          between a picture and its reference.
*
*  @param[out]  ps_mv: mv_t structure where the motion vector is returned
*
*  @param[in]  i4_delta_poc: the delta poc for the current pic w.r.t. reference
*
*  @return None
********************************************************************************
*/
void hme_get_global_mv(layer_ctxt_t *ps_prev_layer, hme_mv_t *ps_mv, S32 i4_delta_poc)
{
    S16 i2_mv_x, i2_mv_y;
    S32 i4_delta_poc_prev;
    S32 i4_poc_prev = ps_prev_layer->i4_poc;
    S32 i4_poc_prev_ref = ps_prev_layer->ai4_ref_id_to_poc_lc[0];

    i4_delta_poc_prev = i4_poc_prev - i4_poc_prev_ref;
    i2_mv_x = ps_prev_layer->s_global_mv[0][GMV_THICK_LOBE].i2_mv_x;
    i2_mv_y = ps_prev_layer->s_global_mv[0][GMV_THICK_LOBE].i2_mv_y;

    i2_mv_x = (S16)((i2_mv_x * i4_delta_poc) / i4_delta_poc_prev);
    i2_mv_y = (S16)((i2_mv_y * i4_delta_poc) / i4_delta_poc_prev);

    ps_mv->i2_mv_x = i2_mv_x;
    ps_mv->i2_mv_y = i2_mv_y;
}

/**
********************************************************************************
*  @fn     hme_calculate_global_mv(
*
*  @brief  Calculates global mv for a given histogram
*
*  @param[in]  ps_hist : the histogram structure
*
*  @param[in]  ps_mv : used to return the global mv
*
*  @param[in]  e_lobe_type : refer to GMV_MVTYPE_T
*
*  @return None
********************************************************************************
*/
void hme_calculate_global_mv(mv_hist_t *ps_hist, hme_mv_t *ps_mv, GMV_MVTYPE_T e_lobe_type)
{
    S32 i4_offset, i4_lobe_size, i4_y, i4_x, *pi4_bin_count;
    S32 i4_max_sum = -1;
    S32 i4_max_x = 0, i4_max_y = 0;

    if(e_lobe_type == GMV_THICK_LOBE)
        i4_lobe_size = ps_hist->i4_lobe1_size;
    else
        i4_lobe_size = ps_hist->i4_lobe2_size;

    i4_offset = i4_lobe_size >> 1;
    for(i4_y = i4_offset; i4_y < ps_hist->i4_num_rows - i4_offset; i4_y++)
    {
        for(i4_x = i4_offset; i4_x < ps_hist->i4_num_cols - i4_offset; i4_x++)
        {
            S32 i4_bin_id, i4_sum;
            i4_bin_id = (i4_x - 2) + ((i4_y - 2) * ps_hist->i4_num_cols);

            pi4_bin_count = &ps_hist->ai4_bin_count[i4_bin_id];
            i4_sum = hme_compute_2d_sum_unsigned(
                (void *)pi4_bin_count,
                i4_lobe_size,
                i4_lobe_size,
                ps_hist->i4_num_cols,
                sizeof(U32));

            if(i4_sum > i4_max_sum)
            {
                i4_max_x = i4_x;
                i4_max_y = i4_y;
                i4_max_sum = i4_sum;
            }
        }
    }

    ps_mv->i2_mv_y = (S16)((i4_max_y << ps_hist->i4_shift_y) + ps_hist->i4_min_y);
    ps_mv->i2_mv_x = (S16)((i4_max_x << ps_hist->i4_shift_x) + ps_hist->i4_min_x);
}

/**
********************************************************************************
*  @fn    ctb_node_t *hme_get_ctb_node(ctb_mem_mgr_t *ps_mem_mgr)
*
*  @brief  returns a new ctb node usable for creating a new ctb candidate
*
*  @param[in] ps_mem_mgr : memory manager holding all ctb nodes
*
*  @return NULL if no free nodes, else ptr to the new ctb node
********************************************************************************
*/
ctb_node_t *hme_get_ctb_node(ctb_mem_mgr_t *ps_mem_mgr)
{
    U08 *pu1_ret;
    if((ps_mem_mgr->i4_used + ps_mem_mgr->i4_size) > ps_mem_mgr->i4_tot)
        return (NULL);
    pu1_ret = ps_mem_mgr->pu1_mem + ps_mem_mgr->i4_used;
    ps_mem_mgr->i4_used += ps_mem_mgr->i4_size;
    return ((ctb_node_t *)pu1_ret);
}

/**
********************************************************************************
*  @fn     hme_map_mvs_to_grid(mv_grid_t **pps_mv_grid,
search_results_t *ps_search_results, S32 i4_num_ref)
*
*  @brief  For a given CU whose results are in ps_search_results, the 17x17
*          mv grid is updated for future use within the CTB
*
*  @param[in] ps_search_results : Search results data structure
*
*  @param[out] pps_mv_grid: The mv grid (as many as num ref)
*
*  @param[in]  i4_num_ref: nuber of search iterations to update
*
*  @return None
********************************************************************************
*/
void hme_map_mvs_to_grid(
    mv_grid_t **pps_mv_grid,
    search_results_t *ps_search_results,
    U08 *pu1_pred_dir_searched,
    S32 i4_num_pred_dir)
{
    S32 i4_cu_start_offset;
    /*************************************************************************/
    /* Start x, y offset of CU relative to CTB. To update the mv grid which  */
    /* stores 1 mv per 4x4, we convert pixel offset to 4x4 blk offset        */
    /*************************************************************************/
    S32 i4_cu_offset_x = (S32)ps_search_results->u1_x_off >> 2;
    S32 i4_cu_offset_y = (S32)ps_search_results->u1_y_off >> 2;

    /* Controls the attribute of a given partition within CU   */
    /* , i.e. start locn, size                                 */
    part_attr_t *ps_part_attr;

    S32 i4_part, i4_part_id, num_parts, i4_stride;
    S16 i2_mv_x, i2_mv_y;
    S08 i1_ref_idx;

    /* Per partition, attributes w.r.t. CU start */
    S32 x_start, y_start, x_end, y_end, i4_x, i4_y;
    PART_TYPE_T e_part_type;

    /* Points to exact mv structures within the grid to be udpated */
    search_node_t *ps_grid_node, *ps_grid_node_tmp;

    /* points to exact mv grid (based on search iteration) to be updated */
    mv_grid_t *ps_mv_grid;

    search_node_t *ps_search_node;

    S32 shift, i, mv_shift = 2;
    /* Proportional to the size of CU, controls the number of 4x4 blks */
    /* to be updated                                                   */
    shift = ps_search_results->e_cu_size;
    ASSERT(i4_num_pred_dir <= 2);

    e_part_type = (PART_TYPE_T)ps_search_results->ps_cu_results->ps_best_results[0].u1_part_type;

    if((ps_search_results->e_cu_size == CU_16x16) && (ps_search_results->u1_split_flag) &&
       (ps_search_results->i4_part_mask & ENABLE_NxN))
    {
        e_part_type = PRT_NxN;
    }

    for(i = 0; i < i4_num_pred_dir; i++)
    {
        num_parts = gau1_num_parts_in_part_type[e_part_type];
        ps_mv_grid = pps_mv_grid[pu1_pred_dir_searched[i]];
        i4_stride = ps_mv_grid->i4_stride;

        i4_cu_start_offset =
            i4_cu_offset_x + i4_cu_offset_y * i4_stride + ps_mv_grid->i4_start_offset;

        /* Move to the appropriate 2d locn of CU start within Grid */
        ps_grid_node = &ps_mv_grid->as_node[i4_cu_start_offset];

        for(i4_part = 0; i4_part < num_parts; i4_part++)
        {
            i4_part_id = ge_part_type_to_part_id[e_part_type][i4_part];

            /* Pick the mvx and y and ref id corresponding to this partition */
            ps_search_node =
                ps_search_results->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id];

            i2_mv_x = ps_search_node->s_mv.i2_mvx;
            i2_mv_y = ps_search_node->s_mv.i2_mvy;
            i1_ref_idx = ps_search_node->i1_ref_idx;

            /* Move to the appropriate location within the CU */
            ps_part_attr = &gas_part_attr_in_cu[i4_part_id];
            x_start = ps_part_attr->u1_x_start;
            x_end = x_start + ps_part_attr->u1_x_count;
            y_start = ps_part_attr->u1_y_start;
            y_end = y_start + ps_part_attr->u1_y_count;

            /* Convert attributes from 8x8 CU size to given CU size */
            x_start = (x_start << shift) >> mv_shift;
            x_end = (x_end << shift) >> mv_shift;
            y_start = (y_start << shift) >> mv_shift;
            y_end = (y_end << shift) >> mv_shift;

            ps_grid_node_tmp = ps_grid_node + y_start * i4_stride;

            /* Update all 4x4 blk mvs with the part mv */
            /* For e.g. we update 4 units in case of NxN for 16x16 CU */
            for(i4_y = y_start; i4_y < y_end; i4_y++)
            {
                for(i4_x = x_start; i4_x < x_end; i4_x++)
                {
                    ps_grid_node_tmp[i4_x].s_mv.i2_mvx = i2_mv_x;
                    ps_grid_node_tmp[i4_x].s_mv.i2_mvy = i2_mv_y;
                    ps_grid_node_tmp[i4_x].i1_ref_idx = i1_ref_idx;
                    ps_grid_node_tmp[i4_x].u1_subpel_done = 1;
                }
                ps_grid_node_tmp += i4_stride;
            }
        }
    }
}

void hme_set_ctb_pred_attr(ctb_node_t *ps_parent, U08 *pu1_pred0, U08 *pu1_pred1, S32 i4_stride)
{
    ps_parent->apu1_pred[0] = pu1_pred0;
    ps_parent->apu1_pred[1] = pu1_pred1;
    ps_parent->i4_pred_stride = i4_stride;
    if(ps_parent->ps_tl != NULL)
    {
        S32 blk_wd = (S32)ps_parent->ps_tr->u1_x_off;
        blk_wd -= (S32)ps_parent->u1_x_off;

        hme_set_ctb_pred_attr(ps_parent->ps_tl, pu1_pred0, pu1_pred1, i4_stride >> 1);

        hme_set_ctb_pred_attr(
            ps_parent->ps_tr, pu1_pred0 + blk_wd, pu1_pred1 + blk_wd, i4_stride >> 1);

        hme_set_ctb_pred_attr(
            ps_parent->ps_bl,
            pu1_pred0 + (blk_wd * i4_stride),
            pu1_pred1 + (blk_wd * i4_stride),
            i4_stride >> 1);

        hme_set_ctb_pred_attr(
            ps_parent->ps_tr,
            pu1_pred0 + (blk_wd * (1 + i4_stride)),
            pu1_pred1 + (blk_wd * (1 + i4_stride)),
            i4_stride >> 1);
    }
}

/**
********************************************************************************
*  @fn     hme_create_valid_part_ids(S32 i4_part_mask, S32 *pi4_valid_part_ids)
*
*  @brief  Expands the part mask to a list of valid part ids terminated by -1
*
*  @param[in] i4_part_mask : bit mask of active partitino ids
*
*  @param[out] pi4_valid_part_ids : array, each entry has one valid part id
*               Terminated by -1 to signal end.
*
*  @return number of partitions
********************************************************************************
*/
S32 hme_create_valid_part_ids(S32 i4_part_mask, S32 *pi4_valid_part_ids)
{
    S32 id = 0, i;
    for(i = 0; i < TOT_NUM_PARTS; i++)
    {
        if(i4_part_mask & (1 << i))
        {
            pi4_valid_part_ids[id] = i;
            id++;
        }
    }
    pi4_valid_part_ids[id] = -1;

    return id;
}

ctb_boundary_attrs_t *
    get_ctb_attrs(S32 ctb_start_x, S32 ctb_start_y, S32 pic_wd, S32 pic_ht, me_frm_ctxt_t *ps_ctxt)
{
    S32 horz_crop, vert_crop;
    ctb_boundary_attrs_t *ps_attrs;

    horz_crop = ((ctb_start_x + 64) > pic_wd) ? 2 : 0;
    vert_crop = ((ctb_start_y + 64) > pic_ht) ? 1 : 0;
    switch(horz_crop + vert_crop)
    {
    case 0:
        ps_attrs = &ps_ctxt->as_ctb_bound_attrs[CTB_CENTRE];
        break;
    case 1:
        ps_attrs = &ps_ctxt->as_ctb_bound_attrs[CTB_BOT_PIC_BOUNDARY];
        break;
    case 2:
        ps_attrs = &ps_ctxt->as_ctb_bound_attrs[CTB_RT_PIC_BOUNDARY];
        break;
    case 3:
        ps_attrs = &ps_ctxt->as_ctb_bound_attrs[CTB_BOT_RT_PIC_BOUNDARY];
        break;
    }
    return (ps_attrs);
}

/**
********************************************************************************
*  @fn     hevc_avg_2d(U08 *pu1_src1,
*                   U08 *pu1_src2,
*                   S32 i4_src1_stride,
*                   S32 i4_src2_stride,
*                   S32 i4_blk_wd,
*                   S32 i4_blk_ht,
*                   U08 *pu1_dst,
*                   S32 i4_dst_stride)
*
*
*  @brief  point wise average of two buffers into a third buffer
*
*  @param[in] pu1_src1 : first source buffer
*
*  @param[in] pu1_src2 : 2nd source buffer
*
*  @param[in] i4_src1_stride : stride of source 1 buffer
*
*  @param[in] i4_src2_stride : stride of source 2 buffer
*
*  @param[in] i4_blk_wd : block width
*
*  @param[in] i4_blk_ht : block height
*
*  @param[out] pu1_dst : destination buffer
*
*  @param[in] i4_dst_stride : stride of the destination buffer
*
*  @return void
********************************************************************************
*/
void hevc_avg_2d(
    U08 *pu1_src1,
    U08 *pu1_src2,
    S32 i4_src1_stride,
    S32 i4_src2_stride,
    S32 i4_blk_wd,
    S32 i4_blk_ht,
    U08 *pu1_dst,
    S32 i4_dst_stride)
{
    S32 i, j;

    for(i = 0; i < i4_blk_ht; i++)
    {
        for(j = 0; j < i4_blk_wd; j++)
        {
            pu1_dst[j] = (pu1_src1[j] + pu1_src2[j] + 1) >> 1;
        }
        pu1_src1 += i4_src1_stride;
        pu1_src2 += i4_src2_stride;
        pu1_dst += i4_dst_stride;
    }
}
/**
********************************************************************************
*  @fn     hme_pick_back_search_node(search_results_t *ps_search_results,
*                                   search_node_t *ps_search_node_fwd,
*                                   S32 i4_part_idx,
*                                   layer_ctxt_t *ps_curr_layer)
*
*
*  @brief  returns the search node corresponding to a ref idx in same or
*          opp direction. Preference is given to opp direction, but if that
*          does not yield results, same direction is attempted.
*
*  @param[in] ps_search_results: search results overall
*
*  @param[in] ps_search_node_fwd: search node corresponding to "fwd" direction
*
*  @param[in] i4_part_idx : partition id
*
*  @param[in] ps_curr_layer : layer context for current layer.
*
*  @return search node corresponding to hte "other direction"
********************************************************************************
*/
//#define PICK_L1_REF_SAME_DIR
search_node_t *hme_pick_back_search_node(
    search_results_t *ps_search_results,
    search_node_t *ps_search_node_fwd,
    S32 i4_part_idx,
    layer_ctxt_t *ps_curr_layer)
{
    S32 is_past_l0, is_past_l1, id, i, i4_poc;
    S32 *pi4_ref_id_to_poc_lc = ps_curr_layer->ai4_ref_id_to_poc_lc;
    //ref_attr_t *ps_ref_attr_lc;
    S08 i1_ref_idx_fwd;
    S16 i2_mv_x, i2_mv_y;
    search_node_t *ps_search_node;

    i1_ref_idx_fwd = ps_search_node_fwd->i1_ref_idx;
    i2_mv_x = ps_search_node_fwd->s_mv.i2_mvx;
    i2_mv_y = ps_search_node_fwd->s_mv.i2_mvy;
    i4_poc = ps_curr_layer->i4_poc;

    //ps_ref_attr_lc = &ps_curr_layer->as_ref_attr_lc[0];
    /* If the ref id already picked up maps to a past pic, then we pick */
    /* a result corresponding to future pic. If such a result is not    */
    /* to be found, then we pick a result corresponding to a past pic   */
    //is_past = ps_ref_attr_lc[i1_ref_idx_fwd].u1_is_past;
    is_past_l0 = (i4_poc > pi4_ref_id_to_poc_lc[i1_ref_idx_fwd]) ? 1 : 0;

    ASSERT(ps_search_results->u1_num_active_ref <= 2);

    /* pick the right iteration of search nodes to pick up */
#ifdef PICK_L1_REF_SAME_DIR
    if(ps_search_results->u1_num_active_ref == 2)
        id = !is_past_l0;
#else
    if(ps_search_results->u1_num_active_ref == 2)
        id = is_past_l0;
#endif
    else
        id = 0;

    ps_search_node = ps_search_results->aps_part_results[id][i4_part_idx];

    for(i = 0; i < ps_search_results->u1_num_results_per_part; i++)
    {
        S08 i1_ref_test = ps_search_node[i].i1_ref_idx;
        is_past_l1 = (pi4_ref_id_to_poc_lc[i1_ref_test] < i4_poc) ? 1 : 0;
        //if (ps_ref_attr_lc[ps_search_node[i].i1_ref_idx].u1_is_past != is_past)
#ifdef PICK_L1_REF_SAME_DIR
        if(is_past_l1 == is_past_l0)
#else
        if(is_past_l1 != is_past_l0)
#endif
        {
            /* belongs to same direction as the ref idx passed, so continue */
            return (ps_search_node + i);
        }
    }

    /* Unable to find best result in opp direction, so try same direction */
    /* However we need to ensure that we do not pick up same result       */
    for(i = 0; i < ps_search_results->u1_num_results_per_part; i++)
    {
        if((ps_search_node->i1_ref_idx != i1_ref_idx_fwd) ||
           (ps_search_node->s_mv.i2_mvx != i2_mv_x) || (ps_search_node->s_mv.i2_mvy != i2_mv_y))
        {
            return (ps_search_node);
        }
        ps_search_node++;
    }

    //ASSERT(0);
    return (ps_search_results->aps_part_results[id][i4_part_idx]);

    //return (NULL);
}

/**
********************************************************************************
*  @fn     hme_study_input_segmentation(U08 *pu1_inp, S32 i4_inp_stride)
*
*
*  @brief  Examines input 16x16 for possible edges and orientations of those,
*          and returns a bit mask of partitions that should be searched for
*
*  @param[in] pu1_inp : input buffer
*
*  @param[in] i4_inp_stride: input stride
*
*  @return part mask (bit mask of active partitions to search)
********************************************************************************
*/

S32 hme_study_input_segmentation(U08 *pu1_inp, S32 i4_inp_stride, S32 limit_active_partitions)
{
    S32 i4_rsum[16], i4_csum[16];
    U08 *pu1_tmp, u1_tmp;
    S32 i4_max_ridx, i4_max_cidx, i4_tmp;
    S32 i, j, i4_ret;
    S32 i4_max_rp[4], i4_max_cp[4];
    S32 i4_seg_lutc[4] = { 0, ENABLE_nLx2N, ENABLE_Nx2N, ENABLE_nRx2N };
    S32 i4_seg_lutr[4] = { 0, ENABLE_2NxnU, ENABLE_2NxN, ENABLE_2NxnD };
#define EDGE_THR (15 * 16)
#define HI_PASS(ptr, i) (2 * (ptr[i] - ptr[i - 1]) + (ptr[i + 1] - ptr[i - 2]))

    if(0 == limit_active_partitions)
    {
        /*********************************************************************/
        /* In this case, we do not optimize on active partitions and search  */
        /* brute force. This way, 17 partitinos would be enabled.            */
        /*********************************************************************/
        return (ENABLE_ALL_PARTS);
    }

    /*************************************************************************/
    /* Control passes below in case we wish to optimize on active partitions.*/
    /* This is based on input characteristics, check how an edge passes along*/
    /* an input 16x16 area, if at all, and decide active partitinos.         */
    /*************************************************************************/

    /* Initialize row and col sums */
    for(i = 0; i < 16; i++)
    {
        i4_rsum[i] = 0;
        i4_csum[i] = 0;
    }
    pu1_tmp = pu1_inp;
    for(i = 0; i < 16; i++)
    {
        for(j = 0; j < 16; j++)
        {
            u1_tmp = *pu1_tmp++;
            i4_rsum[i] += u1_tmp;
            i4_csum[j] += u1_tmp;
        }
        pu1_tmp += (i4_inp_stride - 16);
    }

    /* 0 is dummy; 1 is 4; 2 is 8; 3 is 12 */
    i4_max_rp[0] = 0;
    i4_max_cp[0] = 0;
    i4_max_rp[1] = 0;
    i4_max_cp[1] = 0;
    i4_max_rp[2] = 0;
    i4_max_cp[2] = 0;
    i4_max_rp[3] = 0;
    i4_max_cp[3] = 0;

    /* Get Max edge strength across (2,3) (3,4) (4,5) */
    for(i = 3; i < 6; i++)
    {
        /* Run [-1 -2 2 1] filter through rsum/csum */
        i4_tmp = HI_PASS(i4_rsum, i);
        if(ABS(i4_tmp) > i4_max_rp[1])
            i4_max_rp[1] = i4_tmp;

        i4_tmp = HI_PASS(i4_csum, i);
        if(ABS(i4_tmp) > i4_max_cp[1])
            i4_max_cp[1] = i4_tmp;
    }

    /* Get Max edge strength across (6,7) (7,8) (8,9) */
    for(i = 7; i < 10; i++)
    {
        /* Run [-1 -2 2 1] filter through rsum/csum */
        i4_tmp = HI_PASS(i4_rsum, i);
        if(ABS(i4_tmp) > i4_max_rp[2])
            i4_max_rp[2] = i4_tmp;

        i4_tmp = HI_PASS(i4_csum, i);
        if(ABS(i4_tmp) > i4_max_cp[2])
            i4_max_cp[2] = i4_tmp;
    }

    /* Get Max edge strength across (10,11) (11,12) (12,13) */
    for(i = 11; i < 14; i++)
    {
        /* Run [-1 -2 2 1] filter through rsum/csum */
        i4_tmp = HI_PASS(i4_rsum, i);
        if(ABS(i4_tmp) > i4_max_rp[3])
            i4_max_rp[3] = i4_tmp;

        i4_tmp = HI_PASS(i4_csum, i);
        if(ABS(i4_tmp) > i4_max_cp[3])
            i4_max_cp[3] = i4_tmp;
    }

    /* Find the maximum across the 3 and see whether the strength qualifies as edge */
    i4_max_ridx = 1;
    i4_max_cidx = 1;
    for(i = 2; i <= 3; i++)
    {
        if(i4_max_rp[i] > i4_max_rp[i4_max_ridx])
            i4_max_ridx = i;

        if(i4_max_cp[i] > i4_max_cp[i4_max_cidx])
            i4_max_cidx = i;
    }

    if(EDGE_THR > i4_max_rp[i4_max_ridx])
    {
        i4_max_ridx = 0;
    }

    if(EDGE_THR > i4_max_cp[i4_max_cidx])
    {
        i4_max_cidx = 0;
    }

    i4_ret = ENABLE_2Nx2N;

    /* If only vertical discontinuity, go with one of 2Nx? */
    if(0 == (i4_max_ridx + i4_max_cidx))
    {
        //num_me_parts++;
        return i4_ret;
    }

    if(i4_max_ridx && (i4_max_cidx == 0))
    {
        //num_me_parts += 3;
        return ((i4_ret | i4_seg_lutr[i4_max_ridx]));
    }

    /* If only horizontal discontinuity, go with one of ?x2N */
    if(i4_max_cidx && (i4_max_ridx == 0))
    {
        //num_me_parts += 3;
        return ((i4_ret | i4_seg_lutc[i4_max_cidx]));
    }

    /* If middle is dominant in both directions, go with NxN */
    if((2 == i4_max_cidx) && (2 == i4_max_ridx))
    {
        //num_me_parts += 5;
        return ((i4_ret | ENABLE_NxN));
    }

    /* Otherwise, conservatively, enable NxN and the 2 AMPs */
    //num_me_parts += 9;
    return (i4_ret | ENABLE_NxN | i4_seg_lutr[i4_max_ridx] | i4_seg_lutc[i4_max_cidx]);
}

/**
********************************************************************************
*  @fn     hme_init_search_results(search_results_t *ps_search_results,
*                           S32 i4_num_ref,
*                           S32 i4_num_best_results,
*                           S32 i4_num_results_per_part,
*                           BLK_SIZE_T e_blk_size,
*                           S32 i4_x_off,
*                           S32 i4_y_off)
*
*  @brief  Initializes the search results structure with some key attributes
*
*  @param[out] ps_search_results : search results structure to initialise
*
*  @param[in] i4_num_Ref: corresponds to the number of ref ids searched
*
*  @param[in] i4_num_best_results: Number of best results for the CU to
*               be maintained in the result structure
*
*  @param[in] i4_num_results_per_part: Per active partition the number of best
*               results to be maintained
*
*  @param[in] e_blk_size: blk size of the CU for which this structure used
*
*  @param[in] i4_x_off: x offset of the top left of CU from CTB top left
*
*  @param[in] i4_y_off: y offset of the top left of CU from CTB top left
*
*  @param[in] pu1_is_past : points ot an array that tells whether a given ref id
*              has prominence in L0 or in L1 list (past or future )
*
*  @return void
********************************************************************************
*/
void hme_init_search_results(
    search_results_t *ps_search_results,
    S32 i4_num_ref,
    S32 i4_num_best_results,
    S32 i4_num_results_per_part,
    BLK_SIZE_T e_blk_size,
    S32 i4_x_off,
    S32 i4_y_off,
    U08 *pu1_is_past)
{
    CU_SIZE_T e_cu_size = ge_blk_size_to_cu_size[e_blk_size];

    ASSERT(e_cu_size != -1);
    ps_search_results->e_cu_size = e_cu_size;
    ps_search_results->u1_x_off = (U08)i4_x_off;
    ps_search_results->u1_y_off = (U08)i4_y_off;
    ps_search_results->u1_num_active_ref = (U08)i4_num_ref;
    ps_search_results->u1_num_best_results = (U08)i4_num_best_results;
    ps_search_results->u1_num_results_per_part = (U08)i4_num_results_per_part;
    ps_search_results->pu1_is_past = pu1_is_past;
    ps_search_results->u1_split_flag = 0;
    ps_search_results->best_cu_cost = MAX_32BIT_VAL;
}

/**
********************************************************************************
*  @fn     hme_reset_search_results((search_results_t *ps_search_results,
*                               S32 i4_part_mask)
*
*
*  @brief  Resets the best results to maximum values, so as to allow search
*          for the new CU's partitions. The existing results may be from an
*          older CU using same structure.
*
*  @param[in] ps_search_results: search results structure
*
*  @param[in] i4_part_mask : bit mask of active partitions
*
*  @return part mask (bit mask of active partitions to search)
********************************************************************************
*/
void hme_reset_search_results(search_results_t *ps_search_results, S32 i4_part_mask, S32 mv_res)
{
    S32 i4_num_ref = (S32)ps_search_results->u1_num_active_ref;
    S08 i1_ref_idx;
    S32 i, j;
    search_node_t *ps_search_node;

    /* store this for future use */
    ps_search_results->i4_part_mask = i4_part_mask;

    /* Reset the spli_flag to zero */
    ps_search_results->u1_split_flag = 0;

    HME_SET_MVPRED_RES((&ps_search_results->as_pred_ctxt[0]), mv_res);
    HME_SET_MVPRED_RES((&ps_search_results->as_pred_ctxt[1]), mv_res);

    for(i1_ref_idx = 0; i1_ref_idx < i4_num_ref; i1_ref_idx++)
    {
        /* Reset the individual partitino results */
        for(i = 0; i < TOT_NUM_PARTS; i++)
        {
            if(!(i4_part_mask & (1 << i)))
                continue;

            ps_search_node = ps_search_results->aps_part_results[i1_ref_idx][i];

            for(j = 0; j < ps_search_results->u1_num_results_per_part; j++)
            {
                ps_search_node[j].s_mv.i2_mvx = 0;
                ps_search_node[j].s_mv.i2_mvy = 0;
                ps_search_node[j].i4_tot_cost = MAX_32BIT_VAL;
                ps_search_node[j].i4_sad = MAX_32BIT_VAL;
                ps_search_node[j].i4_sdi = 0;
                ps_search_node[j].i1_ref_idx = -1;
                ps_search_node[j].u1_subpel_done = 0;
                ps_search_node[j].u1_is_avail = 1;
                ps_search_node[j].i4_mv_cost = 0;
            }
        }
    }
}
/**
********************************************************************************
*  @fn     hme_clamp_grid_by_mvrange(search_node_t *ps_search_node,
*                               S32 i4_step,
*                               range_prms_t *ps_mvrange)
*
*  @brief  Given a central pt within mv range, and a grid of points surrounding
*           this pt, this function returns a grid mask of pts within search rng
*
*  @param[in] ps_search_node: the centre pt of the grid
*
*  @param[in] i4_step: step size of grid
*
*  @param[in] ps_mvrange: structure containing the current mv range
*
*  @return bitmask of the  pts in grid within search range
********************************************************************************
*/
S32 hme_clamp_grid_by_mvrange(search_node_t *ps_search_node, S32 i4_step, range_prms_t *ps_mvrange)
{
    S32 i4_mask = GRID_ALL_PTS_VALID;
    if(ps_search_node->s_mv.i2_mvx + i4_step >= ps_mvrange->i2_max_x)
    {
        i4_mask &= (GRID_RT_3_INVALID);
    }
    if(ps_search_node->s_mv.i2_mvx - i4_step < ps_mvrange->i2_min_x)
    {
        i4_mask &= (GRID_LT_3_INVALID);
    }
    if(ps_search_node->s_mv.i2_mvy + i4_step >= ps_mvrange->i2_max_y)
    {
        i4_mask &= (GRID_BOT_3_INVALID);
    }
    if(ps_search_node->s_mv.i2_mvy - i4_step < ps_mvrange->i2_min_y)
    {
        i4_mask &= (GRID_TOP_3_INVALID);
    }
    return i4_mask;
}

/**
********************************************************************************
*  @fn    layer_ctxt_t *hme_get_past_layer_ctxt(me_ctxt_t *ps_ctxt,
S32 i4_layer_id)
*
*  @brief  returns the layer ctxt of the layer with given id from the temporally
*          previous frame
*
*  @param[in] ps_ctxt : ME context
*
*  @param[in] i4_layer_id : id of layer required
*
*  @return layer ctxt of given layer id in temporally previous frame
********************************************************************************
*/
layer_ctxt_t *hme_get_past_layer_ctxt(
    me_ctxt_t *ps_ctxt, me_frm_ctxt_t *ps_frm_ctxt, S32 i4_layer_id, S32 i4_num_me_frm_pllel)
{
    S32 i4_poc = ps_frm_ctxt->ai4_ref_idx_to_poc_lc[0];
    S32 i;
    layers_descr_t *ps_desc;

    for(i = 0; i < (ps_ctxt->aps_me_frm_prms[0]->max_num_ref * i4_num_me_frm_pllel) + 1; i++)
    {
        ps_desc = &ps_ctxt->as_ref_descr[i];
        if(i4_poc == ps_desc->aps_layers[i4_layer_id]->i4_poc)
            return (ps_desc->aps_layers[i4_layer_id]);
    }
    return NULL;
}

/**
********************************************************************************
*  @fn    layer_ctxt_t *hme_coarse_get_past_layer_ctxt(me_ctxt_t *ps_ctxt,
S32 i4_layer_id)
*
*  @brief  returns the layer ctxt of the layer with given id from the temporally
*          previous frame
*
*  @param[in] ps_ctxt : ME context
*
*  @param[in] i4_layer_id : id of layer required
*
*  @return layer ctxt of given layer id in temporally previous frame
********************************************************************************
*/
layer_ctxt_t *hme_coarse_get_past_layer_ctxt(coarse_me_ctxt_t *ps_ctxt, S32 i4_layer_id)
{
    S32 i4_poc = ps_ctxt->ai4_ref_idx_to_poc_lc[0];
    S32 i;
    layers_descr_t *ps_desc;

    for(i = 0; i < ps_ctxt->max_num_ref + 1 + NUM_BUFS_DECOMP_HME; i++)
    {
        ps_desc = &ps_ctxt->as_ref_descr[i];
        if(i4_poc == ps_desc->aps_layers[i4_layer_id]->i4_poc)
            return (ps_desc->aps_layers[i4_layer_id]);
    }
    return NULL;
}

/**
********************************************************************************
*  @fn    void hme_init_mv_bank(layer_ctxt_t *ps_layer_ctxt,
BLK_SIZE_T e_blk_size,
S32 i4_num_ref,
S32 i4_num_results_per_part)
*
*  @brief  Given a blk size to be used for this layer, this function initialize
*          the mv bank to make it ready to store and return results.
*
*  @param[in, out] ps_layer_ctxt: pointer to layer ctxt
*
*  @param[in] e_blk_size : resolution at which mvs are stored
*
*  @param[in] i4_num_ref: number of reference frames corresponding to which
*              results are stored.
*
*  @param[in] e_blk_size : resolution at which mvs are stored
*
*  @param[in] i4_num_results_per_part : Number of results to be stored per
*               ref idx. So these many best results stored
*
*  @return void
********************************************************************************
*/
void hme_init_mv_bank(
    layer_ctxt_t *ps_layer_ctxt,
    BLK_SIZE_T e_blk_size,
    S32 i4_num_ref,
    S32 i4_num_results_per_part,
    U08 u1_enc)
{
    layer_mv_t *ps_mv_bank;
    hme_mv_t *ps_mv1, *ps_mv2;
    S08 *pi1_ref_id1, *pi1_ref_id2;
    S32 blk_wd, mvs_in_blk, blks_in_row, mvs_in_row, blks_in_col;
    S32 i4_i, i4_j, blk_ht;

    ps_mv_bank = ps_layer_ctxt->ps_layer_mvbank;
    ps_mv_bank->i4_num_mvs_per_ref = i4_num_results_per_part;
    ps_mv_bank->i4_num_ref = i4_num_ref;
    mvs_in_blk = i4_num_ref * i4_num_results_per_part;
    ps_mv_bank->i4_num_mvs_per_blk = mvs_in_blk;

    /*************************************************************************/
    /* Store blk size, from blk size derive blk width and use this to compute*/
    /* number of blocks every row. We also pad to left and top by 1, to      */
    /* support the prediction mechanism.                                     */
    /*************************************************************************/
    ps_mv_bank->e_blk_size = e_blk_size;
    blk_wd = gau1_blk_size_to_wd[e_blk_size];
    blk_ht = gau1_blk_size_to_ht[e_blk_size];

    blks_in_row = (ps_layer_ctxt->i4_wd + (blk_wd - 1)) / blk_wd;
    blks_in_col = (ps_layer_ctxt->i4_ht + (blk_ht - 1)) / blk_ht;

    if(u1_enc)
    {
        /* TODO: CTB64x64 is assumed. FIX according to actual CTB */
        WORD32 num_ctb_cols = ((ps_layer_ctxt->i4_wd + 63) >> 6);
        WORD32 num_ctb_rows = ((ps_layer_ctxt->i4_ht + 63) >> 6);

        blks_in_row = (num_ctb_cols << 3);
        blks_in_col = (num_ctb_rows << 3);
    }

    blks_in_row += 2;
    mvs_in_row = blks_in_row * mvs_in_blk;

    ps_mv_bank->i4_num_blks_per_row = blks_in_row;
    ps_mv_bank->i4_num_mvs_per_row = mvs_in_row;

    /* To ensure run time requirements fall within allocation time request */
    ASSERT(ps_mv_bank->i4_num_mvs_per_row <= ps_mv_bank->max_num_mvs_per_row);

    /*************************************************************************/
    /* Increment by one full row at top for padding and one column in left   */
    /* this gives us the actual start of mv for 0,0 blk                      */
    /*************************************************************************/
    ps_mv_bank->ps_mv = ps_mv_bank->ps_mv_base + mvs_in_row + mvs_in_blk;
    ps_mv_bank->pi1_ref_idx = ps_mv_bank->pi1_ref_idx_base + mvs_in_row + mvs_in_blk;

    memset(ps_mv_bank->ps_mv_base, 0, mvs_in_row * sizeof(hme_mv_t));
    memset(ps_mv_bank->pi1_ref_idx_base, -1, mvs_in_row * sizeof(U08));

    /*************************************************************************/
    /* Initialize top row, left col and right col with zeros since these are */
    /* used as candidates during searches.                                   */
    /*************************************************************************/
    ps_mv1 = ps_mv_bank->ps_mv_base + mvs_in_row;
    ps_mv2 = ps_mv1 + mvs_in_row - mvs_in_blk;
    pi1_ref_id1 = ps_mv_bank->pi1_ref_idx_base + mvs_in_row;
    pi1_ref_id2 = pi1_ref_id1 + mvs_in_row - mvs_in_blk;
    for(i4_i = 0; i4_i < blks_in_col; i4_i++)
    {
        for(i4_j = 0; i4_j < mvs_in_blk; i4_j++)
        {
            ps_mv1[i4_j].i2_mv_x = 0;
            ps_mv1[i4_j].i2_mv_y = 0;
            ps_mv2[i4_j].i2_mv_x = 0;
            ps_mv2[i4_j].i2_mv_y = 0;
            pi1_ref_id1[i4_j] = -1;
            pi1_ref_id2[i4_j] = -1;
        }
        ps_mv1 += mvs_in_row;
        ps_mv2 += mvs_in_row;
        pi1_ref_id1 += mvs_in_row;
        pi1_ref_id2 += mvs_in_row;
    }
}
void hme_fill_mvbank_intra(layer_ctxt_t *ps_layer_ctxt)
{
    layer_mv_t *ps_mv_bank;
    hme_mv_t *ps_mv;
    S08 *pi1_ref_id;
    S32 blk_wd, blks_in_row, mvs_in_row, blks_in_col;
    S32 i, j, blk_ht;
    BLK_SIZE_T e_blk_size;

    ps_mv_bank = ps_layer_ctxt->ps_layer_mvbank;

    /*************************************************************************/
    /* Store blk size, from blk size derive blk width and use this to compute*/
    /* number of blocks every row. We also pad to left and top by 1, to      */
    /* support the prediction mechanism.                                     */
    /*************************************************************************/
    e_blk_size = ps_mv_bank->e_blk_size;
    blk_wd = gau1_blk_size_to_wd[e_blk_size];
    blk_ht = gau1_blk_size_to_wd[e_blk_size];
    blks_in_row = ps_layer_ctxt->i4_wd / blk_wd;
    blks_in_col = ps_layer_ctxt->i4_ht / blk_ht;
    mvs_in_row = blks_in_row * ps_mv_bank->i4_num_mvs_per_blk;

    /*************************************************************************/
    /* Increment by one full row at top for padding and one column in left   */
    /* this gives us the actual start of mv for 0,0 blk                      */
    /*************************************************************************/
    ps_mv = ps_mv_bank->ps_mv;
    pi1_ref_id = ps_mv_bank->pi1_ref_idx;

    for(i = 0; i < blks_in_col; i++)
    {
        for(j = 0; j < blks_in_row; j++)
        {
            ps_mv[j].i2_mv_x = INTRA_MV;
            ps_mv[j].i2_mv_y = INTRA_MV;
            pi1_ref_id[j] = -1;
        }
        ps_mv += ps_mv_bank->i4_num_mvs_per_row;
        pi1_ref_id += ps_mv_bank->i4_num_mvs_per_row;
    }
}

/**
********************************************************************************
*  @fn    void hme_derive_search_range(range_prms_t *ps_range,
*                                   range_prms_t *ps_pic_limit,
*                                   range_prms_t *ps_mv_limit,
*                                   S32 i4_x,
*                                   S32 i4_y,
*                                   S32 blk_wd,
*                                   S32 blk_ht)
*
*  @brief  given picture limits and blk dimensions and mv search limits, obtains
*          teh valid search range such that the blk stays within pic boundaries,
*          where picture boundaries include padded portions of picture
*
*  @param[out] ps_range: updated with actual search range
*
*  @param[in] ps_pic_limit : picture boundaries
*
*  @param[in] ps_mv_limit: Search range limits for the mvs
*
*  @param[in] i4_x : x coordinate of the blk
*
*  @param[in] i4_y : y coordinate of the blk
*
*  @param[in] blk_wd : blk width
*
*  @param[in] blk_ht : blk height
*
*  @return void
********************************************************************************
*/
void hme_derive_search_range(
    range_prms_t *ps_range,
    range_prms_t *ps_pic_limit,
    range_prms_t *ps_mv_limit,
    S32 i4_x,
    S32 i4_y,
    S32 blk_wd,
    S32 blk_ht)
{
    ps_range->i2_max_x =
        MIN((ps_pic_limit->i2_max_x - (S16)blk_wd - (S16)i4_x), ps_mv_limit->i2_max_x);
    ps_range->i2_min_x = MAX((ps_pic_limit->i2_min_x - (S16)i4_x), ps_mv_limit->i2_min_x);
    ps_range->i2_max_y =
        MIN((ps_pic_limit->i2_max_y - (S16)blk_ht - (S16)i4_y), ps_mv_limit->i2_max_y);
    ps_range->i2_min_y = MAX((ps_pic_limit->i2_min_y - (S16)i4_y), ps_mv_limit->i2_min_y);
}

/**
********************************************************************************
*  @fn    void hme_get_spatial_candt(search_node_t *ps_search_node,
*                                   layer_ctxt_t *ps_curr_layer,
*                                   S32 i4_blk_x,
*                                   S32 i4_blk_y,
*                                   S08 i1_ref_id,
*                                   S32 i4_result_id)
*
*  @brief  obtains a candt from the same mv bank as the current one, its called
*          spatial candt as it does not require scaling for temporal distances
*
*  @param[out] ps_search_node: mv and ref id updated here of the candt
*
*  @param[in] ps_curr_layer: layer ctxt, has the mv bank structure pointer
*
*  @param[in] i4_blk_x : x coordinate of the block in mv bank
*
*  @param[in] i4_blk_y : y coordinate of the block in mv bank
*
*  @param[in] i1_ref_id : Corresponds to ref idx from which to pick up mv
*              results, useful if multiple ref idx candts maintained separately.
*
*  @param[in] i4_result_id : If multiple results stored per ref idx, this
*              pts to the id of the result
*
*  @param[in] tr_avail : top right availability of the block
*
*  @param[in] bl_avail : bottom left availability of the block
*
*  @return void
********************************************************************************
*/
void hme_get_spatial_candt(
    layer_ctxt_t *ps_curr_layer,
    BLK_SIZE_T e_search_blk_size,
    S32 i4_blk_x,
    S32 i4_blk_y,
    S08 i1_ref_idx,
    search_node_t *ps_top_neighbours,
    search_node_t *ps_left_neighbours,
    S32 i4_result_id,
    S32 tr_avail,
    S32 bl_avail,
    S32 encode)

{
    layer_mv_t *ps_layer_mvbank = ps_curr_layer->ps_layer_mvbank;
    S32 i4_blk_size1 = gau1_blk_size_to_wd[ps_layer_mvbank->e_blk_size];
    S32 i4_blk_size2 = gau1_blk_size_to_wd[e_search_blk_size];
    search_node_t *ps_search_node;
    S32 i4_offset;
    hme_mv_t *ps_mv, *ps_mv_base;
    S08 *pi1_ref_idx, *pi1_ref_idx_base;
    S32 jump = 1, mvs_in_blk, mvs_in_row;
    S32 shift = (encode ? 2 : 0);

    if(i4_blk_size1 != i4_blk_size2)
    {
        i4_blk_x <<= 1;
        i4_blk_y <<= 1;
        jump = 2;
        if((i4_blk_size1 << 2) == i4_blk_size2)
        {
            i4_blk_x <<= 1;
            i4_blk_y <<= 1;
            jump = 4;
        }
    }

    mvs_in_blk = ps_layer_mvbank->i4_num_mvs_per_blk;
    mvs_in_row = ps_layer_mvbank->i4_num_mvs_per_row;

    /* Adjust teh blk coord to point to top left locn */
    i4_blk_x -= 1;
    i4_blk_y -= 1;
    /* Pick up the mvs from the location */
    i4_offset = (i4_blk_x * ps_layer_mvbank->i4_num_mvs_per_blk);
    i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * i4_blk_y);

    ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
    pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;

    ps_mv += (i1_ref_idx * ps_layer_mvbank->i4_num_mvs_per_ref) + i4_result_id;
    pi1_ref_idx += (i1_ref_idx * ps_layer_mvbank->i4_num_mvs_per_ref) + i4_result_id;

    ps_mv_base = ps_mv;
    pi1_ref_idx_base = pi1_ref_idx;

    /* ps_mv and pi1_ref_idx now point to the top left locn */
    /* Get 4 mvs as follows:                                */
    ps_search_node = ps_top_neighbours;
    COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);

    /* Move to top */
    ps_search_node++;
    ps_mv += mvs_in_blk;
    pi1_ref_idx += mvs_in_blk;
    COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);

    /* Move to t1 : relevant for 4x4 part searches or for partitions i 16x16 */
    if(ps_layer_mvbank->i4_num_mvs_per_ref > 1)
    {
        ps_search_node++;
        ps_mv += (mvs_in_blk * (jump >> 1));
        pi1_ref_idx += (mvs_in_blk * (jump >> 1));
        COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);
    }
    else
    {
        ps_search_node++;
        ps_search_node->s_mv.i2_mvx = 0;
        ps_search_node->s_mv.i2_mvy = 0;
        ps_search_node->i1_ref_idx = i1_ref_idx;
        ps_search_node->u1_is_avail = 0;
        ps_search_node->u1_subpel_done = 0;
    }

    /* Move to tr: this will be tr w.r.t. the blk being searched */
    ps_search_node++;
    if(tr_avail == 0)
    {
        ps_search_node->s_mv.i2_mvx = 0;
        ps_search_node->s_mv.i2_mvy = 0;
        ps_search_node->i1_ref_idx = i1_ref_idx;
        ps_search_node->u1_is_avail = 0;
        ps_search_node->u1_subpel_done = 0;
    }
    else
    {
        ps_mv = ps_mv_base + (mvs_in_blk * (1 + jump));
        pi1_ref_idx = pi1_ref_idx_base + (mvs_in_blk * (1 + jump));
        COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);
    }

    /* Move to left */
    ps_search_node = ps_left_neighbours;
    ps_mv = ps_mv_base + mvs_in_row;
    pi1_ref_idx = pi1_ref_idx_base + mvs_in_row;
    COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);

    /* Move to l1 */
    if(ps_layer_mvbank->i4_num_mvs_per_ref > 1)
    {
        ps_search_node++;
        ps_mv += (mvs_in_row * (jump >> 1));
        pi1_ref_idx += (mvs_in_row * (jump >> 1));
        COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);
    }
    else
    {
        ps_search_node++;
        ps_search_node->s_mv.i2_mvx = 0;
        ps_search_node->s_mv.i2_mvy = 0;
        ps_search_node->i1_ref_idx = i1_ref_idx;
        ps_search_node->u1_is_avail = 0;
        ps_search_node->u1_subpel_done = 0;
    }

    /* Move to bl */
    ps_search_node++;
    if(bl_avail == 0)
    {
        ps_search_node->s_mv.i2_mvx = 0;
        ps_search_node->s_mv.i2_mvy = 0;
        ps_search_node->i1_ref_idx = i1_ref_idx;
        ps_search_node->u1_is_avail = 0;
    }
    else
    {
        ps_mv = ps_mv_base + (mvs_in_row * (1 + jump));
        pi1_ref_idx = pi1_ref_idx_base + (mvs_in_row * (1 + jump));
        COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);
    }
}

void hme_get_spatial_candt_in_l1_me(
    layer_ctxt_t *ps_curr_layer,
    BLK_SIZE_T e_search_blk_size,
    S32 i4_blk_x,
    S32 i4_blk_y,
    S08 i1_ref_idx,
    U08 u1_pred_dir,
    search_node_t *ps_top_neighbours,
    search_node_t *ps_left_neighbours,
    S32 i4_result_id,
    S32 tr_avail,
    S32 bl_avail,
    S32 i4_num_act_ref_l0,
    S32 i4_num_act_ref_l1)
{
    search_node_t *ps_search_node;
    hme_mv_t *ps_mv, *ps_mv_base;

    S32 i4_offset;
    S32 mvs_in_blk, mvs_in_row;
    S08 *pi1_ref_idx, *pi1_ref_idx_base;
    S32 i4_mv_pos_in_implicit_array;

    layer_mv_t *ps_layer_mvbank = ps_curr_layer->ps_layer_mvbank;

    S32 i4_blk_size1 = gau1_blk_size_to_wd[ps_layer_mvbank->e_blk_size];
    S32 i4_blk_size2 = gau1_blk_size_to_wd[e_search_blk_size];
    S32 jump = 1;
    S32 shift = 0;
    S32 i4_num_results_in_given_dir =
        ((u1_pred_dir == 1) ? (ps_layer_mvbank->i4_num_mvs_per_ref * i4_num_act_ref_l1)
                            : (ps_layer_mvbank->i4_num_mvs_per_ref * i4_num_act_ref_l0));

    if(i4_blk_size1 != i4_blk_size2)
    {
        i4_blk_x <<= 1;
        i4_blk_y <<= 1;
        jump = 2;
        if((i4_blk_size1 << 2) == i4_blk_size2)
        {
            i4_blk_x <<= 1;
            i4_blk_y <<= 1;
            jump = 4;
        }
    }

    mvs_in_blk = ps_layer_mvbank->i4_num_mvs_per_blk;
    mvs_in_row = ps_layer_mvbank->i4_num_mvs_per_row;

    /* Adjust the blk coord to point to top left locn */
    i4_blk_x -= 1;
    i4_blk_y -= 1;
    /* Pick up the mvs from the location */
    i4_offset = (i4_blk_x * ps_layer_mvbank->i4_num_mvs_per_blk);
    i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * i4_blk_y);

    i4_offset +=
        ((u1_pred_dir == 1) ? (ps_layer_mvbank->i4_num_mvs_per_ref * i4_num_act_ref_l0) : 0);

    ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
    pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;

    ps_mv_base = ps_mv;
    pi1_ref_idx_base = pi1_ref_idx;

    /* TL */
    {
        /* ps_mv and pi1_ref_idx now point to the top left locn */
        ps_search_node = ps_top_neighbours;

        i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
            pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);

        if(-1 != i4_mv_pos_in_implicit_array)
        {
            COPY_MV_TO_SEARCH_NODE(
                ps_search_node,
                &ps_mv[i4_mv_pos_in_implicit_array],
                &pi1_ref_idx[i4_mv_pos_in_implicit_array],
                i1_ref_idx,
                shift);
        }
        else
        {
            ps_search_node->u1_is_avail = 0;
            ps_search_node->s_mv.i2_mvx = 0;
            ps_search_node->s_mv.i2_mvy = 0;
            ps_search_node->i1_ref_idx = i1_ref_idx;
        }
    }

    /* Move to top */
    {
        /* ps_mv and pi1_ref_idx now point to the top left locn */
        ps_search_node++;
        ps_mv += mvs_in_blk;
        pi1_ref_idx += mvs_in_blk;

        i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
            pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);

        if(-1 != i4_mv_pos_in_implicit_array)
        {
            COPY_MV_TO_SEARCH_NODE(
                ps_search_node,
                &ps_mv[i4_mv_pos_in_implicit_array],
                &pi1_ref_idx[i4_mv_pos_in_implicit_array],
                i1_ref_idx,
                shift);
        }
        else
        {
            ps_search_node->u1_is_avail = 0;
            ps_search_node->s_mv.i2_mvx = 0;
            ps_search_node->s_mv.i2_mvy = 0;
            ps_search_node->i1_ref_idx = i1_ref_idx;
        }
    }

    /* Move to t1 : relevant for 4x4 part searches or for partitions i 16x16 */
    if(ps_layer_mvbank->i4_num_mvs_per_ref > 1)
    {
        ps_search_node++;
        ps_mv += (mvs_in_blk * (jump >> 1));
        pi1_ref_idx += (mvs_in_blk * (jump >> 1));

        i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
            pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);

        if(-1 != i4_mv_pos_in_implicit_array)
        {
            COPY_MV_TO_SEARCH_NODE(
                ps_search_node,
                &ps_mv[i4_mv_pos_in_implicit_array],
                &pi1_ref_idx[i4_mv_pos_in_implicit_array],
                i1_ref_idx,
                shift);
        }
        else
        {
            ps_search_node->u1_is_avail = 0;
            ps_search_node->s_mv.i2_mvx = 0;
            ps_search_node->s_mv.i2_mvy = 0;
            ps_search_node->i1_ref_idx = i1_ref_idx;
        }
    }
    else
    {
        ps_search_node++;
        ps_search_node->u1_is_avail = 0;
        ps_search_node->s_mv.i2_mvx = 0;
        ps_search_node->s_mv.i2_mvy = 0;
        ps_search_node->i1_ref_idx = i1_ref_idx;
    }

    /* Move to tr: this will be tr w.r.t. the blk being searched */
    ps_search_node++;
    if(tr_avail == 0)
    {
        ps_search_node->s_mv.i2_mvx = 0;
        ps_search_node->s_mv.i2_mvy = 0;
        ps_search_node->i1_ref_idx = i1_ref_idx;
        ps_search_node->u1_is_avail = 0;
        ps_search_node->u1_subpel_done = 0;
    }
    else
    {
        /* ps_mv and pi1_ref_idx now point to the top left locn */
        ps_mv = ps_mv_base + (mvs_in_blk * (1 + jump));
        pi1_ref_idx = pi1_ref_idx_base + (mvs_in_blk * (1 + jump));

        i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
            pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);

        if(-1 != i4_mv_pos_in_implicit_array)
        {
            COPY_MV_TO_SEARCH_NODE(
                ps_search_node,
                &ps_mv[i4_mv_pos_in_implicit_array],
                &pi1_ref_idx[i4_mv_pos_in_implicit_array],
                i1_ref_idx,
                shift);
        }
        else
        {
            ps_search_node->u1_is_avail = 0;
            ps_search_node->s_mv.i2_mvx = 0;
            ps_search_node->s_mv.i2_mvy = 0;
            ps_search_node->i1_ref_idx = i1_ref_idx;
        }
    }

    /* Move to left */
    {
        /* ps_mv and pi1_ref_idx now point to the top left locn */
        ps_search_node = ps_left_neighbours;
        ps_mv = ps_mv_base + mvs_in_row;
        pi1_ref_idx = pi1_ref_idx_base + mvs_in_row;

        i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
            pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);

        if(-1 != i4_mv_pos_in_implicit_array)
        {
            COPY_MV_TO_SEARCH_NODE(
                ps_search_node,
                &ps_mv[i4_mv_pos_in_implicit_array],
                &pi1_ref_idx[i4_mv_pos_in_implicit_array],
                i1_ref_idx,
                shift);
        }
        else
        {
            ps_search_node->u1_is_avail = 0;
            ps_search_node->s_mv.i2_mvx = 0;
            ps_search_node->s_mv.i2_mvy = 0;
            ps_search_node->i1_ref_idx = i1_ref_idx;
        }
    }

    /* Move to l1 */
    if(ps_layer_mvbank->i4_num_mvs_per_ref > 1)
    {
        /* ps_mv and pi1_ref_idx now point to the top left locn */
        ps_search_node++;
        ps_mv += (mvs_in_row * (jump >> 1));
        pi1_ref_idx += (mvs_in_row * (jump >> 1));

        i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
            pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);

        if(-1 != i4_mv_pos_in_implicit_array)
        {
            COPY_MV_TO_SEARCH_NODE(
                ps_search_node,
                &ps_mv[i4_mv_pos_in_implicit_array],
                &pi1_ref_idx[i4_mv_pos_in_implicit_array],
                i1_ref_idx,
                shift);
        }
        else
        {
            ps_search_node->u1_is_avail = 0;
            ps_search_node->s_mv.i2_mvx = 0;
            ps_search_node->s_mv.i2_mvy = 0;
            ps_search_node->i1_ref_idx = i1_ref_idx;
        }
    }
    else
    {
        ps_search_node++;
        ps_search_node->u1_is_avail = 0;
        ps_search_node->s_mv.i2_mvx = 0;
        ps_search_node->s_mv.i2_mvy = 0;
        ps_search_node->i1_ref_idx = i1_ref_idx;
    }

    /* Move to bl */
    ps_search_node++;
    if(bl_avail == 0)
    {
        ps_search_node->s_mv.i2_mvx = 0;
        ps_search_node->s_mv.i2_mvy = 0;
        ps_search_node->i1_ref_idx = i1_ref_idx;
        ps_search_node->u1_is_avail = 0;
    }
    else
    {
        /* ps_mv and pi1_ref_idx now point to the top left locn */
        ps_mv = ps_mv_base + (mvs_in_row * (1 + jump));
        pi1_ref_idx = pi1_ref_idx_base + (mvs_in_row * (1 + jump));

        i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
            pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);

        if(-1 != i4_mv_pos_in_implicit_array)
        {
            COPY_MV_TO_SEARCH_NODE(
                ps_search_node,
                &ps_mv[i4_mv_pos_in_implicit_array],
                &pi1_ref_idx[i4_mv_pos_in_implicit_array],
                i1_ref_idx,
                shift);
        }
        else
        {
            ps_search_node->u1_is_avail = 0;
            ps_search_node->s_mv.i2_mvx = 0;
            ps_search_node->s_mv.i2_mvy = 0;
            ps_search_node->i1_ref_idx = i1_ref_idx;
        }
    }
}

/**
********************************************************************************
*  @fn    void hme_fill_ctb_neighbour_mvs(layer_ctxt_t *ps_curr_layer,
*                                   S32 i4_blk_x,
*                                   S32 i4_blk_y,
*                                   mvgrid_t *ps_mv_grid ,
*                                   S32 i1_ref_id)
*
*  @brief  The 18x18 MV grid for a ctb, is filled in first row and 1st col
*          this corresponds to neighbours (TL, T, TR, L, BL)
*
*  @param[in] ps_curr_layer: layer ctxt, has the mv bank structure pointer
*
*  @param[in] blk_x : x coordinate of the block in mv bank
*
*  @param[in] blk_y : y coordinate of the block in mv bank
*
*  @param[in] ps_mv_grid : Grid (18x18 mvs at 4x4 level)
*
*  @param[in] i1_ref_idx : Corresponds to ref idx from which to pick up mv
*              results, useful if multiple ref idx candts maintained separately.
*
*  @return void
********************************************************************************
*/
void hme_fill_ctb_neighbour_mvs(
    layer_ctxt_t *ps_curr_layer,
    S32 blk_x,
    S32 blk_y,
    mv_grid_t *ps_mv_grid,
    U08 u1_pred_dir_ctr,
    U08 u1_default_ref_id,
    S32 i4_num_act_ref_l0)
{
    search_node_t *ps_grid_node;
    layer_mv_t *ps_layer_mvbank = ps_curr_layer->ps_layer_mvbank;
    S32 i4_offset;
    hme_mv_t *ps_mv, *ps_mv_base;
    S08 *pi1_ref_idx, *pi1_ref_idx_base;
    S32 jump = 0, inc, i, mvs_in_blk, mvs_in_row;

    if(ps_layer_mvbank->e_blk_size == BLK_4x4)
    {
        /* searching 16x16, mvs are for 4x4 */
        jump = 1;
        blk_x <<= 2;
        blk_y <<= 2;
    }
    else
    {
        /* Searching 16x16, mvs are for 8x8 */
        blk_x <<= 1;
        blk_y <<= 1;
    }
    ASSERT(ps_layer_mvbank->e_blk_size != BLK_16x16);

    mvs_in_blk = ps_layer_mvbank->i4_num_mvs_per_blk;
    mvs_in_row = ps_layer_mvbank->i4_num_mvs_per_row;

    /* Adjust the blk coord to point to top left locn */
    blk_x -= 1;
    blk_y -= 1;

    /* Pick up the mvs from the location */
    i4_offset = (blk_x * ps_layer_mvbank->i4_num_mvs_per_blk);
    i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * blk_y);

    i4_offset += (u1_pred_dir_ctr == 1);

    ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
    pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;

    ps_mv_base = ps_mv;
    pi1_ref_idx_base = pi1_ref_idx;

    /* the 0, 0 entry of the grid pts to top left for the ctb */
    ps_grid_node = &ps_mv_grid->as_node[0];

    /* Copy 18 mvs at 4x4 level including top left, 16 top mvs for ctb, 1 tr */
    for(i = 0; i < 18; i++)
    {
        COPY_MV_TO_SEARCH_NODE(ps_grid_node, ps_mv, pi1_ref_idx, u1_default_ref_id, 0);
        ps_grid_node++;
        inc = 1;
        /* If blk size is 8x8, then every 2 grid nodes are updated with same mv */
        if(i & 1)
            inc = jump;

        ps_mv += (mvs_in_blk * inc);
        pi1_ref_idx += (mvs_in_blk * inc);
    }

    ps_mv = ps_mv_base + mvs_in_row;
    pi1_ref_idx = pi1_ref_idx_base + mvs_in_row;

    /* now copy left 16 left mvs */
    ps_grid_node = &ps_mv_grid->as_node[0];
    ps_grid_node += (ps_mv_grid->i4_stride);
    for(i = 0; i < 16; i++)
    {
        COPY_MV_TO_SEARCH_NODE(ps_grid_node, ps_mv, pi1_ref_idx, u1_default_ref_id, 0);
        ps_grid_node += ps_mv_grid->i4_stride;
        inc = 1;
        /* If blk size is 8x8, then every 2 grid nodes are updated with same mv */
        if(!(i & 1))
            inc = jump;

        ps_mv += (mvs_in_row * inc);
        pi1_ref_idx += (mvs_in_row * inc);
    }
    /* last one set to invalid as bottom left not yet encoded */
    ps_grid_node->u1_is_avail = 0;
}

void hme_reset_wkg_mem(buf_mgr_t *ps_buf_mgr)
{
    ps_buf_mgr->i4_used = 0;
}
void hme_init_wkg_mem(buf_mgr_t *ps_buf_mgr, U08 *pu1_mem, S32 size)
{
    ps_buf_mgr->pu1_wkg_mem = pu1_mem;
    ps_buf_mgr->i4_total = size;
    hme_reset_wkg_mem(ps_buf_mgr);
}

void hme_init_mv_grid(mv_grid_t *ps_mv_grid)
{
    S32 i, j;
    search_node_t *ps_search_node;
    /*************************************************************************/
    /* We have a 64x64 CTB in the worst case. For this, we have 16x16 4x4 MVs*/
    /* Additionally, we have 1 neighbour on each side. This makes it a 18x18 */
    /* MV Grid. The boundary of this Grid on all sides are neighbours and the*/
    /* left and top edges of this grid is filled run time. The center portion*/
    /* represents the actual CTB MVs (16x16) and is also filled run time.    */
    /* However, the availability is always set as available (init time)      */
    /*************************************************************************/
    ps_mv_grid->i4_stride = NUM_COLUMNS_IN_CTB_GRID;
    ps_mv_grid->i4_start_offset = ps_mv_grid->i4_stride + CTB_MV_GRID_PAD;
    ps_search_node = &ps_mv_grid->as_node[ps_mv_grid->i4_start_offset];
    for(i = 0; i < 16; i++)
    {
        for(j = 0; j < 16; j++)
        {
            ps_search_node[j].u1_is_avail = 1;
        }

        ps_search_node += ps_mv_grid->i4_stride;
    }
}
/**
********************************************************************************
*  @fn    void hme_pad_left(U08 *pu1_dst, S32 stride, S32 pad_wd, S32 pad_ht)
*
*  @brief  Pads horizontally to left side. Each pixel replicated across a line
*
*  @param[in] pu1_dst : destination pointer. Points to the pixel to be repeated
*
*  @param[in] stride : stride of destination buffer
*
*  @param[in] pad_wd : Amt of horizontal padding to be done
*
*  @param[in] pad_ht : Number of lines for which horizontal padding to be done
*
*  @return void
********************************************************************************
*/
void hme_pad_left(U08 *pu1_dst, S32 stride, S32 pad_wd, S32 pad_ht)
{
    S32 i, j;
    U08 u1_val;
    for(i = 0; i < pad_ht; i++)
    {
        u1_val = pu1_dst[0];
        for(j = -pad_wd; j < 0; j++)
            pu1_dst[j] = u1_val;

        pu1_dst += stride;
    }
}
/**
********************************************************************************
*  @fn    void hme_pad_right(U08 *pu1_dst, S32 stride, S32 pad_wd, S32 pad_ht)
*
*  @brief  Pads horizontally to rt side. Each pixel replicated across a line
*
*  @param[in] pu1_dst : destination pointer. Points to the pixel to be repeated
*
*  @param[in] stride : stride of destination buffer
*
*  @param[in] pad_wd : Amt of horizontal padding to be done
*
*  @param[in] pad_ht : Number of lines for which horizontal padding to be done
*
*  @return void
********************************************************************************
*/
void hme_pad_right(U08 *pu1_dst, S32 stride, S32 pad_wd, S32 pad_ht)
{
    S32 i, j;
    U08 u1_val;
    for(i = 0; i < pad_ht; i++)
    {
        u1_val = pu1_dst[0];
        for(j = 1; j <= pad_wd; j++)
            pu1_dst[j] = u1_val;

        pu1_dst += stride;
    }
}
/**
********************************************************************************
*  @fn    void hme_pad_top(U08 *pu1_dst, S32 stride, S32 pad_ht, S32 pad_wd)
*
*  @brief  Pads vertically on the top. Repeats the top line for top padding
*
*  @param[in] pu1_dst : destination pointer. Points to the line to be repeated
*
*  @param[in] stride : stride of destination buffer
*
*  @param[in] pad_ht : Amt of vertical padding to be done
*
*  @param[in] pad_wd : Number of columns for which vertical padding to be done
*
*  @return void
********************************************************************************
*/
void hme_pad_top(U08 *pu1_dst, S32 stride, S32 pad_ht, S32 pad_wd)
{
    S32 i;
    for(i = 1; i <= pad_ht; i++)
        memcpy(pu1_dst - (i * stride), pu1_dst, pad_wd);
}
/**
********************************************************************************
*  @fn    void hme_pad_bot(U08 *pu1_dst, S32 stride, S32 pad_ht, S32 pad_wd)
*
*  @brief  Pads vertically on the bot. Repeats the top line for top padding
*
*  @param[in] pu1_dst : destination pointer. Points to the line to be repeated
*
*  @param[in] stride : stride of destination buffer
*
*  @param[in] pad_ht : Amt of vertical padding to be done
*
*  @param[in] pad_wd : Number of columns for which vertical padding to be done
*
*  @return void
********************************************************************************
*/
void hme_pad_bot(U08 *pu1_dst, S32 stride, S32 pad_ht, S32 pad_wd)
{
    S32 i;
    for(i = 1; i <= pad_ht; i++)
        memcpy(pu1_dst + (i * stride), pu1_dst, pad_wd);
}

/**
********************************************************************************
*  @fn    void hme_get_wt_inp(layer_ctxt_t *ps_curr_layer,  S32 pos_x,
*                           S32 pos_y, S32 size)
*
*  @brief  Does weighting of the input in case the search needs to happen
*          with reference frames weighted
*
*  @param[in] ps_curr_layer: layer ctxt
*
*  @param[in] pos_x : x coordinate of the input blk in the picture
*
*  @param[in] pos_y : y coordinate of hte input blk in the picture
*
*  @param[in] size : size of the input block
*
*  @param[in] num_ref : Number of reference frames
*
*  @return void
********************************************************************************
*/
void hme_get_wt_inp(
    layer_ctxt_t *ps_curr_layer,
    wgt_pred_ctxt_t *ps_wt_inp_prms,
    S32 dst_stride,
    S32 pos_x,
    S32 pos_y,
    S32 size,
    S32 num_ref,
    U08 u1_is_wt_pred_on)
{
    S32 ref, i, j;
    U08 *pu1_src, *pu1_dst, *pu1_src_tmp;
    S32 log_wdc = ps_wt_inp_prms->wpred_log_wdc;
    S32 x_count, y_count;

    /* Fixed source */
    pu1_src = ps_curr_layer->pu1_inp;

    /* Make sure the start positions of block are inside frame limits */
    pos_x = MIN(pos_x, ps_curr_layer->i4_wd - 1);
    pos_y = MIN(pos_y, ps_curr_layer->i4_ht - 1);

    pu1_src += (pos_x + (pos_y * ps_curr_layer->i4_inp_stride));

    /* In case we handle imcomplete CTBs, we copy only as much as reqd */
    /* from input buffers to prevent out of bound accesses. In this    */
    /* case, we do padding in x or y or both dirns */
    x_count = MIN(size, (ps_curr_layer->i4_wd - pos_x));
    y_count = MIN(size, (ps_curr_layer->i4_ht - pos_y));

    for(i = 0; i < num_ref + 1; i++)
    {
        ps_wt_inp_prms->apu1_wt_inp[i] = ps_wt_inp_prms->apu1_wt_inp_buf_array[num_ref];
    }

    /* Run thro all ref ids */
    for(ref = 0; ref < num_ref + 1; ref++)
    {
        S32 wt, off;
        S32 inv_wt;

        pu1_src_tmp = pu1_src;

        /* Each ref id may have differnet wt/offset. */
        /* So we have unique inp buf for each ref id */
        pu1_dst = ps_wt_inp_prms->apu1_wt_inp[ref];

        if(ref == num_ref)
        {
            /* last ref will be non weighted input */
            for(i = 0; i < y_count; i++)
            {
                for(j = 0; j < x_count; j++)
                {
                    pu1_dst[j] = pu1_src_tmp[j];
                }
                pu1_src_tmp += ps_curr_layer->i4_inp_stride;
                pu1_dst += dst_stride;
            }
        }
        else
        {
            /* Wt and off specific to this ref id */
            wt = ps_wt_inp_prms->a_wpred_wt[ref];
            inv_wt = ps_wt_inp_prms->a_inv_wpred_wt[ref];
            off = ps_wt_inp_prms->a_wpred_off[ref];

            /* Generate size*size worth of modified input samples */
            for(i = 0; i < y_count; i++)
            {
                for(j = 0; j < x_count; j++)
                {
                    S32 tmp;

                    /* Since we scale input, we use inverse transform of wt pred */
                    //tmp = HME_INV_WT_PRED(pu1_src_tmp[j], wt, off, log_wdc);
                    tmp = HME_INV_WT_PRED1(pu1_src_tmp[j], inv_wt, off, log_wdc);
                    pu1_dst[j] = (U08)(HME_CLIP(tmp, 0, 255));
                }
                pu1_src_tmp += ps_curr_layer->i4_inp_stride;
                pu1_dst += dst_stride;
            }
        }

        /* Check and do padding in right direction if need be */
        pu1_dst = ps_wt_inp_prms->apu1_wt_inp[ref];
        if(x_count != size)
        {
            hme_pad_right(pu1_dst + x_count - 1, dst_stride, size - x_count, y_count);
        }

        /* Check and do padding in bottom directino if need be */
        if(y_count != size)
        {
            hme_pad_bot(pu1_dst + (y_count - 1) * dst_stride, dst_stride, size - y_count, size);
        }
    }
}
/**
****************************************************************************************
*  @fn     hme_pick_best_pu_cand(pu_result_t *ps_pu_results_dst,
*                                pu_result_t *ps_pu_results_inp,
*                                UWORD8 u1_num_results_per_part,
*                                UWORD8 u1_num_best_cand)
*
*  @brief  Does the candidate evaluation across all the current candidates and returns
*           the best two or one candidates across given lists
*
*  @param[in]  - ps_pu_results_inp : Pointer to the input candidates
*              - u1_num_results_per_part: Number of available candidates
*
*  @param[out] - ps_pu_results_dst : Pointer to best PU results
*
****************************************************************************************
*/
void hme_pick_best_pu_cand(
    pu_result_t *ps_pu_results_dst,
    pu_result_t *ps_pu_results_list0,
    pu_result_t *ps_pu_results_list1,
    UWORD8 u1_num_results_per_part_l0,
    UWORD8 u1_num_results_per_part_l1,
    UWORD8 u1_candidate_rank)
{
    struct cand_pos_data
    {
        U08 u1_cand_list_id;

        U08 u1_cand_id_in_cand_list;
    } as_cand_pos_data[MAX_NUM_RESULTS_PER_PART_LIST << 1];

    S32 ai4_costs[MAX_NUM_RESULTS_PER_PART_LIST << 1];
    U08 i, j;

    for(i = 0; i < u1_num_results_per_part_l0; i++)
    {
        ai4_costs[i] = ps_pu_results_list0[i].i4_tot_cost;
        as_cand_pos_data[i].u1_cand_id_in_cand_list = i;
        as_cand_pos_data[i].u1_cand_list_id = 0;
    }

    for(i = 0, j = u1_num_results_per_part_l0; i < u1_num_results_per_part_l1; i++, j++)
    {
        ai4_costs[j] = ps_pu_results_list1[i].i4_tot_cost;
        as_cand_pos_data[j].u1_cand_id_in_cand_list = i;
        as_cand_pos_data[j].u1_cand_list_id = 1;
    }

    SORT_PRIMARY_INTTYPE_ARRAY_AND_REORDER_GENERIC_COMPANION_ARRAY(
        ai4_costs,
        as_cand_pos_data,
        u1_num_results_per_part_l0 + u1_num_results_per_part_l1,
        struct cand_pos_data);

    if(as_cand_pos_data[u1_candidate_rank].u1_cand_list_id)
    {
        ps_pu_results_dst[0] =
            ps_pu_results_list1[as_cand_pos_data[u1_candidate_rank].u1_cand_id_in_cand_list];
    }
    else
    {
        ps_pu_results_dst[0] =
            ps_pu_results_list0[as_cand_pos_data[u1_candidate_rank].u1_cand_id_in_cand_list];
    }
}

/* Returns the number of candidates */
static S32 hme_tu_recur_cand_harvester(
    part_type_results_t *ps_cand_container,
    inter_pu_results_t *ps_pu_data,
    inter_ctb_prms_t *ps_inter_ctb_prms,
    S32 i4_part_mask)
{
    part_type_results_t s_cand_data;

    U08 i, j;
    PART_ID_T e_part_id;

    S32 i4_num_cands = 0;

    /* 2Nx2N part_type decision part */
    if(i4_part_mask & ENABLE_2Nx2N)
    {
        U08 u1_num_candt_to_pick;

        e_part_id = ge_part_type_to_part_id[PRT_2Nx2N][0];

        ASSERT(ps_inter_ctb_prms->u1_max_2nx2n_tu_recur_cands >= 1);

        if(!ps_inter_ctb_prms->i4_bidir_enabled || (i4_part_mask == ENABLE_2Nx2N))
        {
            u1_num_candt_to_pick =
                MIN(ps_inter_ctb_prms->u1_max_2nx2n_tu_recur_cands,
                    ps_pu_data->u1_num_results_per_part_l0[e_part_id] +
                        ps_pu_data->u1_num_results_per_part_l1[e_part_id]);
        }
        else
        {
            u1_num_candt_to_pick =
                MIN(1,
                    ps_pu_data->u1_num_results_per_part_l0[e_part_id] +
                        ps_pu_data->u1_num_results_per_part_l1[e_part_id]);
        }

        if(ME_XTREME_SPEED_25 == ps_inter_ctb_prms->i1_quality_preset)
        {
            u1_num_candt_to_pick = MIN(u1_num_candt_to_pick, MAX_NUM_TU_RECUR_CANDS_IN_XS25);
        }

        for(i = 0; i < u1_num_candt_to_pick; i++)
        {
            /* Picks the best two candidates of all the available ones */
            hme_pick_best_pu_cand(
                ps_cand_container[i4_num_cands].as_pu_results,
                ps_pu_data->aps_pu_results[0][e_part_id],
                ps_pu_data->aps_pu_results[1][e_part_id],
                ps_pu_data->u1_num_results_per_part_l0[e_part_id],
                ps_pu_data->u1_num_results_per_part_l1[e_part_id],
                i);

            /* Update the other params part_type and total_cost in part_type_results */
            ps_cand_container[i4_num_cands].u1_part_type = e_part_id;
            ps_cand_container[i4_num_cands].i4_tot_cost =
                ps_cand_container[i4_num_cands].as_pu_results->i4_tot_cost;

            i4_num_cands++;
        }
    }

    /* SMP */
    {
        S32 i4_total_cost;

        S32 num_part_types = PRT_Nx2N - PRT_2NxN + 1;
        S32 start_part_type = PRT_2NxN;
        S32 best_cost = MAX_32BIT_VAL;
        S32 part_type_cnt = 0;

        for(j = 0; j < num_part_types; j++)
        {
            if(!(i4_part_mask & gai4_part_type_to_part_mask[j + start_part_type]))
            {
                continue;
            }

            for(i = 0; i < gau1_num_parts_in_part_type[j + start_part_type]; i++)
            {
                e_part_id = ge_part_type_to_part_id[j + start_part_type][i];

                /* Pick the best candidate for the partition acroos lists */
                hme_pick_best_pu_cand(
                    &s_cand_data.as_pu_results[i],
                    ps_pu_data->aps_pu_results[0][e_part_id],
                    ps_pu_data->aps_pu_results[1][e_part_id],
                    ps_pu_data->u1_num_results_per_part_l0[e_part_id],
                    ps_pu_data->u1_num_results_per_part_l1[e_part_id],
                    0);
            }

            i4_total_cost =
                s_cand_data.as_pu_results[0].i4_tot_cost + s_cand_data.as_pu_results[1].i4_tot_cost;

            if(i4_total_cost < best_cost)
            {
                /* Stores the index of the best part_type in the sub-catoegory */
                best_cost = i4_total_cost;

                ps_cand_container[i4_num_cands] = s_cand_data;

                ps_cand_container[i4_num_cands].u1_part_type = j + start_part_type;
                ps_cand_container[i4_num_cands].i4_tot_cost = i4_total_cost;
            }

            part_type_cnt++;
        }

        i4_num_cands = (part_type_cnt) ? (i4_num_cands + 1) : i4_num_cands;
    }

    /* AMP */
    {
        S32 i4_total_cost;

        S32 num_part_types = PRT_nRx2N - PRT_2NxnU + 1;
        S32 start_part_type = PRT_2NxnU;
        S32 best_cost = MAX_32BIT_VAL;
        S32 part_type_cnt = 0;

        for(j = 0; j < num_part_types; j++)
        {
            if(!(i4_part_mask & gai4_part_type_to_part_mask[j + start_part_type]))
            {
                continue;
            }

            for(i = 0; i < gau1_num_parts_in_part_type[j + start_part_type]; i++)
            {
                e_part_id = ge_part_type_to_part_id[j + start_part_type][i];

                /* Pick the best candidate for the partition acroos lists */
                hme_pick_best_pu_cand(
                    &s_cand_data.as_pu_results[i],
                    ps_pu_data->aps_pu_results[0][e_part_id],
                    ps_pu_data->aps_pu_results[1][e_part_id],
                    ps_pu_data->u1_num_results_per_part_l0[e_part_id],
                    ps_pu_data->u1_num_results_per_part_l1[e_part_id],
                    0);
            }

            i4_total_cost =
                s_cand_data.as_pu_results[0].i4_tot_cost + s_cand_data.as_pu_results[1].i4_tot_cost;

            if(i4_total_cost < best_cost)
            {
                /* Stores the index of the best part_type in the sub-catoegory */
                best_cost = i4_total_cost;

                ps_cand_container[i4_num_cands] = s_cand_data;

                ps_cand_container[i4_num_cands].u1_part_type = j + start_part_type;
                ps_cand_container[i4_num_cands].i4_tot_cost = i4_total_cost;
            }

            part_type_cnt++;
        }

        i4_num_cands = (part_type_cnt) ? (i4_num_cands + 1) : i4_num_cands;
    }

    return i4_num_cands;
}

/**
*****************************************************************************
*  @fn     hme_decide_part_types(search_results_t *ps_search_results)
*
*  @brief  Does uni/bi evaluation accross various partition types,
*          decides best inter partition types for the CU, compares
*          intra cost and decides the best K results for the CU
*
*          This is called post subpel refinmenent for 16x16s, 8x8s and
*          for post merge evaluation for 32x32,64x64 CUs
*
*  @param[in,out] ps_search_results : Search results data structure
*                 - In : 2 lists of upto 2mvs & refids, active partition mask
*                 - Out: Best results for final rdo evaluation of the cu
*
*  @param[in]     ps_subpel_prms : Sub pel params data structure
*
*
*  @par Description
*    --------------------------------------------------------------------------------
*     Flow:
*            for each category (SMP,AMP,2Nx2N based on part mask)
*            {
*                for each part_type
*                {
*                    for each part
*                        pick best candidate from each list
*                    combine uni part type
*                    update best results for part type
*                }
*                pick the best part type for given category (for SMP & AMP)
*            }
*                    ||
*                    ||
*                    \/
*           Bi-Pred evaluation:
*            for upto 4 best part types
*            {
*                for each part
*                {
*                    compute fixed size had for all uni and remember coeffs
*                    compute bisatd
*                    uni vs bi and gives upto two results
*                    also gives the pt level pred buffer
*                }
*             }
*                    ||
*                    ||
*                    \/
*            select X candidates for tu recursion as per the Note below
*               tu_rec_on_part_type (reuse transform coeffs)
*                    ||
*                    ||
*                    \/
*            insert intra nodes at appropriate result id
*                    ||
*                    ||
*                    \/
*            populate y best resuls for rdo based on preset
*
*     Note :
*     number of TU rec for P pics : 2 2nx2n + 1 smp + 1 amp for ms or 9 for hq
*     number of TU rec for B pics : 1 2nx2n + 1 smp + 1 amp for ms or 2 uni 2nx2n + 1 smp + 1 amp for ms or 9 for hq
*     --------------------------------------------------------------------------------
*
*  @return None
********************************************************************************
*/
void hme_decide_part_types(
    inter_cu_results_t *ps_cu_results,
    inter_pu_results_t *ps_pu_results,
    inter_ctb_prms_t *ps_inter_ctb_prms,
    me_frm_ctxt_t *ps_ctxt,
    ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list,
    ihevce_me_optimised_function_list_t *ps_me_optimised_function_list

)
{
    S32 i, j;
    S32 i4_part_mask;
    ULWORD64 au8_pred_sigmaXSquare[NUM_BEST_ME_OUTPUTS][NUM_INTER_PU_PARTS];
    ULWORD64 au8_pred_sigmaX[NUM_BEST_ME_OUTPUTS][NUM_INTER_PU_PARTS];
    S32 i4_noise_term;
    WORD32 e_part_id;

    PF_SAD_FXN_TU_REC apf_err_compute[4];

    part_type_results_t as_part_type_results[NUM_BEST_ME_OUTPUTS];
    part_type_results_t *ps_part_type_results;

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

    i4_part_mask = ps_cu_results->i4_part_mask;

    num_best_cand = hme_tu_recur_cand_harvester(
        as_part_type_results, ps_pu_results, ps_inter_ctb_prms, i4_part_mask);

    /* Partition ID for the current PU */
    e_part_id = (UWORD8)ge_part_type_to_part_id[PRT_2Nx2N][0];

    ps_part_type_results = as_part_type_results;
    for(i = 0; i < num_best_cand; i++)
    {
        hme_compute_pred_and_evaluate_bi(
            ps_cu_results,
            ps_pu_results,
            ps_inter_ctb_prms,
            &(ps_part_type_results[i]),
            au8_pred_sigmaXSquare[i],
            au8_pred_sigmaX[i],
            ps_cmn_utils_optimised_function_list,
            ps_me_optimised_function_list

        );
    }
    /* Perform TU_REC on the best candidates selected */
    {
        WORD32 i4_sad_grid;
        WORD32 ai4_tu_split_flag[4];
        WORD32 ai4_tu_early_cbf[4];

        WORD32 best_cost[NUM_BEST_ME_OUTPUTS];
        WORD32 ai4_final_idx[NUM_BEST_ME_OUTPUTS];
        WORD16 i2_wght;
        WORD32 i4_satd;

        err_prms_t s_err_prms;
        err_prms_t *ps_err_prms = &s_err_prms;

        /* Default cost and final idx initialization */
        for(i = 0; i < num_best_cand; i++)
        {
            best_cost[i] = MAX_32BIT_VAL;
            ai4_final_idx[i] = -1;
        }

        /* Assign the stad function to the err_compute function pointer :
        Implemented only for 32x32 and 64x64, hence 16x16 and 8x8 are kept NULL */
        apf_err_compute[CU_64x64] = hme_evalsatd_pt_pu_64x64_tu_rec;
        apf_err_compute[CU_32x32] = hme_evalsatd_pt_pu_32x32_tu_rec;
        apf_err_compute[CU_16x16] = hme_evalsatd_pt_pu_16x16_tu_rec;
        apf_err_compute[CU_8x8] = hme_evalsatd_pt_pu_8x8_tu_rec;

        ps_err_prms->pi4_sad_grid = &i4_sad_grid;
        ps_err_prms->pi4_tu_split_flags = ai4_tu_split_flag;
        ps_err_prms->u1_max_tr_depth = ps_inter_ctb_prms->u1_max_tr_depth;
        ps_err_prms->pi4_tu_early_cbf = ai4_tu_early_cbf;
        ps_err_prms->i4_grid_mask = 1;
        ps_err_prms->pu1_wkg_mem = ps_inter_ctb_prms->pu1_wkg_mem;
        ps_err_prms->u1_max_tr_size = 32;

        if(ps_inter_ctb_prms->u1_is_cu_noisy)
        {
            ps_err_prms->u1_max_tr_size = MAX_TU_SIZE_WHEN_NOISY;
        }

        /* TU_REC for the best candidates, as mentioned in NOTE above (except candidates that
        are disabled by Part_mask */
        for(i = 0; i < num_best_cand; i++)
        {
            part_type_results_t *ps_best_results;
            pu_result_t *ps_pu_result;
            WORD32 part_type_cost;
            WORD32 cand_idx;

            WORD32 pred_dir;
            S32 i4_inp_off;

            S32 lambda;
            U08 lambda_qshift;
            U08 *apu1_inp[MAX_NUM_INTER_PARTS];
            S16 ai2_wt[MAX_NUM_INTER_PARTS];
            S32 ai4_inv_wt[MAX_NUM_INTER_PARTS];
            S32 ai4_inv_wt_shift_val[MAX_NUM_INTER_PARTS];

            WORD32 part_type = ps_part_type_results[i].u1_part_type;
            WORD32 e_cu_size = ps_cu_results->u1_cu_size;
            WORD32 e_blk_size = ge_cu_size_to_blk_size[e_cu_size];
            U08 u1_num_parts = gau1_num_parts_in_part_type[part_type];
            U08 u1_inp_buf_idx = UCHAR_MAX;

            ps_err_prms->i4_part_mask = i4_part_mask;
            ps_err_prms->i4_blk_wd = gau1_blk_size_to_wd[e_blk_size];
            ps_err_prms->i4_blk_ht = gau1_blk_size_to_ht[e_blk_size];
            ps_err_prms->pu1_ref = ps_part_type_results[i].pu1_pred;
            ps_err_prms->i4_ref_stride = ps_part_type_results[i].i4_pred_stride;

            /* Current offset for the present part type */
            i4_inp_off = ps_cu_results->i4_inp_offset;

            ps_best_results = &(ps_part_type_results[i]);

            part_type_cost = 0;
            lambda = ps_inter_ctb_prms->i4_lamda;
            lambda_qshift = ps_inter_ctb_prms->u1_lamda_qshift;

            for(j = 0; j < u1_num_parts; j++)
            {
                ps_pu_result = &(ps_best_results->as_pu_results[j]);

                pred_dir = ps_pu_result->pu.b2_pred_mode;

                if(PRED_L0 == pred_dir)
                {
                    apu1_inp[j] =
                        ps_inter_ctb_prms->apu1_wt_inp[PRED_L0][ps_pu_result->pu.mv.i1_l0_ref_idx] +
                        i4_inp_off;
                    ai2_wt[j] =
                        ps_inter_ctb_prms->pps_rec_list_l0[ps_pu_result->pu.mv.i1_l0_ref_idx]
                            ->s_weight_offset.i2_luma_weight;
                    ai4_inv_wt[j] =
                        ps_inter_ctb_prms->pi4_inv_wt
                            [ps_inter_ctb_prms->pi1_past_list[ps_pu_result->pu.mv.i1_l0_ref_idx]];
                    ai4_inv_wt_shift_val[j] =
                        ps_inter_ctb_prms->pi4_inv_wt_shift_val
                            [ps_inter_ctb_prms->pi1_past_list[ps_pu_result->pu.mv.i1_l0_ref_idx]];
                }
                else if(PRED_L1 == pred_dir)
                {
                    apu1_inp[j] =
                        ps_inter_ctb_prms->apu1_wt_inp[PRED_L1][ps_pu_result->pu.mv.i1_l1_ref_idx] +
                        i4_inp_off;
                    ai2_wt[j] =
                        ps_inter_ctb_prms->pps_rec_list_l1[ps_pu_result->pu.mv.i1_l1_ref_idx]
                            ->s_weight_offset.i2_luma_weight;
                    ai4_inv_wt[j] =
                        ps_inter_ctb_prms->pi4_inv_wt
                            [ps_inter_ctb_prms->pi1_future_list[ps_pu_result->pu.mv.i1_l1_ref_idx]];
                    ai4_inv_wt_shift_val[j] =
                        ps_inter_ctb_prms->pi4_inv_wt_shift_val
                            [ps_inter_ctb_prms->pi1_future_list[ps_pu_result->pu.mv.i1_l1_ref_idx]];
                }
                else if(PRED_BI == pred_dir)
                {
                    apu1_inp[j] = ps_inter_ctb_prms->pu1_non_wt_inp + i4_inp_off;
                    ai2_wt[j] = 1 << ps_inter_ctb_prms->wpred_log_wdc;
                    ai4_inv_wt[j] = i4_default_src_wt;
                    ai4_inv_wt_shift_val[j] = 0;
                }
                else
                {
                    ASSERT(0);
                }

                part_type_cost += ps_pu_result->i4_mv_cost;
            }

            if((u1_num_parts == 1) || (ai2_wt[0] == ai2_wt[1]))
            {
                ps_err_prms->pu1_inp = apu1_inp[0];
                ps_err_prms->i4_inp_stride = ps_inter_ctb_prms->i4_inp_stride;
                i2_wght = ai2_wt[0];
            }
            else
            {
                if(1 != ihevce_get_free_pred_buf_indices(
                            &u1_inp_buf_idx,
                            &ps_inter_ctb_prms->s_pred_buf_mngr.u4_pred_buf_usage_indicator,
                            1))
                {
                    ASSERT(0);
                }
                else
                {
                    U08 *pu1_dst =
                        ps_inter_ctb_prms->s_pred_buf_mngr.apu1_pred_bufs[u1_inp_buf_idx];
                    U08 *pu1_src = apu1_inp[0];
                    U08 u1_pu1_wd = (ps_part_type_results[i].as_pu_results[0].pu.b4_wd + 1) << 2;
                    U08 u1_pu1_ht = (ps_part_type_results[i].as_pu_results[0].pu.b4_ht + 1) << 2;
                    U08 u1_pu2_wd = (ps_part_type_results[i].as_pu_results[1].pu.b4_wd + 1) << 2;
                    U08 u1_pu2_ht = (ps_part_type_results[i].as_pu_results[1].pu.b4_ht + 1) << 2;

                    ps_cmn_utils_optimised_function_list->pf_copy_2d(
                        pu1_dst,
                        MAX_CU_SIZE,
                        pu1_src,
                        ps_inter_ctb_prms->i4_inp_stride,
                        u1_pu1_wd,
                        u1_pu1_ht);

                    pu1_dst +=
                        (gai1_is_part_vertical[ge_part_type_to_part_id[part_type][0]]
                             ? u1_pu1_ht * MAX_CU_SIZE
                             : u1_pu1_wd);
                    pu1_src =
                        apu1_inp[1] + (gai1_is_part_vertical[ge_part_type_to_part_id[part_type][0]]
                                           ? u1_pu1_ht * ps_inter_ctb_prms->i4_inp_stride
                                           : u1_pu1_wd);

                    ps_cmn_utils_optimised_function_list->pf_copy_2d(
                        pu1_dst,
                        MAX_CU_SIZE,
                        pu1_src,
                        ps_inter_ctb_prms->i4_inp_stride,
                        u1_pu2_wd,
                        u1_pu2_ht);

                    ps_err_prms->pu1_inp =
                        ps_inter_ctb_prms->s_pred_buf_mngr.apu1_pred_bufs[u1_inp_buf_idx];
                    ps_err_prms->i4_inp_stride = MAX_CU_SIZE;
                    i2_wght = ai2_wt[1];
                }
            }

#if !DISABLE_TU_RECURSION
            i4_satd = apf_err_compute[e_cu_size](
                ps_err_prms,
                lambda,
                lambda_qshift,
                ps_inter_ctb_prms->i4_qstep_ls8,
                ps_ctxt->ps_func_selector);
#else
            ps_err_prms->pi4_sad_grid = &i4_satd;

            pf_err_compute(ps_err_prms);

            if((part_type == PRT_2Nx2N) || (e_cu_size != CU_64x64))
            {
                ai4_tu_split_flag[0] = 1;
                ai4_tu_split_flag[1] = 1;
                ai4_tu_split_flag[2] = 1;
                ai4_tu_split_flag[3] = 1;

                ps_err_prms->i4_tu_split_cost = 0;
            }
            else
            {
                ai4_tu_split_flag[0] = 1;
                ai4_tu_split_flag[1] = 1;
                ai4_tu_split_flag[2] = 1;
                ai4_tu_split_flag[3] = 1;

                ps_err_prms->i4_tu_split_cost = 0;
            }
#endif

#if UNI_SATD_SCALE
            i4_satd = (i4_satd * i2_wght) >> ps_inter_ctb_prms->wpred_log_wdc;
#endif

            if(ps_inter_ctb_prms->u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)
            {
                ULWORD64 u8_temp_var, u8_temp_var1, u8_pred_sigmaSquaredX;
                ULWORD64 u8_src_variance, u8_pred_variance;
                unsigned long u4_shift_val;
                S32 i4_bits_req;
                S32 i4_q_level = STIM_Q_FORMAT + ALPHA_Q_FORMAT;

                if(1 == u1_num_parts)
                {
                    u8_pred_sigmaSquaredX = au8_pred_sigmaX[i][0] * au8_pred_sigmaX[i][0];
                    u8_pred_variance = au8_pred_sigmaXSquare[i][0] - u8_pred_sigmaSquaredX;

                    if(e_cu_size == CU_8x8)
                    {
                        PART_ID_T e_part_id = (PART_ID_T)(
                            (PART_ID_NxN_TL) + (ps_cu_results->u1_x_off & 1) +
                            ((ps_cu_results->u1_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,
                            ai4_inv_wt[0],
                            ai4_inv_wt_shift_val[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,
                            ai4_inv_wt[0],
                            ai4_inv_wt_shift_val[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;

                    ASSERT(i4_noise_term >= 0);

                    i4_noise_term *= ps_inter_ctb_prms->i4_alpha_stim_multiplier;

                    u8_temp_var = i4_satd;
                    u8_temp_var *= ((1 << (i4_q_level)) - (i4_noise_term));
                    u8_temp_var += (1 << ((i4_q_level)-1));
                    i4_satd = (UWORD32)(u8_temp_var >> (i4_q_level));
                }
                else /*if(e_cu_size <= CU_16x16)*/
                {
                    unsigned long temp_shift_val;
                    PART_ID_T ae_part_id[MAX_NUM_INTER_PARTS] = {
                        ge_part_type_to_part_id[part_type][0], ge_part_type_to_part_id[part_type][1]
                    };

                    u4_shift_val = ihevce_calc_variance_for_diff_weights(
                        ps_inter_ctb_prms->pu8_part_src_sigmaX,
                        ps_inter_ctb_prms->pu8_part_src_sigmaXSquared,
                        &u8_src_variance,
                        ai4_inv_wt,
                        ai4_inv_wt_shift_val,
                        ps_best_results->as_pu_results,
                        ps_inter_ctb_prms->wpred_log_wdc,
                        ae_part_id,
                        gau1_blk_size_to_wd[e_blk_size],
                        u1_num_parts,
                        1);

                    temp_shift_val = u4_shift_val;

                    u4_shift_val = ihevce_calc_variance_for_diff_weights(
                        au8_pred_sigmaX[i],
                        au8_pred_sigmaXSquare[i],
                        &u8_pred_variance,
                        ai4_inv_wt,
                        ai4_inv_wt_shift_val,
                        ps_best_results->as_pu_results,
                        0,
                        ae_part_id,
                        gau1_blk_size_to_wd[e_blk_size],
                        u1_num_parts,
                        0);

                    u8_pred_variance = u8_pred_variance >> temp_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;

                    ASSERT(i4_noise_term >= 0);
                    ASSERT(i4_noise_term <= (1 << (STIM_Q_FORMAT + ALPHA_Q_FORMAT)));

                    i4_noise_term *= ps_inter_ctb_prms->i4_alpha_stim_multiplier;

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

                    ASSERT(i4_satd >= 0);
                }
            }

            if(u1_inp_buf_idx != UCHAR_MAX)
            {
                ihevce_set_pred_buf_as_free(
                    &ps_inter_ctb_prms->s_pred_buf_mngr.u4_pred_buf_usage_indicator,
                    u1_inp_buf_idx);
            }

            part_type_cost += i4_satd;

            /*Update the best results with the new results */
            ps_best_results->i4_tot_cost = part_type_cost;

            ps_best_results->i4_tu_split_cost = ps_err_prms->i4_tu_split_cost;

            ASSERT(ai4_tu_split_flag[0] >= 0);
            if(e_cu_size == CU_64x64)
            {
                ps_best_results->ai4_tu_split_flag[0] = ai4_tu_split_flag[0];
                ps_best_results->ai4_tu_split_flag[1] = ai4_tu_split_flag[1];
                ps_best_results->ai4_tu_split_flag[2] = ai4_tu_split_flag[2];
                ps_best_results->ai4_tu_split_flag[3] = ai4_tu_split_flag[3];

                /* Update the TU early cbf flags into the best results structure */
                ps_best_results->ai4_tu_early_cbf[0] = ai4_tu_early_cbf[0];
                ps_best_results->ai4_tu_early_cbf[1] = ai4_tu_early_cbf[1];
                ps_best_results->ai4_tu_early_cbf[2] = ai4_tu_early_cbf[2];
                ps_best_results->ai4_tu_early_cbf[3] = ai4_tu_early_cbf[3];
            }
            else
            {
                ps_best_results->ai4_tu_split_flag[0] = ai4_tu_split_flag[0];
                ps_best_results->ai4_tu_early_cbf[0] = ai4_tu_early_cbf[0];
            }

            if(part_type_cost < best_cost[num_best_cand - 1])
            {
                /* Push and sort current part type if it is one of the num_best_cand */
                for(cand_idx = 0; cand_idx < i; cand_idx++)
                {
                    if(part_type_cost <= best_cost[cand_idx])
                    {
                        memmove(
                            &ai4_final_idx[cand_idx + 1],
                            &ai4_final_idx[cand_idx],
                            sizeof(WORD32) * (i - cand_idx));
                        memmove(
                            &best_cost[cand_idx + 1],
                            &best_cost[cand_idx],
                            sizeof(WORD32) * (i - cand_idx));
                        break;
                    }
                }

                ai4_final_idx[cand_idx] = i;
                best_cost[cand_idx] = part_type_cost;
            }
        }

        ps_cu_results->u1_num_best_results = num_best_cand;

        for(i = 0; i < num_best_cand; i++)
        {
            ASSERT(ai4_final_idx[i] < num_best_cand);

            if(ai4_final_idx[i] != -1)
            {
                memcpy(
                    &(ps_cu_results->ps_best_results[i]),
                    &(ps_part_type_results[ai4_final_idx[i]]),
                    sizeof(part_type_results_t));
            }
        }
    }

    for(i = 0; i < (MAX_NUM_PRED_BUFS_USED_FOR_PARTTYPE_DECISIONS)-2; i++)
    {
        ihevce_set_pred_buf_as_free(
            &ps_inter_ctb_prms->s_pred_buf_mngr.u4_pred_buf_usage_indicator, i);
    }
}

/**
**************************************************************************************************
*  @fn     hme_populate_pus(search_results_t *ps_search_results, inter_cu_results_t *ps_cu_results)
*
*  @brief Does the population of the inter_cu_results structure with the results after the
*           subpel refinement
*
*          This is called post subpel refinmenent for 16x16s, 8x8s and
*          for post merge evaluation for 32x32,64x64 CUs
*
*  @param[in,out] ps_search_results : Search results data structure
*                 - ps_cu_results : cu_results data structure
*                   ps_pu_result  : Pointer to the memory for storing PU's
*
****************************************************************************************************
*/
void hme_populate_pus(
    me_ctxt_t *ps_thrd_ctxt,
    me_frm_ctxt_t *ps_ctxt,
    hme_subpel_prms_t *ps_subpel_prms,
    search_results_t *ps_search_results,
    inter_cu_results_t *ps_cu_results,
    inter_pu_results_t *ps_pu_results,
    pu_result_t *ps_pu_result,
    inter_ctb_prms_t *ps_inter_ctb_prms,
    wgt_pred_ctxt_t *ps_wt_prms,
    layer_ctxt_t *ps_curr_layer,
    U08 *pu1_pred_dir_searched,
    WORD32 i4_num_active_ref)
{
    WORD32 i, j, k;
    WORD32 i4_part_mask;
    WORD32 i4_ref;
    UWORD8 e_part_id;
    pu_result_t *ps_curr_pu;
    search_node_t *ps_search_node;
    part_attr_t *ps_part_attr;
    UWORD8 e_cu_size = ps_search_results->e_cu_size;
    WORD32 num_results_per_part_l0 = 0;
    WORD32 num_results_per_part_l1 = 0;
    WORD32 i4_ref_id;
    WORD32 i4_total_act_ref;

    i4_part_mask = ps_search_results->i4_part_mask;

    /* pred_buf_mngr init */
    {
        hme_get_wkg_mem(&ps_ctxt->s_buf_mgr, MAX_WKG_MEM_SIZE_PER_THREAD);

        ps_inter_ctb_prms->s_pred_buf_mngr.u4_pred_buf_usage_indicator = UINT_MAX;

        for(i = 0; i < MAX_NUM_PRED_BUFS_USED_FOR_PARTTYPE_DECISIONS - 2; i++)
        {
            ps_inter_ctb_prms->s_pred_buf_mngr.apu1_pred_bufs[i] =
                ps_ctxt->s_buf_mgr.pu1_wkg_mem + i * INTERP_OUT_BUF_SIZE;
            ps_inter_ctb_prms->s_pred_buf_mngr.u4_pred_buf_usage_indicator &= ~(1 << i);
        }

        ps_inter_ctb_prms->pu1_wkg_mem = ps_ctxt->s_buf_mgr.pu1_wkg_mem + i * INTERP_OUT_BUF_SIZE;
    }

    ps_inter_ctb_prms->i4_alpha_stim_multiplier = ALPHA_FOR_NOISE_TERM_IN_ME;
    ps_inter_ctb_prms->u1_is_cu_noisy = ps_subpel_prms->u1_is_cu_noisy;
    ps_inter_ctb_prms->i4_lamda = ps_search_results->as_pred_ctxt[0].lambda;

    /* Populate the CU level parameters */
    ps_cu_results->u1_cu_size = ps_search_results->e_cu_size;
    ps_cu_results->u1_num_best_results = ps_search_results->u1_num_best_results;
    ps_cu_results->i4_part_mask = ps_search_results->i4_part_mask;
    ps_cu_results->u1_x_off = ps_search_results->u1_x_off;
    ps_cu_results->u1_y_off = ps_search_results->u1_y_off;

    i4_total_act_ref =
        ps_ctxt->s_frm_prms.u1_num_active_ref_l0 + ps_ctxt->s_frm_prms.u1_num_active_ref_l1;
    /*Populate the partition results
    Loop across all the active references that are enabled right now */
    for(i = 0; i < MAX_PART_TYPES; i++)
    {
        if(!(i4_part_mask & gai4_part_type_to_part_mask[i]))
        {
            continue;
        }

        for(j = 0; j < gau1_num_parts_in_part_type[i]; j++)
        {
            /* Partition ID for the current PU */
            e_part_id = (UWORD8)ge_part_type_to_part_id[i][j];
            ps_part_attr = &gas_part_attr_in_cu[e_part_id];

            num_results_per_part_l0 = 0;
            num_results_per_part_l1 = 0;

            ps_pu_results->aps_pu_results[0][e_part_id] =
                ps_pu_result + (e_part_id * MAX_NUM_RESULTS_PER_PART_LIST);
            ps_pu_results->aps_pu_results[1][e_part_id] =
                ps_pu_result + ((e_part_id + TOT_NUM_PARTS) * MAX_NUM_RESULTS_PER_PART_LIST);

            for(i4_ref = 0; i4_ref < i4_num_active_ref; i4_ref++)
            {
                U08 u1_pred_dir = pu1_pred_dir_searched[i4_ref];

                for(k = 0; k < ps_search_results->u1_num_results_per_part; k++)
                {
                    ps_search_node =
                        &ps_search_results->aps_part_results[u1_pred_dir][e_part_id][k];

                    /* If subpel is done then the node is a valid candidate else break the loop */
                    if(ps_search_node->u1_subpel_done)
                    {
                        i4_ref_id = ps_search_node->i1_ref_idx;

                        ASSERT(i4_ref_id >= 0);

                        /* Check whether current ref_id is past or future and assign the pointers to L0 or L1 list accordingly */
                        if(!u1_pred_dir)
                        {
                            ps_curr_pu = ps_pu_results->aps_pu_results[0][e_part_id] +
                                         num_results_per_part_l0;

                            ASSERT(
                                ps_ctxt->a_ref_idx_lc_to_l0[i4_ref_id] <
                                ps_inter_ctb_prms->u1_num_active_ref_l0);

                            /* Always populate the ref_idx value in l0_ref_idx */
                            ps_curr_pu->pu.mv.i1_l0_ref_idx =
                                ps_ctxt->a_ref_idx_lc_to_l0[i4_ref_id];
                            ps_curr_pu->pu.mv.s_l0_mv = ps_search_node->s_mv;
                            ps_curr_pu->pu.mv.i1_l1_ref_idx = -1;
                            ps_curr_pu->pu.b2_pred_mode = PRED_L0;

                            ps_inter_ctb_prms->apu1_wt_inp[0][ps_curr_pu->pu.mv.i1_l0_ref_idx] =
                                ps_wt_prms->apu1_wt_inp[i4_ref_id];

                            num_results_per_part_l0++;
                        }
                        else
                        {
                            ps_curr_pu = ps_pu_results->aps_pu_results[1][e_part_id] +
                                         num_results_per_part_l1;

                            ASSERT(
                                ps_ctxt->a_ref_idx_lc_to_l1[i4_ref_id] <
                                ps_inter_ctb_prms->u1_num_active_ref_l1);

                            /* populate the ref_idx value in l1_ref_idx */
                            ps_curr_pu->pu.mv.i1_l1_ref_idx =
                                ps_ctxt->a_ref_idx_lc_to_l1[i4_ref_id];
                            ps_curr_pu->pu.mv.s_l1_mv = ps_search_node->s_mv;
                            ps_curr_pu->pu.mv.i1_l0_ref_idx = -1;
                            ps_curr_pu->pu.b2_pred_mode = PRED_L1;

                            /* Copy the values from weighted params to common_frm_aprams */
                            ps_inter_ctb_prms->apu1_wt_inp[1][ps_curr_pu->pu.mv.i1_l1_ref_idx] =
                                ps_wt_prms->apu1_wt_inp[i4_ref_id];

                            num_results_per_part_l1++;
                        }
                        ps_curr_pu->i4_mv_cost = ps_search_node->i4_mv_cost;
                        ps_curr_pu->i4_sdi = ps_search_node->i4_sdi;

#if UNI_SATD_SCALE
                        /*SATD is scaled by weight. Hence rescale the SATD */
                        ps_curr_pu->i4_tot_cost =
                            ((ps_search_node->i4_sad *
                                  ps_ctxt->s_wt_pred.a_wpred_wt[ps_search_node->i1_ref_idx] +
                              (1 << (ps_inter_ctb_prms->wpred_log_wdc - 1))) >>
                             ps_inter_ctb_prms->wpred_log_wdc) +
                            ps_search_node->i4_mv_cost;
#endif

                        /* Packed format of the width and height */
                        ps_curr_pu->pu.b4_wd = ((ps_part_attr->u1_x_count << e_cu_size) >> 2) - 1;
                        ps_curr_pu->pu.b4_ht = ((ps_part_attr->u1_y_count << e_cu_size) >> 2) - 1;

                        ps_curr_pu->pu.b4_pos_x =
                            (((ps_part_attr->u1_x_start << e_cu_size) + ps_cu_results->u1_x_off) >>
                             2);
                        ps_curr_pu->pu.b4_pos_y =
                            (((ps_part_attr->u1_y_start << e_cu_size) + ps_cu_results->u1_y_off) >>
                             2);

                        ps_curr_pu->pu.b1_intra_flag = 0;

                        /* Unweighted input */
                        ps_inter_ctb_prms->pu1_non_wt_inp =
                            ps_wt_prms->apu1_wt_inp[i4_total_act_ref];

                        ps_search_node++;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            ps_pu_results->u1_num_results_per_part_l0[e_part_id] = num_results_per_part_l0;
            ps_pu_results->u1_num_results_per_part_l1[e_part_id] = num_results_per_part_l1;
        }
    }
}

/**
*********************************************************************************************************
*  @fn     hme_populate_pus_8x8_cu(search_results_t *ps_search_results, inter_cu_results_t *ps_cu_results)
*
*  @brief Does the population of the inter_cu_results structure with the results after the
*           subpel refinement
*
*          This is called post subpel refinmenent for 16x16s, 8x8s and
*          for post merge evaluation for 32x32,64x64 CUs
*
*  @param[in,out] ps_search_results : Search results data structure
*                 - ps_cu_results : cu_results data structure
*                   ps_pu_results : Pointer for the PU's
*                   ps_pu_result  : Pointer to the memory for storing PU's
*
*********************************************************************************************************
*/
void hme_populate_pus_8x8_cu(
    me_ctxt_t *ps_thrd_ctxt,
    me_frm_ctxt_t *ps_ctxt,
    hme_subpel_prms_t *ps_subpel_prms,
    search_results_t *ps_search_results,
    inter_cu_results_t *ps_cu_results,
    inter_pu_results_t *ps_pu_results,
    pu_result_t *ps_pu_result,
    inter_ctb_prms_t *ps_inter_ctb_prms,
    U08 *pu1_pred_dir_searched,
    WORD32 i4_num_active_ref,
    U08 u1_blk_8x8_mask)
{
    WORD32 i, k;
    WORD32 i4_part_mask;
    WORD32 i4_ref;
    pu_result_t *ps_curr_pu;
    search_node_t *ps_search_node;
    WORD32 i4_ref_id;
    WORD32 x_off, y_off;

    /* Make part mask available as only 2Nx2N
    Later support for 4x8 and 8x4 needs to be added */
    i4_part_mask = ENABLE_2Nx2N;

    x_off = ps_search_results->u1_x_off;
    y_off = ps_search_results->u1_y_off;

    for(i = 0; i < 4; i++)
    {
        if(u1_blk_8x8_mask & (1 << i))
        {
            UWORD8 u1_x_pos, u1_y_pos;

            WORD32 num_results_per_part_l0 = 0;
            WORD32 num_results_per_part_l1 = 0;

            ps_cu_results->u1_cu_size = CU_8x8;
            ps_cu_results->u1_num_best_results = ps_search_results->u1_num_best_results;
            ps_cu_results->i4_part_mask = i4_part_mask;
            ps_cu_results->u1_x_off = x_off + (i & 1) * 8;
            ps_cu_results->u1_y_off = y_off + (i >> 1) * 8;
            ps_cu_results->i4_inp_offset = ps_cu_results->u1_x_off + (ps_cu_results->u1_y_off * 64);

            ps_cu_results->ps_best_results[0].i4_tot_cost = MAX_32BIT_VAL;
            ps_cu_results->ps_best_results[0].i4_tu_split_cost = 0;

            u1_x_pos = ps_cu_results->u1_x_off >> 2;
            u1_y_pos = ps_cu_results->u1_y_off >> 2;

            if(!(ps_search_results->i4_part_mask & ENABLE_NxN))
            {
                ps_curr_pu = &ps_cu_results->ps_best_results[0].as_pu_results[0];

                ps_cu_results->i4_part_mask = 0;
                ps_cu_results->u1_num_best_results = 0;

                ps_curr_pu->i4_tot_cost = MAX_32BIT_VAL;

                ps_curr_pu->pu.b4_wd = 1;
                ps_curr_pu->pu.b4_ht = 1;
                ps_curr_pu->pu.b4_pos_x = u1_x_pos;
                ps_curr_pu->pu.b4_pos_y = u1_y_pos;
                ps_cu_results->ps_best_results[0].i4_tu_split_cost = 0;

                ps_cu_results++;
                ps_pu_results++;

                continue;
            }

            ps_pu_results->aps_pu_results[0][0] =
                ps_pu_result + (i * MAX_NUM_RESULTS_PER_PART_LIST);
            ps_pu_results->aps_pu_results[1][0] =
                ps_pu_result + ((i + TOT_NUM_PARTS) * MAX_NUM_RESULTS_PER_PART_LIST);

            for(i4_ref = 0; i4_ref < i4_num_active_ref; i4_ref++)
            {
                U08 u1_pred_dir = pu1_pred_dir_searched[i4_ref];

                /* Select the NxN partition node for the current ref_idx in the search results*/
                ps_search_node =
                    ps_search_results->aps_part_results[u1_pred_dir][PART_ID_NxN_TL + i];

                for(k = 0; k < ps_search_results->u1_num_results_per_part; k++)
                {
                    /* If subpel is done then the node is a valid candidate else break the loop */
                    if((ps_search_node->u1_is_avail) || (ps_search_node->u1_subpel_done))
                    {
                        i4_ref_id = ps_search_node->i1_ref_idx;

                        ASSERT(i4_ref_id >= 0);

                        if(!u1_pred_dir)
                        {
                            ps_curr_pu =
                                ps_pu_results->aps_pu_results[0][0] + num_results_per_part_l0;

                            ASSERT(
                                ps_ctxt->a_ref_idx_lc_to_l0[i4_ref_id] <
                                ps_inter_ctb_prms->u1_num_active_ref_l0);

                            ps_curr_pu->pu.mv.i1_l0_ref_idx =
                                ps_ctxt->a_ref_idx_lc_to_l0[i4_ref_id];
                            ps_curr_pu->pu.mv.s_l0_mv = ps_search_node->s_mv;
                            ps_curr_pu->pu.mv.i1_l1_ref_idx = -1;
                            ps_curr_pu->pu.b2_pred_mode = PRED_L0;

                            num_results_per_part_l0++;
                        }
                        else
                        {
                            ps_curr_pu =
                                ps_pu_results->aps_pu_results[1][0] + num_results_per_part_l1;

                            ASSERT(
                                ps_ctxt->a_ref_idx_lc_to_l1[i4_ref_id] <
                                ps_inter_ctb_prms->u1_num_active_ref_l1);

                            ps_curr_pu->pu.mv.i1_l1_ref_idx =
                                ps_ctxt->a_ref_idx_lc_to_l1[i4_ref_id];
                            ps_curr_pu->pu.mv.s_l1_mv = ps_search_node->s_mv;
                            ps_curr_pu->pu.mv.i1_l0_ref_idx = -1;
                            ps_curr_pu->pu.b2_pred_mode = PRED_L1;

                            num_results_per_part_l1++;
                        }
                        ps_curr_pu->i4_mv_cost = ps_search_node->i4_mv_cost;
                        ps_curr_pu->i4_sdi = ps_search_node->i4_sdi;

#if UNI_SATD_SCALE
                        /*SATD is scaled by weight. Hence rescale the SATD */
                        ps_curr_pu->i4_tot_cost =
                            ((ps_search_node->i4_sad *
                                  ps_ctxt->s_wt_pred.a_wpred_wt[ps_search_node->i1_ref_idx] +
                              (1 << (ps_inter_ctb_prms->wpred_log_wdc - 1))) >>
                             ps_inter_ctb_prms->wpred_log_wdc) +
                            ps_search_node->i4_mv_cost;
#endif

                        ps_curr_pu->pu.b4_wd = 1;
                        ps_curr_pu->pu.b4_ht = 1;
                        ps_curr_pu->pu.b4_pos_x = u1_x_pos;
                        ps_curr_pu->pu.b4_pos_y = u1_y_pos;
                        ps_curr_pu->pu.b1_intra_flag = 0;

                        ps_search_node++;
                    }
                    else
                    {
                        /* if NxN was not evaluated at 16x16 level, assign max cost to 8x8 CU
                        to remove 8x8's as possible candidates during evaluation */

                        ps_curr_pu = ps_pu_results->aps_pu_results[0][0] + num_results_per_part_l0;

                        ps_curr_pu->i4_tot_cost = MAX_32BIT_VAL;

                        ps_curr_pu = ps_pu_results->aps_pu_results[1][0] + num_results_per_part_l1;

                        ps_curr_pu->i4_tot_cost = MAX_32BIT_VAL;

                        break;
                    }
                }
            }

            /* Update the num_results per_part across lists L0 and L1 */
            ps_pu_results->u1_num_results_per_part_l0[0] = num_results_per_part_l0;
            ps_pu_results->u1_num_results_per_part_l1[0] = num_results_per_part_l1;
        }
        ps_cu_results++;
        ps_pu_results++;
    }
}

/**
********************************************************************************
*  @fn     hme_insert_intra_nodes_post_bipred
*
*  @brief  Compares intra costs (populated by IPE) with the best inter costs
*          (populated after evaluating bi-pred) and updates the best results
*          if intra cost is better
*
*  @param[in,out]  ps_cu_results    [inout] : Best results structure of CU
*                  ps_cur_ipe_ctb   [in]    : intra results for the current CTB
*                  i4_frm_qstep     [in]    : current frame quantizer(qscale)*
*
*  @return None
********************************************************************************
*/
void hme_insert_intra_nodes_post_bipred(
    inter_cu_results_t *ps_cu_results,
    ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb,
    WORD32 i4_frm_qstep)
{
    WORD32 i;
    WORD32 num_results;
    WORD32 cu_size = ps_cu_results->u1_cu_size;
    UWORD8 u1_x_off = ps_cu_results->u1_x_off;
    UWORD8 u1_y_off = ps_cu_results->u1_y_off;

    /* Id of the 32x32 block, 16x16 block in a CTB */
    WORD32 i4_32x32_id = (u1_y_off >> 5) * 2 + (u1_x_off >> 5);
    WORD32 i4_16x16_id = ((u1_y_off >> 4) & 0x1) * 2 + ((u1_x_off >> 4) & 0x1);

    /* Flags to indicate if intra64/intra32/intra16 cusize are invalid as per IPE decision */
    WORD32 disable_intra64 = 0;
    WORD32 disable_intra32 = 0;
    WORD32 disable_intra16 = 0;

    S32 i4_intra_2nx2n_cost;

    /* ME final results for this CU (post seeding of best uni/bi pred results) */
    part_type_results_t *ps_best_result;

    i4_frm_qstep *= !L0ME_IN_OPENLOOP_MODE;

    /*If inter candidates are enabled then enter the for loop to update the intra candidate */

    if((ps_cu_results->u1_num_best_results == 0) && (CU_8x8 == ps_cu_results->u1_cu_size))
    {
        ps_cu_results->u1_num_best_results = 1;
    }

    num_results = ps_cu_results->u1_num_best_results;

    ps_best_result = &ps_cu_results->ps_best_results[0];

    /* Disable intra16/32/64 flags based on split flags recommended by IPE */
    if(ps_cur_ipe_ctb->u1_split_flag)
    {
        disable_intra64 = 1;
        if(ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id].b1_split_flag)
        {
            disable_intra32 = 1;

            if(ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id]
                   .as_intra16_analyse[i4_16x16_id]
                   .b1_split_flag)
            {
                disable_intra16 = 1;
            }
        }
    }

    /* Derive the intra cost based on current cu size and offset */
    switch(cu_size)
    {
    case CU_8x8:
    {
        i4_intra_2nx2n_cost = ps_cur_ipe_ctb->ai4_best8x8_intra_cost[u1_y_off + (u1_x_off >> 3)];

        /* Accounting for coding noise in the open loop IPE cost */
        i4_intra_2nx2n_cost +=
            ((i4_frm_qstep * 16) >> 2) /*+ ((i4_frm_qstep*i4_intra_2nx2n_cost)/256) */;

        break;
    }

    case CU_16x16:
    {
        i4_intra_2nx2n_cost =
            ps_cur_ipe_ctb->ai4_best16x16_intra_cost[(u1_y_off >> 4) * 4 + (u1_x_off >> 4)];

        /* Accounting for coding noise in the open loop IPE cost */
        i4_intra_2nx2n_cost +=
            ((i4_frm_qstep * 16)); /* + ((i4_frm_qstep*i4_intra_2nx2n_cost)/256) */

        if(disable_intra16)
        {
            /* Disable intra 2Nx2N (intra 16) as IPE suggested best mode as 8x8 */
            i4_intra_2nx2n_cost = MAX_32BIT_VAL;
        }
        break;
    }

    case CU_32x32:
    {
        i4_intra_2nx2n_cost =
            ps_cur_ipe_ctb->ai4_best32x32_intra_cost[(u1_y_off >> 5) * 2 + (u1_x_off >> 5)];

        /* Accounting for coding noise in the open loop IPE cost */
        i4_intra_2nx2n_cost +=
            (i4_frm_qstep * 16 * 4) /* + ((i4_frm_qstep*i4_intra_2nx2n_cost)/256) */;

        if(disable_intra32)
        {
            /* Disable intra 2Nx2N (intra 32) as IPE suggested best mode as 16x16 or 8x8 */
            i4_intra_2nx2n_cost = MAX_32BIT_VAL;
        }
        break;
    }

    case CU_64x64:
    {
        i4_intra_2nx2n_cost = ps_cur_ipe_ctb->i4_best64x64_intra_cost;

        /* Accounting for coding noise in the open loop IPE cost */
        i4_intra_2nx2n_cost +=
            (i4_frm_qstep * 16 * 16) /* + ((i4_frm_qstep*i4_intra_2nx2n_cost)/256) */;

        if(disable_intra64)
        {
            /* Disable intra 2Nx2N (intra 64) as IPE suggested best mode as 32x32 /16x16 / 8x8 */
            i4_intra_2nx2n_cost = MAX_32BIT_VAL;
        }
        break;
    }

    default:
        ASSERT(0);
    }

    {
        /*****************************************************************/
        /* Intra / Inter cost comparison for  2Nx2N : cu size 8/16/32/64 */
        /* Identify where the current result isto be placed. Basically   */
        /* find the node which has cost just higher than node under test */
        /*****************************************************************/
        for(i = 0; i < num_results; i++)
        {
            /* Subtrqact the tu_spli_flag_cost from total_inter_cost for fair comparision */
            WORD32 inter_cost = ps_best_result[i].i4_tot_cost - ps_best_result[i].i4_tu_split_cost;

            if(i4_intra_2nx2n_cost < inter_cost)
            {
                if(i < (num_results - 1))
                {
                    memmove(
                        ps_best_result + i + 1,
                        ps_best_result + i,
                        sizeof(ps_best_result[0]) * (num_results - 1 - i));
                }

                /* Insert the intra node result */
                ps_best_result[i].u1_part_type = PRT_2Nx2N;
                ps_best_result[i].i4_tot_cost = i4_intra_2nx2n_cost;
                ps_best_result[i].ai4_tu_split_flag[0] = 0;
                ps_best_result[i].ai4_tu_split_flag[1] = 0;
                ps_best_result[i].ai4_tu_split_flag[2] = 0;
                ps_best_result[i].ai4_tu_split_flag[3] = 0;

                /* Populate intra flag, cost and default mvs, refidx for intra pu */
                ps_best_result[i].as_pu_results[0].i4_tot_cost = i4_intra_2nx2n_cost;
                //ps_best_result[i].as_pu_results[0].i4_sad = i4_intra_2nx2n_cost;
                ps_best_result[i].as_pu_results[0].i4_mv_cost = 0;
                ps_best_result[i].as_pu_results[0].pu.b1_intra_flag = 1;
                ps_best_result[i].as_pu_results[0].pu.mv.i1_l0_ref_idx = -1;
                ps_best_result[i].as_pu_results[0].pu.mv.i1_l1_ref_idx = -1;
                ps_best_result[i].as_pu_results[0].pu.mv.s_l0_mv.i2_mvx = INTRA_MV;
                ps_best_result[i].as_pu_results[0].pu.mv.s_l0_mv.i2_mvy = INTRA_MV;
                ps_best_result[i].as_pu_results[0].pu.mv.s_l1_mv.i2_mvx = INTRA_MV;
                ps_best_result[i].as_pu_results[0].pu.mv.s_l1_mv.i2_mvy = INTRA_MV;

                break;
            }
        }
    }
}

S32 hme_recompute_lambda_from_min_8x8_act_in_ctb(
    me_frm_ctxt_t *ps_ctxt, ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb)
{
    double lambda;
    double lambda_modifier;
    WORD32 i4_cu_qp;
    frm_lambda_ctxt_t *ps_frm_lambda_ctxt;
    //ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb;
    WORD32 i4_frame_qp;
    rc_quant_t *ps_rc_quant_ctxt;
    WORD32 i4_is_bpic;

    ps_frm_lambda_ctxt = &ps_ctxt->s_frm_lambda_ctxt;
    //ps_cur_ipe_ctb = ps_ctxt->ps_ipe_l0_ctb_frm_base;
    i4_frame_qp = ps_ctxt->s_frm_prms.i4_frame_qp;
    ps_rc_quant_ctxt = ps_ctxt->ps_rc_quant_ctxt;
    i4_is_bpic = ps_ctxt->s_frm_prms.bidir_enabled;

    i4_cu_qp = ps_rc_quant_ctxt->pi4_qp_to_qscale[i4_frame_qp + ps_rc_quant_ctxt->i1_qp_offset];

    {
        if(ps_ctxt->i4_l0me_qp_mod)
        {
#if MODULATE_LAMDA_WHEN_SPATIAL_MOD_ON
#if LAMDA_BASED_ON_QUANT
            WORD32 i4_activity = ps_cur_ipe_ctb->i4_64x64_act_factor[2][0];
#else
            WORD32 i4_activity = ps_cur_ipe_ctb->i4_64x64_act_factor[3][0];
#endif
            i4_cu_qp = (((i4_cu_qp)*i4_activity) + (1 << (QP_LEVEL_MOD_ACT_FACTOR - 1))) >>
                       QP_LEVEL_MOD_ACT_FACTOR;

#endif
        }
        if(i4_cu_qp > ps_rc_quant_ctxt->i2_max_qscale)
            i4_cu_qp = ps_rc_quant_ctxt->i2_max_qscale;
        else if(i4_cu_qp < ps_rc_quant_ctxt->i2_min_qscale)
            i4_cu_qp = ps_rc_quant_ctxt->i2_min_qscale;

        i4_cu_qp = ps_rc_quant_ctxt->pi4_qscale_to_qp[i4_cu_qp];
    }

    if(i4_cu_qp > ps_rc_quant_ctxt->i2_max_qp)
        i4_cu_qp = ps_rc_quant_ctxt->i2_max_qp;
    else if(i4_cu_qp < ps_rc_quant_ctxt->i2_min_qp)
        i4_cu_qp = ps_rc_quant_ctxt->i2_min_qp;

    lambda = pow(2.0, (((double)(i4_cu_qp - 12)) / 3));

    lambda_modifier = ps_frm_lambda_ctxt->lambda_modifier;

    if(i4_is_bpic)
    {
        lambda_modifier = lambda_modifier * CLIP3((((double)(i4_cu_qp - 12)) / 6.0), 2.00, 4.00);
    }
    if(ps_ctxt->i4_use_const_lamda_modifier)
    {
        if(ps_ctxt->s_frm_prms.is_i_pic)
        {
            lambda_modifier = ps_ctxt->f_i_pic_lamda_modifier;
        }
        else
        {
            lambda_modifier = CONST_LAMDA_MOD_VAL;
        }
    }
    lambda *= lambda_modifier;

    return ((WORD32)(sqrt(lambda) * (1 << LAMBDA_Q_SHIFT)));
}

/**
********************************************************************************
*  @fn     hme_update_dynamic_search_params
*
*  @brief  Update the Dynamic search params based on the current MVs
*
*  @param[in,out]  ps_dyn_range_prms    [inout] : Dyn. Range Param str.
*                  i2_mvy               [in]    : current MV y comp.
*
*  @return None
********************************************************************************
*/
void hme_update_dynamic_search_params(dyn_range_prms_t *ps_dyn_range_prms, WORD16 i2_mvy)
{
    /* If MV is up large, update i2_dyn_max_y */
    if(i2_mvy > ps_dyn_range_prms->i2_dyn_max_y)
        ps_dyn_range_prms->i2_dyn_max_y = i2_mvy;
    /* If MV is down large, update i2_dyn_min_y */
    if(i2_mvy < ps_dyn_range_prms->i2_dyn_min_y)
        ps_dyn_range_prms->i2_dyn_min_y = i2_mvy;
}

void hme_add_new_node_to_a_sorted_array(
    search_node_t *ps_result_node,
    search_node_t **pps_sorted_array,
    U08 *pu1_shifts,
    U32 u4_num_results_updated,
    U08 u1_shift)
{
    U32 i;

    if(NULL == pu1_shifts)
    {
        S32 i4_cur_node_cost = ps_result_node->i4_tot_cost;

        for(i = 0; i < u4_num_results_updated; i++)
        {
            if(i4_cur_node_cost < pps_sorted_array[i]->i4_tot_cost)
            {
                memmove(
                    &pps_sorted_array[i + 1],
                    &pps_sorted_array[i],
                    (u4_num_results_updated - i) * sizeof(search_node_t *));

                break;
            }
        }
    }
    else
    {
        S32 i4_cur_node_cost =
            (u1_shift == 0) ? ps_result_node->i4_tot_cost
                            : (ps_result_node->i4_tot_cost + (1 << (u1_shift - 1))) >> u1_shift;

        for(i = 0; i < u4_num_results_updated; i++)
        {
            S32 i4_prev_node_cost = (pu1_shifts[i] == 0) ? pps_sorted_array[i]->i4_tot_cost
                                                         : (pps_sorted_array[i]->i4_tot_cost +
                                                            (1 << (pu1_shifts[i] - 1))) >>
                                                               pu1_shifts[i];

            if(i4_cur_node_cost < i4_prev_node_cost)
            {
                memmove(
                    &pps_sorted_array[i + 1],
                    &pps_sorted_array[i],
                    (u4_num_results_updated - i) * sizeof(search_node_t *));
                memmove(
                    &pu1_shifts[i + 1], &pu1_shifts[i], (u4_num_results_updated - i) * sizeof(U08));

                break;
            }
        }

        pu1_shifts[i] = u1_shift;
    }

    pps_sorted_array[i] = ps_result_node;
}

S32 hme_find_pos_of_implicitly_stored_ref_id(
    S08 *pi1_ref_idx, S08 i1_ref_idx, S32 i4_result_id, S32 i4_num_results)
{
    S32 i;

    for(i = 0; i < i4_num_results; i++)
    {
        if(i1_ref_idx == pi1_ref_idx[i])
        {
            if(0 == i4_result_id)
            {
                return i;
            }
            else
            {
                i4_result_id--;
            }
        }
    }

    return -1;
}

static __inline void hme_search_node_populator(
    search_node_t *ps_search_node, hme_mv_t *ps_mv, S08 i1_ref_idx, S08 i1_mv_magnitude_shift)
{
    ps_search_node->ps_mv->i2_mvx = SHL_NEG((WORD16)ps_mv->i2_mv_x, i1_mv_magnitude_shift);
    ps_search_node->ps_mv->i2_mvy = SHL_NEG((WORD16)ps_mv->i2_mv_y, i1_mv_magnitude_shift);
    ps_search_node->i1_ref_idx = i1_ref_idx;
    ps_search_node->u1_is_avail = 1;
    ps_search_node->u1_subpel_done = 0;
}

S32 hme_populate_search_candidates(fpel_srch_cand_init_data_t *ps_ctxt)
{
    hme_mv_t *ps_mv;

    S32 wd_c, ht_c, wd_p, ht_p;
    S32 blksize_p, blksize_c;
    S32 i;
    S08 *pi1_ref_idx;
    /* Cache for storing offsets */
    S32 ai4_cand_offsets[NUM_SEARCH_CAND_LOCATIONS];

    layer_ctxt_t *ps_curr_layer = ps_ctxt->ps_curr_layer;
    layer_ctxt_t *ps_coarse_layer = ps_ctxt->ps_coarse_layer;
    layer_mv_t *ps_coarse_layer_mvbank = ps_coarse_layer->ps_layer_mvbank;
    layer_mv_t *ps_curr_layer_mvbank = ps_curr_layer->ps_layer_mvbank;
    search_candt_t *ps_search_cands = ps_ctxt->ps_search_cands;
    hme_mv_t s_zero_mv = { 0 };

    S32 i4_pos_x = ps_ctxt->i4_pos_x;
    S32 i4_pos_y = ps_ctxt->i4_pos_y;
    S32 i4_num_act_ref_l0 = ps_ctxt->i4_num_act_ref_l0;
    S32 i4_num_act_ref_l1 = ps_ctxt->i4_num_act_ref_l1;
    U08 u1_pred_dir = ps_ctxt->u1_pred_dir;
    U08 u1_pred_dir_ctr = ps_ctxt->u1_pred_dir_ctr;
    U08 u1_num_results_in_curr_mvbank = ps_ctxt->u1_num_results_in_mvbank;
    U08 u1_num_results_in_coarse_mvbank =
        (u1_pred_dir == 0) ? (i4_num_act_ref_l0 * ps_coarse_layer_mvbank->i4_num_mvs_per_ref)
                           : (i4_num_act_ref_l1 * ps_coarse_layer_mvbank->i4_num_mvs_per_ref);
    S32 i4_init_offset_projected =
        (u1_pred_dir == 1) ? (i4_num_act_ref_l0 * ps_coarse_layer_mvbank->i4_num_mvs_per_ref) : 0;
    S32 i4_init_offset_spatial =
        (u1_pred_dir_ctr == 1)
            ? (ps_curr_layer_mvbank->i4_num_mvs_per_ref * u1_num_results_in_curr_mvbank)
            : 0;
    U08 u1_search_candidate_list_index = ps_ctxt->u1_search_candidate_list_index;
    U08 u1_max_num_search_cands =
        gau1_max_num_search_cands_in_l0_me[u1_search_candidate_list_index];
    S32 i4_num_srch_cands = MIN(u1_max_num_search_cands, ps_ctxt->i4_max_num_init_cands << 1);
    U16 u2_is_offset_available = 0;
    U08 u1_search_blk_to_spatial_mvbank_blk_size_factor = 1;

    /* Width and ht of current and prev layers */
    wd_c = ps_curr_layer->i4_wd;
    ht_c = ps_curr_layer->i4_ht;
    wd_p = ps_coarse_layer->i4_wd;
    ht_p = ps_coarse_layer->i4_ht;

    blksize_p = gau1_blk_size_to_wd_shift[ps_coarse_layer_mvbank->e_blk_size];
    blksize_c = gau1_blk_size_to_wd_shift[ps_curr_layer_mvbank->e_blk_size];

    /* ASSERT for valid sizes */
    ASSERT((blksize_p == 3) || (blksize_p == 4) || (blksize_p == 5));

    {
        S32 x = i4_pos_x >> 4;
        S32 y = i4_pos_y >> 4;

        if(blksize_c != gau1_blk_size_to_wd_shift[ps_ctxt->e_search_blk_size])
        {
            x *= 2;
            y *= 2;

            u1_search_blk_to_spatial_mvbank_blk_size_factor = 2;
        }

        i4_init_offset_spatial += (x + y * ps_curr_layer_mvbank->i4_num_blks_per_row) *
                                  ps_curr_layer_mvbank->i4_num_mvs_per_blk;
    }

    for(i = 0; i < i4_num_srch_cands; i++)
    {
        SEARCH_CANDIDATE_TYPE_T e_search_cand_type =
            gae_search_cand_priority_to_search_cand_type_map_in_l0_me[u1_search_candidate_list_index]
                                                                     [i];
        SEARCH_CAND_LOCATIONS_T e_search_cand_loc =
            gae_search_cand_type_to_location_map[e_search_cand_type];
        S08 i1_result_id = MIN(
            gai1_search_cand_type_to_result_id_map[e_search_cand_type],
            (e_search_cand_loc < 0 ? 0
                                   : ps_ctxt->pu1_num_fpel_search_cands[e_search_cand_loc] - 1));
        U08 u1_is_spatial_cand = (1 == gau1_search_cand_type_to_spatiality_map[e_search_cand_type]);
        U08 u1_is_proj_cand = (0 == gau1_search_cand_type_to_spatiality_map[e_search_cand_type]);
        U08 u1_is_zeroMV_cand = (ZERO_MV == e_search_cand_type) ||
                                (ZERO_MV_ALTREF == e_search_cand_type);

        /* When spatial candidates are available, use them, else use the projected candidates */
        /* This is required since some blocks will never have certain spatial candidates, and in order */
        /* to accomodate such instances in 'gae_search_cand_priority_to_search_cand_type_map_in_l0_me' list,  */
        /* all candidates apart from the 'LEFT' have been marked as projected */
        if(((e_search_cand_loc == TOPLEFT) || (e_search_cand_loc == TOP) ||
            (e_search_cand_loc == TOPRIGHT)) &&
           (i1_result_id < u1_num_results_in_curr_mvbank) && u1_is_proj_cand)
        {
            if(e_search_cand_loc == TOPLEFT)
            {
                u1_is_spatial_cand = ps_ctxt->u1_is_topLeft_available ||
                                     !ps_ctxt->u1_is_left_available;
            }
            else if(e_search_cand_loc == TOPRIGHT)
            {
                u1_is_spatial_cand = ps_ctxt->u1_is_topRight_available;
            }
            else
            {
                u1_is_spatial_cand = ps_ctxt->u1_is_top_available;
            }

            u1_is_proj_cand = !u1_is_spatial_cand;
        }

        switch(u1_is_zeroMV_cand + (u1_is_spatial_cand << 1) + (u1_is_proj_cand << 2))
        {
        case 1:
        {
            hme_search_node_populator(
                ps_search_cands[i].ps_search_node,
                &s_zero_mv,
                (ZERO_MV == e_search_cand_type) ? ps_ctxt->i1_default_ref_id
                                                : ps_ctxt->i1_alt_default_ref_id,
                0);

            break;
        }
        case 2:
        {
            S08 i1_mv_magnitude_shift = 0;

            S32 i4_offset = i4_init_offset_spatial;

            i1_result_id = MIN(i1_result_id, u1_num_results_in_curr_mvbank - 1);
            i4_offset += i1_result_id;

            switch(e_search_cand_loc)
            {
            case LEFT:
            {
                if(ps_ctxt->u1_is_left_available)
                {
                    i1_mv_magnitude_shift = -2;

                    i4_offset -= ps_curr_layer_mvbank->i4_num_mvs_per_blk;

                    ps_mv = ps_curr_layer_mvbank->ps_mv + i4_offset;
                    pi1_ref_idx = ps_curr_layer_mvbank->pi1_ref_idx + i4_offset;
                }
                else
                {
                    i1_mv_magnitude_shift = 0;

                    ps_mv = &s_zero_mv;
                    pi1_ref_idx = &ps_ctxt->i1_default_ref_id;
                }

                break;
            }
            case TOPLEFT:
            {
                if(ps_ctxt->u1_is_topLeft_available)
                {
                    i1_mv_magnitude_shift = -2;

                    i4_offset -= ps_curr_layer_mvbank->i4_num_mvs_per_blk;
                    i4_offset -= ps_curr_layer_mvbank->i4_num_mvs_per_row;

                    ps_mv = ps_curr_layer_mvbank->ps_mv + i4_offset;
                    pi1_ref_idx = ps_curr_layer_mvbank->pi1_ref_idx + i4_offset;
                }
                else
                {
                    i1_mv_magnitude_shift = 0;

                    ps_mv = &s_zero_mv;
                    pi1_ref_idx = &ps_ctxt->i1_default_ref_id;
                }

                break;
            }
            case TOP:
            {
                if(ps_ctxt->u1_is_top_available)
                {
                    i1_mv_magnitude_shift = -2;

                    i4_offset -= ps_curr_layer_mvbank->i4_num_mvs_per_row;

                    ps_mv = ps_curr_layer_mvbank->ps_mv + i4_offset;
                    pi1_ref_idx = ps_curr_layer_mvbank->pi1_ref_idx + i4_offset;
                }
                else
                {
                    i1_mv_magnitude_shift = 0;

                    ps_mv = &s_zero_mv;
                    pi1_ref_idx = &ps_ctxt->i1_default_ref_id;
                }

                break;
            }
            case TOPRIGHT:
            {
                if(ps_ctxt->u1_is_topRight_available)
                {
                    i1_mv_magnitude_shift = -2;

                    i4_offset += ps_curr_layer_mvbank->i4_num_mvs_per_blk *
                                 u1_search_blk_to_spatial_mvbank_blk_size_factor;
                    i4_offset -= ps_curr_layer_mvbank->i4_num_mvs_per_row;

                    ps_mv = ps_curr_layer_mvbank->ps_mv + i4_offset;
                    pi1_ref_idx = ps_curr_layer_mvbank->pi1_ref_idx + i4_offset;
                }
                else
                {
                    i1_mv_magnitude_shift = 0;
                    ps_mv = &s_zero_mv;
                    pi1_ref_idx = &ps_ctxt->i1_default_ref_id;
                }

                break;
            }
            default:
            {
                /* AiyAiyYo!! */
                ASSERT(0);
            }
            }

            hme_search_node_populator(
                ps_search_cands[i].ps_search_node, ps_mv, pi1_ref_idx[0], i1_mv_magnitude_shift);

            break;
        }
        case 4:
        {
            ASSERT(ILLUSORY_CANDIDATE != e_search_cand_type);
            ASSERT(ILLUSORY_LOCATION != e_search_cand_loc);

            i1_result_id = MIN(i1_result_id, u1_num_results_in_coarse_mvbank - 1);

            if(!(u2_is_offset_available & (1 << e_search_cand_loc)))
            {
                S32 x, y;

                x = i4_pos_x + gai4_search_cand_location_to_x_offset_map[e_search_cand_loc];
                y = i4_pos_y + gai4_search_cand_location_to_y_offset_map[e_search_cand_loc];

                /* Safety check to avoid uninitialized access across temporal layers */
                x = CLIP3(x, 0, (wd_c - blksize_p));
                y = CLIP3(y, 0, (ht_c - blksize_p));

                /* Project the positions to prev layer */
                x = x >> blksize_p;
                y = y >> blksize_p;

                ai4_cand_offsets[e_search_cand_loc] =
                    (x * ps_coarse_layer_mvbank->i4_num_mvs_per_blk);
                ai4_cand_offsets[e_search_cand_loc] +=
                    (y * ps_coarse_layer_mvbank->i4_num_mvs_per_row);
                ai4_cand_offsets[e_search_cand_loc] += i4_init_offset_projected;

                u2_is_offset_available |= (1 << e_search_cand_loc);
            }

            ps_mv =
                ps_coarse_layer_mvbank->ps_mv + ai4_cand_offsets[e_search_cand_loc] + i1_result_id;
            pi1_ref_idx = ps_coarse_layer_mvbank->pi1_ref_idx +
                          ai4_cand_offsets[e_search_cand_loc] + i1_result_id;

            hme_search_node_populator(ps_search_cands[i].ps_search_node, ps_mv, pi1_ref_idx[0], 1);

            break;
        }
        default:
        {
            /* NoNoNoNoNooooooooNO! */
            ASSERT(0);
        }
        }

        ASSERT(ps_search_cands[i].ps_search_node->i1_ref_idx >= 0);
        ASSERT(
            !u1_pred_dir
                ? (ps_ctxt->pi4_ref_id_lc_to_l0_map[ps_search_cands[i].ps_search_node->i1_ref_idx] <
                   i4_num_act_ref_l0)
                : (ps_ctxt->pi4_ref_id_lc_to_l1_map[ps_search_cands[i].ps_search_node->i1_ref_idx] <
                   ps_ctxt->i4_num_act_ref_l1));
    }

    return i4_num_srch_cands;
}

void hme_mv_clipper(
    hme_search_prms_t *ps_search_prms_blk,
    S32 i4_num_srch_cands,
    S08 i1_check_for_mult_refs,
    U08 u1_fpel_refine_extent,
    U08 u1_hpel_refine_extent,
    U08 u1_qpel_refine_extent)
{
    S32 candt;
    range_prms_t *ps_range_prms;

    for(candt = 0; candt < i4_num_srch_cands; candt++)
    {
        search_node_t *ps_search_node;

        ps_search_node = ps_search_prms_blk->ps_search_candts[candt].ps_search_node;
        ps_range_prms = ps_search_prms_blk->aps_mv_range[ps_search_node->i1_ref_idx];

        /* Clip the motion vectors as well here since after clipping
        two candidates can become same and they will be removed during deduplication */
        CLIP_MV_WITHIN_RANGE(
            ps_search_node->ps_mv->i2_mvx,
            ps_search_node->ps_mv->i2_mvy,
            ps_range_prms,
            u1_fpel_refine_extent,
            u1_hpel_refine_extent,
            u1_qpel_refine_extent);
    }
}

void hme_init_pred_buf_info(
    hme_pred_buf_info_t (*ps_info)[MAX_NUM_INTER_PARTS],
    hme_pred_buf_mngr_t *ps_buf_mngr,
    U08 u1_pu1_wd,
    U08 u1_pu1_ht,
    PART_TYPE_T e_part_type)
{
    U08 u1_pred_buf_array_id;

    if(1 != ihevce_get_free_pred_buf_indices(
                &u1_pred_buf_array_id, &ps_buf_mngr->u4_pred_buf_usage_indicator, 1))
    {
        ASSERT(0);
    }
    else
    {
        ps_info[0][0].i4_pred_stride = MAX_CU_SIZE;
        ps_info[0][0].pu1_pred = ps_buf_mngr->apu1_pred_bufs[u1_pred_buf_array_id];
        ps_info[0][0].u1_pred_buf_array_id = u1_pred_buf_array_id;

        if(PRT_2Nx2N != e_part_type)
        {
            ps_info[0][1].i4_pred_stride = MAX_CU_SIZE;
            ps_info[0][1].pu1_pred = ps_buf_mngr->apu1_pred_bufs[u1_pred_buf_array_id] +
                                     (gai1_is_part_vertical[ge_part_type_to_part_id[e_part_type][0]]
                                          ? u1_pu1_ht * ps_info[0][1].i4_pred_stride
                                          : u1_pu1_wd);
            ps_info[0][1].u1_pred_buf_array_id = u1_pred_buf_array_id;
        }
    }
}

void hme_debrief_bipred_eval(
    part_type_results_t *ps_part_type_result,
    hme_pred_buf_info_t (*ps_pred_buf_info)[MAX_NUM_INTER_PARTS],
    hme_pred_buf_mngr_t *ps_pred_buf_mngr,
    U08 *pu1_allocated_pred_buf_array_indixes,
    ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list

)
{
    PART_TYPE_T e_part_type = (PART_TYPE_T)ps_part_type_result->u1_part_type;

    U32 *pu4_pred_buf_usage_indicator = &ps_pred_buf_mngr->u4_pred_buf_usage_indicator;
    U08 u1_is_part_vertical = gai1_is_part_vertical[ge_part_type_to_part_id[e_part_type][0]];

    if(0 == ps_part_type_result->u1_part_type)
    {
        if(ps_part_type_result->as_pu_results->pu.b2_pred_mode == PRED_BI)
        {
            ASSERT(UCHAR_MAX != ps_pred_buf_info[2][0].u1_pred_buf_array_id);

            ps_part_type_result->pu1_pred = ps_pred_buf_info[2][0].pu1_pred;
            ps_part_type_result->i4_pred_stride = ps_pred_buf_info[2][0].i4_pred_stride;

            ihevce_set_pred_buf_as_free(
                pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[0]);

            ihevce_set_pred_buf_as_free(
                pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[1]);
        }
        else
        {
            ps_part_type_result->pu1_pred = ps_pred_buf_info[0][0].pu1_pred;
            ps_part_type_result->i4_pred_stride = ps_pred_buf_info[0][0].i4_pred_stride;

            ihevce_set_pred_buf_as_free(
                pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[2]);

            ihevce_set_pred_buf_as_free(
                pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[1]);

            if(UCHAR_MAX == ps_pred_buf_info[0][0].u1_pred_buf_array_id)
            {
                ihevce_set_pred_buf_as_free(
                    pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[0]);
            }
        }
    }
    else
    {
        U08 *pu1_src_pred;
        U08 *pu1_dst_pred;
        S32 i4_src_pred_stride;
        S32 i4_dst_pred_stride;

        U08 u1_pu1_wd = (ps_part_type_result->as_pu_results[0].pu.b4_wd + 1) << 2;
        U08 u1_pu1_ht = (ps_part_type_result->as_pu_results[0].pu.b4_ht + 1) << 2;
        U08 u1_pu2_wd = (ps_part_type_result->as_pu_results[1].pu.b4_wd + 1) << 2;
        U08 u1_pu2_ht = (ps_part_type_result->as_pu_results[1].pu.b4_ht + 1) << 2;

        U08 u1_condition_for_switch =
            (ps_part_type_result->as_pu_results[0].pu.b2_pred_mode == PRED_BI) |
            ((ps_part_type_result->as_pu_results[1].pu.b2_pred_mode == PRED_BI) << 1);

        switch(u1_condition_for_switch)
        {
        case 0:
        {
            ps_part_type_result->pu1_pred =
                ps_pred_buf_mngr->apu1_pred_bufs[pu1_allocated_pred_buf_array_indixes[0]];
            ps_part_type_result->i4_pred_stride = MAX_CU_SIZE;

            ihevce_set_pred_buf_as_free(
                pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[2]);

            ihevce_set_pred_buf_as_free(
                pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[1]);

            if(UCHAR_MAX == ps_pred_buf_info[0][0].u1_pred_buf_array_id)
            {
                pu1_src_pred = ps_pred_buf_info[0][0].pu1_pred;
                pu1_dst_pred = ps_part_type_result->pu1_pred;
                i4_src_pred_stride = ps_pred_buf_info[0][0].i4_pred_stride;
                i4_dst_pred_stride = ps_part_type_result->i4_pred_stride;

                ps_cmn_utils_optimised_function_list->pf_copy_2d(
                    pu1_dst_pred,
                    i4_dst_pred_stride,
                    pu1_src_pred,
                    i4_src_pred_stride,
                    u1_pu1_wd,
                    u1_pu1_ht);
            }

            if(UCHAR_MAX == ps_pred_buf_info[0][1].u1_pred_buf_array_id)
            {
                pu1_src_pred = ps_pred_buf_info[0][1].pu1_pred;
                pu1_dst_pred = ps_part_type_result->pu1_pred +
                               (u1_is_part_vertical
                                    ? u1_pu1_ht * ps_part_type_result->i4_pred_stride
                                    : u1_pu1_wd);
                i4_src_pred_stride = ps_pred_buf_info[0][1].i4_pred_stride;
                i4_dst_pred_stride = ps_part_type_result->i4_pred_stride;

                ps_cmn_utils_optimised_function_list->pf_copy_2d(
                    pu1_dst_pred,
                    i4_dst_pred_stride,
                    pu1_src_pred,
                    i4_src_pred_stride,
                    u1_pu2_wd,
                    u1_pu2_ht);
            }

            break;
        }
        case 1:
        {
            ASSERT(UCHAR_MAX != ps_pred_buf_info[2][0].u1_pred_buf_array_id);

            ihevce_set_pred_buf_as_free(
                pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[1]);

            /* Copy PU1 pred into PU2's pred buf */
            if(((u1_pu1_ht < u1_pu2_ht) || (u1_pu1_wd < u1_pu2_wd)) &&
               (UCHAR_MAX != ps_pred_buf_info[0][1].u1_pred_buf_array_id))
            {
                ps_part_type_result->pu1_pred =
                    ps_pred_buf_info[0][1].pu1_pred -
                    (u1_is_part_vertical ? u1_pu1_ht * ps_pred_buf_info[0][1].i4_pred_stride
                                         : u1_pu1_wd);
                ps_part_type_result->i4_pred_stride = ps_pred_buf_info[0][1].i4_pred_stride;

                ihevce_set_pred_buf_as_free(
                    pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[2]);

                pu1_src_pred = ps_pred_buf_info[2][0].pu1_pred;
                pu1_dst_pred = ps_part_type_result->pu1_pred;
                i4_src_pred_stride = ps_pred_buf_info[2][0].i4_pred_stride;
                i4_dst_pred_stride = ps_part_type_result->i4_pred_stride;

                ps_cmn_utils_optimised_function_list->pf_copy_2d(
                    pu1_dst_pred,
                    i4_dst_pred_stride,
                    pu1_src_pred,
                    i4_src_pred_stride,
                    u1_pu1_wd,
                    u1_pu1_ht);
            }
            else
            {
                ps_part_type_result->pu1_pred = ps_pred_buf_info[2][0].pu1_pred;
                ps_part_type_result->i4_pred_stride = ps_pred_buf_info[2][0].i4_pred_stride;

                ihevce_set_pred_buf_as_free(
                    pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[0]);

                pu1_src_pred = ps_pred_buf_info[0][1].pu1_pred;
                pu1_dst_pred = ps_part_type_result->pu1_pred;
                i4_src_pred_stride = ps_pred_buf_info[0][1].i4_pred_stride;
                i4_dst_pred_stride = ps_part_type_result->i4_pred_stride;

                ps_cmn_utils_optimised_function_list->pf_copy_2d(
                    pu1_dst_pred,
                    i4_dst_pred_stride,
                    pu1_src_pred,
                    i4_src_pred_stride,
                    u1_pu2_wd,
                    u1_pu2_ht);
            }

            break;
        }
        case 2:
        {
            ASSERT(UCHAR_MAX != ps_pred_buf_info[2][1].u1_pred_buf_array_id);

            ihevce_set_pred_buf_as_free(
                pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[1]);

            /* Copy PU2 pred into PU1's pred buf */
            if(((u1_pu1_ht > u1_pu2_ht) || (u1_pu1_wd > u1_pu2_wd)) &&
               (UCHAR_MAX != ps_pred_buf_info[0][0].u1_pred_buf_array_id))
            {
                ps_part_type_result->pu1_pred = ps_pred_buf_info[0][0].pu1_pred;
                ps_part_type_result->i4_pred_stride = ps_pred_buf_info[0][0].i4_pred_stride;

                ihevce_set_pred_buf_as_free(
                    pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[2]);

                pu1_src_pred = ps_pred_buf_info[2][1].pu1_pred;
                pu1_dst_pred = ps_part_type_result->pu1_pred +
                               (u1_is_part_vertical
                                    ? u1_pu1_ht * ps_part_type_result->i4_pred_stride
                                    : u1_pu1_wd);
                i4_src_pred_stride = ps_pred_buf_info[2][1].i4_pred_stride;
                i4_dst_pred_stride = ps_part_type_result->i4_pred_stride;

                ps_cmn_utils_optimised_function_list->pf_copy_2d(
                    pu1_dst_pred,
                    i4_dst_pred_stride,
                    pu1_src_pred,
                    i4_src_pred_stride,
                    u1_pu2_wd,
                    u1_pu2_ht);
            }
            else
            {
                ps_part_type_result->pu1_pred =
                    ps_pred_buf_info[2][1].pu1_pred -
                    (u1_is_part_vertical ? u1_pu1_ht * ps_pred_buf_info[2][1].i4_pred_stride
                                         : u1_pu1_wd);
                ps_part_type_result->i4_pred_stride = ps_pred_buf_info[2][1].i4_pred_stride;

                ihevce_set_pred_buf_as_free(
                    pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[0]);

                pu1_src_pred = ps_pred_buf_info[0][0].pu1_pred;
                pu1_dst_pred = ps_part_type_result->pu1_pred;
                i4_src_pred_stride = ps_pred_buf_info[0][0].i4_pred_stride;
                i4_dst_pred_stride = ps_part_type_result->i4_pred_stride;

                ps_cmn_utils_optimised_function_list->pf_copy_2d(
                    pu1_dst_pred,
                    i4_dst_pred_stride,
                    pu1_src_pred,
                    i4_src_pred_stride,
                    u1_pu1_wd,
                    u1_pu1_ht);
            }

            break;
        }
        case 3:
        {
            ASSERT(UCHAR_MAX != ps_pred_buf_info[2][0].u1_pred_buf_array_id);
            ASSERT(UCHAR_MAX != ps_pred_buf_info[2][1].u1_pred_buf_array_id);
            ASSERT(
                ps_pred_buf_info[2][1].u1_pred_buf_array_id ==
                ps_pred_buf_info[2][0].u1_pred_buf_array_id);

            ps_part_type_result->pu1_pred = ps_pred_buf_info[2][0].pu1_pred;
            ps_part_type_result->i4_pred_stride = ps_pred_buf_info[2][0].i4_pred_stride;

            ihevce_set_pred_buf_as_free(
                pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[0]);

            break;
        }
        }
    }
}

U08 hme_decide_search_candidate_priority_in_l1_and_l2_me(
    SEARCH_CANDIDATE_TYPE_T e_cand_type, ME_QUALITY_PRESETS_T e_quality_preset)
{
    U08 u1_priority_val =
        gau1_search_cand_priority_in_l1_and_l2_me[e_quality_preset >= ME_MEDIUM_SPEED][e_cand_type];

    if(UCHAR_MAX == u1_priority_val)
    {
        ASSERT(0);
    }

    ASSERT(u1_priority_val <= MAX_INIT_CANDTS);

    return u1_priority_val;
}

U08 hme_decide_search_candidate_priority_in_l0_me(SEARCH_CANDIDATE_TYPE_T e_cand_type, U08 u1_index)
{
    U08 u1_priority_val = gau1_search_cand_priority_in_l0_me[u1_index][e_cand_type];

    if(UCHAR_MAX == u1_priority_val)
    {
        ASSERT(0);
    }

    ASSERT(u1_priority_val <= MAX_INIT_CANDTS);

    return u1_priority_val;
}

void hme_search_cand_data_init(
    S32 *pi4_id_Z,
    S32 *pi4_id_coloc,
    S32 *pi4_num_coloc_cands,
    U08 *pu1_search_candidate_list_index,
    S32 i4_num_act_ref_l0,
    S32 i4_num_act_ref_l1,
    U08 u1_is_bidir_enabled,
    U08 u1_4x4_blk_in_l1me)
{
    S32 i, j;
    S32 i4_num_coloc_cands;

    U08 u1_search_candidate_list_index;

    if(!u1_is_bidir_enabled && !u1_4x4_blk_in_l1me)
    {
        S32 i;

        u1_search_candidate_list_index = (i4_num_act_ref_l0 - 1) * 2;
        i4_num_coloc_cands = i4_num_act_ref_l0 * 2;

        switch(i4_num_act_ref_l0)
        {
        case 1:
        {
            for(i = 0; i < 2; i++)
            {
                pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                    (SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
                    u1_search_candidate_list_index);
            }

            break;
        }
        case 2:
        {
            for(i = 0; i < 4; i++)
            {
                pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                    (SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
                    u1_search_candidate_list_index);
            }

            break;
        }
        case 3:
        {
            for(i = 0; i < 6; i++)
            {
                pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                    (SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
                    u1_search_candidate_list_index);
            }

            break;
        }
        case 4:
        {
            for(i = 0; i < 8; i++)
            {
                pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                    (SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
                    u1_search_candidate_list_index);
            }

            break;
        }
        default:
        {
            ASSERT(0);
        }
        }

        *pi4_num_coloc_cands = i4_num_coloc_cands;
        *pu1_search_candidate_list_index = u1_search_candidate_list_index;
    }
    else if(!u1_is_bidir_enabled && u1_4x4_blk_in_l1me)
    {
        S32 i;

        i4_num_coloc_cands = i4_num_act_ref_l0 * 2;
        u1_search_candidate_list_index = (i4_num_act_ref_l0 - 1) * 2 + 1;

        switch(i4_num_act_ref_l0)
        {
        case 1:
        {
            for(i = 0; i < 2; i++)
            {
                pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                    (SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
                    u1_search_candidate_list_index);
            }

            pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_TR0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 1] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BL0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 2] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BR0, u1_search_candidate_list_index);

            i4_num_coloc_cands += 3;

            break;
        }
        case 2:
        {
            for(i = 0; i < 4; i++)
            {
                pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                    (SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
                    u1_search_candidate_list_index);
            }

            pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_TR0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 1] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BL0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 2] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BR0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 3] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_TR1, u1_search_candidate_list_index);

            pi4_id_coloc[i + 4] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BL1, u1_search_candidate_list_index);

            pi4_id_coloc[i + 5] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BR1, u1_search_candidate_list_index);

            i4_num_coloc_cands += 6;

            break;
        }
        case 3:
        {
            for(i = 0; i < 6; i++)
            {
                pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                    (SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
                    u1_search_candidate_list_index);
            }

            pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_TR0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 1] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BL0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 2] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BR0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 3] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_TR1, u1_search_candidate_list_index);

            pi4_id_coloc[i + 4] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BL1, u1_search_candidate_list_index);

            pi4_id_coloc[i + 5] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BR1, u1_search_candidate_list_index);

            i4_num_coloc_cands += 6;

            break;
        }
        case 4:
        {
            for(i = 0; i < 8; i++)
            {
                pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                    (SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
                    u1_search_candidate_list_index);
            }

            pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_TR0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 1] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BL0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 2] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BR0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 3] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_TR1, u1_search_candidate_list_index);

            pi4_id_coloc[i + 4] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BL1, u1_search_candidate_list_index);

            pi4_id_coloc[i + 5] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BR1, u1_search_candidate_list_index);

            i4_num_coloc_cands += 6;

            break;
        }
        default:
        {
            ASSERT(0);
        }
        }

        *pi4_num_coloc_cands = i4_num_coloc_cands;
        *pu1_search_candidate_list_index = u1_search_candidate_list_index;
    }
    else
    {
        /* The variable 'u1_search_candidate_list_index' is hardcoded */
        /* to 10 and 11 respectively. But, these values are not returned */
        /* by this function since the actual values are dependent on */
        /* the number of refs in L0 and L1 respectively */
        /* Hence, the actual return values are being recomputed */
        /* in the latter part of this block */

        if(!u1_4x4_blk_in_l1me)
        {
            u1_search_candidate_list_index = 10;

            i4_num_coloc_cands = 2 + (2 * ((i4_num_act_ref_l0 > 1) || (i4_num_act_ref_l1 > 1)));

            for(i = 0; i < i4_num_coloc_cands; i++)
            {
                pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                    (SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
                    u1_search_candidate_list_index);
            }
        }
        else
        {
            u1_search_candidate_list_index = 11;

            i4_num_coloc_cands = 2 + (2 * ((i4_num_act_ref_l0 > 1) || (i4_num_act_ref_l1 > 1)));

            for(i = 0; i < i4_num_coloc_cands; i++)
            {
                pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                    (SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
                    u1_search_candidate_list_index);
            }

            pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_TR0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 1] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BL0, u1_search_candidate_list_index);

            pi4_id_coloc[i + 2] = hme_decide_search_candidate_priority_in_l0_me(
                PROJECTED_COLOC_BR0, u1_search_candidate_list_index);
        }

        for(j = 0; j < 2; j++)
        {
            if(0 == j)
            {
                pu1_search_candidate_list_index[j] =
                    8 + ((i4_num_act_ref_l0 > 1) * 2) + u1_4x4_blk_in_l1me;
                pi4_num_coloc_cands[j] =
                    (u1_4x4_blk_in_l1me * 3) + 2 + ((i4_num_act_ref_l0 > 1) * 2);
            }
            else
            {
                pu1_search_candidate_list_index[j] =
                    8 + ((i4_num_act_ref_l1 > 1) * 2) + u1_4x4_blk_in_l1me;
                pi4_num_coloc_cands[j] =
                    (u1_4x4_blk_in_l1me * 3) + 2 + ((i4_num_act_ref_l1 > 1) * 2);
            }
        }
    }

    if(i4_num_act_ref_l0 || i4_num_act_ref_l1)
    {
        pi4_id_Z[0] = hme_decide_search_candidate_priority_in_l0_me(
            (SEARCH_CANDIDATE_TYPE_T)ZERO_MV, pu1_search_candidate_list_index[0]);
    }

    if((i4_num_act_ref_l0 > 1) && !u1_is_bidir_enabled)
    {
        pi4_id_Z[1] = hme_decide_search_candidate_priority_in_l0_me(
            (SEARCH_CANDIDATE_TYPE_T)ZERO_MV_ALTREF, pu1_search_candidate_list_index[0]);
    }
}

static U08
    hme_determine_base_block_size(S32 *pi4_valid_part_array, S32 i4_num_valid_parts, U08 u1_cu_size)
{
    ASSERT(i4_num_valid_parts > 0);

    if(1 == i4_num_valid_parts)
    {
        ASSERT(pi4_valid_part_array[i4_num_valid_parts - 1] == PART_ID_2Nx2N);

        return u1_cu_size;
    }
    else
    {
        if(pi4_valid_part_array[i4_num_valid_parts - 1] <= PART_ID_NxN_BR)
        {
            return u1_cu_size / 2;
        }
        else if(pi4_valid_part_array[i4_num_valid_parts - 1] <= PART_ID_nRx2N_R)
        {
            return u1_cu_size / 4;
        }
    }

    return u1_cu_size / 4;
}

static U32 hme_compute_variance_of_pu_from_base_blocks(
    ULWORD64 *pu8_SigmaX,
    ULWORD64 *pu8_SigmaXSquared,
    U08 u1_cu_size,
    U08 u1_base_block_size,
    S32 i4_part_id)
{
    U08 i, j;
    ULWORD64 u8_final_variance;

    U08 u1_part_dimension_multiplier = (u1_cu_size >> 4);
    S32 i4_part_wd = gai1_part_wd_and_ht[i4_part_id][0] * u1_part_dimension_multiplier;
    S32 i4_part_ht = gai1_part_wd_and_ht[i4_part_id][1] * u1_part_dimension_multiplier;
    U08 u1_num_base_blocks_in_pu_row = i4_part_wd / u1_base_block_size;
    U08 u1_num_base_blocks_in_pu_column = i4_part_ht / u1_base_block_size;
    U08 u1_num_base_blocks_in_cu_row = u1_cu_size / u1_base_block_size;
    U08 u1_num_base_blocks = (u1_num_base_blocks_in_pu_row * u1_num_base_blocks_in_pu_column);
    U32 u4_num_pixels_in_base_block = u1_base_block_size * u1_base_block_size;
    ULWORD64 u8_final_SigmaXSquared = 0;
    ULWORD64 u8_final_SigmaX = 0;

    if(ge_part_id_to_part_type[i4_part_id] != PRT_NxN)
    {
        U08 u1_column_start_index = gau1_part_id_to_part_num[i4_part_id]
                                        ? (gai1_is_part_vertical[i4_part_id]
                                               ? 0
                                               : (u1_cu_size - i4_part_wd) / u1_base_block_size)
                                        : 0;
        U08 u1_row_start_index = gau1_part_id_to_part_num[i4_part_id]
                                     ? (gai1_is_part_vertical[i4_part_id]
                                            ? (u1_cu_size - i4_part_ht) / u1_base_block_size
                                            : 0)
                                     : 0;
        U08 u1_column_end_index = u1_column_start_index + u1_num_base_blocks_in_pu_row;
        U08 u1_row_end_index = u1_row_start_index + u1_num_base_blocks_in_pu_column;

        for(i = u1_row_start_index; i < u1_row_end_index; i++)
        {
            for(j = u1_column_start_index; j < u1_column_end_index; j++)
            {
                u8_final_SigmaXSquared += pu8_SigmaXSquared[j + i * u1_num_base_blocks_in_cu_row];
                u8_final_SigmaX += pu8_SigmaX[j + i * u1_num_base_blocks_in_cu_row];
            }
        }

        u8_final_variance =
            u1_num_base_blocks * u4_num_pixels_in_base_block * u8_final_SigmaXSquared;
        u8_final_variance -= u8_final_SigmaX * u8_final_SigmaX;
        u8_final_variance +=
            ((u1_num_base_blocks * u4_num_pixels_in_base_block) *
             (u1_num_base_blocks * u4_num_pixels_in_base_block) / 2);
        u8_final_variance /= (u1_num_base_blocks * u4_num_pixels_in_base_block) *
                             (u1_num_base_blocks * u4_num_pixels_in_base_block);

        ASSERT(u8_final_variance <= UINT_MAX);
    }
    else
    {
        U08 u1_row_start_index;
        U08 u1_column_start_index;
        U08 u1_row_end_index;
        U08 u1_column_end_index;

        switch(gau1_part_id_to_part_num[i4_part_id])
        {
        case 0:
        {
            u1_row_start_index = 0;
            u1_column_start_index = 0;

            break;
        }
        case 1:
        {
            u1_row_start_index = 0;
            u1_column_start_index = u1_num_base_blocks_in_pu_row;

            break;
        }
        case 2:
        {
            u1_row_start_index = u1_num_base_blocks_in_pu_column;
            u1_column_start_index = 0;

            break;
        }
        case 3:
        {
            u1_row_start_index = u1_num_base_blocks_in_pu_column;
            u1_column_start_index = u1_num_base_blocks_in_pu_row;

            break;
        }
        }

        u1_column_end_index = u1_column_start_index + u1_num_base_blocks_in_pu_row;
        u1_row_end_index = u1_row_start_index + u1_num_base_blocks_in_pu_column;

        for(i = u1_row_start_index; i < u1_row_end_index; i++)
        {
            for(j = u1_column_start_index; j < u1_column_end_index; j++)
            {
                u8_final_SigmaXSquared += pu8_SigmaXSquared[j + i * u1_num_base_blocks_in_cu_row];
                u8_final_SigmaX += pu8_SigmaX[j + i * u1_num_base_blocks_in_cu_row];
            }
        }

        u8_final_variance =
            u1_num_base_blocks * u4_num_pixels_in_base_block * u8_final_SigmaXSquared;
        u8_final_variance -= u8_final_SigmaX * u8_final_SigmaX;
        u8_final_variance +=
            ((u1_num_base_blocks * u4_num_pixels_in_base_block) *
             (u1_num_base_blocks * u4_num_pixels_in_base_block) / 2);
        u8_final_variance /= (u1_num_base_blocks * u4_num_pixels_in_base_block) *
                             (u1_num_base_blocks * u4_num_pixels_in_base_block);

        ASSERT(u8_final_variance <= UINT_MAX);
    }

    return u8_final_variance;
}

void hme_compute_variance_for_all_parts(
    U08 *pu1_data,
    S32 i4_data_stride,
    S32 *pi4_valid_part_array,
    U32 *pu4_variance,
    S32 i4_num_valid_parts,
    U08 u1_cu_size)
{
    ULWORD64 au8_SigmaX[16];
    ULWORD64 au8_SigmaXSquared[16];
    U08 i, j, k, l;
    U08 u1_base_block_size;
    U08 u1_num_base_blocks_in_cu_row;
    U08 u1_num_base_blocks_in_cu_column;

    u1_base_block_size =
        hme_determine_base_block_size(pi4_valid_part_array, i4_num_valid_parts, u1_cu_size);

    u1_num_base_blocks_in_cu_row = u1_num_base_blocks_in_cu_column =
        u1_cu_size / u1_base_block_size;

    ASSERT(u1_num_base_blocks_in_cu_row <= 4);

    for(i = 0; i < u1_num_base_blocks_in_cu_column; i++)
    {
        for(j = 0; j < u1_num_base_blocks_in_cu_row; j++)
        {
            U08 *pu1_buf =
                pu1_data + (u1_base_block_size * j) + (u1_base_block_size * i * i4_data_stride);

            au8_SigmaX[j + i * u1_num_base_blocks_in_cu_row] = 0;
            au8_SigmaXSquared[j + i * u1_num_base_blocks_in_cu_row] = 0;

            for(k = 0; k < u1_base_block_size; k++)
            {
                for(l = 0; l < u1_base_block_size; l++)
                {
                    au8_SigmaX[j + i * u1_num_base_blocks_in_cu_row] +=
                        pu1_buf[l + k * i4_data_stride];
                    au8_SigmaXSquared[j + i * u1_num_base_blocks_in_cu_row] +=
                        pu1_buf[l + k * i4_data_stride] * pu1_buf[l + k * i4_data_stride];
                }
            }
        }
    }

    for(i = 0; i < i4_num_valid_parts; i++)
    {
        pu4_variance[pi4_valid_part_array[i]] = hme_compute_variance_of_pu_from_base_blocks(
            au8_SigmaX, au8_SigmaXSquared, u1_cu_size, u1_base_block_size, pi4_valid_part_array[i]);
    }
}

void hme_compute_final_sigma_of_pu_from_base_blocks(
    U32 *pu4_SigmaX,
    U32 *pu4_SigmaXSquared,
    ULWORD64 *pu8_final_sigmaX,
    ULWORD64 *pu8_final_sigmaX_Squared,
    U08 u1_cu_size,
    U08 u1_base_block_size,
    S32 i4_part_id,
    U08 u1_base_blk_array_stride)
{
    U08 i, j;
    //U08 u1_num_base_blocks_in_cu_row;

    U08 u1_part_dimension_multiplier = (u1_cu_size >> 4);
    S32 i4_part_wd = gai1_part_wd_and_ht[i4_part_id][0] * u1_part_dimension_multiplier;
    S32 i4_part_ht = gai1_part_wd_and_ht[i4_part_id][1] * u1_part_dimension_multiplier;
    U08 u1_num_base_blocks_in_pu_row = i4_part_wd / u1_base_block_size;
    U08 u1_num_base_blocks_in_pu_column = i4_part_ht / u1_base_block_size;
    U16 u2_num_base_blocks = (u1_num_base_blocks_in_pu_row * u1_num_base_blocks_in_pu_column);
    U32 u4_num_pixels_in_base_block = u1_base_block_size * u1_base_block_size;
    U32 u4_N = (u2_num_base_blocks * u4_num_pixels_in_base_block);

    /*if (u1_is_for_src)
    {
    u1_num_base_blocks_in_cu_row = 16;
    }
    else
    {
    u1_num_base_blocks_in_cu_row = u1_cu_size / u1_base_block_size;
    }*/

    pu8_final_sigmaX[i4_part_id] = 0;
    pu8_final_sigmaX_Squared[i4_part_id] = 0;

    if(ge_part_id_to_part_type[i4_part_id] != PRT_NxN)
    {
        U08 u1_column_start_index = gau1_part_id_to_part_num[i4_part_id]
                                        ? (gai1_is_part_vertical[i4_part_id]
                                               ? 0
                                               : (u1_cu_size - i4_part_wd) / u1_base_block_size)
                                        : 0;
        U08 u1_row_start_index = gau1_part_id_to_part_num[i4_part_id]
                                     ? (gai1_is_part_vertical[i4_part_id]
                                            ? (u1_cu_size - i4_part_ht) / u1_base_block_size
                                            : 0)
                                     : 0;
        U08 u1_column_end_index = u1_column_start_index + u1_num_base_blocks_in_pu_row;
        U08 u1_row_end_index = u1_row_start_index + u1_num_base_blocks_in_pu_column;

        for(i = u1_row_start_index; i < u1_row_end_index; i++)
        {
            for(j = u1_column_start_index; j < u1_column_end_index; j++)
            {
                pu8_final_sigmaX_Squared[i4_part_id] +=
                    pu4_SigmaXSquared[j + i * u1_base_blk_array_stride];
                pu8_final_sigmaX[i4_part_id] += pu4_SigmaX[j + i * u1_base_blk_array_stride];
            }
        }
    }
    else
    {
        U08 u1_row_start_index;
        U08 u1_column_start_index;
        U08 u1_row_end_index;
        U08 u1_column_end_index;

        switch(gau1_part_id_to_part_num[i4_part_id])
        {
        case 0:
        {
            u1_row_start_index = 0;
            u1_column_start_index = 0;

            break;
        }
        case 1:
        {
            u1_row_start_index = 0;
            u1_column_start_index = u1_num_base_blocks_in_pu_row;

            break;
        }
        case 2:
        {
            u1_row_start_index = u1_num_base_blocks_in_pu_column;
            u1_column_start_index = 0;

            break;
        }
        case 3:
        {
            u1_row_start_index = u1_num_base_blocks_in_pu_column;
            u1_column_start_index = u1_num_base_blocks_in_pu_row;

            break;
        }
        }

        u1_column_end_index = u1_column_start_index + u1_num_base_blocks_in_pu_row;
        u1_row_end_index = u1_row_start_index + u1_num_base_blocks_in_pu_column;

        for(i = u1_row_start_index; i < u1_row_end_index; i++)
        {
            for(j = u1_column_start_index; j < u1_column_end_index; j++)
            {
                pu8_final_sigmaX_Squared[i4_part_id] +=
                    pu4_SigmaXSquared[j + i * u1_base_blk_array_stride];
                pu8_final_sigmaX[i4_part_id] += pu4_SigmaX[j + i * u1_base_blk_array_stride];
            }
        }
    }

    pu8_final_sigmaX_Squared[i4_part_id] *= u4_N;
}

void hme_compute_stim_injected_distortion_for_all_parts(
    U08 *pu1_pred,
    S32 i4_pred_stride,
    S32 *pi4_valid_part_array,
    ULWORD64 *pu8_src_sigmaX,
    ULWORD64 *pu8_src_sigmaXSquared,
    S32 *pi4_sad_array,
    S32 i4_alpha_stim_multiplier,
    S32 i4_inv_wt,
    S32 i4_inv_wt_shift_val,
    S32 i4_num_valid_parts,
    S32 i4_wpred_log_wdc,
    U08 u1_cu_size)
{
    U32 au4_sigmaX[16], au4_sigmaXSquared[16];
    ULWORD64 au8_final_ref_sigmaX[17], au8_final_ref_sigmaXSquared[17];
    S32 i4_noise_term;
    U16 i2_count;

    ULWORD64 u8_temp_var, u8_temp_var1, u8_pure_dist;
    ULWORD64 u8_ref_X_Square, u8_src_var, u8_ref_var;

    U08 u1_base_block_size;

    WORD32 i4_q_level = STIM_Q_FORMAT + ALPHA_Q_FORMAT;

    u1_base_block_size =
        hme_determine_base_block_size(pi4_valid_part_array, i4_num_valid_parts, u1_cu_size);

    ASSERT(u1_cu_size >= 16);

    hme_compute_sigmaX_and_sigmaXSquared(
        pu1_pred,
        i4_pred_stride,
        au4_sigmaX,
        au4_sigmaXSquared,
        u1_base_block_size,
        u1_base_block_size,
        u1_cu_size,
        u1_cu_size,
        1,
        u1_cu_size / u1_base_block_size);

    /* Noise Term Computation */
    for(i2_count = 0; i2_count < i4_num_valid_parts; i2_count++)
    {
        unsigned long u4_shift_val;
        S32 i4_bits_req;
        S32 part_id = pi4_valid_part_array[i2_count];

        if(i4_alpha_stim_multiplier)
        {
            /* Final SigmaX and SigmaX-Squared Calculation */
            hme_compute_final_sigma_of_pu_from_base_blocks(
                au4_sigmaX,
                au4_sigmaXSquared,
                au8_final_ref_sigmaX,
                au8_final_ref_sigmaXSquared,
                u1_cu_size,
                u1_base_block_size,
                part_id,
                (u1_cu_size / u1_base_block_size));

            u8_ref_X_Square = (au8_final_ref_sigmaX[part_id] * au8_final_ref_sigmaX[part_id]);
            u8_ref_var = (au8_final_ref_sigmaXSquared[part_id] - u8_ref_X_Square);

            u4_shift_val = ihevce_calc_stim_injected_variance(
                pu8_src_sigmaX,
                pu8_src_sigmaXSquared,
                &u8_src_var,
                i4_inv_wt,
                i4_inv_wt_shift_val,
                i4_wpred_log_wdc,
                part_id);

            u8_ref_var = u8_ref_var >> u4_shift_val;

            GETRANGE64(i4_bits_req, u8_ref_var);

            if(i4_bits_req > 27)
            {
                u8_ref_var = u8_ref_var >> (i4_bits_req - 27);
                u8_src_var = u8_src_var >> (i4_bits_req - 27);
            }

            if(u8_src_var == u8_ref_var)
            {
                u8_temp_var = (1 << STIM_Q_FORMAT);
            }
            else
            {
                u8_temp_var = (u8_src_var * u8_ref_var * (1 << STIM_Q_FORMAT));
                u8_temp_var1 = (u8_src_var * u8_src_var) + (u8_ref_var * u8_ref_var);
                u8_temp_var = (u8_temp_var + (u8_temp_var1 / 2));
                u8_temp_var = (u8_temp_var / u8_temp_var1);
                u8_temp_var = (2 * u8_temp_var);
            }

            i4_noise_term = (UWORD32)u8_temp_var;

            ASSERT(i4_noise_term >= 0);

            i4_noise_term *= i4_alpha_stim_multiplier;
        }
        else
        {
            i4_noise_term = 0;
        }

        u8_pure_dist = pi4_sad_array[part_id];
        u8_pure_dist *= ((1 << (i4_q_level)) - (i4_noise_term));
        u8_pure_dist += (1 << ((i4_q_level)-1));
        pi4_sad_array[part_id] = (UWORD32)(u8_pure_dist >> (i4_q_level));
    }
}

void hme_compute_sigmaX_and_sigmaXSquared(
    U08 *pu1_data,
    S32 i4_buf_stride,
    void *pv_sigmaX,
    void *pv_sigmaXSquared,
    U08 u1_base_blk_wd,
    U08 u1_base_blk_ht,
    U08 u1_blk_wd,
    U08 u1_blk_ht,
    U08 u1_is_sigma_pointer_size_32_bit,
    U08 u1_array_stride)
{
    U08 i, j, k, l;
    U08 u1_num_base_blks_in_row;
    U08 u1_num_base_blks_in_column;

    u1_num_base_blks_in_row = u1_blk_wd / u1_base_blk_wd;
    u1_num_base_blks_in_column = u1_blk_ht / u1_base_blk_ht;

    if(u1_is_sigma_pointer_size_32_bit)
    {
        U32 *sigmaX, *sigmaXSquared;

        sigmaX = (U32 *)pv_sigmaX;
        sigmaXSquared = (U32 *)pv_sigmaXSquared;

        /* Loop to compute the sigma_X and sigma_X_Squared */
        for(i = 0; i < u1_num_base_blks_in_column; i++)
        {
            for(j = 0; j < u1_num_base_blks_in_row; j++)
            {
                U32 u4_sigmaX = 0, u4_sigmaXSquared = 0;
                U08 *pu1_buf =
                    pu1_data + (u1_base_blk_wd * j) + (u1_base_blk_ht * i * i4_buf_stride);

                for(k = 0; k < u1_base_blk_ht; k++)
                {
                    for(l = 0; l < u1_base_blk_wd; l++)
                    {
                        u4_sigmaX += pu1_buf[l + k * i4_buf_stride];
                        u4_sigmaXSquared +=
                            (pu1_buf[l + k * i4_buf_stride] * pu1_buf[l + k * i4_buf_stride]);
                    }
                }

                sigmaX[j + i * u1_array_stride] = u4_sigmaX;
                sigmaXSquared[j + i * u1_array_stride] = u4_sigmaXSquared;
            }
        }
    }
    else
    {
        ULWORD64 *sigmaX, *sigmaXSquared;

        sigmaX = (ULWORD64 *)pv_sigmaX;
        sigmaXSquared = (ULWORD64 *)pv_sigmaXSquared;

        /* Loop to compute the sigma_X and sigma_X_Squared */
        for(i = 0; i < u1_num_base_blks_in_column; i++)
        {
            for(j = 0; j < u1_num_base_blks_in_row; j++)
            {
                ULWORD64 u8_sigmaX = 0, u8_sigmaXSquared = 0;
                U08 *pu1_buf =
                    pu1_data + (u1_base_blk_wd * j) + (u1_base_blk_ht * i * i4_buf_stride);

                for(k = 0; k < u1_base_blk_ht; k++)
                {
                    for(l = 0; l < u1_base_blk_wd; l++)
                    {
                        u8_sigmaX += pu1_buf[l + k * i4_buf_stride];
                        u8_sigmaXSquared +=
                            (pu1_buf[l + k * i4_buf_stride] * pu1_buf[l + k * i4_buf_stride]);
                    }
                }

                u8_sigmaXSquared = u8_sigmaXSquared * u1_blk_wd * u1_blk_ht;

                sigmaX[j + i * u1_array_stride] = u8_sigmaX;
                sigmaXSquared[j + i * u1_array_stride] = u8_sigmaXSquared;
            }
        }
    }
}

#if TEMPORAL_NOISE_DETECT
WORD32 ihevce_16x16block_temporal_noise_detect(
    WORD32 had_block_size,
    WORD32 ctb_width,
    WORD32 ctb_height,
    ihevce_ctb_noise_params *ps_ctb_noise_params,
    fpel_srch_cand_init_data_t *s_proj_srch_cand_init_data,
    hme_search_prms_t *s_search_prms_blk,
    me_frm_ctxt_t *ps_ctxt,
    WORD32 num_pred_dir,
    WORD32 i4_num_act_ref_l0,
    WORD32 i4_num_act_ref_l1,
    WORD32 i4_cu_x_off,
    WORD32 i4_cu_y_off,
    wgt_pred_ctxt_t *ps_wt_inp_prms,
    WORD32 input_stride,
    WORD32 index_8x8_block,
    WORD32 num_horz_blocks,
    WORD32 num_8x8_in_ctb_row,
    WORD32 i4_16x16_index)
{
    WORD32 i;
    WORD32 noise_detected;

    UWORD8 *pu1_l0_block;
    UWORD8 *pu1_l1_block;

    WORD32 mean;
    UWORD32 variance_8x8;

    /* to store the mean and variance of each 8*8 block and find the variance of any higher block sizes later on. block */
    WORD16 pi2_residue_16x16[256];
    WORD32 mean_16x16;
    UWORD32 variance_16x16[2];

    /* throw errors in case of un- supported arguments */
    /* assumptions size is 8 or 16 or 32 */
    assert(
        (had_block_size == 8) || (had_block_size == 16) || (had_block_size == 32));  //ihevc_assert

    /* initialize the variables */
    noise_detected = 0;
    variance_8x8 = 0;

    mean = 0;

    {
        i = 0;
        /* get the ref/pred and source using the MV of both directions */
        /* pick the best candidates in each direction */
        /* Colocated cands */
        {
            // steps to be done
            /* pick the candidates */
            /* do motion compoensation using the candidates got from prev step : pick from the offset */
            /* get the ref or the pred from the offset*/
            /* get the source data */
            /* send the pred - source to noise detect */
            /* do noise detect on the residue of source and pred */

            layer_mv_t *ps_layer_mvbank;
            hme_mv_t *ps_mv;

            //S32 i;
            S32 wd_c, ht_c, wd_p, ht_p;
            S32 blksize_p, blk_x, blk_y, i4_offset;
            S08 *pi1_ref_idx;
            fpel_srch_cand_init_data_t *ps_ctxt_2 = s_proj_srch_cand_init_data;
            layer_ctxt_t *ps_curr_layer = ps_ctxt_2->ps_curr_layer;
            layer_ctxt_t *ps_coarse_layer = ps_ctxt_2->ps_coarse_layer;
            err_prms_t s_err_prms;
            S32 i4_blk_wd;
            S32 i4_blk_ht;
            BLK_SIZE_T e_blk_size;
            hme_search_prms_t *ps_search_prms;
            S32 i4_part_mask;
            S32 *pi4_valid_part_ids;

            /* has list of valid partition to search terminated by -1 */
            S32 ai4_valid_part_ids[TOT_NUM_PARTS + 1];

            /*SEARCH_COMPLEXITY_T e_search_complexity = ps_ctxt->e_search_complexity;*/

            S32 i4_pos_x;
            S32 i4_pos_y;
            U08 u1_pred_dir;  // = ps_ctxt_2->u1_pred_dir;
            U08 u1_default_ref_id = 0;  //ps_ctxt_2->u1_default_ref_id;
            S32 i4_inp_off, i4_ref_offset, i4_ref_stride;

            /* The reference is actually an array of ptrs since there are several    */
            /* reference id. So an array gets passed form calling function           */
            U08 **ppu1_ref;

            /* Atributes of input candidates */
            search_node_t as_search_node[2];
            wgt_pred_ctxt_t *ps_wt_inp_prms;

            S32 posx;
            S32 posy;
            S32 i4_num_results_to_proj;
            S32 ai4_sad_grid[9 * TOT_NUM_PARTS];
            S32 i4_inp_stride;

            /* intialize variables */
            /* Width and ht of current and prev layers */
            wd_c = ps_curr_layer->i4_wd;
            ht_c = ps_curr_layer->i4_ht;
            wd_p = ps_coarse_layer->i4_wd;
            ht_p = ps_coarse_layer->i4_ht;

            ps_search_prms = s_search_prms_blk;

            ps_wt_inp_prms = &ps_ctxt->s_wt_pred;
            e_blk_size = ps_search_prms->e_blk_size;
            i4_part_mask = ps_search_prms->i4_part_mask;

            i4_blk_wd = gau1_blk_size_to_wd[e_blk_size];
            i4_blk_ht = gau1_blk_size_to_ht[e_blk_size];

            ps_layer_mvbank = ps_coarse_layer->ps_layer_mvbank;
            blksize_p = gau1_blk_size_to_wd_shift[ps_layer_mvbank->e_blk_size];

            /* ASSERT for valid sizes */
            ASSERT((blksize_p == 3) || (blksize_p == 4) || (blksize_p == 5));

            i4_pos_x = i4_cu_x_off;
            i4_pos_y = i4_cu_y_off;
            posx = i4_pos_x + 2;
            posy = i4_pos_y + 2;

            i4_inp_stride = ps_search_prms->i4_inp_stride;
            /* Move to the location of the search blk in inp buffer */
            //i4_inp_off = i4_cu_x_off;
            //i4_inp_off += i4_cu_y_off * i4_inp_stride;
            i4_inp_off = (i4_16x16_index % 4) * 16;
            i4_inp_off += (i4_16x16_index / 4) * 16 * i4_inp_stride;

            /***********pick the candidates**************************************/
            for(u1_pred_dir = 0; u1_pred_dir < num_pred_dir; u1_pred_dir++)
            {
                WORD32 actual_pred_dir = 0;

                if(u1_pred_dir == 0 && i4_num_act_ref_l0 == 0)
                {
                    actual_pred_dir = 1;
                }
                else if(u1_pred_dir == 0 && i4_num_act_ref_l0 != 0)
                {
                    actual_pred_dir = 0;
                }
                else if(u1_pred_dir == 1)
                {
                    actual_pred_dir = 1;
                }

                i4_num_results_to_proj = 1;  // only the best proj

                /* Safety check to avoid uninitialized access across temporal layers */
                posx = CLIP3(posx, 0, (wd_c - blksize_p)); /* block position withing frAME */
                posy = CLIP3(posy, 0, (ht_c - blksize_p));

                /* Project the positions to prev layer */
                blk_x = posx >> blksize_p;
                blk_y = posy >> blksize_p;

                /* Pick up the mvs from the location */
                i4_offset = (blk_x * ps_layer_mvbank->i4_num_mvs_per_blk);
                i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * blk_y);

                ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
                pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;

                if(actual_pred_dir == 1)
                {
                    ps_mv += (i4_num_act_ref_l0 * ps_layer_mvbank->i4_num_mvs_per_ref);
                    pi1_ref_idx += (i4_num_act_ref_l0 * ps_layer_mvbank->i4_num_mvs_per_ref);
                }

                {
                    as_search_node[actual_pred_dir].s_mv.i2_mvx = ps_mv[0].i2_mv_x << 1;
                    as_search_node[actual_pred_dir].s_mv.i2_mvy = ps_mv[0].i2_mv_y << 1;
                    as_search_node[actual_pred_dir].i1_ref_idx = pi1_ref_idx[0];

                    if((as_search_node[actual_pred_dir].i1_ref_idx < 0) ||
                       (as_search_node[actual_pred_dir].s_mv.i2_mvx == INTRA_MV))
                    {
                        as_search_node[actual_pred_dir].i1_ref_idx = u1_default_ref_id;
                        as_search_node[actual_pred_dir].s_mv.i2_mvx = 0;
                        as_search_node[actual_pred_dir].s_mv.i2_mvy = 0;
                    }
                }

                /********************************************************************************************/
                {
                    /* declare the variables */
                    //ps_fullpel_refine_ctxt = ps_search_prms->ps_fullpel_refine_ctxt;

                    pi4_valid_part_ids = ai4_valid_part_ids;
                    i4_ref_stride = ps_curr_layer->i4_rec_stride;
                    s_err_prms.i4_inp_stride = i4_inp_stride;
                    s_err_prms.i4_ref_stride = i4_ref_stride;
                    s_err_prms.i4_part_mask = i4_part_mask;
                    s_err_prms.pi4_sad_grid = &ai4_sad_grid[0];
                    s_err_prms.i4_blk_wd = i4_blk_wd;
                    s_err_prms.i4_blk_ht = i4_blk_ht;
                    s_err_prms.i4_step = 1;
                    s_err_prms.pi4_valid_part_ids = pi4_valid_part_ids;
                    //s_err_prms.i4_num_partitions = ps_fullpel_refine_ctxt->i4_num_valid_parts;

                    /*************************************************************************/
                    /* Depending on flag i4_use_rec, we use either input of previously       */
                    /* encoded pictures or we use recon of previously encoded pictures.      */
                    i4_ref_stride = ps_curr_layer->i4_rec_stride;
                    ppu1_ref = ps_curr_layer->ppu1_list_rec_fxfy;  // pointer to the pred

                    i4_ref_offset = (i4_ref_stride * i4_cu_y_off) + i4_cu_x_off;  //i4_x_off;

                    s_err_prms.pu1_ref =
                        ppu1_ref[as_search_node[actual_pred_dir].i1_ref_idx] + i4_ref_offset;
                    s_err_prms.pu1_ref += as_search_node[actual_pred_dir].s_mv.i2_mvx;
                    s_err_prms.pu1_ref +=
                        as_search_node[actual_pred_dir].s_mv.i2_mvy * i4_ref_stride;

                    /*get the source */
                    s_err_prms.pu1_inp =
                        ps_wt_inp_prms->apu1_wt_inp[as_search_node[actual_pred_dir].i1_ref_idx] +
                        i4_inp_off;  //pu1_src_input + i4_inp_off;//ps_wt_inp_prms->apu1_wt_inp[as_search_node[actual_pred_dir].i1_ref_idx] + i4_inp_off;

                    /* send the pred - source to noise detect */
                    // noise_detect_hme(noise_structure, s_err_prms.pu1_inp, s_err_prms.pu1_ref);
                }
                /* change the l0/l1 blcok pointer names accrodingle */

                /* get memory pointers the input and the reference */
                pu1_l0_block = s_err_prms.pu1_inp;
                pu1_l1_block = s_err_prms.pu1_ref;

                {
                    WORD32 i2, j2;
                    WORD32 dim = 16;
                    UWORD8 *buf1;
                    UWORD8 *buf2;
                    for(i2 = 0; i2 < dim; i2++)
                    {
                        buf1 = pu1_l0_block + i2 * i4_inp_stride;
                        buf2 = pu1_l1_block + i2 * i4_ref_stride;

                        for(j2 = 0; j2 < dim; j2++)
                        {
                            pi2_residue_16x16[i2 * dim + j2] = (WORD16)(buf1[j2] - buf2[j2]);
                        }
                    }

                    ihevce_calc_variance_signed(
                        pi2_residue_16x16, 16, &mean_16x16, &variance_16x16[u1_pred_dir], 16, 16);

                    /* compare the source and residue variance for this block ps_ctb_noise_params->i4_variance_src_16x16 */
                    if(variance_16x16[u1_pred_dir] >
                       ((TEMPORAL_VARIANCE_FACTOR *
                         ps_ctb_noise_params->au4_variance_src_16x16[i4_16x16_index]) >>
                        Q_TEMPORAL_VARIANCE_FACTOR))
                    {
                        /* update noisy block count only if all  best MV in diff directions indicates noise */
                        if(u1_pred_dir == num_pred_dir - 1)
                        {
                            ps_ctb_noise_params->au1_is_8x8Blk_noisy[index_8x8_block] = 1;
                            ps_ctb_noise_params->au1_is_8x8Blk_noisy[index_8x8_block + 1] = 1;
                            ps_ctb_noise_params
                                ->au1_is_8x8Blk_noisy[index_8x8_block + num_8x8_in_ctb_row] = 1;
                            ps_ctb_noise_params
                                ->au1_is_8x8Blk_noisy[index_8x8_block + num_8x8_in_ctb_row + 1] = 1;
                            noise_detected = 1;
                        }
                    }
                    else /* if any one of the direction mv says it as non noise then dont check for the other directions MV , move for next block*/
                    {
                        noise_detected = 0;
                        ps_ctb_noise_params->au1_is_8x8Blk_noisy[index_8x8_block] = 0;
                        ps_ctb_noise_params->au1_is_8x8Blk_noisy[index_8x8_block + 1] = 0;
                        ps_ctb_noise_params
                            ->au1_is_8x8Blk_noisy[index_8x8_block + num_8x8_in_ctb_row] = 0;
                        ps_ctb_noise_params
                            ->au1_is_8x8Blk_noisy[index_8x8_block + num_8x8_in_ctb_row + 1] = 0;
                        break;
                    }
                }  // variance analysis and calculation
            }  // for each direction
        }  // HME code

    }  // for each 16x16 block

    return (noise_detected);
}
#endif

void hme_qpel_interp_avg_1pt(
    interp_prms_t *ps_prms,
    S32 i4_mv_x,
    S32 i4_mv_y,
    S32 i4_buf_id,
    U08 **ppu1_final,
    S32 *pi4_final_stride)
{
    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];

    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);
    ppu1_final[i4_buf_id] = pu1_dst;
    pi4_final_stride[i4_buf_id] = ps_prms->i4_out_stride;
}

void hme_qpel_interp_avg_2pt_vert_with_reuse(
    interp_prms_t *ps_prms, S32 i4_mv_x, S32 i4_mv_y, U08 **ppu1_final, S32 *pi4_final_stride)
{
    hme_qpel_interp_avg_1pt(ps_prms, i4_mv_x, i4_mv_y + 1, 3, ppu1_final, pi4_final_stride);

    hme_qpel_interp_avg_1pt(ps_prms, i4_mv_x, i4_mv_y - 1, 1, ppu1_final, pi4_final_stride);
}

void hme_qpel_interp_avg_2pt_horz_with_reuse(
    interp_prms_t *ps_prms, S32 i4_mv_x, S32 i4_mv_y, U08 **ppu1_final, S32 *pi4_final_stride)
{
    hme_qpel_interp_avg_1pt(ps_prms, i4_mv_x + 1, i4_mv_y, 2, ppu1_final, pi4_final_stride);

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

void hme_set_mv_limit_using_dvsr_data(
    me_frm_ctxt_t *ps_ctxt,
    layer_ctxt_t *ps_curr_layer,
    range_prms_t *ps_mv_limit,
    S16 *pi2_prev_enc_frm_max_mv_y,
    U08 u1_num_act_ref_pics)
{
    WORD32 ref_ctr;

    /* Only for B/b pic. */
    if(1 == ps_ctxt->s_frm_prms.bidir_enabled)
    {
        WORD16 i2_mv_y_per_poc, i2_max_mv_y;
        WORD32 cur_poc, prev_poc, ref_poc, abs_poc_diff;
        WORD32 prev_poc_count = 0;
        WORD32 i4_p_idx;

        pi2_prev_enc_frm_max_mv_y[0] = 0;

        cur_poc = ps_ctxt->i4_curr_poc;

        i4_p_idx = 0;

        /* Get abs MAX for symmetric search */
        i2_mv_y_per_poc = ps_curr_layer->i2_max_mv_y;
        /* Assuming P to P distance as 4 */
        i2_mv_y_per_poc = (i2_mv_y_per_poc + 2) >> 2;

        for(ref_ctr = 0; ref_ctr < u1_num_act_ref_pics; ref_ctr++)
        {
            /* Get the prev. encoded frame POC */
            prev_poc = ps_ctxt->i4_prev_poc;

            ref_poc = ps_ctxt->ai4_ref_idx_to_poc_lc[ref_ctr];
            abs_poc_diff = ABS((cur_poc - ref_poc));
            /* Get the cur. max MV based on POC distance */
            i2_max_mv_y = i2_mv_y_per_poc * abs_poc_diff;
            i2_max_mv_y = MIN(i2_max_mv_y, ps_curr_layer->i2_max_mv_y);

            ps_mv_limit[ref_ctr].i2_min_x = -ps_curr_layer->i2_max_mv_x;
            ps_mv_limit[ref_ctr].i2_min_y = -i2_max_mv_y;
            ps_mv_limit[ref_ctr].i2_max_x = ps_curr_layer->i2_max_mv_x;
            ps_mv_limit[ref_ctr].i2_max_y = i2_max_mv_y;

            /* Find the MAX MV for the prev. encoded frame to optimize */
            /* the reverse dependency of ME on Enc.Loop                */
            if(ref_poc == prev_poc)
            {
                /* TO DO : Same thing for horz. search also */
                pi2_prev_enc_frm_max_mv_y[0] = i2_max_mv_y;
                prev_poc_count++;
            }
        }
    }
    else
    {
        ASSERT(0 == ps_ctxt->s_frm_prms.u1_num_active_ref_l1);

        /* Set the Config. File Params for P pic. */
        for(ref_ctr = 0; ref_ctr < ps_ctxt->s_frm_prms.u1_num_active_ref_l0; ref_ctr++)
        {
            ps_mv_limit[ref_ctr].i2_min_x = -ps_curr_layer->i2_max_mv_x;
            ps_mv_limit[ref_ctr].i2_min_y = -ps_curr_layer->i2_max_mv_y;
            ps_mv_limit[ref_ctr].i2_max_x = ps_curr_layer->i2_max_mv_x;
            ps_mv_limit[ref_ctr].i2_max_y = ps_curr_layer->i2_max_mv_y;
        }

        /* For P PIC., go with  Config. File Params */
        pi2_prev_enc_frm_max_mv_y[0] = ps_curr_layer->i2_max_mv_y;
    }
}

S32 hme_part_mask_populator(
    U08 *pu1_inp,
    S32 i4_inp_stride,
    U08 u1_limit_active_partitions,
    U08 u1_is_bPic,
    U08 u1_is_refPic,
    U08 u1_blk_8x8_mask,
    ME_QUALITY_PRESETS_T e_me_quality_preset)
{
    if(15 != u1_blk_8x8_mask)
    {
        return ENABLE_NxN;
    }
    else
    {
        U08 u1_call_inp_segmentation_based_part_mask_populator =
            (ME_XTREME_SPEED_25 != e_me_quality_preset) ||
            (!u1_is_bPic && !DISABLE_8X8CUS_IN_PPICS_IN_P6) ||
            (u1_is_bPic && u1_is_refPic && !DISABLE_8X8CUS_IN_REFBPICS_IN_P6) ||
            (u1_is_bPic && !u1_is_refPic && !DISABLE_8X8CUS_IN_NREFBPICS_IN_P6);

        if(u1_call_inp_segmentation_based_part_mask_populator)
        {
            S32 i4_part_mask =
                hme_study_input_segmentation(pu1_inp, i4_inp_stride, u1_limit_active_partitions);

            if(e_me_quality_preset == ME_XTREME_SPEED)
            {
                i4_part_mask &= ~ENABLE_AMP;
            }

            if(e_me_quality_preset == ME_XTREME_SPEED_25)
            {
                i4_part_mask &= ~ENABLE_AMP;

                i4_part_mask &= ~ENABLE_SMP;
            }

            return i4_part_mask;
        }
        else
        {
            return ENABLE_2Nx2N;
        }
    }
}