hme_utils.c - Android社区 - https://www.androidos.net.cn/

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

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;