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

 *

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