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

 *

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

*

* \brief

*    This file contains interface functions of Intra Prediction Estimation

*    module

* \date

*    18/09/2012

*

* \author

*    Ittiam

*

*

* List of Functions

*

*

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

*/

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

/* File Includes                                                             */

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

/* System include files */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include <stdarg.h>

#include <math.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_debug.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 "ihevc_quant_tables.h"

#include "ihevce_defs.h"

#include "ihevce_hle_interface.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 "ihevc_weighted_pred.h"

#include "ihevce_ipe_instr_set_router.h"

#include "ihevce_ipe_structs.h"

#include "ihevce_ipe_pass.h"

#include "ihevce_decomp_pre_intra_structs.h"

#include "ihevce_decomp_pre_intra_pass.h"

#include "ihevce_recur_bracketing.h"

#include "ihevce_nbr_avail.h"

#include "ihevce_global_tables.h"

#include "ihevc_resi_trans.h"

#include "cast_types.h"

#include "osal.h"

#include "osal_defaults.h"

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

/* Global Tables                                                             */

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

/**

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

* @brief  Look up table for choosing the appropriate function for

*         Intra prediction

*

* @remarks Same look up table enums are used for luma & chroma but each

*          have seperate functions implemented

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

*/

WORD32 g_i4_ipe_funcs[MAX_NUM_IP_MODES] = {

    IPE_FUNC_MODE_0, /* Mode 0 */

    IPE_FUNC_MODE_1, /* Mode 1 */

    IPE_FUNC_MODE_2, /* Mode 2 */

    IPE_FUNC_MODE_3TO9, /* Mode 3 */

    IPE_FUNC_MODE_3TO9, /* Mode 4 */

    IPE_FUNC_MODE_3TO9, /* Mode 5 */

    IPE_FUNC_MODE_3TO9, /* Mode 6 */

    IPE_FUNC_MODE_3TO9, /* Mode 7 */

    IPE_FUNC_MODE_3TO9, /* Mode 8 */

    IPE_FUNC_MODE_3TO9, /* Mode 9 */

    IPE_FUNC_MODE_10, /* Mode 10 */

    IPE_FUNC_MODE_11TO17, /* Mode 11 */

    IPE_FUNC_MODE_11TO17, /* Mode 12 */

    IPE_FUNC_MODE_11TO17, /* Mode 13 */

    IPE_FUNC_MODE_11TO17, /* Mode 14 */

    IPE_FUNC_MODE_11TO17, /* Mode 15 */

    IPE_FUNC_MODE_11TO17, /* Mode 16 */

    IPE_FUNC_MODE_11TO17, /* Mode 17 */

    IPE_FUNC_MODE_18_34, /* Mode 18 */

    IPE_FUNC_MODE_19TO25, /* Mode 19 */

    IPE_FUNC_MODE_19TO25, /* Mode 20 */

    IPE_FUNC_MODE_19TO25, /* Mode 21 */

    IPE_FUNC_MODE_19TO25, /* Mode 22 */

    IPE_FUNC_MODE_19TO25, /* Mode 23 */

    IPE_FUNC_MODE_19TO25, /* Mode 24 */

    IPE_FUNC_MODE_19TO25, /* Mode 25 */

    IPE_FUNC_MODE_26, /* Mode 26 */

    IPE_FUNC_MODE_27TO33, /* Mode 27 */

    IPE_FUNC_MODE_27TO33, /* Mode 26 */

    IPE_FUNC_MODE_27TO33, /* Mode 29 */

    IPE_FUNC_MODE_27TO33, /* Mode 30 */

    IPE_FUNC_MODE_27TO33, /* Mode 31 */

    IPE_FUNC_MODE_27TO33, /* Mode 32 */

    IPE_FUNC_MODE_27TO33, /* Mode 33 */

    IPE_FUNC_MODE_18_34, /* Mode 34 */

};

/**

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

* @brief  Look up table for deciding whether to use original samples or

*         filtered reference samples for Intra prediction

*

* @remarks This table has the flags for transform size of 8, 16 and 32

*          Input is log2nT - 3 and intra prediction mode

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

*/

UWORD8 gau1_ipe_filter_flag[3][MAX_NUM_IP_MODES] = {

    { 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

      1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },

    { 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1,

      1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 },

    { 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,

      1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 }

};

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

/* Function Definitions                                                      */

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

/*!

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

* \if Function name : ihevce_ipe_recompute_lambda_from_min_8x8_act_in_ctb \endif

*

* \brief

*    This function recomputes lambda using min 8x8 act in CTB

*

* \author

*    Ittiam

*

* \return

*    Nothing

*

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

*/

void ihevce_ipe_recompute_lambda_from_min_8x8_act_in_ctb(

    ihevce_ipe_ctxt_t *ps_ctxt, ihevce_ed_ctb_l1_t *ps_ed_ctb_l1)

{

    WORD32 i4_cu_qp = 0;

#if MODULATE_LAMDA_WHEN_SPATIAL_MOD_ON

    WORD32 i4_activity;

#endif

    WORD32 i4_qscale;

    WORD32 i4_curr_satd;

    long double ld_avg_satd;

#if LAMDA_BASED_ON_QUANT

    i4_curr_satd = ps_ed_ctb_l1->i4_32x32_satd[0][2];

    i8_avg_satd = ps_ctxt->i8_curr_frame_32x32_avg_act[2];

#else

    i4_curr_satd = ps_ed_ctb_l1->i4_32x32_satd[0][3];

    ld_avg_satd = 2.0 + ps_ctxt->ld_curr_frame_16x16_log_avg[0];

#endif

    if(ps_ctxt->i4_l0ipe_qp_mod)

    {

#if MODULATE_LAMDA_WHEN_SPATIAL_MOD_ON

        i4_cu_qp = ihevce_cu_level_qp_mod(

            ps_ctxt->i4_qscale,

            i4_curr_satd,

            ld_avg_satd,

            ps_ctxt->f_strength,

            &i4_activity,

            &i4_qscale,

            ps_ctxt->ps_rc_quant_ctxt);

#endif

    }

    ihevce_get_ipe_ol_cu_lambda_prms(ps_ctxt, i4_cu_qp);

}

/*!

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

* \if Function name : ihevce_ipe_pass_satd \endif

*

* \brief

*    This function calcuates the SATD for a given size and returns the value

*

* \date

*    18/09/2012

*

* \author

*    Ittiam

*

* \return

*

* List of Functions

*

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

*/

UWORD32 ihevce_ipe_pass_satd(WORD16 *pi2_coeff, WORD32 coeff_stride, WORD32 trans_size)

{

    WORD32 i, j, satd;

    satd = 0;

    /* run a loop and find the satd by doing ABS */

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

    {

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

        {

            satd += abs(*pi2_coeff++);

        }

        /* row level update */

        pi2_coeff += coeff_stride - trans_size;

    }

    {

        WORD32 transform_shift;

        WORD32 log2_trans_size;

        GETRANGE(log2_trans_size, trans_size);

        log2_trans_size -= 1;

        transform_shift = MAX_TR_DYNAMIC_RANGE - BIT_DEPTH - log2_trans_size;

        satd >>= transform_shift;

    }

    return (satd);

}

/*!

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

* \if Function name : ihevce_ipe_get_num_mem_recs \endif

*

* \brief

*    Number of memory records are returned for IPE module

*

*

* \return

*    None

*

* \author

*  Ittiam

*

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

*/

WORD32 ihevce_ipe_get_num_mem_recs(void)

{

    return (NUM_IPE_MEM_RECS);

}

/*!

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

* \if Function name : ihevce_ipe_get_mem_recs \endif

*

* \brief

*    Memory requirements are returned for IPE.

*

* \param[in,out]  ps_mem_tab : pointer to memory descriptors table

* \param[in] ps_init_prms : Create time static parameters

* \param[in] i4_num_proc_thrds : Number of processing threads for this module

* \param[in] i4_mem_space : memspace in whihc memory request should be done

*

* \return

*    None

*

* \author

*  Ittiam

*

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

*/

WORD32

    ihevce_ipe_get_mem_recs(iv_mem_rec_t *ps_mem_tab, WORD32 i4_num_proc_thrds, WORD32 i4_mem_space)

{

    /* memories should be requested assuming worst case requirememnts */

    /* Module context structure */

    ps_mem_tab[IPE_CTXT].i4_mem_size = sizeof(ihevce_ipe_master_ctxt_t);

    ps_mem_tab[IPE_CTXT].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space;

    ps_mem_tab[IPE_CTXT].i4_mem_alignment = 8;

    /* Threads ctxt structure */

    ps_mem_tab[IPE_THRDS_CTXT].i4_mem_size = i4_num_proc_thrds * sizeof(ihevce_ipe_ctxt_t);

    ps_mem_tab[IPE_THRDS_CTXT].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space;

    ps_mem_tab[IPE_THRDS_CTXT].i4_mem_alignment = 32;

    return (NUM_IPE_MEM_RECS);

}

/*!

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

* \if Function name : ihevce_ipe_init \endif

*

* \brief

*    Intialization for IPE context state structure .

*

* \param[in] ps_mem_tab : pointer to memory descriptors table

* \param[in] ps_init_prms : Create time static parameters

*

* \return

*    None

*

* \author

*  Ittiam

*

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

*/

void *ihevce_ipe_init(

    iv_mem_rec_t *ps_mem_tab,

    ihevce_static_cfg_params_t *ps_init_prms,

    WORD32 i4_num_proc_thrds,

    WORD32 i4_ref_id,

    func_selector_t *ps_func_selector,

    rc_quant_t *ps_rc_quant_ctxt,

    WORD32 i4_resolution_id,

    UWORD8 u1_is_popcnt_available)

{

    WORD32 i4_thrds;

    UWORD32 u4_width, u4_ctb_in_a_row;

    //  WORD32 i4_ctr;

    ihevce_ipe_master_ctxt_t *ps_master_ctxt;

    ihevce_ipe_ctxt_t *ps_ctxt;

    /* IPE master state structure */

    ps_master_ctxt = (ihevce_ipe_master_ctxt_t *)ps_mem_tab[IPE_CTXT].pv_base;

    ps_master_ctxt->i4_num_proc_thrds = i4_num_proc_thrds;

    ps_ctxt = (ihevce_ipe_ctxt_t *)ps_mem_tab[IPE_THRDS_CTXT].pv_base;

    ps_ctxt->ps_rc_quant_ctxt = ps_rc_quant_ctxt;

    /*width of the input YUV to be encoded. */

    u4_width = ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_width;

    /*making the width a multiple of CTB size*/

    u4_width += SET_CTB_ALIGN(

        ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_width, MAX_CTB_SIZE);

    u4_ctb_in_a_row = (u4_width / MAX_CTB_SIZE);

    /* perform all one initialisation here */

    for(i4_thrds = 0; i4_thrds < ps_master_ctxt->i4_num_proc_thrds; i4_thrds++)

    {

        ps_master_ctxt->aps_ipe_thrd_ctxt[i4_thrds] = ps_ctxt;

        /* initialise the CU and TU sizes */

        ps_ctxt->u1_ctb_size = (1 << ps_init_prms->s_config_prms.i4_max_log2_cu_size);

        ps_ctxt->u1_min_cu_size = (1 << ps_init_prms->s_config_prms.i4_min_log2_cu_size);

        ps_ctxt->u1_min_tu_size = (1 << ps_init_prms->s_config_prms.i4_min_log2_tu_size);

        /** Register the function selector pointer*/

        ps_ctxt->ps_func_selector = ps_func_selector;

        /* Initiailize the encoder quality preset           */

        /* IPE algorithm is controlled based on this preset */

        ps_ctxt->i4_quality_preset =

            ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_quality_preset;

        if(ps_ctxt->i4_quality_preset == IHEVCE_QUALITY_P7)

        {

            ps_ctxt->i4_quality_preset = IHEVCE_QUALITY_P6;

        }

        /* initialise all the pointer to start of arrays */

        ps_ctxt->ps_ipe_cu_tree = &ps_ctxt->as_ipe_cu_tree[0];

        /* initialize QP */

        ps_ctxt->i1_QP =

            ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].ai4_frame_qp[i4_ref_id];

        ps_ctxt->u1_num_b_frames =

            (1 << ps_init_prms->s_coding_tools_prms.i4_max_temporal_layers) - 1;

        ps_ctxt->b_sad_type = IPE_SAD_TYPE;

        ps_ctxt->u1_ipe_step_size = IPE_STEP_SIZE;

        ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_0] =

            ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_planar_fptr;

        ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_1] =

            ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_dc_fptr;

        ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_2] =

            ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_mode2_fptr;

        ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_3TO9] =

            ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_mode_3_to_9_fptr;

        ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_10] =

            ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_horz_fptr;

        ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_11TO17] =

            ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_mode_11_to_17_fptr;

        ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_18_34] =

            ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_mode_18_34_fptr;

        ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_19TO25] =

            ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_mode_19_to_25_fptr;

        ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_26] =

            ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_ver_fptr;

        ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_27TO33] =

            ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_mode_27_to_33_fptr;

        /* nbr parameters initialization */

        /* perform all one initialisation here */

        ps_ctxt->i4_nbr_map_strd = MAX_PU_IN_CTB_ROW + 1 + 8;

        ps_ctxt->pu1_ctb_nbr_map = ps_ctxt->au1_nbr_ctb_map[0];

        /* move the pointer to 1,2 location */

        ps_ctxt->pu1_ctb_nbr_map += ps_ctxt->i4_nbr_map_strd;

        ps_ctxt->pu1_ctb_nbr_map++;

        ps_ctxt->i4_l0ipe_qp_mod = ps_init_prms->s_config_prms.i4_cu_level_rc & 1;

        ps_ctxt->i4_pass = ps_init_prms->s_pass_prms.i4_pass;

        if(ps_init_prms->s_coding_tools_prms.i4_use_default_sc_mtx == 0)

        {

            /* initialise the scale & rescale matricies */

            ps_ctxt->api2_scal_mat[0] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];

            ps_ctxt->api2_scal_mat[1] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];

            ps_ctxt->api2_scal_mat[2] = (WORD16 *)&gi2_flat_scale_mat_8x8[0];

            ps_ctxt->api2_scal_mat[3] = (WORD16 *)&gi2_flat_scale_mat_16x16[0];

            ps_ctxt->api2_scal_mat[4] = (WORD16 *)&gi2_flat_scale_mat_32x32[0];

            /*init for inter matrix*/

            ps_ctxt->api2_scal_mat[5] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];

            ps_ctxt->api2_scal_mat[6] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];

            ps_ctxt->api2_scal_mat[7] = (WORD16 *)&gi2_flat_scale_mat_8x8[0];

            ps_ctxt->api2_scal_mat[8] = (WORD16 *)&gi2_flat_scale_mat_16x16[0];

            ps_ctxt->api2_scal_mat[9] = (WORD16 *)&gi2_flat_scale_mat_32x32[0];

            /*init for rescale matrix*/

            ps_ctxt->api2_rescal_mat[0] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];

            ps_ctxt->api2_rescal_mat[1] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];

            ps_ctxt->api2_rescal_mat[2] = (WORD16 *)&gi2_flat_rescale_mat_8x8[0];

            ps_ctxt->api2_rescal_mat[3] = (WORD16 *)&gi2_flat_rescale_mat_16x16[0];

            ps_ctxt->api2_rescal_mat[4] = (WORD16 *)&gi2_flat_rescale_mat_32x32[0];

            /*init for rescale inter matrix*/

            ps_ctxt->api2_rescal_mat[5] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];

            ps_ctxt->api2_rescal_mat[6] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];

            ps_ctxt->api2_rescal_mat[7] = (WORD16 *)&gi2_flat_rescale_mat_8x8[0];

            ps_ctxt->api2_rescal_mat[8] = (WORD16 *)&gi2_flat_rescale_mat_16x16[0];

            ps_ctxt->api2_rescal_mat[9] = (WORD16 *)&gi2_flat_rescale_mat_32x32[0];

        }

        else if(ps_init_prms->s_coding_tools_prms.i4_use_default_sc_mtx == 1)

        {

            /* initialise the scale & rescale matricies */

            ps_ctxt->api2_scal_mat[0] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];

            ps_ctxt->api2_scal_mat[1] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];

            ps_ctxt->api2_scal_mat[2] = (WORD16 *)&gi2_intra_default_scale_mat_8x8[0];

            ps_ctxt->api2_scal_mat[3] = (WORD16 *)&gi2_intra_default_scale_mat_16x16[0];

            ps_ctxt->api2_scal_mat[4] = (WORD16 *)&gi2_intra_default_scale_mat_32x32[0];

            /*init for inter matrix*/

            ps_ctxt->api2_scal_mat[5] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];

            ps_ctxt->api2_scal_mat[6] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];

            ps_ctxt->api2_scal_mat[7] = (WORD16 *)&gi2_inter_default_scale_mat_8x8[0];

            ps_ctxt->api2_scal_mat[8] = (WORD16 *)&gi2_inter_default_scale_mat_16x16[0];

            ps_ctxt->api2_scal_mat[9] = (WORD16 *)&gi2_inter_default_scale_mat_32x32[0];

            /*init for rescale matrix*/

            ps_ctxt->api2_rescal_mat[0] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];

            ps_ctxt->api2_rescal_mat[1] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];

            ps_ctxt->api2_rescal_mat[2] = (WORD16 *)&gi2_intra_default_rescale_mat_8x8[0];

            ps_ctxt->api2_rescal_mat[3] = (WORD16 *)&gi2_intra_default_rescale_mat_16x16[0];

            ps_ctxt->api2_rescal_mat[4] = (WORD16 *)&gi2_intra_default_rescale_mat_32x32[0];

            /*init for rescale inter matrix*/

            ps_ctxt->api2_rescal_mat[5] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];

            ps_ctxt->api2_rescal_mat[6] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];

            ps_ctxt->api2_rescal_mat[7] = (WORD16 *)&gi2_inter_default_rescale_mat_8x8[0];

            ps_ctxt->api2_rescal_mat[8] = (WORD16 *)&gi2_inter_default_rescale_mat_16x16[0];

            ps_ctxt->api2_rescal_mat[9] = (WORD16 *)&gi2_inter_default_rescale_mat_32x32[0];

        }

        else

        {

            ASSERT(0);

        }

        ps_ctxt->u1_bit_depth = ps_init_prms->s_tgt_lyr_prms.i4_internal_bit_depth;

        /**

        * Initialize the intra prediction modes map for the CTB to INTRA_DC

        **/

        {

            WORD32 row, col;

            for(row = 0; row < (MAX_TU_ROW_IN_CTB + 1); row++)

                for(col = 0; col < (MAX_TU_COL_IN_CTB + 1); col++)

                    ps_ctxt->au1_ctb_mode_map[row][col] = INTRA_DC;

        }

        ihevce_cmn_utils_instr_set_router(

            &ps_ctxt->s_cmn_opt_func, u1_is_popcnt_available, ps_init_prms->e_arch_type);

        ihevce_ipe_instr_set_router(

            &ps_ctxt->s_ipe_optimised_function_list, ps_init_prms->e_arch_type);

        /* increment the thread ctxt pointer */

        ps_ctxt++;

    }

    /* return the handle to caller */

    return ((void *)ps_master_ctxt);

}

/*!

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

* \if Function name : ihevce_ipe_get_frame_intra_satd_cost \endif

*

* \brief

*    Function to export frame-level accumalated SATD .

*

* \param[in] pv_ctxt : pointer to IPE module

*

* \return

*    None

*

* \author

*  Ittiam

*

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

*/

LWORD64 ihevce_ipe_get_frame_intra_satd_cost(

    void *pv_ctxt,

    LWORD64 *pi8_frame_satd_by_qpmod,

    LWORD64 *pi8_frame_acc_mode_bits_cost,

    LWORD64 *pi8_frame_acc_activity_factor,

    LWORD64 *pi8_frame_l0_acc_satd)

{

    WORD32 i4_thrds;

    ihevce_ipe_master_ctxt_t *ps_master_ctxt;

    ihevce_ipe_ctxt_t *ps_ctxt;

    LWORD64 i8_frame_acc_satd_cost = 0;

    LWORD64 i8_frame_acc_satd = 0;

    LWORD64 i8_frame_satd_by_qpmod = 0;

    LWORD64 i8_frame_acc_mode_bits_cost = 0;

    LWORD64 i8_frame_acc_activity_factor = 0;

    /* IPE master state structure */

    ps_master_ctxt = (ihevce_ipe_master_ctxt_t *)pv_ctxt;

    /* perform all one initialisation here */

    for(i4_thrds = 0; i4_thrds < ps_master_ctxt->i4_num_proc_thrds; i4_thrds++)

    {

        ps_ctxt = ps_master_ctxt->aps_ipe_thrd_ctxt[i4_thrds];

        i8_frame_acc_satd_cost += ps_ctxt->i8_frame_acc_satd_cost;

        i8_frame_satd_by_qpmod += (ps_ctxt->i8_frame_acc_satd_by_modqp_q10 >> SATD_BY_ACT_Q_FAC);

        i8_frame_acc_mode_bits_cost += ps_ctxt->i8_frame_acc_mode_bits_cost;

        i8_frame_acc_activity_factor += ps_ctxt->i8_frame_acc_act_factor;

        i8_frame_acc_satd += ps_ctxt->i8_frame_acc_satd;

    }

    *pi8_frame_satd_by_qpmod = i8_frame_satd_by_qpmod;

    *pi8_frame_acc_mode_bits_cost = i8_frame_acc_mode_bits_cost;

    *pi8_frame_acc_activity_factor = i8_frame_acc_activity_factor;

    *pi8_frame_l0_acc_satd = i8_frame_acc_satd;

    return (i8_frame_acc_satd_cost);

}

/**

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

* \if Function name : ihevce_intra_pred_ref_filtering \endif

*

* \brief

*    Intra prediction interpolation filter for ref_filtering for Encoder

*

* \par Description:

*    Reference DC filtering for neighboring samples dependent  on TU size and

*    mode  Refer to section 8.4.4.2.3 in the standard

*

* \param[in] pu1_src pointer to the source

* \param[out] pu1_dst pointer to the destination

* \param[in] nt integer Transform Block size

*

* \returns

*  none

*

* \author

*  Ittiam

*

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

*/

#if IHEVCE_INTRA_REF_FILTERING == C

void ihevce_intra_pred_ref_filtering(UWORD8 *pu1_src, WORD32 nt, UWORD8 *pu1_dst)

{

    WORD32 i; /* Generic indexing variable */

    WORD32 four_nt = 4 * nt;

    /* Extremities Untouched*/

    pu1_dst[0] = pu1_src[0];

    pu1_dst[4 * nt] = pu1_src[4 * nt];

    /* Perform bilinear filtering of Reference Samples */

    for(i = 0; i < (four_nt - 1); i++)

    {

        pu1_dst[i + 1] = (pu1_src[i] + 2 * pu1_src[i + 1] + pu1_src[i + 2] + 2) >> 2;

    }

}

#endif

/*!

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

* \if Function name : ihevce_ipe_process_ctb \endif

*

* \brief

*    CTB level IPE function

*

* \param[in] pv_ctxt : pointer to IPE module

* \param[in] ps_frm_ctb_prms : CTB characteristics parameters

* \param[in] ps_curr_src  : pointer to input yuv buffer (row buffer)

* \param[out] ps_ctb_out : pointer to CTB analyse output structure (row buffer)

* \param[out] ps_row_cu : pointer to CU analyse output structure (row buffer)

*

* \return

*    None

*

* Note : This function will receive CTB pointers which may point to

* blocks of CTB size or smaller (at the right and bottom edges of the picture)

* This function recursively creates smaller square partitions and passes them

* on for intra processing estimation

*

* \author

*  Ittiam

*

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

*/

void ihevce_ipe_process_ctb(

    ihevce_ipe_ctxt_t *ps_ctxt,

    frm_ctb_ctxt_t *ps_frm_ctb_prms,

    iv_enc_yuv_buf_t *ps_curr_src,

    ihevce_ipe_cu_tree_t *ps_curr_ctb_node,

    ipe_l0_ctb_analyse_for_me_t *ps_l0_ipe_out_ctb,

    ctb_analyse_t *ps_ctb_out,

    //cu_analyse_t      *ps_row_cu,

    ihevce_ed_blk_t *ps_ed_l1_ctb,

    ihevce_ed_blk_t *ps_ed_l2_ctb,

    ihevce_ed_ctb_l1_t *ps_ed_ctb_l1)

{

    /* reset the map buffer to 0*/

    memset(

        &ps_ctxt->au1_nbr_ctb_map[0][0],

        0,

        (MAX_PU_IN_CTB_ROW + 1 + 8) * (MAX_PU_IN_CTB_ROW + 1 + 8));

    /* set the CTB neighbour availability flags */

    ihevce_set_ctb_nbr(

        &ps_ctxt->s_ctb_nbr_avail_flags,

        ps_ctxt->pu1_ctb_nbr_map,

        ps_ctxt->i4_nbr_map_strd,

        ps_ctxt->u2_ctb_num_in_row,

        ps_ctxt->u2_ctb_row_num,

        ps_frm_ctb_prms);

    /* IPE cu and mode decision */

    ihevce_bracketing_analysis(

        ps_ctxt,

        ps_curr_ctb_node,

        ps_curr_src,

        ps_ctb_out,

        //ps_row_cu,

        ps_ed_l1_ctb,

        ps_ed_l2_ctb,

        ps_ed_ctb_l1,

        ps_l0_ipe_out_ctb);

    return;

}

/*!

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

* \if Function name : ihevce_ipe_process_row \endif

*

* \brief

*    Row level IPE function

*

* \param[in] pv_ctxt : pointer to IPE module

* \param[in] ps_frm_ctb_prms : CTB characteristics parameters

* \param[in] ps_curr_src  : pointer to input yuv buffer (row buffer)

* \param[out] ps_ctb_out : pointer to CTB analyse output structure (row buffer)

* \param[out] ps_cu_out : pointer to CU analyse output structure (row buffer)

*\param[out]  pi4_num_ctbs_cur_row  : pointer to store the number of ctbs processed in current row

*\param[in]  pi4_num_ctbs_top_row  : pointer to check the number of ctbs processed in top row

*

* \return

*    None

*

* Note : Currently the frame level calculations done assumes that

*        framewidth of the input are excat multiple of ctbsize

*

* \author

*  Ittiam

*

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

*/

void ihevce_ipe_process_row(

    ihevce_ipe_ctxt_t *ps_ctxt,

    frm_ctb_ctxt_t *ps_frm_ctb_prms,

    iv_enc_yuv_buf_t *ps_curr_src,

    ipe_l0_ctb_analyse_for_me_t *ps_ipe_ctb_out_row,

    ctb_analyse_t *ps_ctb_out,

    //cu_analyse_t   *ps_row_cu,

    ihevce_ed_blk_t *ps_ed_l1_row,

    ihevce_ed_blk_t *ps_ed_l2_row,

    ihevce_ed_ctb_l1_t *ps_ed_ctb_l1_row,

    WORD32 blk_inc_ctb_l1,

    WORD32 blk_inc_ctb_l2)

{

    /* local variables */

    UWORD16 ctb_ctr;

    iv_enc_yuv_buf_t s_curr_src_bufs;

    ipe_l0_ctb_analyse_for_me_t *ps_l0_ipe_out_ctb;

    UWORD16 u2_pic_wdt;

    UWORD16 u2_pic_hgt;

    ihevce_ed_blk_t *ps_ed_l1_ctb;

    ihevce_ed_blk_t *ps_ed_l2_ctb;

    ihevce_ed_ctb_l1_t *ps_ed_ctb_l1;

    UWORD8 u1_ctb_size;

    u2_pic_wdt = ps_frm_ctb_prms->i4_cu_aligned_pic_wd;

    u2_pic_hgt = ps_frm_ctb_prms->i4_cu_aligned_pic_ht;

    u1_ctb_size = ps_ctxt->u1_ctb_size;

    /* ----------------------------------------------------- */

    /* store the stride and dimensions of source             */

    /* buffer pointers will be over written at every CTB row */

    /* ----------------------------------------------------- */

    memcpy(&s_curr_src_bufs, ps_curr_src, sizeof(iv_enc_yuv_buf_t));

    ps_l0_ipe_out_ctb = ps_ipe_ctb_out_row;

    /* --------- Loop over all the CTBs in a row --------------- */

    for(ctb_ctr = 0; ctb_ctr < ps_frm_ctb_prms->i4_num_ctbs_horz; ctb_ctr++)

    {

        //UWORD8            num_cus_in_ctb;

        UWORD8 *pu1_tmp;

        /* Create pointer to ctb node */

        ihevce_ipe_cu_tree_t *ps_ctb_node;

        WORD32 nbr_flags;

        WORD32 row;

        /* luma src */

        pu1_tmp = (UWORD8 *)ps_curr_src->pv_y_buf;

        pu1_tmp += (ctb_ctr * ps_frm_ctb_prms->i4_ctb_size);

        s_curr_src_bufs.pv_y_buf = pu1_tmp;

        /* Cb & CR pixel interleaved src */

        pu1_tmp = (UWORD8 *)ps_curr_src->pv_u_buf;

        pu1_tmp += (ctb_ctr * (ps_frm_ctb_prms->i4_ctb_size >> 1));

        s_curr_src_bufs.pv_u_buf = pu1_tmp;

        /* Store the number of current ctb within row in the context */

        ps_ctxt->u2_ctb_num_in_row = ctb_ctr;

        /* Initialize number of coding units in ctb to 0 */

        ps_ctb_out->u1_num_cus_in_ctb = 0;

        /* Initialize split flag to 0 - No partition  */

        ps_ctb_out->u4_cu_split_flags = 0;

        /* store the cu pointer for current ctb out */

        //ps_ctb_out->ps_coding_units_in_ctb = ps_row_cu;

        /* Initialize the CTB parameters at the root node level */

        ps_ctb_node = ps_ctxt->ps_ipe_cu_tree;

        ps_ctb_node->ps_parent = NULL;

        ps_ctb_node->u1_depth = 0;

        ps_ctb_node->u1_cu_size = u1_ctb_size;

        ps_ctb_node->u2_x0 = 0;

        ps_ctb_node->u2_y0 = 0;

        ps_ctb_node->u2_orig_x = ctb_ctr * ps_ctb_node->u1_cu_size;

        ps_ctb_node->u2_orig_y = ps_ctxt->u2_ctb_row_num * ps_ctb_node->u1_cu_size;

        ps_ctb_node->u1_width = u1_ctb_size;

        ps_ctb_node->u1_height = u1_ctb_size;

#if !(PIC_ALIGN_CTB_SIZE)

        if(ps_ctxt->u2_ctb_num_in_row == (ps_frm_ctb_prms->i4_num_ctbs_horz - 1))

        {

            ps_ctb_node->u1_width = u2_pic_wdt - (ps_ctxt->u2_ctb_num_in_row) * (u1_ctb_size);

        }

        if(ps_ctxt->u2_ctb_row_num == (ps_frm_ctb_prms->i4_num_ctbs_vert - 1))

        {

            ps_ctb_node->u1_height = u2_pic_hgt - (ps_ctxt->u2_ctb_row_num) * (u1_ctb_size);

        }

#endif

        switch(ps_ctb_node->u1_cu_size)

        {

        case 64:

            ps_ctb_node->u1_log2_nt = 6;

            ps_ctb_node->u1_part_flag_pos = 0;

            break;

        case 32:

            ps_ctb_node->u1_log2_nt = 5;

            ps_ctb_node->u1_part_flag_pos = 4;

            break;

        case 16:

            ps_ctb_node->u1_log2_nt = 4;

            ps_ctb_node->u1_part_flag_pos = 8;

            break;

        }

        /* Set neighbor flags for the CTB */

        nbr_flags = 0;

        if(ps_ctxt->u2_ctb_num_in_row != 0)

        {

            nbr_flags |= LEFT_FLAG; /* Set Left Flag if not in first column */

            ps_ctb_node->u1_num_left_avail = ((u2_pic_hgt - ps_ctb_node->u2_orig_y) >= u1_ctb_size)

                                                 ? u1_ctb_size

                                                 : u2_pic_hgt - ps_ctb_node->u2_orig_y;

        }

        else

        {

            ps_ctb_node->u1_num_left_avail = 0;

        }

        if((ps_ctxt->u2_ctb_num_in_row != 0) && (ps_ctxt->u2_ctb_row_num != 0))

            nbr_flags |= TOP_LEFT_FLAG; /* Set Top-Left Flag if not in first row or first column */

        if(ps_ctxt->u2_ctb_row_num != 0)

        {

            nbr_flags |= TOP_FLAG; /* Set Top Flag if not in first row */

            ps_ctb_node->u1_num_top_avail = ((u2_pic_wdt - ps_ctb_node->u2_orig_x) >= u1_ctb_size)

                                                ? u1_ctb_size

                                                : u2_pic_wdt - ps_ctb_node->u2_orig_x;

        }

        else

        {

            ps_ctb_node->u1_num_top_avail = 0;

        }

        if(ps_ctxt->u2_ctb_row_num != 0)

        {

            if(ps_ctxt->u2_ctb_num_in_row == (ps_frm_ctb_prms->i4_num_ctbs_horz - 1))

                ps_ctb_node->u1_num_top_right_avail = 0;

            else

            {

                ps_ctb_node->u1_num_top_right_avail =

                    ((u2_pic_wdt - ps_ctb_node->u2_orig_x - u1_ctb_size) >= u1_ctb_size)

                        ? u1_ctb_size

                        : u2_pic_wdt - ps_ctb_node->u2_orig_x - u1_ctb_size;

                nbr_flags |=

                    TOP_RIGHT_FLAG; /* Set Top-Right Flag if not in first row or last column*/

            }

        }

        else

        {

            ps_ctb_node->u1_num_top_right_avail = 0;

        }

        ps_ctb_node->u1_num_bottom_left_avail = 0;

        ps_ctb_node->i4_nbr_flag = nbr_flags;

        /**

        * Update CTB Mode Map

        * In case this is first CTB in a row, set left most column to INTRA_DC (NA)

        * else copy last column to first column

        **/

        if(ctb_ctr == 0)

        {

            for(row = 0; row < (MAX_TU_ROW_IN_CTB + 1); row++)

            {

                ps_ctxt->au1_ctb_mode_map[row][0] = INTRA_DC;

            }

        }

        else

        {

            for(row = 0; row < (MAX_TU_ROW_IN_CTB + 1); row++)

            {

                ps_ctxt->au1_ctb_mode_map[row][0] =

                    ps_ctxt->au1_ctb_mode_map[row][MAX_TU_COL_IN_CTB];

            }

        }

        /* --------- IPE call at CTB level ------------------ */

        /* IPE CTB function is expected to Decide on the CUs sizes  */

        /* and populate the best intra prediction modes and TX flags*/

        /* Interface of this CTb level function is kept open */

        ps_ed_l1_ctb = ps_ed_l1_row + ctb_ctr * blk_inc_ctb_l1;

        ps_ed_l2_ctb = ps_ed_l2_row + ctb_ctr * blk_inc_ctb_l2;

        ps_ed_ctb_l1 = ps_ed_ctb_l1_row + ctb_ctr;

        if(ps_ctxt->u1_use_lambda_derived_from_min_8x8_act_in_ctb)

        {

            ihevce_ipe_recompute_lambda_from_min_8x8_act_in_ctb(ps_ctxt, ps_ed_ctb_l1);

        }

        ihevce_ipe_process_ctb(

            ps_ctxt,

            ps_frm_ctb_prms,

            &s_curr_src_bufs,

            ps_ctb_node,

            ps_l0_ipe_out_ctb,

            ps_ctb_out,

            //ps_row_cu,

            ps_ed_l1_ctb,

            ps_ed_l2_ctb,

            ps_ed_ctb_l1);

        /* -------------- ctb level updates ----------------- */

        ps_l0_ipe_out_ctb++;

        //num_cus_in_ctb = ps_ctb_out->u1_num_cus_in_ctb;

        //ps_row_cu += num_cus_in_ctb;

        ps_ctb_out++;

    }

    return;

}

/*!

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

* \if Function name : ihevce_ipe_process \endif

*

* \brief

*    Frame level IPE function

*

* \param[in] pv_ctxt : pointer to IPE module

* \param[in] ps_frm_ctb_prms : CTB characteristics parameters

* \param[in] ps_inp  : pointer to input yuv buffer (frame buffer)

* \param[out] ps_ctb_out : pointer to CTB analyse output structure (frame buffer)

* \param[out] ps_cu_out : pointer to CU analyse output structure (frame buffer)

*

* \return

*    None

*

* Note : Currently the frame level calculations done assumes that

*        framewidth of the input are excat multiple of ctbsize

*

* \author

*  Ittiam

*

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

*/

void ihevce_ipe_process(

    void *pv_ctxt,

    frm_ctb_ctxt_t *ps_frm_ctb_prms,

    frm_lambda_ctxt_t *ps_frm_lamda,

    ihevce_lap_enc_buf_t *ps_curr_inp,

    pre_enc_L0_ipe_encloop_ctxt_t *ps_L0_IPE_curr_out_pre_enc,

    ctb_analyse_t *ps_ctb_out,

    //cu_analyse_t               *ps_cu_out,

    ipe_l0_ctb_analyse_for_me_t *ps_ipe_ctb_out,

    void *pv_multi_thrd_ctxt,

    WORD32 slice_type,

    ihevce_ed_blk_t *ps_ed_pic_l1,

    ihevce_ed_blk_t *ps_ed_pic_l2,

    ihevce_ed_ctb_l1_t *ps_ed_ctb_l1_pic,

    WORD32 thrd_id,

    WORD32 i4_ping_pong)

{

    /* local variables */

    ihevce_ipe_master_ctxt_t *ps_master_ctxt;

    iv_enc_yuv_buf_t *ps_inp = &ps_curr_inp->s_lap_out.s_input_buf;

    ihevce_ipe_ctxt_t *ps_ctxt;

    iv_enc_yuv_buf_t s_curr_src_bufs;

    WORD32 end_of_frame;

    ihevce_ed_blk_t *ps_ed_l1_row;

    ihevce_ed_blk_t *ps_ed_l2_row;

    ihevce_ed_ctb_l1_t *ps_ed_ctb_l1_row;

    WORD32 blk_inc_ctb_l1 = 0;

    WORD32 blk_inc_ctb_l2 = 0;

    /* Layer 1 pre intra analysis related initilization.

    * Compute no of 8x8 blks in the ctb which which is

    * same as no of 4x4 blks in the ctb in layer 1 */

    blk_inc_ctb_l1 = ps_frm_ctb_prms->i4_ctb_size >> 3;

    blk_inc_ctb_l1 = blk_inc_ctb_l1 * blk_inc_ctb_l1;

    /* Layer 2 pre intra analysis related initilization.

    * Compute no of 16x16 blks in the ctb which which is

    * same as no of 8x8 blks in the ctb in layer 2 */

    blk_inc_ctb_l2 = ps_frm_ctb_prms->i4_ctb_size >> 4;

    blk_inc_ctb_l2 = blk_inc_ctb_l2 * blk_inc_ctb_l2;

    /* ----------------------------------------------------- */

    /* store the stride and dimensions of source             */

    /* buffer pointers will be over written at every CTB row */

    /* ----------------------------------------------------- */

    memcpy(&s_curr_src_bufs, ps_inp, sizeof(iv_enc_yuv_buf_t));

    ps_master_ctxt = (ihevce_ipe_master_ctxt_t *)pv_ctxt;

    ps_ctxt = ps_master_ctxt->aps_ipe_thrd_ctxt[thrd_id];

    end_of_frame = 0;

    if(ISLICE == slice_type)

    {

        ps_ctxt->b_sad_type = IPE_SAD_TYPE;

        ps_ctxt->i4_ol_satd_lambda = ps_frm_lamda->i4_ol_satd_lambda_qf;

        ps_ctxt->i4_ol_sad_lambda = ps_frm_lamda->i4_ol_sad_lambda_qf;

    }

    else

    {

        ps_ctxt->b_sad_type = IPE_SAD_TYPE; /* SAD */

        ps_ctxt->i4_ol_satd_lambda = ps_frm_lamda->i4_ol_satd_lambda_qf;

        ps_ctxt->i4_ol_sad_lambda = ps_frm_lamda->i4_ol_sad_lambda_qf;

    }

    ihevce_populate_ipe_ol_cu_lambda_prms(

        (void *)ps_ctxt,

        ps_frm_lamda,

        slice_type,

        ps_curr_inp->s_lap_out.i4_temporal_lyr_id,

        IPE_LAMBDA_TYPE);

    /* register the slice type in the ctxt */

    ps_ctxt->i4_slice_type = slice_type;

    /** Frame-levelSATD cost accumalator init to 0 */

    ps_ctxt->i8_frame_acc_satd_cost = 0;

    /** Frame-levelSATD accumalator init to 0 */

    ps_ctxt->i8_frame_acc_satd = 0;

    /** Frame-level Activity factor accumalator init to 1 */

    ps_ctxt->i8_frame_acc_act_factor = 1;