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

 *

 * 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_err_compute.c

*

* \brief

*    SAD / SATD routines for error computation

*

* Detailed_description : Contains various types of SAD/SATD routines for

*   error computation between a given input and reference ptr. The SAD

*   routines can evaluate for either a single point or a grid, and can

*   evaluate with either partial updates or no partial updates. Partial

*   updates means evaluating sub block SADs, e.g. 4 4x4 subblock SAD in

*   addition to the main 8x8 block SAD.

*

* \date

*    22/9/2012

*

* \author  Ittiam

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

*/

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

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

#include "ihevce_stasino_helpers.h"

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

*                         MACRO DEFINITIONS

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

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

/* Theoritically, the various types of SAD functions that are needed for     */

/* reasons of optimality. SADs that are to be evaluated at a single pt can be*/

/* more optimal than SADs that are to be evaluated for a grid of 3x3. The    */

/* SADs to be evaluated at a grid are classified as separate functions, since*/

/* evaluating them on a single function call helps reuse inputs for a small  */

/* grid of 3x3. Also, if no partial updates are required, there are 3 basic  */

/* funcitons, width 4K (K = odd number), width 8K (K = odd number) and width */

/* 16K, K any number. For partial updates, it is assumed that the block size */

/* is square (8x8, 16x16, 32x32, 64x64) and further differentiation is done  */

/* based on the basic evaluation unit. E.g. if 16x16 blk size requires, part */

/* update on AMP partitions, then basic SAD unit is 4x4, if it doesnt, then  */

/* basic SAD unit is 8x8.                                                    */

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

#define UPD_RES_PT_NPU_BEST1 hme_update_results_grid_pu_bestn

#define UPD_RES_PT_NPU_BESTN hme_update_results_grid_pu_bestn

#define UPD_RES_PT_PU_BEST1 hme_update_results_grid_pu_bestn

#define UPD_RES_PT_PU_BESTN hme_update_results_grid_pu_bestn

#define UPD_RES_GRID_NPU_BEST1 hme_update_results_grid_pu_bestn

#define UPD_RES_GRID_NPU_BESTN hme_update_results_grid_pu_bestn

#define UPD_RES_GRID_PU_BEST1 hme_update_results_grid_pu_bestn

#define UPD_RES_GRID_PU_BESTN hme_update_results_grid_pu_bestn

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

*                         FUNCTION DEFINITIONS

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

S32 hme_cmp_nodes(search_node_t *ps_best_node1, search_node_t *ps_best_node2)

{

    if((ps_best_node1->s_mv.i2_mvx == ps_best_node2->s_mv.i2_mvx) &&

       (ps_best_node1->s_mv.i2_mvy == ps_best_node2->s_mv.i2_mvy) &&

       (ps_best_node1->i1_ref_idx == ps_best_node2->i1_ref_idx))

    {

        return 0;

    }

    return -1;

}

void compute_4x4_sads_for_16x16_blk(

    grid_ctxt_t *ps_grid, /* Grid ctxt */

    UWORD8 *pu1_cur_ptr, /* Pointer to top-left of current block */

    WORD32 cur_buf_stride, /* Buffer stride of current buffer */

    UWORD16 **

        u2_part_sads, /* 2D Array containing SADs for all 17 partitions. As many rows as partitions. SADs in a row correspond to each of the candidates */

    cand_t *ps_cand, /* Return the list of candidates evaluated */

    WORD32 *num_cands /* Number of candidates that were processed */

)

{

    WORD32 a, b, c, d, i;

    WORD16 grd_sz_y = (ps_grid->grd_sz_y_x & 0xFFFF0000) >> 16;

    WORD16 grd_sz_x = (ps_grid->grd_sz_y_x & 0xFFFF);

    //WORD32 offset_x[9] = {-grd_sz_x, 0, grd_sz_x, -grd_sz_x, 0, grd_sz_x, grd_sz_x, 0, -grd_sz_x};

    //WORD32 offset_y[9] = {-grd_sz_y, -grd_sz_y, -grd_sz_y, 0, 0, 0, grd_sz_y, grd_sz_y, grd_sz_y};

    /* Assumes the following order: C, L, T, R, B, TL, TR, BL, BR */

    WORD32 offset_x[9] = { 0, -grd_sz_x, 0, grd_sz_x, 0, -grd_sz_x, grd_sz_x, -grd_sz_x, grd_sz_x };

    WORD32 offset_y[9] = { 0, 0, -grd_sz_y, 0, grd_sz_y, -grd_sz_y, -grd_sz_y, grd_sz_y, grd_sz_y };

    WORD32 ref_buf_stride = ps_grid->ref_buf_stride;

    WORD32 cur_buf_stride_ls2 = (cur_buf_stride << 2);

    WORD32 ref_buf_stride_ls2 = (ref_buf_stride << 2);

    cand_t *cand0 = ps_cand;

    UWORD16 au2_4x4_sad[NUM_4X4];

    *num_cands = 0;

    /* Loop to fill up the cand_t array and to calculate num_cands */

    for(i = 0; i < ps_grid->num_grids; i++)

    {

        WORD32 j;

        WORD32 mask = ps_grid->pi4_grd_mask[i];

        UWORD8 *pu1_ref_ptr_center = ps_grid->ppu1_ref_ptr[i];

        WORD32 mv_x = ps_grid->p_mv[i].i2_mv_x;

        WORD32 mv_y = (ps_grid->p_mv[i].i2_mv_y);

        for(j = 0; j < NUM_CANDIDATES_IN_GRID; j++, mask >>= 1)

        {

            if(mask & 1)

            {

                *num_cands = *num_cands + 1;

                cand0->grid_ix = i;

                cand0->ref_idx = ps_grid->p_ref_idx[i];

                cand0->pu1_ref_ptr =

                    pu1_ref_ptr_center + offset_x[j] + ref_buf_stride * offset_y[j];

                cand0->mv.i2_mv_x = (S16)(mv_x) + offset_x[j];

                cand0->mv.i2_mv_y = (S16)(mv_y) + offset_y[j];

                cand0++;

            }

        }

    }

    /* Loop to compute the SAD's */

    for(a = 0; a < *num_cands; a++)

    {

        cand_t *cand = ps_cand + a;

        memset(&au2_4x4_sad[0], 0, NUM_4X4 * sizeof(UWORD16));

        for(b = 0; b < NUM_4X4; b++)

        {

            WORD32 t1 = (b % 4) * NUM_PIXELS_IN_ROW + (b >> 2) * cur_buf_stride_ls2;

            WORD32 t2 = (b % 4) * NUM_PIXELS_IN_ROW + (b >> 2) * ref_buf_stride_ls2;

            for(c = 0; c < NUM_ROWS_IN_4X4; c++)

            {

                WORD32 z_cur = (cur_buf_stride)*c + t1;

                WORD32 z_ref = (ref_buf_stride)*c + t2;

                for(d = 0; d < NUM_PIXELS_IN_ROW; d++)

                {

                    au2_4x4_sad[b] += (UWORD16)ABS(

                        (((S32)cand->pu1_ref_ptr[(z_ref + d)]) - ((S32)pu1_cur_ptr[(z_cur + d)])));

                }

            }

        }

        u2_part_sads[PART_ID_NxN_TL][a] =

            (au2_4x4_sad[0] + au2_4x4_sad[1] + au2_4x4_sad[4] + au2_4x4_sad[5]);

        u2_part_sads[PART_ID_NxN_TR][a] =

            (au2_4x4_sad[2] + au2_4x4_sad[3] + au2_4x4_sad[6] + au2_4x4_sad[7]);

        u2_part_sads[PART_ID_NxN_BL][a] =

            (au2_4x4_sad[8] + au2_4x4_sad[9] + au2_4x4_sad[12] + au2_4x4_sad[13]);

        u2_part_sads[PART_ID_NxN_BR][a] =

            (au2_4x4_sad[10] + au2_4x4_sad[11] + au2_4x4_sad[14] + au2_4x4_sad[15]);

        u2_part_sads[PART_ID_Nx2N_L][a] =

            u2_part_sads[PART_ID_NxN_TL][a] + u2_part_sads[PART_ID_NxN_BL][a];

        u2_part_sads[PART_ID_Nx2N_R][a] =

            u2_part_sads[PART_ID_NxN_TR][a] + u2_part_sads[PART_ID_NxN_BR][a];

        u2_part_sads[PART_ID_2NxN_T][a] =

            u2_part_sads[PART_ID_NxN_TR][a] + u2_part_sads[PART_ID_NxN_TL][a];

        u2_part_sads[PART_ID_2NxN_B][a] =

            u2_part_sads[PART_ID_NxN_BR][a] + u2_part_sads[PART_ID_NxN_BL][a];

        u2_part_sads[PART_ID_nLx2N_L][a] =

            (au2_4x4_sad[8] + au2_4x4_sad[0] + au2_4x4_sad[12] + au2_4x4_sad[4]);

        u2_part_sads[PART_ID_nRx2N_R][a] =

            (au2_4x4_sad[3] + au2_4x4_sad[7] + au2_4x4_sad[15] + au2_4x4_sad[11]);

        u2_part_sads[PART_ID_2NxnU_T][a] =

            (au2_4x4_sad[1] + au2_4x4_sad[0] + au2_4x4_sad[2] + au2_4x4_sad[3]);

        u2_part_sads[PART_ID_2NxnD_B][a] =

            (au2_4x4_sad[15] + au2_4x4_sad[14] + au2_4x4_sad[12] + au2_4x4_sad[13]);

        u2_part_sads[PART_ID_2Nx2N][a] =

            u2_part_sads[PART_ID_2NxN_T][a] + u2_part_sads[PART_ID_2NxN_B][a];

        u2_part_sads[PART_ID_2NxnU_B][a] =

            u2_part_sads[PART_ID_2Nx2N][a] - u2_part_sads[PART_ID_2NxnU_T][a];

        u2_part_sads[PART_ID_2NxnD_T][a] =

            u2_part_sads[PART_ID_2Nx2N][a] - u2_part_sads[PART_ID_2NxnD_B][a];

        u2_part_sads[PART_ID_nRx2N_L][a] =

            u2_part_sads[PART_ID_2Nx2N][a] - u2_part_sads[PART_ID_nRx2N_R][a];

        u2_part_sads[PART_ID_nLx2N_R][a] =

            u2_part_sads[PART_ID_2Nx2N][a] - u2_part_sads[PART_ID_nLx2N_L][a];

    }

}

/**

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

*  @fn     compute_part_sads_for_MxM_blk(grid_ctxt_t *ps_grid,

*                                       UWORD8      *pu1_cur_ptr,

*                                       WORD32      cur_buf_stride,

*                                       WORD32     **pi4_part_sads,

*                                       cand_t      *ps_cand,

*                                       WORD32      *num_cands

*

*  @brief  Computes partial SADs and updates partition results for an MxM blk

*          and does so for several grids of points. This can be used for

*          32x32/64x64 blks with 17 partition updates

*

*

*  @param[in]  ps_grid : Pointer to grid ctxt that has multiple grid of max

*                        9 pts per grid

*

*  @param[in]  pu1_cur_ptr : Top left of input buffer

*

*  @param[in]  pi4_part_sads : array of pointers, each entry pointing to

*                             results to be updated for a given partition

*

*  @return   The ps_search_results structure has the best result updated for

*            the 2Nx2N partition alone.

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

*/

void compute_part_sads_for_MxM_blk(

    grid_ctxt_t *ps_grid,

    UWORD8 *pu1_cur_ptr,

    WORD32 cur_buf_stride,

    WORD32 **pp_part_sads,

    cand_t *ps_cand,

    WORD32 *num_cands,

    CU_SIZE_T e_cu_size)

{

    WORD32 a, b, c, d, i;

    WORD16 grd_sz_y = (ps_grid->grd_sz_y_x & 0xFFFF0000) >> 16;

    WORD16 grd_sz_x = (ps_grid->grd_sz_y_x & 0xFFFF);

    /* Assumes the following order: C, L, T, R, B, TL, TR, BL, BR */

    WORD32 offset_x[9] = { 0, -grd_sz_x, 0, grd_sz_x, 0, -grd_sz_x, grd_sz_x, -grd_sz_x, grd_sz_x };

    WORD32 offset_y[9] = { 0, 0, -grd_sz_y, 0, grd_sz_y, -grd_sz_y, -grd_sz_y, grd_sz_y, grd_sz_y };

    WORD32 shift = (WORD32)e_cu_size;

    WORD32 ref_buf_stride = ps_grid->ref_buf_stride;

    WORD32 cur_buf_stride_lsN = (cur_buf_stride << (1 + shift));

    WORD32 ref_buf_stride_lsN = (ref_buf_stride << (1 + shift));

    /* Num rows and pixels per row: 8 for CU_32x32 and 16 for CU_64x64 */

    WORD32 num_rows_in_nxn = 2 << shift;

    WORD32 num_pixels_in_row = 2 << shift;

    cand_t *cand0 = ps_cand;

    /* for a 2Nx2N partition we evaluate nxn SADs, where n = N/2. This is */

    /* needed for AMP cases.                                              */

    WORD32 a_nxn_sad[NUM_4X4];

    *num_cands = 0;

    /* Loop to fill up the cand_t array and to calculate num_cands */

    for(i = 0; i < ps_grid->num_grids; i++)

    {

        WORD32 j;

        WORD32 mask = ps_grid->pi4_grd_mask[i];

        UWORD8 *pu1_ref_ptr_center = ps_grid->ppu1_ref_ptr[i];

        WORD32 mv_x = ps_grid->p_mv[i].i2_mv_x;

        WORD32 mv_y = (ps_grid->p_mv[i].i2_mv_y);

        for(j = 0; j < NUM_CANDIDATES_IN_GRID; j++, mask >>= 1)

        {

            if(mask & 1)

            {

                *num_cands = *num_cands + 1;

                cand0->grid_ix = i;

                cand0->ref_idx = ps_grid->p_ref_idx[i];

                cand0->pu1_ref_ptr =

                    pu1_ref_ptr_center + offset_x[j] + ref_buf_stride * offset_y[j];

                cand0->mv.i2_mv_x = (S16)(mv_x) + offset_x[j];

                cand0->mv.i2_mv_y = (S16)(mv_y) + offset_y[j];

                cand0++;

            }

        }

    }

    /* Loop to compute the SAD's */

    for(a = 0; a < *num_cands; a++)

    {

        cand_t *cand = ps_cand + a;

        memset(&a_nxn_sad[0], 0, NUM_4X4 * sizeof(WORD32));

        for(b = 0; b < NUM_4X4; b++)

        {

            WORD32 t1 = (b % 4) * num_pixels_in_row + (b >> 2) * cur_buf_stride_lsN;

            WORD32 t2 = (b % 4) * num_pixels_in_row + (b >> 2) * ref_buf_stride_lsN;

            for(c = 0; c < num_rows_in_nxn; c++)

            {

                WORD32 z_cur = (cur_buf_stride)*c + t1;

                WORD32 z_ref = (ref_buf_stride)*c + t2;

                for(d = 0; d < num_pixels_in_row; d++)

                {

                    a_nxn_sad[b] += (WORD32)ABS(

                        (((WORD32)cand->pu1_ref_ptr[(z_ref + d)]) -

                         ((WORD32)pu1_cur_ptr[(z_cur + d)])));

                }

            }

        }

        pp_part_sads[PART_ID_NxN_TL][a] =

            (a_nxn_sad[0] + a_nxn_sad[1] + a_nxn_sad[4] + a_nxn_sad[5]);

        pp_part_sads[PART_ID_NxN_TR][a] =

            (a_nxn_sad[2] + a_nxn_sad[3] + a_nxn_sad[6] + a_nxn_sad[7]);

        pp_part_sads[PART_ID_NxN_BL][a] =

            (a_nxn_sad[8] + a_nxn_sad[9] + a_nxn_sad[12] + a_nxn_sad[13]);

        pp_part_sads[PART_ID_NxN_BR][a] =

            (a_nxn_sad[10] + a_nxn_sad[11] + a_nxn_sad[14] + a_nxn_sad[15]);

        pp_part_sads[PART_ID_Nx2N_L][a] =

            pp_part_sads[PART_ID_NxN_TL][a] + pp_part_sads[PART_ID_NxN_BL][a];

        pp_part_sads[PART_ID_Nx2N_R][a] =

            pp_part_sads[PART_ID_NxN_TR][a] + pp_part_sads[PART_ID_NxN_BR][a];

        pp_part_sads[PART_ID_2NxN_T][a] =

            pp_part_sads[PART_ID_NxN_TR][a] + pp_part_sads[PART_ID_NxN_TL][a];

        pp_part_sads[PART_ID_2NxN_B][a] =

            pp_part_sads[PART_ID_NxN_BR][a] + pp_part_sads[PART_ID_NxN_BL][a];

        pp_part_sads[PART_ID_nLx2N_L][a] =

            (a_nxn_sad[8] + a_nxn_sad[0] + a_nxn_sad[12] + a_nxn_sad[4]);

        pp_part_sads[PART_ID_nRx2N_R][a] =

            (a_nxn_sad[3] + a_nxn_sad[7] + a_nxn_sad[15] + a_nxn_sad[11]);

        pp_part_sads[PART_ID_2NxnU_T][a] =

            (a_nxn_sad[1] + a_nxn_sad[0] + a_nxn_sad[2] + a_nxn_sad[3]);

        pp_part_sads[PART_ID_2NxnD_B][a] =

            (a_nxn_sad[15] + a_nxn_sad[14] + a_nxn_sad[12] + a_nxn_sad[13]);

        pp_part_sads[PART_ID_2Nx2N][a] =

            pp_part_sads[PART_ID_2NxN_T][a] + pp_part_sads[PART_ID_2NxN_B][a];

        pp_part_sads[PART_ID_2NxnU_B][a] =

            pp_part_sads[PART_ID_2Nx2N][a] - pp_part_sads[PART_ID_2NxnU_T][a];

        pp_part_sads[PART_ID_2NxnD_T][a] =

            pp_part_sads[PART_ID_2Nx2N][a] - pp_part_sads[PART_ID_2NxnD_B][a];

        pp_part_sads[PART_ID_nRx2N_L][a] =

            pp_part_sads[PART_ID_2Nx2N][a] - pp_part_sads[PART_ID_nRx2N_R][a];

        pp_part_sads[PART_ID_nLx2N_R][a] =

            pp_part_sads[PART_ID_2Nx2N][a] - pp_part_sads[PART_ID_nLx2N_L][a];

    }

}

void hme_evalsad_grid_pu_16x16(err_prms_t *ps_prms)

{

    grid_ctxt_t s_grid;

    cand_t as_candt[9];

    U16 au2_sad_grid[TOT_NUM_PARTS * 9];

    U16 *apu2_sad_grid[TOT_NUM_PARTS];

    hme_mv_t s_mv = { 0, 0 };

    S32 i4_ref_idx = 0, i;

    S32 num_candts = 0;

    s_grid.num_grids = 1;

    s_grid.ref_buf_stride = ps_prms->i4_ref_stride;

    s_grid.grd_sz_y_x = ((ps_prms->i4_step << 16) | ps_prms->i4_step);

    s_grid.ppu1_ref_ptr = &ps_prms->pu1_ref;

    s_grid.pi4_grd_mask = &ps_prms->i4_grid_mask;

    s_grid.p_mv = &s_mv;

    s_grid.p_ref_idx = &i4_ref_idx;

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

    {

        if(s_grid.pi4_grd_mask[0] & (1 << i))

            num_candts++;

    }

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

        apu2_sad_grid[i] = &au2_sad_grid[i * num_candts];

    compute_4x4_sads_for_16x16_blk(

        &s_grid, ps_prms->pu1_inp, ps_prms->i4_inp_stride, apu2_sad_grid, as_candt, &num_candts);

    for(i = 0; i < TOT_NUM_PARTS * num_candts; i++)

    {

        ps_prms->pi4_sad_grid[i] = au2_sad_grid[i];

    }

}

void hme_evalsad_grid_npu_MxN(err_prms_t *ps_prms)

{

    U08 *pu1_inp_base, *pu1_ref_c;

    S32 *pi4_sad = ps_prms->pi4_sad_grid;

    S32 i, grid_count = 0;

    S32 step = ps_prms->i4_step;

    S32 x_off = step, y_off = step * ps_prms->i4_ref_stride;

    ASSERT((ps_prms->i4_part_mask & (ps_prms->i4_part_mask - 1)) == 0);

    //assert(ps_prms->i4_blk_ht <= 8);

    //assert(ps_prms->i4_blk_wd <= 8);

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

    {

        if(ps_prms->i4_grid_mask & (1 << i))

            grid_count++;

    }

    pi4_sad += (ps_prms->pi4_valid_part_ids[0] * grid_count);

    pu1_inp_base = ps_prms->pu1_inp;

    pu1_ref_c = ps_prms->pu1_ref;

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

    {

        S32 sad = 0, j, k;

        U08 *pu1_inp, *pu1_ref;

        if(!(ps_prms->i4_grid_mask & (1 << i)))

            continue;

        pu1_ref = pu1_ref_c + x_off * gai1_grid_id_to_x[i];

        pu1_ref += y_off * gai1_grid_id_to_y[i];

        pu1_inp = pu1_inp_base;

        for(j = 0; j < ps_prms->i4_blk_ht; j++)

        {

            for(k = 0; k < ps_prms->i4_blk_wd; k++)

            {

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

            }

            pu1_inp += ps_prms->i4_inp_stride;

            pu1_ref += ps_prms->i4_ref_stride;

        }

        *pi4_sad++ = sad;

    }

}

WORD32 hme_evalsad_pt_npu_MxN_8bit_compute(

    WORD32 ht,

    WORD32 wd,

    UWORD8 *pu1_inp,

    UWORD8 *pu1_ref,

    WORD32 i4_inp_stride,

    WORD32 i4_ref_stride)

{

    WORD32 i, j;

    WORD32 sad = 0;

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

    {

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

        {

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

        }

        pu1_inp += i4_inp_stride;

        pu1_ref += i4_ref_stride;

    }

    return sad;

}

void hme_evalsad_pt_npu_MxN_8bit(err_prms_t *ps_prms)

{

    S32 wd, ht;

    U08 *pu1_inp, *pu1_ref;

    wd = ps_prms->i4_blk_wd;

    ht = ps_prms->i4_blk_ht;

    pu1_inp = ps_prms->pu1_inp;

    pu1_ref = ps_prms->pu1_ref;

    ps_prms->pi4_sad_grid[0] = hme_evalsad_pt_npu_MxN_8bit_compute(

        ht, wd, pu1_inp, pu1_ref, ps_prms->i4_inp_stride, ps_prms->i4_ref_stride);

}

void compute_satd_8bit(err_prms_t *ps_prms)

{

    U08 *pu1_origin;

    S32 src_strd;

    U08 *pu1_pred_buf;

    S32 dst_strd;

    S32 wd, ht;

    U32 u4_sad = 0;

    WORD32 x, y;

    U08 *u1_pi0, *u1_pi1;

    pu1_origin = ps_prms->pu1_inp;

    pu1_pred_buf = ps_prms->pu1_ref;

    src_strd = ps_prms->i4_inp_stride;

    dst_strd = ps_prms->i4_ref_stride;

    wd = ps_prms->i4_blk_wd;

    ht = ps_prms->i4_blk_ht;

    u1_pi0 = pu1_origin;

    u1_pi1 = pu1_pred_buf;

    /* Follows the following logic:

    For block sizes less than or equal to 16X16, the basic transform size is 4x4

    For block sizes greater than or equal to 32x32, the basic transform size is 8x8 */

    if((wd > 0x10) || (ht > 0x10))

    {

        for(y = 0; y < ht; y += 8)

        {

            for(x = 0; x < wd; x += 8)

            {

                u4_sad += ps_prms->ps_cmn_utils_optimised_function_list->pf_HAD_8x8_8bit(

                    &u1_pi0[x], src_strd, &u1_pi1[x], dst_strd, NULL, 1);

            }

            u1_pi0 += src_strd * 8;

            u1_pi1 += dst_strd * 8;

        }

    }

    else

    {

        for(y = 0; y < ht; y += 4)

        {

            for(x = 0; x < wd; x += 4)

            {

                u4_sad += ps_prms->ps_cmn_utils_optimised_function_list->pf_HAD_4x4_8bit(

                    &u1_pi0[x], src_strd, &u1_pi1[x], dst_strd, NULL, 1);

            }

            u1_pi0 += src_strd * 4;

            u1_pi1 += dst_strd * 4;

        }

    }

    ps_prms->pi4_sad_grid[0] = (S32)u4_sad;

}

void hme_init_pred_part(

    pred_ctxt_t *ps_pred_ctxt,

    search_node_t *ps_tl,

    search_node_t *ps_t,

    search_node_t *ps_tr,

    search_node_t *ps_l,

    search_node_t *ps_bl,

    search_node_t *ps_coloc,

    search_node_t *ps_zeromv,

    search_node_t **pps_proj_coloc,

    PART_ID_T e_part_id)

{

    pred_candt_nodes_t *ps_candt_nodes;

    ps_candt_nodes = &ps_pred_ctxt->as_pred_nodes[e_part_id];

    ps_candt_nodes->ps_tl = ps_tl;

    ps_candt_nodes->ps_tr = ps_tr;

    ps_candt_nodes->ps_t = ps_t;

    ps_candt_nodes->ps_l = ps_l;

    ps_candt_nodes->ps_bl = ps_bl;

    ps_candt_nodes->ps_coloc = ps_coloc;

    ps_candt_nodes->ps_zeromv = ps_zeromv;

    ps_candt_nodes->pps_proj_coloc = pps_proj_coloc;

}

void hme_init_pred_ctxt_no_encode(

    pred_ctxt_t *ps_pred_ctxt,

    search_results_t *ps_search_results,

    search_node_t *ps_top_candts,

    search_node_t *ps_left_candts,

    search_node_t **pps_proj_coloc_candts,

    search_node_t *ps_coloc_candts,

    search_node_t *ps_zeromv_candt,

    S32 pred_lx,

    S32 lambda,

    S32 lambda_q_shift,

    U08 **ppu1_ref_bits_tlu,

    S16 *pi2_ref_scf)

{

    search_node_t *ps_invalid, *ps_l, *ps_t, *ps_tl, *ps_tr, *ps_bl;

    search_node_t *ps_coloc;

    PART_ID_T e_part_id;

    /* Assume that resolution is subpel to begin with */

    ps_pred_ctxt->mv_pel = 0;  // FPEL

    /* lambda and pred_lx (PRED_L0/PRED_L1) */

    ps_pred_ctxt->lambda = lambda;

    ps_pred_ctxt->lambda_q_shift = lambda_q_shift;

    ps_pred_ctxt->pred_lx = pred_lx;

    ps_pred_ctxt->ppu1_ref_bits_tlu = ppu1_ref_bits_tlu;

    ps_pred_ctxt->pi2_ref_scf = pi2_ref_scf;

    ps_pred_ctxt->proj_used = 0;

    /* Bottom left should not be valid */

    ASSERT(ps_left_candts[2].u1_is_avail == 0);

    ps_invalid = &ps_left_candts[2];

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

    /* for the case of no encode, the idea is to set up cants as follows     */

    /*                                                                       */

    /*    ____ ______________                                                */

    /*   | TL | T  | T1 | TR |                                               */

    /*   |____|____|____|____|                                               */

    /*   | L  | b0 | b1 |                                                    */

    /*   |____|____|____|                                                    */

    /*   | L1 | b2 | b3 |                                                    */

    /*   |____|____|____|                                                    */

    /*   | BL |                                                              */

    /*   |____|                                                              */

    /*                                                                       */

    /*  If use_4x4 is 0, then b0,b1,b2,b3 are single 8x8 blk. then T=T1      */

    /* and L=L1. topleft, top and topright are TL,T,TR respectively          */

    /* Left and bottom left is L and BL respectively.                        */

    /* If use_4x4 is 1: then the above holds true only for PARTID = 0 (8x8)  */

    /*  For the 4 subblocks (partids 4-7)                                    */

    /*                                                                       */

    /*  Block   Left   Top   Top Left   Top Right   Bottom Left             */

    /*    b0    L      T      TL          T1          L1                     */

    /*    b1    b0     T1     T           TR          BL(invalid)            */

    /*    b2    L1     b0     L0          b1          BL (invalid)           */

    /*    b3    b2     b1     b0          BL(inv)     BL (inv)               */

    /*                                                                       */

    /* Note : For block b1, bottom left pts to b2, which is not yet ready    */

    /*  hence it is kept invalid and made to pt to BL. For block b3 top rt   */

    /* is invalid and hence made to pt to BL which is invalid.               */

    /* BL is invalid since it lies in a bottom left 8x8 blk and not yet ready*/

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

    /* ps_coloc always points to a fixe candt (global) */

    /* TODO : replace incoming ps_coloc from global to geniune coloc */

    ps_coloc = ps_coloc_candts;

    /* INITIALIZATION OF 8x8 BLK */

    ps_tl = ps_top_candts;

    ps_t = ps_tl + 2;

    ps_tr = ps_t + 1;

    ps_l = ps_left_candts + 1;

    ps_bl = ps_invalid;

    e_part_id = PART_ID_2Nx2N;

    hme_init_pred_part(

        ps_pred_ctxt,

        ps_tl,

        ps_t,

        ps_tr,

        ps_l,

        ps_bl,

        ps_coloc,

        ps_zeromv_candt,

        pps_proj_coloc_candts,

        e_part_id);

    /* INITIALIZATION OF 4x4 TL BLK */

    e_part_id = PART_ID_NxN_TL;

    ps_tl = ps_top_candts;

    ps_t = ps_tl + 1;

    ps_tr = ps_t + 1;

    ps_l = ps_left_candts;

    ps_bl = ps_l + 1;

    hme_init_pred_part(

        ps_pred_ctxt,

        ps_tl,

        ps_t,

        ps_tr,

        ps_l,

        ps_bl,

        ps_coloc,

        ps_zeromv_candt,

        pps_proj_coloc_candts,

        e_part_id);

    /* INITIALIZATION OF 4x4 TR BLK */

    e_part_id = PART_ID_NxN_TR;

    ps_tl = ps_top_candts + 1;

    ps_t = ps_tl + 1;

    ps_tr = ps_t + 1;

    ps_l = ps_search_results->aps_part_results[pred_lx][PART_ID_NxN_TL];

    ps_bl = ps_invalid;

    hme_init_pred_part(

        ps_pred_ctxt,

        ps_tl,

        ps_t,

        ps_tr,

        ps_l,

        ps_bl,

        ps_coloc,

        ps_zeromv_candt,

        pps_proj_coloc_candts,

        e_part_id);

    /* INITIALIZATION OF 4x4 BL BLK */

    e_part_id = PART_ID_NxN_BL;

    ps_tl = ps_left_candts;

    ps_t = ps_search_results->aps_part_results[pred_lx][PART_ID_NxN_TL];

    ps_tr = ps_search_results->aps_part_results[pred_lx][PART_ID_NxN_TR];

    ps_l = ps_left_candts + 1;

    ps_bl = ps_invalid;  //invalid

    hme_init_pred_part(

        ps_pred_ctxt,

        ps_tl,

        ps_t,

        ps_tr,

        ps_l,

        ps_bl,

        ps_coloc,

        ps_zeromv_candt,

        pps_proj_coloc_candts,

        e_part_id);

    /* INITIALIZATION OF 4x4 BR BLK */

    e_part_id = PART_ID_NxN_BR;

    ps_tl = ps_search_results->aps_part_results[pred_lx][PART_ID_NxN_TL];

    ps_t = ps_search_results->aps_part_results[pred_lx][PART_ID_NxN_TR];

    ps_tr = ps_invalid;  // invalid

    ps_l = ps_search_results->aps_part_results[pred_lx][PART_ID_NxN_BL];

    ps_bl = ps_invalid;  // invalid

    hme_init_pred_part(

        ps_pred_ctxt,

        ps_tl,

        ps_t,

        ps_tr,

        ps_l,

        ps_bl,

        ps_coloc,

        ps_zeromv_candt,

        pps_proj_coloc_candts,

        e_part_id);

}

void hme_init_pred_ctxt_encode(

    pred_ctxt_t *ps_pred_ctxt,

    search_results_t *ps_search_results,

    search_node_t *ps_coloc_candts,

    search_node_t *ps_zeromv_candt,

    mv_grid_t *ps_mv_grid,

    S32 pred_lx,

    S32 lambda,

    S32 lambda_q_shift,

    U08 **ppu1_ref_bits_tlu,

    S16 *pi2_ref_scf)

{

    search_node_t *ps_invalid, *ps_l, *ps_t, *ps_tl, *ps_tr, *ps_bl;

    search_node_t *ps_coloc;

    search_node_t *ps_grid_cu_base;

    CU_SIZE_T e_cu_size = ps_search_results->e_cu_size;

    /* Part Start, Part sizes in 4x4 units */

    S32 part_wd, part_ht, part_start_x, part_start_y;

    /* Partition type, number of partitions in type */

    S32 part_id;

    /* Coordinates of the CU in 4x4 units */

    S32 cu_start_x, cu_start_y;

    S32 shift = e_cu_size;

    /* top right and bot left validity at CU level */

    S32 cu_tr_valid, cu_bl_valid;

    /* strideo f the grid */

    S32 grid_stride = ps_mv_grid->i4_stride;

    ps_pred_ctxt->lambda = lambda;

    ps_pred_ctxt->lambda_q_shift = lambda_q_shift;

    ps_pred_ctxt->pred_lx = pred_lx;

    ps_pred_ctxt->mv_pel = 0;

    ps_pred_ctxt->ppu1_ref_bits_tlu = ppu1_ref_bits_tlu;

    ps_pred_ctxt->pi2_ref_scf = pi2_ref_scf;

    ps_pred_ctxt->proj_used = 1;

    cu_start_x = ps_search_results->u1_x_off >> 2;

    cu_start_y = ps_search_results->u1_y_off >> 2;

    /* Coloc always points to fixed global candt */

    ps_coloc = ps_coloc_candts;

    /* Go to base of the CU in the MV Grid */

    ps_grid_cu_base = &ps_mv_grid->as_node[0];

    ps_grid_cu_base += (ps_mv_grid->i4_start_offset + cu_start_x);

    ps_grid_cu_base += (grid_stride * cu_start_y);

    /* points to the real bottom left of the grid, will never be valid */

    ps_invalid = &ps_mv_grid->as_node[0];

    ps_invalid += (grid_stride * 17);

    {

        S32 shift = 1 + e_cu_size;

        cu_tr_valid = gau1_cu_tr_valid[cu_start_y >> shift][cu_start_x >> shift];

        cu_bl_valid = gau1_cu_bl_valid[cu_start_y >> shift][cu_start_x >> shift];

    }

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

    /* for the case of    encode, the idea is to set up cants as follows     */

    /*                                                                       */

    /*    ____ ______________ ____ ____                                      */

    /*   | T0 | T1 | T2 | T3 | T4 | T5 |                                     */

    /*   |____|____|____|____|____|____|                                     */

    /*   | L1 |    |              |                                          */

    /*   |____|    |              |                                          */

    /*   | L2 | p0 |     p1       |                                          */

    /*   |____|    |              |                                          */

    /*   | L3 |    |              |                                          */

    /*   |____|    |              |                                          */

    /*   | L4 | L' |              |                                          */

    /*   |____|____|______________|                                          */

    /*   | BL |                                                              */

    /*   |____|                                                              */

    /*  The example is shown with 16x16 CU, though it can be generalized     */

    /*  This CU has 2 partitions, cu_wd = 4. also p_wd, p_ht are partition   */

    /*  width and ht in 4x4 units.                                           */

    /*  For a given CU, derive the top left, top and bottom left and top rt  */

    /*  pts. Left and top are assumed to be valid.                           */

    /*  IF there aretwo partitions in the CU (like p0 and p1) and vertical,  */

    /*  then for first partition, left, top, top left and top right valid    */

    /*  Bottom left is valid. store these validity flags. Also store the     */

    /*  grid offsets of the partitions w.r.t. CU start in units of 4x4.For p0*/

    /*  Left grid offset = -1, 3. Top Grd offset = -1, 0.                    */

    /*  Top left grid offset = -1, -1. Top right = 1, -1. BL = -1, 4.        */

    /*  For p1, validity flags are left, top, top left, top right, valid.    */

    /*  BL is invalid. Grid offsets are: Left = dont care. T = 1, -1 (T2)    */

    /*  TR = 4, -1 (T5). TL = 0, -1 (T1). BL = don't care.                   */

    /*  For p1, set the left pred candt to the best search result of p0.     */

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

    /* Loop over all partitions, and identify the 5 neighbours */

    for(part_id = 0; part_id < TOT_NUM_PARTS; part_id++)

    {

        part_attr_t *ps_part_attr = &gas_part_attr_in_cu[part_id];

        S32 tr_valid, bl_valid, is_vert;

        search_node_t *ps_grid_pu_base;

        PART_TYPE_T e_part_type;

        PART_ID_T first_part;

        S32 part_num;

        e_part_type = ge_part_id_to_part_type[part_id];

        first_part = ge_part_type_to_part_id[e_part_type][0];

        is_vert = gau1_is_vert_part[e_part_type];

        part_num = gau1_part_id_to_part_num[part_id];

        tr_valid = gau1_partid_tr_valid[part_id] & cu_tr_valid;

        bl_valid = gau1_partid_bl_valid[part_id] & cu_bl_valid;

        part_start_x = (ps_part_attr->u1_x_start << shift) >> 2;

        part_start_y = (ps_part_attr->u1_y_start << shift) >> 2;

        part_wd = (ps_part_attr->u1_x_count << shift) >> 2;

        part_ht = (ps_part_attr->u1_y_count << shift) >> 2;

        /* go to top left of part */

        ps_grid_pu_base = ps_grid_cu_base + part_start_x;

        ps_grid_pu_base += (part_start_y * grid_stride);

        ps_tl = ps_grid_pu_base - 1 - grid_stride;

        ps_t = ps_grid_pu_base - grid_stride + part_wd - 1;

        ps_l = ps_grid_pu_base - 1 + ((part_ht - 1) * grid_stride);

        ps_tr = ps_t + 1;

        ps_bl = ps_l + grid_stride;

        if(!tr_valid)

            ps_tr = ps_invalid;

        if(!bl_valid)

            ps_bl = ps_invalid;

        if(part_num == 1)

        {

            /* for cases of two partitions 2nd part has 1st part as candt */

            /* if vertical type, left candt of 2nd part is 1st part.      */

            /* if horz type, top candt of 2nd part is 1st part.           */

            if(is_vert)

            {

                ps_l = ps_search_results->aps_part_results[pred_lx][first_part];

            }

            else

            {

                ps_t = ps_search_results->aps_part_results[pred_lx][first_part];

            }

        }

        if(part_num == 2)

        {

            /* only possible for NxN_BL */

            ps_t = ps_search_results->aps_part_results[pred_lx][PART_ID_NxN_TL];

            ps_tr = ps_search_results->aps_part_results[pred_lx][PART_ID_NxN_TR];

        }

        if(part_num == 3)

        {

            /* only possible for NxN_BR */

            ps_t = ps_search_results->aps_part_results[pred_lx][PART_ID_NxN_TR];

            ps_tl = ps_search_results->aps_part_results[pred_lx][PART_ID_NxN_TL];

            ps_l = ps_search_results->aps_part_results[pred_lx][PART_ID_NxN_BL];

        }

        hme_init_pred_part(

            ps_pred_ctxt,

            ps_tl,

            ps_t,

            ps_tr,

            ps_l,

            ps_bl,

            ps_coloc,

            ps_zeromv_candt,

            NULL,

            (PART_ID_T)part_id);

    }

}

/**

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

*  @fn     compute_mv_cost_explicit(search_node_t *ps_node,

*                   pred_ctxt_t *ps_pred_ctxt,

*                   PART_ID_T e_part_id)

*

*  @brief  MV cost for explicit search in layers not encoded

*

*  @param[in]  ps_node: search node having mv and ref id for which to eval cost

*

*  @param[in]  ps_pred_ctxt : mv pred context

*

*  @param[in]  e_part_id : Partition id.

*

*  @return   Cost value

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

*/

S32 compute_mv_cost_explicit(

    search_node_t *ps_node, pred_ctxt_t *ps_pred_ctxt, PART_ID_T e_part_id, S32 inp_mv_pel)

{

#define RETURN_FIXED_COST 0

    search_node_t *ps_pred_node_a = NULL, *ps_pred_node_b = NULL;

    pred_candt_nodes_t *ps_pred_nodes;

    S32 inp_shift = 2 - inp_mv_pel;

    S32 pred_shift = 2 - ps_pred_ctxt->mv_pel;

    S32 mv_p_x, mv_p_y;

    S16 mvdx1, mvdx2, mvdy1, mvdy2;

    S32 cost, ref_bits;

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

    /* Logic for cost computation for explicit search. For such a search,    */

    /* it is guaranteed that all predictor candts have same ref id. The only */

    /* probable issue is with the availability which needs checking. This fxn*/

    /* does not suffer the need to scale predictor candts due to diff ref id */

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

    /* Hack: currently we always assume 2Nx2N. */

    /* TODO: get rid of this hack and return cost tuned to each partition */

    ps_pred_nodes = &ps_pred_ctxt->as_pred_nodes[e_part_id];

    ref_bits = ps_pred_ctxt->ppu1_ref_bits_tlu[ps_pred_ctxt->pred_lx][ps_node->i1_ref_idx];

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

    /* Priority to bottom left availability. Else we go to left. If both are */

    /* not available, then a remains null                                    */

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

    if(ps_pred_nodes->ps_tl->u1_is_avail)

        ps_pred_node_a = ps_pred_nodes->ps_tl;

    else if(ps_pred_nodes->ps_l->u1_is_avail)

        ps_pred_node_a = ps_pred_nodes->ps_l;

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

    /* For encoder, top left may not be really needed unless we use slices,  */

    /* and even then in ME it may not be relevant. So we only consider T or  */

    /* TR, as, if both T and TR are not available, TL also will not be       */

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

    if(ps_pred_nodes->ps_tr->u1_is_avail)

        ps_pred_node_b = ps_pred_nodes->ps_tr;

    else if(ps_pred_nodes->ps_t->u1_is_avail)

        ps_pred_node_b = ps_pred_nodes->ps_t;

    if(ps_pred_node_a == NULL)

    {

        ps_pred_node_a = ps_pred_nodes->ps_coloc;

        if(ps_pred_node_b == NULL)

            ps_pred_node_b = ps_pred_nodes->ps_zeromv;

    }

    else if(ps_pred_node_b == NULL)

        ps_pred_node_b = ps_pred_nodes->ps_coloc;

    else if(0 == hme_cmp_nodes(ps_pred_node_a, ps_pred_node_b))

    {

        ps_pred_node_b = ps_pred_nodes->ps_coloc;

    }

    mv_p_x = ps_pred_node_a->s_mv.i2_mvx;

    mv_p_y = ps_pred_node_a->s_mv.i2_mvy;

    COMPUTE_DIFF_MV(mvdx1, mvdy1, ps_node, mv_p_x, mv_p_y, inp_shift, pred_shift);

    mvdx1 = ABS(mvdx1);

    mvdy1 = ABS(mvdy1);

    mv_p_x = ps_pred_node_b->s_mv.i2_mvx;

    mv_p_y = ps_pred_node_b->s_mv.i2_mvy;

    COMPUTE_DIFF_MV(mvdx2, mvdy2, ps_node, mv_p_x, mv_p_y, inp_shift, pred_shift);

    mvdx2 = ABS(mvdx2);

    mvdy2 = ABS(mvdy2);

    if((mvdx1 + mvdy1) < (mvdx2 + mvdy2))

    {

        cost =

            hme_get_range(mvdx1) + hme_get_range(mvdy1) + (mvdx1 > 0) + (mvdy1 > 0) + ref_bits + 2;

    }

    else

    {