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

 *

 * Copyright (C) 2018 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at:

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 *

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

 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore

*/

/**

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

* @file hme_coarse.c

*

* @brief

*    Contains ME algorithm for the coarse layer.

*

* @author

*    Ittiam

*

*

* List of Functions

* hme_update_mv_bank_coarse()

* hme_coarse()

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

*/

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

/* File Includes                                                             */

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

/* System include files */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include <stdarg.h>

#include <math.h>

#include <limits.h>

/* User include files */

#include "ihevc_typedefs.h"

#include "itt_video_api.h"

#include "ihevce_api.h"

#include "rc_cntrl_param.h"

#include "rc_frame_info_collector.h"

#include "rc_look_ahead_params.h"

#include "ihevc_defs.h"

#include "ihevc_structs.h"

#include "ihevc_platform_macros.h"

#include "ihevc_deblk.h"

#include "ihevc_itrans_recon.h"

#include "ihevc_chroma_itrans_recon.h"

#include "ihevc_chroma_intra_pred.h"

#include "ihevc_intra_pred.h"

#include "ihevc_inter_pred.h"

#include "ihevc_mem_fns.h"

#include "ihevc_padding.h"

#include "ihevc_weighted_pred.h"

#include "ihevc_sao.h"

#include "ihevc_resi_trans.h"

#include "ihevc_quant_iquant_ssd.h"

#include "ihevc_cabac_tables.h"

#include "ihevce_defs.h"

#include "ihevce_lap_enc_structs.h"

#include "ihevce_multi_thrd_structs.h"

#include "ihevce_multi_thrd_funcs.h"

#include "ihevce_me_common_defs.h"

#include "ihevce_had_satd.h"

#include "ihevce_error_codes.h"

#include "ihevce_bitstream.h"

#include "ihevce_cabac.h"

#include "ihevce_rdoq_macros.h"

#include "ihevce_function_selector.h"

#include "ihevce_enc_structs.h"

#include "ihevce_entropy_structs.h"

#include "ihevce_cmn_utils_instr_set_router.h"

#include "ihevce_enc_loop_structs.h"

#include "ihevce_bs_compute_ctb.h"

#include "ihevce_global_tables.h"

#include "ihevce_dep_mngr_interface.h"

#include "hme_datatype.h"

#include "hme_interface.h"

#include "hme_common_defs.h"

#include "hme_defs.h"

#include "ihevce_me_instr_set_router.h"

#include "hme_globals.h"

#include "hme_utils.h"

#include "hme_coarse.h"

#include "hme_refine.h"

#include "hme_err_compute.h"

#include "hme_common_utils.h"

#include "hme_search_algo.h"

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

*                             MACROS

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

#define COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, ps_search_node, shift)                              \

    {                                                                                              \

        ps_mv->i2_mv_x = ps_search_node->s_mv.i2_mvx >> (shift);                                   \

        ps_mv->i2_mv_y = ps_search_node->s_mv.i2_mvy >> (shift);                                   \

        *pi1_ref_idx = ps_search_node->i1_ref_idx;                                                 \

    }

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

/* Function Definitions                                                      */

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

/**

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

*  @fn     void hme_update_mv_bank_coarse(search_results_t *ps_search_results,

*                                   layer_mv_t *ps_layer_mv,

*                                   S32 i4_blk_x,

*                                   S32 i4_blk_y,

*                                   search_node_t *ps_search_node_4x8_l,

*                                   search_node_t *ps_search_node_8x4_t,

*                                   S08 i1_ref_idx,

*                                   mvbank_update_prms_t *ps_prms

*

*  @brief  Updates the coarse layer MV Bank for a given ref id and blk pos

*

*  @param[in]  ps_search_results: Search results data structure

*

*  @param[in, out]  ps_layer_mv : MV Bank for this layer

*

*  @param[in]  i4_search_blk_x: column number of the 4x4 blk searched

*

*  @param[in]  i4_search_blk_y: row number of the 4x4 blk searched

*

*  @param[in]  ps_search_node_4x8_t: Best MV of the 4x8T blk

*

*  @param[in]  ps_search_node_8x4_l: Best MV of the 8x4L blk

*

*  @param[in]  i1_ref_idx : Reference ID that has been searched

*

*  @param[in]  ps_prms : Parameters pertaining to the MV Bank update

*

*  @return None

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

*/

void hme_update_mv_bank_coarse(

    search_results_t *ps_search_results,

    layer_mv_t *ps_layer_mv,

    S32 i4_search_blk_x,

    S32 i4_search_blk_y,

    search_node_t *ps_search_node_4x8_t,

    search_node_t *ps_search_node_8x4_l,

    S08 i1_ref_idx,

    mvbank_update_prms_t *ps_prms)

{

    /* These point to the MV and ref idx posn to be udpated */

    hme_mv_t *ps_mv;

    S08 *pi1_ref_idx;

    /* Offset within the bank */

    S32 i4_offset;

    S32 i, j, i4_blk_x, i4_blk_y;

    /* Best results for 8x4R and 4x8B blocks */

    search_node_t *ps_search_node_8x4_r, *ps_search_node_4x8_b;

    /* Number of MVs in a block */

    S32 num_mvs = ps_layer_mv->i4_num_mvs_per_ref;

    search_node_t *aps_search_nodes[4];

    /* The search blk may be different in size from the blk used to hold MV */

    i4_blk_x = i4_search_blk_x << ps_prms->i4_shift;

    i4_blk_y = i4_search_blk_y << ps_prms->i4_shift;

    /* Compute the offset in the MV bank */

    i4_offset = i4_blk_x + i4_blk_y * ps_layer_mv->i4_num_blks_per_row;

    i4_offset *= ps_layer_mv->i4_num_mvs_per_blk;

    /* Identify the correct offset in the mvbank and the reference id buf */

    ps_mv = ps_layer_mv->ps_mv + (i4_offset + (num_mvs * i1_ref_idx));

    pi1_ref_idx = ps_layer_mv->pi1_ref_idx + (i4_offset + (num_mvs * i1_ref_idx));

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

    /* We have atleast 4 distinct results: the 4x8 top (coming from top blk) */

    /* 8x4 left (coming from left blk), 8x4 and 4x8 right and bot resp.      */

    /* If number of results to be stored is 4, then we store all these 4     */

    /* results, else we pick best ones                                       */

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

    ps_search_node_8x4_r = ps_search_results->aps_part_results[i1_ref_idx][PART_ID_2NxN_B];

    ps_search_node_4x8_b = ps_search_results->aps_part_results[i1_ref_idx][PART_ID_Nx2N_R];

    ASSERT(num_mvs <= 4);

    /* Doing this to sort best results */

    aps_search_nodes[0] = ps_search_node_8x4_r;

    aps_search_nodes[1] = ps_search_node_4x8_b;

    aps_search_nodes[2] = ps_search_node_8x4_l;

    aps_search_nodes[3] = ps_search_node_4x8_t;

    if(num_mvs == 4)

    {

        COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, aps_search_nodes[0], 0);

        ps_mv++;

        pi1_ref_idx++;

        COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, aps_search_nodes[1], 0);

        ps_mv++;

        pi1_ref_idx++;

        COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, aps_search_nodes[2], 0);

        ps_mv++;

        pi1_ref_idx++;

        COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, aps_search_nodes[3], 0);

        ps_mv++;

        pi1_ref_idx++;

        return;

    }

    /* Run through the results, store them in best to worst order */

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

    {

        for(j = i + 1; j < 4; j++)

        {

            if(aps_search_nodes[j]->i4_tot_cost < aps_search_nodes[i]->i4_tot_cost)

            {

                SWAP_HME(aps_search_nodes[j], aps_search_nodes[i], search_node_t *);

            }

        }

        COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, aps_search_nodes[i], 0);

        ps_mv++;

        pi1_ref_idx++;

    }

}

/**

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

*  @fn     void hme_coarse_frm_init(me_ctxt_t *ps_ctxt, coarse_prms_t *ps_coarse_prms)

*

*  @brief  Frame init entry point Coarse ME.

*

*  @param[in,out]  ps_ctxt: ME Handle

*

*  @param[in]  ps_coarse_prms : Coarse layer config params

*

*  @return None

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

*/

void hme_coarse_frm_init(coarse_me_ctxt_t *ps_ctxt, coarse_prms_t *ps_coarse_prms)

{

    layer_ctxt_t *ps_curr_layer;

    S32 i4_pic_wd, i4_pic_ht;

    S32 num_blks_in_pic, num_blks_in_row;

    BLK_SIZE_T e_search_blk_size = BLK_4x4;

    S32 blk_size_shift = 2, blk_wd = 4, blk_ht = 4;

    /* Number of references to search */

    S32 i4_num_ref;

    ps_curr_layer = ps_ctxt->ps_curr_descr->aps_layers[ps_coarse_prms->i4_layer_id];

    i4_num_ref = ps_coarse_prms->i4_num_ref;

    i4_pic_wd = ps_curr_layer->i4_wd;

    i4_pic_ht = ps_curr_layer->i4_ht;

    /* Macro updates num_blks_in_pic and num_blks_in_row*/

    GET_NUM_BLKS_IN_PIC(i4_pic_wd, i4_pic_ht, blk_size_shift, num_blks_in_row, num_blks_in_pic);

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

    /* Initialize the mv bank that holds results of this layer.             */

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

    hme_init_mv_bank(

        ps_curr_layer,

        BLK_4x4,

        i4_num_ref,

        ps_coarse_prms->num_results,

        ps_ctxt->u1_encode[ps_coarse_prms->i4_layer_id]);

    return;

}

/**

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

*  @fn    void hme_derive_worst_case_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_worst_case_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)

{

    /* Taking max x of left block, min x of current block */

    ps_range->i2_max_x =

        MIN((ps_pic_limit->i2_max_x - (S16)blk_wd - (S16)(i4_x - 4)), 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);

    /* Taking max y of top block, min y of current block */

    ps_range->i2_max_y =

        MIN((ps_pic_limit->i2_max_y - (S16)blk_ht - (S16)(i4_y - 4)), 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_combine_4x4_sads_and_compute_cost(S08 i1_ref_idx,

*                                           range_prms_t *ps_mv_range,

*                                           range_prms_t *ps_mv_limit,

*                                           hme_mv_t *ps_best_mv_4x8,

*                                           hme_mv_t *ps_best_mv_8x4,

*                                           pred_ctxt_t *ps_pred_ctxt,

*                                           PF_MV_COST_FXN pf_mv_cost_compute,

*                                           ME_QUALITY_PRESETS_T e_me_quality_preset,

*                                           S16 *pi2_sads_4x4_current,

*                                           S16 *pi2_sads_4x4_east,

*                                           S16 *pi2_sads_4x4_south,

*                                           FILE *fp_dump_sad)

*

*  @brief  Does a full search on entire srch window with a given step size in coarse layer

*

*  @param[in] i1_ref_idx : Cur ref idx

*

*  @param[in] ps_layer_ctxt: All info about this layer

*

*  @param[out] ps_best_mv  : type hme_mv_t contains best mv x and y

*

*  @param[in] ps_pred_ctxt : Prediction ctxt for cost computation

*

*  @param[in] pf_mv_cost_compute : mv cost computation function

*

*  @return void

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

*/

void hme_combine_4x4_sads_and_compute_cost_high_quality(

    S08 i1_ref_idx,

    range_prms_t *ps_mv_range,

    range_prms_t *ps_mv_limit,

    hme_mv_t *ps_best_mv_4x8,

    hme_mv_t *ps_best_mv_8x4,

    pred_ctxt_t *ps_pred_ctxt,

    PF_MV_COST_FXN pf_mv_cost_compute,

    S16 *pi2_sads_4x4_current,

    S16 *pi2_sads_4x4_east,

    S16 *pi2_sads_4x4_south)

{

    /* These control number of parts and number of pts in grid to search */

    S32 stepy, stepx, best_mv_y_4x8, best_mv_x_4x8, best_mv_y_8x4, best_mv_x_8x4;

    S32 step_shift_x, step_shift_y;

    S32 mvx, mvy, mv_x_offset, mv_y_offset, mv_x_range, mv_y_range;

    S32 min_cost_4x8 = MAX_32BIT_VAL;

    S32 min_cost_8x4 = MAX_32BIT_VAL;

    search_node_t s_search_node;

    s_search_node.i1_ref_idx = i1_ref_idx;

    stepx = stepy = HME_COARSE_STEP_SIZE_HIGH_QUALITY;

    /*TODO: Calculate Step shift from the #define HME_COARSE_STEP_SIZE_HIGH_QUALITY */

    step_shift_x = step_shift_y = 1;

    mv_x_offset = (-ps_mv_limit->i2_min_x >> step_shift_x);

    mv_y_offset = (-ps_mv_limit->i2_min_y >> step_shift_y);

    mv_x_range = (-ps_mv_limit->i2_min_x + ps_mv_limit->i2_max_x) >> step_shift_x;

    mv_y_range = (-ps_mv_limit->i2_min_y + ps_mv_limit->i2_max_y) >> step_shift_y;

    /* Run 2loops to sweep over the reference area */

    for(mvy = ps_mv_range->i2_min_y; mvy < ps_mv_range->i2_max_y; mvy += stepy)

    {

        for(mvx = ps_mv_range->i2_min_x; mvx < ps_mv_range->i2_max_x; mvx += stepx)

        {

            S32 sad_4x8, cost_4x8, sad_8x4, cost_8x4;

            S32 sad_pos = ((mvx >> step_shift_x) + mv_x_offset) +

                          ((mvy >> step_shift_y) + mv_y_offset) * mv_x_range;

            /* Get SAD by adding SAD for current and neighbour S  */

            sad_4x8 = pi2_sads_4x4_current[sad_pos] + pi2_sads_4x4_south[sad_pos];

            sad_8x4 = pi2_sads_4x4_current[sad_pos] + pi2_sads_4x4_east[sad_pos];

            //          fprintf(fp_dump_sad,"%d\t",sad);

            s_search_node.s_mv.i2_mvx = mvx;

            s_search_node.s_mv.i2_mvy = mvy;

            cost_4x8 = cost_8x4 =

                pf_mv_cost_compute(&s_search_node, ps_pred_ctxt, PART_ID_2Nx2N, MV_RES_FPEL);

            cost_4x8 += sad_4x8;

            cost_8x4 += sad_8x4;

            if(cost_4x8 < min_cost_4x8)

            {

                best_mv_x_4x8 = mvx;

                best_mv_y_4x8 = mvy;

                min_cost_4x8 = cost_4x8;

            }

            if(cost_8x4 < min_cost_8x4)

            {

                best_mv_x_8x4 = mvx;

                best_mv_y_8x4 = mvy;

                min_cost_8x4 = cost_8x4;

            }

        }

    }

    ps_best_mv_4x8->i2_mv_x = best_mv_x_4x8;

    ps_best_mv_4x8->i2_mv_y = best_mv_y_4x8;

    ps_best_mv_8x4->i2_mv_x = best_mv_x_8x4;

    ps_best_mv_8x4->i2_mv_y = best_mv_y_8x4;

}

void hme_combine_4x4_sads_and_compute_cost_high_speed(

    S08 i1_ref_idx,

    range_prms_t *ps_mv_range,

    range_prms_t *ps_mv_limit,

    hme_mv_t *ps_best_mv_4x8,

    hme_mv_t *ps_best_mv_8x4,

    pred_ctxt_t *ps_pred_ctxt,

    PF_MV_COST_FXN pf_mv_cost_compute,

    S16 *pi2_sads_4x4_current,

    S16 *pi2_sads_4x4_east,

    S16 *pi2_sads_4x4_south)

{

    /* These control number of parts and number of pts in grid to search */

    S32 stepy, stepx, best_mv_y_4x8, best_mv_x_4x8, best_mv_y_8x4, best_mv_x_8x4;

    S32 step_shift_x, step_shift_y;

    S32 mvx, mvy, mv_x_offset, mv_y_offset, mv_x_range, mv_y_range;

    S32 rnd, lambda, lambda_q_shift;

    S32 min_cost_4x8 = MAX_32BIT_VAL;

    S32 min_cost_8x4 = MAX_32BIT_VAL;

    (void)pf_mv_cost_compute;

    stepx = stepy = HME_COARSE_STEP_SIZE_HIGH_SPEED;

    /*TODO: Calculate Step shift from the #define HME_COARSE_STEP_SIZE_HIGH_SPEED */

    step_shift_x = step_shift_y = 2;

    mv_x_offset = (-ps_mv_limit->i2_min_x >> step_shift_x);

    mv_y_offset = (-ps_mv_limit->i2_min_y >> step_shift_y);

    mv_x_range = (-ps_mv_limit->i2_min_x + ps_mv_limit->i2_max_x) >> step_shift_x;

    mv_y_range = (-ps_mv_limit->i2_min_y + ps_mv_limit->i2_max_y) >> step_shift_y;

    lambda = ps_pred_ctxt->lambda;

    lambda_q_shift = ps_pred_ctxt->lambda_q_shift;

    rnd = 1 << (lambda_q_shift - 1);

    ASSERT(MAX_MVX_SUPPORTED_IN_COARSE_LAYER >= ABS(ps_mv_range->i2_max_x));

    ASSERT(MAX_MVY_SUPPORTED_IN_COARSE_LAYER >= ABS(ps_mv_range->i2_max_y));

    /* Run 2loops to sweep over the reference area */

    for(mvy = ps_mv_range->i2_min_y; mvy < ps_mv_range->i2_max_y; mvy += stepy)

    {

        for(mvx = ps_mv_range->i2_min_x; mvx < ps_mv_range->i2_max_x; mvx += stepx)

        {

            S32 sad_4x8, cost_4x8, sad_8x4, cost_8x4;

            S32 sad_pos = ((mvx >> step_shift_x) + mv_x_offset) +

                          ((mvy >> step_shift_y) + mv_y_offset) * mv_x_range;

            /* Get SAD by adding SAD for current and neighbour S  */

            sad_4x8 = pi2_sads_4x4_current[sad_pos] + pi2_sads_4x4_south[sad_pos];

            sad_8x4 = pi2_sads_4x4_current[sad_pos] + pi2_sads_4x4_east[sad_pos];

            //          fprintf(fp_dump_sad,"%d\t",sad);

            cost_4x8 = cost_8x4 =

                (2 * hme_get_range(ABS(mvx)) - 1) + (2 * hme_get_range(ABS(mvy)) - 1) + i1_ref_idx;

            cost_4x8 += (mvx != 0) ? 1 : 0;

            cost_4x8 += (mvy != 0) ? 1 : 0;

            cost_4x8 = (cost_4x8 * lambda + rnd) >> lambda_q_shift;

            cost_8x4 += (mvx != 0) ? 1 : 0;

            cost_8x4 += (mvy != 0) ? 1 : 0;

            cost_8x4 = (cost_8x4 * lambda + rnd) >> lambda_q_shift;

            cost_4x8 += sad_4x8;

            cost_8x4 += sad_8x4;

            if(cost_4x8 < min_cost_4x8)

            {

                best_mv_x_4x8 = mvx;

                best_mv_y_4x8 = mvy;

                min_cost_4x8 = cost_4x8;

            }

            if(cost_8x4 < min_cost_8x4)

            {

                best_mv_x_8x4 = mvx;

                best_mv_y_8x4 = mvy;

                min_cost_8x4 = cost_8x4;

            }

        }

    }

    ps_best_mv_4x8->i2_mv_x = best_mv_x_4x8;

    ps_best_mv_4x8->i2_mv_y = best_mv_y_4x8;

    ps_best_mv_8x4->i2_mv_x = best_mv_x_8x4;

    ps_best_mv_8x4->i2_mv_y = best_mv_y_8x4;

}

/**

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

*  @fn     hme_store_4x4_sads(hme_search_prms_t *ps_search_prms,

*                               layer_ctxt_t *ps_layer_ctxt)

*

*  @brief  Does a 4x4 sad computation on a given range and stores it in memory

*

*  @param[in] ps_search_prms : Search prms structure containing info like

*               blk dimensions, search range etc

*

*  @param[in] ps_layer_ctxt: All info about this layer

*

*  @param[in] ps_wt_inp_prms: All info about weighted input

*

*  @param[in] e_me_quality_preset: motion estimation quality preset

*

*  @param[in] pi2_sads_4x4: Memory to store all 4x4 SADs for given range

*

*  @return void

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

*/

void hme_store_4x4_sads_high_quality(

    hme_search_prms_t *ps_search_prms,

    layer_ctxt_t *ps_layer_ctxt,

    range_prms_t *ps_mv_limit,

    wgt_pred_ctxt_t *ps_wt_inp_prms,

    S16 *pi2_sads_4x4)

{

    S32 sad, i, j;

    /* Input and reference attributes */

    U08 *pu1_inp, *pu1_inp_orig, *pu1_ref;

    S32 i4_inp_stride, i4_ref_stride, i4_ref_offset;

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

    S32 stepy, stepx, step_shift_x, step_shift_y;

    S32 mvx, mvy, mv_x_offset, mv_y_offset, mv_x_range, mv_y_range;

    /* Points to the range limits for mv */

    range_prms_t *ps_range_prms;

    /* Reference index to be searched */

    S32 i4_search_idx = ps_search_prms->i1_ref_idx;

    /* Using the member 0 to store for all ref. idx. */

    ps_range_prms = ps_search_prms->aps_mv_range[0];

    pu1_inp_orig = ps_wt_inp_prms->apu1_wt_inp[i4_search_idx];

    i4_inp_stride = ps_search_prms->i4_inp_stride;

    /* Move to the location of the search blk in inp buffer */

    pu1_inp_orig += ps_search_prms->i4_cu_x_off;

    pu1_inp_orig += ps_search_prms->i4_cu_y_off * i4_inp_stride;

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

    /* we use either input of previously encoded pictures as reference       */

    /* in coarse layer                                                       */

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

    i4_ref_stride = ps_layer_ctxt->i4_inp_stride;

    ppu1_ref = ps_layer_ctxt->ppu1_list_inp;

    /* colocated position in reference picture */

    i4_ref_offset = (i4_ref_stride * ps_search_prms->i4_y_off) + ps_search_prms->i4_x_off;

    pu1_ref_coloc = ppu1_ref[i4_search_idx] + i4_ref_offset;

    stepx = stepy = HME_COARSE_STEP_SIZE_HIGH_QUALITY;

    /*TODO: Calculate Step shift from the #define HME_COARSE_STEP_SIZE_HIGH_QUALITY */

    step_shift_x = step_shift_y = 1;

    mv_x_offset = -(ps_mv_limit->i2_min_x >> step_shift_x);

    mv_y_offset = -(ps_mv_limit->i2_min_y >> step_shift_y);

    mv_x_range = (-ps_mv_limit->i2_min_x + ps_mv_limit->i2_max_x) >> step_shift_x;

    mv_y_range = (-ps_mv_limit->i2_min_y + ps_mv_limit->i2_max_y) >> step_shift_y;

    /* Run 2loops to sweep over the reference area */

    for(mvy = ps_range_prms->i2_min_y; mvy < ps_range_prms->i2_max_y; mvy += stepy)

    {

        for(mvx = ps_range_prms->i2_min_x; mvx < ps_range_prms->i2_max_x; mvx += stepx)

        {

            /* Set up the reference and inp ptr */

            pu1_ref = pu1_ref_coloc + mvx + (mvy * i4_ref_stride);

            pu1_inp = pu1_inp_orig;

            /* SAD computation */

            {

                sad = 0;

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

                {

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

                    {

                        sad += (ABS(((S32)pu1_inp[j] - (S32)pu1_ref[j])));

                    }

                    pu1_inp += i4_inp_stride;

                    pu1_ref += i4_ref_stride;

                }

            }

            pi2_sads_4x4

                [((mvx >> step_shift_x) + mv_x_offset) +

                 ((mvy >> step_shift_y) + mv_y_offset) * mv_x_range] = sad;

        }

    }

}

void hme_store_4x4_sads_high_speed(

    hme_search_prms_t *ps_search_prms,

    layer_ctxt_t *ps_layer_ctxt,

    range_prms_t *ps_mv_limit,

    wgt_pred_ctxt_t *ps_wt_inp_prms,

    S16 *pi2_sads_4x4)

{

    S32 sad, i, j;

    /* Input and reference attributes */

    U08 *pu1_inp, *pu1_inp_orig, *pu1_ref;

    S32 i4_inp_stride, i4_ref_stride, i4_ref_offset;

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

    S32 stepy, stepx, step_shift_x, step_shift_y;

    S32 mvx, mvy, mv_x_offset, mv_y_offset, mv_x_range, mv_y_range;

    /* Points to the range limits for mv */

    range_prms_t *ps_range_prms;

    /* Reference index to be searched */

    S32 i4_search_idx = ps_search_prms->i1_ref_idx;

    /* Using the member 0 for all ref. idx */

    ps_range_prms = ps_search_prms->aps_mv_range[0];

    pu1_inp_orig = ps_wt_inp_prms->apu1_wt_inp[i4_search_idx];

    i4_inp_stride = ps_search_prms->i4_inp_stride;

    /* Move to the location of the search blk in inp buffer */

    pu1_inp_orig += ps_search_prms->i4_cu_x_off;

    pu1_inp_orig += ps_search_prms->i4_cu_y_off * i4_inp_stride;

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

    /* we use either input of previously encoded pictures as reference       */

    /* in coarse layer                                                       */

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

    i4_ref_stride = ps_layer_ctxt->i4_inp_stride;

    ppu1_ref = ps_layer_ctxt->ppu1_list_inp;

    /* colocated position in reference picture */

    i4_ref_offset = (i4_ref_stride * ps_search_prms->i4_y_off) + ps_search_prms->i4_x_off;

    pu1_ref_coloc = ppu1_ref[i4_search_idx] + i4_ref_offset;

    stepx = stepy = HME_COARSE_STEP_SIZE_HIGH_SPEED;

    /*TODO: Calculate Step shift from the #define HME_COARSE_STEP_SIZE_HIGH_SPEED */

    step_shift_x = step_shift_y = 2;

    mv_x_offset = -(ps_mv_limit->i2_min_x >> step_shift_x);

    mv_y_offset = -(ps_mv_limit->i2_min_y >> step_shift_y);

    mv_x_range = (-ps_mv_limit->i2_min_x + ps_mv_limit->i2_max_x) >> step_shift_x;

    mv_y_range = (-ps_mv_limit->i2_min_y + ps_mv_limit->i2_max_y) >> step_shift_y;

    /* Run 2loops to sweep over the reference area */

    for(mvy = ps_range_prms->i2_min_y; mvy < ps_range_prms->i2_max_y; mvy += stepy)

    {

        for(mvx = ps_range_prms->i2_min_x; mvx < ps_range_prms->i2_max_x; mvx += stepx)

        {

            /* Set up the reference and inp ptr */

            pu1_ref = pu1_ref_coloc + mvx + (mvy * i4_ref_stride);

            pu1_inp = pu1_inp_orig;

            /* SAD computation */

            {

                sad = 0;

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

                {

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

                    {

                        sad += (ABS(((S32)pu1_inp[j] - (S32)pu1_ref[j])));

                    }

                    pu1_inp += i4_inp_stride;

                    pu1_ref += i4_ref_stride;

                }

            }

            pi2_sads_4x4

                [((mvx >> step_shift_x) + mv_x_offset) +

                 ((mvy >> step_shift_y) + mv_y_offset) * mv_x_range] = sad;

        }

    }

}

/**

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

*  @fn     void hme_coarsest(me_ctxt_t *ps_ctxt, coarse_prms_t *ps_coarse_prms)

*

*  @brief  Top level entry point for Coarse ME. Runs across blks and searches

*          at a 4x4 blk granularity by using 4x8 and 8x4 patterns.

*

*  @param[in,out]  ps_ctxt: ME Handle

*

*  @param[in]  ps_coarse_prms : Coarse layer config params

*

*  @param[in]  ps_multi_thrd_ctxt : Multi thread context

*

*  @return None

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

*/

void hme_coarsest(

    coarse_me_ctxt_t *ps_ctxt,

    coarse_prms_t *ps_coarse_prms,

    multi_thrd_ctxt_t *ps_multi_thrd_ctxt,

    WORD32 i4_ping_pong,

    void **ppv_dep_mngr_hme_sync)

{

    S16 *pi2_cur_ref_sads_4x4;

    S32 ai4_sad_4x4_block_size[MAX_NUM_REF], ai4_sad_4x4_block_stride[MAX_NUM_REF];

    S32 num_rows_coarse;

    S32 sad_top_offset, sad_current_offset;

    S32 search_node_top_offset, search_node_left_offset;

    ME_QUALITY_PRESETS_T e_me_quality_preset =

        ps_ctxt->s_init_prms.s_me_coding_tools.e_me_quality_presets;

    search_results_t *ps_search_results;

    mvbank_update_prms_t s_mv_update_prms;

    BLK_SIZE_T e_search_blk_size = BLK_4x4;

    hme_search_prms_t s_search_prms_4x8, s_search_prms_8x4, s_search_prms_4x4;

    S32 global_id_8x4, global_id_4x8;

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

    /* These directly point to the best search result nodes that will be     */

    /* updated by the search algorithm, rather than have to go through an    */

    /* elaborate structure                                                   */

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

    search_node_t *aps_best_search_node_8x4[MAX_NUM_REF];

    search_node_t *aps_best_search_node_4x8[MAX_NUM_REF];

    /* These point to various spatial candts */

    search_node_t *ps_candt_8x4_l, *ps_candt_8x4_t, *ps_candt_8x4_tl;

    search_node_t *ps_candt_4x8_l, *ps_candt_4x8_t, *ps_candt_4x8_tl;

    search_node_t *ps_candt_zeromv_8x4, *ps_candt_zeromv_4x8;

    search_node_t *ps_candt_fs_8x4, *ps_candt_fs_4x8;

    search_node_t as_top_neighbours[4], as_left_neighbours[3];

    /* Holds the global mv for a given ref index */

    search_node_t s_candt_global[MAX_NUM_REF];

    /* All the search candidates */

    search_candt_t as_search_candts_8x4[MAX_INIT_CANDTS];

    search_candt_t as_search_candts_4x8[MAX_INIT_CANDTS];

    search_candt_t *ps_search_candts_8x4, *ps_search_candts_4x8;

    /* Actual range per blk and the pic level boundaries */

    range_prms_t s_range_prms, s_pic_limit, as_mv_limit[MAX_NUM_REF];

    /* Current and prev pic layer ctxt at the coarsest layer */

    layer_ctxt_t *ps_curr_layer, *ps_prev_layer;

    /* best mv of full search */

    hme_mv_t best_mv_4x8, best_mv_8x4;

    /* Book keeping at blk level */

    S32 blk_x, num_blks_in_pic, num_blks_in_row, num_4x4_blks_in_row;

    S32 blk_y;

    /* Block dimensions */

    S32 blk_size_shift = 2, blk_wd = 4, blk_ht = 4;

    S32 lambda = ps_coarse_prms->lambda;

    /* Number of references to search */

    S32 i4_num_ref;

    S32 i4_i, id, i;

    S08 i1_ref_idx;

    S32 i4_pic_wd, i4_pic_ht;

    S32 i4_layer_id;

    S32 end_of_frame;

    pf_get_wt_inp fp_get_wt_inp;

    /* Maximum search iterations around any candidate */

    S32 i4_max_iters = ps_coarse_prms->i4_max_iters;

    ps_curr_layer = ps_ctxt->ps_curr_descr->aps_layers[ps_coarse_prms->i4_layer_id];

    ps_prev_layer = hme_coarse_get_past_layer_ctxt(ps_ctxt, ps_coarse_prms->i4_layer_id);

    /* We need only one instance of search results structure */

    ps_search_results = &ps_ctxt->s_search_results_8x8;

    ps_search_candts_8x4 = &as_search_candts_8x4[0];

    ps_search_candts_4x8 = &as_search_candts_4x8[0];

    end_of_frame = 0;

    i4_pic_wd = ps_curr_layer->i4_wd;

    i4_pic_ht = ps_curr_layer->i4_ht;

    fp_get_wt_inp = ((ihevce_me_optimised_function_list_t *)ps_ctxt->pv_me_optimised_function_list)

                        ->pf_get_wt_inp_8x8;

    num_rows_coarse = ps_ctxt->i4_num_row_bufs;

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

    /* Coarse Layer always does explicit search. Number of reference frames  */

    /* to search is a configurable parameter supplied by the application     */

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

    i4_num_ref = ps_coarse_prms->i4_num_ref;

    i4_layer_id = ps_coarse_prms->i4_layer_id;

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

    /*  The search algorithm goes as follows:                                */

    /*                                                                       */

    /*          ___                                                          */

    /*         | e |                                                         */

    /*      ___|___|___                                                      */

    /*     | c | a | b |                                                     */

    /*     |___|___|___|                                                     */

    /*         | d |                                                         */

    /*         |___|                                                         */

    /*                                                                       */

    /* For the target block a, we collect best results from 2 8x4 blks       */

    /* These are c-a and a-b. The 4x8 blks are e-a and a-d                   */

    /* c-a result is already available from results of blk c. a-b is         */

    /* evaluated in this blk. Likewise e-a result is stored in a row buffer  */

    /* a-d is evaluated this blk                                             */

    /* So we store a row buffer which stores best 4x8 results of all top blk */

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

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

    /* Initialize the pointers to the best node.                            */

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

    for(i4_i = 0; i4_i < i4_num_ref; i4_i++)

    {

        aps_best_search_node_8x4[i4_i] = ps_search_results->aps_part_results[i4_i][PART_ID_2NxN_B];

        aps_best_search_node_4x8[i4_i] = ps_search_results->aps_part_results[i4_i][PART_ID_Nx2N_R];

    }

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

    /* Initialize the "searchresults" structure. This will set up the number*/

    /* of search types, result updates etc                                  */

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

    {

        S32 num_results_per_part;

        /* We evaluate 4 types of results per 4x4 blk. 8x4L and 8x4R and     */

        /* 4x8 T and 4x8B. So if we are to give 4 results, then we need to   */

        /* only evaluate 1 result per part. In the coarse layer, we are      */

        /* limited to 2 results max per part, and max of 8 results.          */

        num_results_per_part = (ps_coarse_prms->num_results + 3) >> 2;

        hme_init_search_results(

            ps_search_results,

            i4_num_ref,

            ps_coarse_prms->num_results,

            num_results_per_part,

            BLK_8x8,

            0,

            0,

            ps_ctxt->au1_is_past);

    }

    /* Macro updates num_blks_in_pic and num_blks_in_row*/

    GET_NUM_BLKS_IN_PIC(i4_pic_wd, i4_pic_ht, blk_size_shift, num_blks_in_row, num_blks_in_pic);

    num_4x4_blks_in_row = num_blks_in_row + 1;

    s_mv_update_prms.e_search_blk_size = e_search_blk_size;

    s_mv_update_prms.i4_num_ref = i4_num_ref;

    s_mv_update_prms.i4_shift = 0;

    /* For full search, support 2 or 4 step size */

    if(ps_coarse_prms->do_full_search)

    {

        ASSERT((ps_coarse_prms->full_search_step == 2) || (ps_coarse_prms->full_search_step == 4));

    }

    for(i4_i = 0; i4_i < i4_num_ref; i4_i++)

    {

        S32 blk, delta_poc;

        S32 mv_x_clip, mv_y_clip;

        /* Initialize only the first row */

        for(blk = 0; blk < num_blks_in_row; blk++)

        {

            INIT_SEARCH_NODE(&ps_ctxt->aps_best_search_nodes_4x8_n_rows[i4_i][blk], i4_i);

        }

        delta_poc = ABS(ps_curr_layer->i4_poc - ps_curr_layer->ai4_ref_id_to_poc_lc[i4_i]);

        /* Setting search range for different references based on the delta poc */

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

        /* set the MV limit per ref. pic.                                        */

        /*    - P pic. : Based on the config params.                             */

        /*    - B/b pic: Based on the Max/Min MV from prev. P and config. param. */

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

        {

            /* TO DO : Remove hard coding of P-P dist. of 4 */

            mv_x_clip = (ps_curr_layer->i2_max_mv_x * delta_poc) / 4;

            /* Only for B/b pic. */

            if(1 == ps_ctxt->s_frm_prms.bidir_enabled)

            {

                WORD16 i2_mv_y_per_poc;

                /* Get abs MAX for symmetric search */

                i2_mv_y_per_poc =

                    MAX(ps_ctxt->s_coarse_dyn_range_prms.i2_dyn_max_y_per_poc[i4_layer_id],

                        (ABS(ps_ctxt->s_coarse_dyn_range_prms.i2_dyn_min_y_per_poc[i4_layer_id])));

                mv_y_clip = i2_mv_y_per_poc * delta_poc;

            }

            /* Set the Config. File Params for P pic. */

            else

            {

                /* TO DO : Remove hard coding of P-P dist. of 4 */

                mv_y_clip = (ps_curr_layer->i2_max_mv_y * delta_poc) / 4;

            }

            /* Making mv_x and mv_y range multiple of 4 */

            mv_x_clip = (((mv_x_clip + 3) >> 2) << 2);

            mv_y_clip = (((mv_y_clip + 3) >> 2) << 2);

            /* Clipping the range of mv_x and mv_y */

            mv_x_clip = CLIP3(mv_x_clip, 4, MAX_MVX_SUPPORTED_IN_COARSE_LAYER);

            mv_y_clip = CLIP3(mv_y_clip, 4, MAX_MVY_SUPPORTED_IN_COARSE_LAYER);

            as_mv_limit[i4_i].i2_min_x = -mv_x_clip;

            as_mv_limit[i4_i].i2_min_y = -mv_y_clip;

            as_mv_limit[i4_i].i2_max_x = mv_x_clip;

            as_mv_limit[i4_i].i2_max_y = mv_y_clip;

        }

        /*Populating SAD block size based on search range */

        ai4_sad_4x4_block_size[i4_i] = ((2 * mv_x_clip) / ps_coarse_prms->full_search_step) *

                                       ((2 * mv_y_clip) / ps_coarse_prms->full_search_step);

        ai4_sad_4x4_block_stride[i4_i] = (num_blks_in_row + 1) * ai4_sad_4x4_block_size[i4_i];

    }

    for(i = 0; i < 2 * MAX_INIT_CANDTS; i++)

    {

        search_node_t *ps_search_node;

        ps_search_node = &ps_ctxt->s_init_search_node[i];

        INIT_SEARCH_NODE(ps_search_node, 0);

    }

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

    {

        search_node_t *ps_search_node;

        ps_search_node = &as_left_neighbours[i];

        INIT_SEARCH_NODE(ps_search_node, 0);

        ps_search_node = &as_top_neighbours[i];

        INIT_SEARCH_NODE(ps_search_node, 0);

    }

    INIT_SEARCH_NODE(&as_top_neighbours[3], 0);

    /* Set up place holders to hold the search nodes of each initial candt */

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

    {

        ps_search_candts_8x4[i].ps_search_node = &ps_ctxt->s_init_search_node[i];

        ps_search_candts_4x8[i].ps_search_node = &ps_ctxt->s_init_search_node[MAX_INIT_CANDTS + i];

        ps_search_candts_8x4[i].u1_num_steps_refine = (U08)i4_max_iters;

        ps_search_candts_4x8[i].u1_num_steps_refine = (U08)i4_max_iters;

    }

    /* For Top,TopLeft and Left cand., no need for refinement */

    id = 0;

    if((ps_coarse_prms->do_full_search) && (ME_XTREME_SPEED_25 == e_me_quality_preset))

    {

        /* This search candt has the full search result */

        ps_candt_fs_8x4 = ps_search_candts_8x4[id].ps_search_node;

        id++;

    }

    ps_candt_8x4_l = ps_search_candts_8x4[id].ps_search_node;

    ps_search_candts_8x4[id].u1_num_steps_refine = 0;

    id++;

    ps_candt_8x4_t = ps_search_candts_8x4[id].ps_search_node;

    ps_search_candts_8x4[id].u1_num_steps_refine = 0;

    id++;

    ps_candt_8x4_tl = ps_search_candts_8x4[id].ps_search_node;

    ps_search_candts_8x4[id].u1_num_steps_refine = 0;

    id++;

    /* This search candt stores the global candt */

    global_id_8x4 = id;

    id++;

    if((ps_coarse_prms->do_full_search) && (ME_XTREME_SPEED_25 != e_me_quality_preset))

    {

        /* This search candt has the full search result */

        ps_candt_fs_8x4 = ps_search_candts_8x4[id].ps_search_node;

        id++;

    }

    /* Don't increment id as (0,0) is removed from cand. list. Initializing */

    /* the pointer for hme_init_pred_ctxt_no_encode()                       */

    ps_candt_zeromv_8x4 = ps_search_candts_8x4[id].ps_search_node;

    /* For Top,TopLeft and Left cand., no need for refinement */

    id = 0;

    if((ps_coarse_prms->do_full_search) && (ME_XTREME_SPEED_25 == e_me_quality_preset))

    {

        /* This search candt has the full search result */

        ps_candt_fs_4x8 = ps_search_candts_4x8[id].ps_search_node;

        id++;

    }

    ps_candt_4x8_l = ps_search_candts_4x8[id].ps_search_node;

    ps_search_candts_4x8[id].u1_num_steps_refine = 0;

    id++;

    ps_candt_4x8_t = ps_search_candts_4x8[id].ps_search_node;

    ps_search_candts_4x8[id].u1_num_steps_refine = 0;

    id++;

    ps_candt_4x8_tl = ps_search_candts_4x8[id].ps_search_node;

    ps_search_candts_4x8[id].u1_num_steps_refine = 0;

    id++;

    /* This search candt stores the global candt */

    global_id_4x8 = id;

    id++;

    if((ps_coarse_prms->do_full_search) && (ME_XTREME_SPEED_25 != e_me_quality_preset))

    {

        /* This search candt has the full search result */

        ps_candt_fs_4x8 = ps_search_candts_4x8[id].ps_search_node;

        id++;

    }

    /* Don't increment id4as (0,0) is removed from cand. list. Initializing */

    /* the pointer for hme_init_pred_ctxt_no_encode()                       */

    ps_candt_zeromv_4x8 = ps_search_candts_4x8[id].ps_search_node;

    /* Zero mv always has 0 mvx and y componnent, ref idx initialized inside */

    ps_candt_zeromv_8x4->s_mv.i2_mvx = 0;

    ps_candt_zeromv_8x4->s_mv.i2_mvy = 0;

    ps_candt_zeromv_4x8->s_mv.i2_mvx = 0;

    ps_candt_zeromv_4x8->s_mv.i2_mvy = 0;

    /* SET UP THE PRED CTXT FOR L0 AND L1 */