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

 *

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

*

* \brief

*    Converts the language of the encoder to language of me. This is an i/f

*    between the encoder style APIs and ME style APIs. This is basically

*    a memoryless glue layer.

*

* \date

*    22/10/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 "ihevce_defs.h"

#include "ihevce_lap_enc_structs.h"

#include "ihevce_multi_thrd_structs.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 "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_utils.h"

#include "hme_coarse.h"

#include "hme_refine.h"

#include "hme_function_selector.h"

#include "ihevce_me_pass.h"

#include "cast_types.h"

#include "osal.h"

#include "osal_defaults.h"

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

/* Macros                                                                    */

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

/** orig simple five tap scaler */

#define FIVE_TAP_ORIG_SCALER 0

/** simple gaussian filter, blurs the image a bit */

#define SIMPLE_GAUSSIAN_SCALER 0

/** lanczos scaler gives sharper images           */

#define LANCZOS_SCALER 1

// Saturated addition z = x + y

// overflow condition: z<x or z<y

#define SATURATED_ADD(z, x, y)                                                                     \

    {                                                                                              \

        (z) = (x) + (y);                                                                           \

        if(((z) < (x)) || ((z) < (y)))                                                             \

            (z) = MAX_INTRA_COST_IPE;                                                              \

    }

#define SATURATED_SUB(z, x, y)                                                                     \

    {                                                                                              \

        (z) = (x) - (y);                                                                           \

        if((z) < 0) /*if (((z) > (x)) || ((z) > (y))) */                                           \

            (z) = 0;                                                                               \

    }

#if(FIVE_TAP_ORIG_SCALER + SIMPLE_GAUSSIAN_SCALER + LANCZOS_SCALER) > 1

#error "HME ERROR: Only one scaler can be enabled at a time"

#endif

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

/* Function Definitions                                                      */

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

/*!

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

* \if Function name : ihevce_me_get_num_mem_recs \endif

*

* \brief

*    Number of memory records are returned for ME module

*    Note : Include TOT MEM. req. for ME + TOT MEM. req. for Dep Mngr for L0 ME

*

* \return

*    Number of memory records

*

* \author

*  Ittiam

*

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

*/

WORD32 ihevce_me_get_num_mem_recs(WORD32 i4_num_me_frm_pllel)

{

    WORD32 me_mem_recs = hme_enc_num_alloc(i4_num_me_frm_pllel);

    return (me_mem_recs);

}

void ihevce_derive_me_init_prms(

    ihevce_static_cfg_params_t *ps_init_prms,

    hme_init_prms_t *ps_hme_init_prms,

    S32 i4_num_proc_thrds,

    S32 i4_resolution_id)

{

    WORD32 i4_field_pic = ps_init_prms->s_src_prms.i4_field_pic;

    WORD32 min_cu_size;

    /* max number of ref frames. This should be > ref frms sent any frm */

    ps_hme_init_prms->max_num_ref = ((DEFAULT_MAX_REFERENCE_PICS) << i4_field_pic);

    /* get the min cu size from config params */

    min_cu_size = ps_init_prms->s_config_prms.i4_min_log2_cu_size;

    min_cu_size = 1 << min_cu_size;

    /* Width and height for the layer being encoded */

    ps_hme_init_prms->a_wd[0] =

        ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_width +

        SET_CTB_ALIGN(

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

    ps_hme_init_prms->a_ht[0] =

        ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_height +

        SET_CTB_ALIGN(

            ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_height, min_cu_size);

    /* we store 4 results in coarsest layer per blk. 8x4L, 8x4R, 4x8T, 4x8B */

    ps_hme_init_prms->max_num_results_coarse = 4;

    /* Every refinement layer stores a max of 2 results per partition */

    ps_hme_init_prms->max_num_results = 2;

    /* Assuming abt 4 layers for 1080p, we do explicit search across all ref */

    /* frames in all but final layer In final layer, it could be 1/2 */

    ps_hme_init_prms->num_layers_explicit_search = 3;

    /* Populate the max_tr_depth for Inter */

    ps_hme_init_prms->u1_max_tr_depth = ps_init_prms->s_config_prms.i4_max_tr_tree_depth_nI;

    ps_hme_init_prms->log_ctb_size = ps_init_prms->s_config_prms.i4_max_log2_cu_size;

    ASSERT(ps_hme_init_prms->log_ctb_size == 6);

    /* currently encoding only 1 layer */

    ps_hme_init_prms->num_simulcast_layers = 1;

    /* this feature not yet supported */

    ps_hme_init_prms->segment_higher_layers = 0;

    /* Allow 4x4 in refinement layers. Unconditionally enabled in coarse lyr */

    /* And not enabled in encode layers, this is just for intermediate refine*/

    /* layers, where it could be used for better accuracy of motion.         */

#if !OLD_XTREME_SPEED

    if((IHEVCE_QUALITY_P6 ==

        ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_quality_preset) ||

       (IHEVCE_QUALITY_P7 ==

        ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_quality_preset) ||

       (IHEVCE_QUALITY_P5 ==

        ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_quality_preset) ||

       (IHEVCE_QUALITY_P4 ==

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

        ps_hme_init_prms->use_4x4 = 0;

    else

        ps_hme_init_prms->use_4x4 = 1;

#else

    ps_hme_init_prms->use_4x4 = 1;

#endif

    ps_hme_init_prms->num_b_frms =

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

    ps_hme_init_prms->i4_num_proc_thrds = i4_num_proc_thrds;

    if(IHEVCE_QUALITY_P0 ==

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

    {

        ps_hme_init_prms->s_me_coding_tools.e_me_quality_presets = ME_PRISTINE_QUALITY;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_hpel_refine = 3;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_qpel_refine = 3;

    }

    else if(

        IHEVCE_QUALITY_P2 ==

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

    {

        ps_hme_init_prms->s_me_coding_tools.e_me_quality_presets = ME_HIGH_QUALITY;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_hpel_refine = 3;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_qpel_refine = 3;

    }

    else if(

        IHEVCE_QUALITY_P3 ==

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

    {

        ps_hme_init_prms->s_me_coding_tools.e_me_quality_presets = ME_MEDIUM_SPEED;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_hpel_refine = 2;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_qpel_refine = 2;

    }

    else if(

        IHEVCE_QUALITY_P4 ==

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

    {

        ps_hme_init_prms->s_me_coding_tools.e_me_quality_presets = ME_HIGH_SPEED;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_hpel_refine = 1;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_qpel_refine = 1;

    }

    else if(

        IHEVCE_QUALITY_P5 ==

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

    {

        ps_hme_init_prms->s_me_coding_tools.e_me_quality_presets = ME_XTREME_SPEED;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_hpel_refine = 1;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_qpel_refine = 1;

    }

    else if(

        IHEVCE_QUALITY_P6 ==

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

    {

        ps_hme_init_prms->s_me_coding_tools.e_me_quality_presets = ME_XTREME_SPEED_25;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_hpel_refine = 1;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_qpel_refine = 1;

    }

    else if(

        IHEVCE_QUALITY_P7 ==

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

    {

        ps_hme_init_prms->s_me_coding_tools.e_me_quality_presets = ME_XTREME_SPEED_25;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_hpel_refine = 1;

        ps_hme_init_prms->s_me_coding_tools.i4_num_steps_qpel_refine = 0;

    }

    ps_hme_init_prms->s_me_coding_tools.u1_l0_me_controlled_via_cmd_line = 0;

    /* Register the search range params from static params */

    ps_hme_init_prms->max_horz_search_range = ps_init_prms->s_config_prms.i4_max_search_range_horz;

    ps_hme_init_prms->max_vert_search_range = ps_init_prms->s_config_prms.i4_max_search_range_vert;

    ps_hme_init_prms->e_arch_type = ps_init_prms->e_arch_type;

    ps_hme_init_prms->is_interlaced = (ps_init_prms->s_src_prms.i4_field_pic == IV_INTERLACED);

    ps_hme_init_prms->u1_is_stasino_enabled =

        ((ps_init_prms->s_coding_tools_prms.i4_vqet &

          (1 << BITPOS_IN_VQ_TOGGLE_FOR_CONTROL_TOGGLER)) &&

         (ps_init_prms->s_coding_tools_prms.i4_vqet &

          (1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_NOISE_PRESERVATION)));

}

/*!

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

* \if Function name : ihevce_me_get_mem_recs \endif

*

* \brief

*    Memory requirements are returned for ME.

*

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

*    Number of records

*

* \author

*  Ittiam

*

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

*/

WORD32 ihevce_me_get_mem_recs(

    iv_mem_rec_t *ps_mem_tab,

    ihevce_static_cfg_params_t *ps_init_prms,

    WORD32 i4_num_proc_thrds,

    WORD32 i4_mem_space,

    WORD32 i4_resolution_id,

    WORD32 i4_num_me_frm_pllel)

{

    hme_memtab_t as_memtabs[MAX_HME_ENC_TOT_MEMTABS];

    WORD32 n_tabs, i;

    /* Init prms structure specific to HME */

    hme_init_prms_t s_hme_init_prms;

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

    /* code flow: we call hme alloc function and then remap those memtabs    */

    /* to a different type of memtab structure.                              */

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

    if(i4_num_me_frm_pllel > 1)

    {

        ASSERT(MAX_HME_ENC_TOT_MEMTABS >= hme_enc_num_alloc(i4_num_me_frm_pllel));

    }

    else

    {

        ASSERT(MIN_HME_ENC_TOT_MEMTABS >= hme_enc_num_alloc(i4_num_me_frm_pllel));

    }

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

    /* POPULATE THE HME INIT PRMS                                            */

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

    ihevce_derive_me_init_prms(ps_init_prms, &s_hme_init_prms, i4_num_proc_thrds, i4_resolution_id);

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

    /* CALL THE ME FUNCTION TO GET MEMTABS                                   */

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

    n_tabs = hme_enc_alloc(&as_memtabs[0], &s_hme_init_prms, i4_num_me_frm_pllel);

    ASSERT(n_tabs == hme_enc_num_alloc(i4_num_me_frm_pllel));

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

    /* REMAP RESULTS TO ENCODER MEMTAB STRUCTURE                             */

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

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

    {

        ps_mem_tab[i].i4_mem_size = as_memtabs[i].size;

        ps_mem_tab[i].i4_mem_alignment = as_memtabs[i].align;

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

        ps_mem_tab[i].i4_size = sizeof(iv_mem_rec_t);

    }

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

    /* --- L0 ME sync Dep Mngr Mem requests --                               */

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

    ps_mem_tab += n_tabs;

    return (n_tabs);

}

/*!

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

* \if Function name : ihevce_me_init \endif

*

* \brief

*    Intialization for ME context state structure .

*

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

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

* \param[in] pv_osal_handle : Osal handle

*

* \return

*    Handle to the ME context

*

* \author

*  Ittiam

*

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

*/

void *ihevce_me_init(

    iv_mem_rec_t *ps_mem_tab,

    ihevce_static_cfg_params_t *ps_init_prms,

    WORD32 i4_num_proc_thrds,

    void *pv_osal_handle,

    rc_quant_t *ps_rc_quant_ctxt,

    void *pv_tile_params_base,

    WORD32 i4_resolution_id,

    WORD32 i4_num_me_frm_pllel,

    UWORD8 u1_is_popcnt_available)

{

    /* ME handle to be returned */

    void *pv_me_ctxt;

    WORD32 status;

    me_master_ctxt_t *ps_me_ctxt;

    IV_ARCH_T e_arch_type;

    /* Init prms structure specific to HME */

    hme_init_prms_t s_hme_init_prms;

    /* memtabs to be passed to hme */

    hme_memtab_t as_memtabs[MAX_HME_ENC_TOT_MEMTABS];

    WORD32 n_tabs, i;

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

    /* POPULATE THE HME INIT PRMS                                            */

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

    ihevce_derive_me_init_prms(ps_init_prms, &s_hme_init_prms, i4_num_proc_thrds, i4_resolution_id);

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

    /* Ensure local declaration is sufficient                                */

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

    n_tabs = hme_enc_num_alloc(i4_num_me_frm_pllel);

    if(i4_num_me_frm_pllel > 1)

    {

        ASSERT(MAX_HME_ENC_TOT_MEMTABS >= n_tabs);

    }

    else

    {

        ASSERT(MIN_HME_ENC_TOT_MEMTABS >= n_tabs);

    }

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

    /* MAP RESULTS TO HME MEMTAB STRUCTURE                                   */

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

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

    {

        as_memtabs[i].size = ps_mem_tab[i].i4_mem_size;

        as_memtabs[i].align = ps_mem_tab[i].i4_mem_alignment;

        as_memtabs[i].pu1_mem = (U08 *)ps_mem_tab[i].pv_base;

    }

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

    /* CALL THE ME FUNCTION TO GET MEMTABS                                   */

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

    pv_me_ctxt = (void *)as_memtabs[0].pu1_mem;

    ps_me_ctxt = (me_master_ctxt_t *)pv_me_ctxt;

    /* Store Tile params base into ME context */

    ps_me_ctxt->pv_tile_params_base = pv_tile_params_base;

    status = hme_enc_init(

        pv_me_ctxt, &as_memtabs[0], &s_hme_init_prms, ps_rc_quant_ctxt, i4_num_me_frm_pllel);

    if(status == -1)

        return NULL;

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

    /* --- L0 ME sync Dep Mngr Mem init --                                     */

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

    /* Update numer of ME frames running in parallel in me master context */

    ps_me_ctxt->i4_num_me_frm_pllel = i4_num_me_frm_pllel;

    e_arch_type = ps_init_prms->e_arch_type;

    hme_init_function_ptr(ps_me_ctxt, e_arch_type);

    ihevce_me_instr_set_router(

        (ihevce_me_optimised_function_list_t *)ps_me_ctxt->pv_me_optimised_function_list,

        e_arch_type);

    ihevce_cmn_utils_instr_set_router(

        &ps_me_ctxt->s_cmn_opt_func, u1_is_popcnt_available, e_arch_type);

    ps_mem_tab += n_tabs;

    return (pv_me_ctxt);

}

/**

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

* \if Function name : ihevce_me_set_resolution \endif

*

* \brief

*    Sets the resolution for ME state

*

* \par Description:

*    ME requires information of resolution to prime up its layer descriptors

*    and contexts. This API is called whenever a control call from application

*    causes a change of resolution. Has to be called once initially before

*    processing any frame. Again this is just a glue function and calls the

*    actual ME API for the same.

*

* \param[in,out] pv_me_ctxt: Handle to the ME context

* \param[in] n_enc_layers: Number of layers getting encoded

* \param[in] p_wd : Pointer containing widths of each layer getting encoded.

* \param[in] p_ht : Pointer containing heights of each layer getting encoded.

*

* \returns

*  none

*

* \author

*  Ittiam

*

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

*/

void ihevce_me_set_resolution(void *pv_me_ctxt, WORD32 n_enc_layers, WORD32 *p_wd, WORD32 *p_ht)

{

    /* local variables */

    me_master_ctxt_t *ps_master_ctxt = (me_master_ctxt_t *)pv_me_ctxt;

    WORD32 thrds;

    WORD32 i;

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

    {

        me_ctxt_t *ps_me_thrd_ctxt;

        ps_me_thrd_ctxt = ps_master_ctxt->aps_me_ctxt[thrds];

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

        {

            hme_set_resolution((void *)ps_me_thrd_ctxt, n_enc_layers, p_wd, p_ht, i);

        }

    }

}

void ihevce_populate_me_ctb_data(

    me_ctxt_t *ps_ctxt,

    me_frm_ctxt_t *ps_frm_ctxt,

    cur_ctb_cu_tree_t *ps_cu_tree,

    me_ctb_data_t *ps_me_ctb_data,

    CU_POS_T e_grandparent_blk_pos,

    CU_POS_T e_parent_blk_pos,

    CU_POS_T e_cur_blk_pos)

{

    inter_cu_results_t *ps_cu_results;

    switch(ps_cu_tree->u1_cu_size)

    {

    case 64:

    {

        block_data_64x64_t *ps_data = &ps_me_ctb_data->s_64x64_block_data;

        ps_cu_results = &ps_frm_ctxt->s_cu64x64_results;

        ps_data->num_best_results = (ps_cu_tree->is_node_valid) ? ps_cu_results->u1_num_best_results

                                                                : 0;

        break;

    }

    case 32:

    {

        block_data_32x32_t *ps_data = &ps_me_ctb_data->as_32x32_block_data[e_cur_blk_pos];

        ps_cu_results = &ps_frm_ctxt->as_cu32x32_results[e_cur_blk_pos];

        ps_data->num_best_results = (ps_cu_tree->is_node_valid) ? ps_cu_results->u1_num_best_results

                                                                : 0;

        break;

    }

    case 16:

    {

        WORD32 i4_blk_id = e_cur_blk_pos + (e_parent_blk_pos << 2);

        block_data_16x16_t *ps_data = &ps_me_ctb_data->as_block_data[i4_blk_id];

        ps_cu_results = &ps_frm_ctxt->as_cu16x16_results[i4_blk_id];

        ps_data->num_best_results = (ps_cu_tree->is_node_valid) ? ps_cu_results->u1_num_best_results

                                                                : 0;

        break;

    }

    case 8:

    {

        WORD32 i4_blk_id = e_cur_blk_pos + (e_parent_blk_pos << 2) + (e_grandparent_blk_pos << 4);

        block_data_8x8_t *ps_data = &ps_me_ctb_data->as_8x8_block_data[i4_blk_id];

        ps_cu_results = &ps_frm_ctxt->as_cu8x8_results[i4_blk_id];

        ps_data->num_best_results = (ps_cu_tree->is_node_valid) ? ps_cu_results->u1_num_best_results

                                                                : 0;

        break;

    }

    }

    if(ps_cu_tree->is_node_valid)

    {

        if((ps_ctxt->s_init_prms.s_me_coding_tools.e_me_quality_presets == ME_PRISTINE_QUALITY) &&

           (ps_cu_tree->u1_cu_size != 8))

        {

            ihevce_populate_me_ctb_data(

                ps_ctxt,

                ps_frm_ctxt,

                ps_cu_tree->ps_child_node_tl,

                ps_me_ctb_data,

                e_parent_blk_pos,

                e_cur_blk_pos,

                POS_TL);

            ihevce_populate_me_ctb_data(

                ps_ctxt,

                ps_frm_ctxt,

                ps_cu_tree->ps_child_node_tr,

                ps_me_ctb_data,

                e_parent_blk_pos,

                e_cur_blk_pos,

                POS_TR);

            ihevce_populate_me_ctb_data(

                ps_ctxt,

                ps_frm_ctxt,

                ps_cu_tree->ps_child_node_bl,

                ps_me_ctb_data,

                e_parent_blk_pos,

                e_cur_blk_pos,

                POS_BL);

            ihevce_populate_me_ctb_data(

                ps_ctxt,

                ps_frm_ctxt,

                ps_cu_tree->ps_child_node_br,

                ps_me_ctb_data,

                e_parent_blk_pos,

                e_cur_blk_pos,

                POS_BR);

        }

    }

    else if(ps_cu_tree->u1_cu_size != 8)

    {

        ihevce_populate_me_ctb_data(

            ps_ctxt,

            ps_frm_ctxt,

            ps_cu_tree->ps_child_node_tl,

            ps_me_ctb_data,

            e_parent_blk_pos,

            e_cur_blk_pos,

            POS_TL);

        ihevce_populate_me_ctb_data(

            ps_ctxt,

            ps_frm_ctxt,

            ps_cu_tree->ps_child_node_tr,

            ps_me_ctb_data,

            e_parent_blk_pos,

            e_cur_blk_pos,

            POS_TR);

        ihevce_populate_me_ctb_data(

            ps_ctxt,

            ps_frm_ctxt,

            ps_cu_tree->ps_child_node_bl,

            ps_me_ctb_data,

            e_parent_blk_pos,

            e_cur_blk_pos,

            POS_BL);

        ihevce_populate_me_ctb_data(

            ps_ctxt,

            ps_frm_ctxt,

            ps_cu_tree->ps_child_node_br,

            ps_me_ctb_data,

            e_parent_blk_pos,

            e_cur_blk_pos,

            POS_BR);

    }

}

void ihevce_me_update_ctb_results(

    void *pv_me_ctxt, void *pv_me_frm_ctxt, WORD32 i4_ctb_x, WORD32 i4_ctb_y)

{

    ctb_analyse_t *ps_ctb_out;

    cur_ctb_cu_tree_t *ps_cu_tree;

    me_ctb_data_t *ps_me_ctb_data;

    me_ctxt_t *ps_ctxt = (me_ctxt_t *)pv_me_ctxt;

    me_frm_ctxt_t *ps_frm_ctxt = (me_frm_ctxt_t *)pv_me_frm_ctxt;

    ps_ctb_out = ps_frm_ctxt->ps_ctb_analyse_curr_row + i4_ctb_x;

    ps_me_ctb_data = ps_frm_ctxt->ps_me_ctb_data_curr_row + i4_ctb_x;

    ps_cu_tree = ps_frm_ctxt->ps_cu_tree_curr_row + (i4_ctb_x * MAX_NUM_NODES_CU_TREE);

    ps_ctb_out->ps_cu_tree = ps_cu_tree;

    ps_ctb_out->ps_me_ctb_data = ps_me_ctb_data;

    ihevce_populate_me_ctb_data(

        ps_ctxt, ps_frm_ctxt, ps_cu_tree, ps_me_ctb_data, POS_NA, POS_NA, POS_NA);

}

WORD32 ihevce_me_find_poc_in_list(

    recon_pic_buf_t **pps_rec_list, WORD32 poc, WORD32 i4_idr_gop_num, WORD32 num_ref)

{

    WORD32 i;

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

    {

        if(pps_rec_list[i]->i4_poc == poc && pps_rec_list[i]->i4_idr_gop_num == i4_idr_gop_num)

            return (i);

    }

    /* should never come here */

    ASSERT(0);

    return (-1);

}

void ihevc_me_update_ref_desc(

    hme_ref_desc_t *ps_ref_desc,

    recon_pic_buf_t *ps_recon_pic,

    WORD32 ref_id_l0,

    WORD32 ref_id_l1,

    WORD32 ref_id_lc,

    WORD32 is_fwd)

{

    hme_ref_buf_info_t *ps_ref_info = &ps_ref_desc->as_ref_info[0];

    iv_enc_yuv_buf_t *ps_yuv_desc = (iv_enc_yuv_buf_t *)&ps_recon_pic->s_yuv_buf_desc;

    iv_enc_yuv_buf_t *ps_src_yuv_desc = (iv_enc_yuv_buf_t *)&ps_recon_pic->s_yuv_buf_desc_src;

    S32 offset;

    /* Padding beyond 64 is not of use to ME */

    ps_ref_info->u1_pad_x = MIN(64, PAD_HORZ);

    ps_ref_info->u1_pad_y = MIN(64, PAD_VERT);

    /* Luma stride and offset. Assuming here that supplied ptr is */

    /* 0, 0 position and hence setting offset to 0. In fact, it is */

    /* not used inside ME as of now.                               */

    ps_ref_info->luma_stride = ps_yuv_desc->i4_y_strd;

    ps_ref_info->luma_offset = 0;

    /* 4 planes, fxfy is the direct recon buf, others are from subpel planes */

    //offset = ps_ref_info->luma_stride * PAD_VERT + PAD_HORZ;

    offset = 0;

    ps_ref_info->pu1_rec_fxfy = (UWORD8 *)ps_yuv_desc->pv_y_buf + offset;

    ps_ref_info->pu1_rec_hxfy = ps_recon_pic->apu1_y_sub_pel_planes[0] + offset;

    ps_ref_info->pu1_rec_fxhy = ps_recon_pic->apu1_y_sub_pel_planes[1] + offset;

    ps_ref_info->pu1_rec_hxhy = ps_recon_pic->apu1_y_sub_pel_planes[2] + offset;

    ps_ref_info->pu1_ref_src = (UWORD8 *)ps_src_yuv_desc->pv_y_buf + offset;

    /* U V ptrs though they are not used */

    ps_ref_info->pu1_rec_u = (U08 *)ps_yuv_desc->pv_u_buf;

    ps_ref_info->pu1_rec_v = (U08 *)ps_yuv_desc->pv_v_buf;

    /* uv offsets and strides, same treatment sa luma */

    ps_ref_info->chroma_offset = 0;

    ps_ref_info->chroma_stride = ps_yuv_desc->i4_uv_strd;

    ps_ref_info->pv_dep_mngr = ps_recon_pic->pv_dep_mngr_recon;

    /* L0, L1 and LC id. */

    ps_ref_desc->i1_ref_id_l0 = ref_id_l0;

    ps_ref_desc->i1_ref_id_l1 = ref_id_l1;

    ps_ref_desc->i1_ref_id_lc = ref_id_lc;

    /* POC of the ref pic */

    ps_ref_desc->i4_poc = ps_recon_pic->i4_poc;

    /* Display num of the ref pic */

    ps_ref_desc->i4_display_num = ps_recon_pic->i4_display_num;

    /* GOP number of the reference pic*/

    ps_ref_desc->i4_GOP_num = ps_recon_pic->i4_idr_gop_num;

    /* Whether this picture is in past (fwd) or future (bck) */

    ps_ref_desc->u1_is_fwd = is_fwd;

    /* store the weight and offsets fo refernce picture */

    ps_ref_desc->i2_weight = ps_recon_pic->s_weight_offset.i2_luma_weight;

    ps_ref_desc->i2_offset = ps_recon_pic->s_weight_offset.i2_luma_offset;

}

/* Create the reference map for ME */

void ihevce_me_create_ref_map(

    recon_pic_buf_t **pps_rec_list_l0,

    recon_pic_buf_t **pps_rec_list_l1,

    WORD32 num_ref_l0_active,

    WORD32 num_ref_l1_active,

    WORD32 num_ref,

    hme_ref_map_t *ps_ref_map)

{

    WORD32 min_ref, i, poc, ref_id_l0, ref_id_l1;

    /* tracks running count of ref pics */

    WORD32 ref_count = 0, i4_idr_gop_num;

    /* points to One instance of a ref pic structure */

    recon_pic_buf_t *ps_recon_pic;

    /* points to one instance of ref desc str used by ME */

    hme_ref_desc_t *ps_ref_desc;

    min_ref = MIN(num_ref_l0_active, num_ref_l1_active);

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

    {

        /* Create interleaved L0 and L1 entries */

        ps_ref_desc = &ps_ref_map->as_ref_desc[ref_count];

        ps_recon_pic = pps_rec_list_l0[i];

        poc = ps_recon_pic->i4_poc;

        i4_idr_gop_num = ps_recon_pic->i4_idr_gop_num;

        ref_id_l0 = i;

        ref_id_l1 = ihevce_me_find_poc_in_list(pps_rec_list_l1, poc, i4_idr_gop_num, num_ref);

        ihevc_me_update_ref_desc(ps_ref_desc, ps_recon_pic, ref_id_l0, ref_id_l1, 2 * i, 1);

        ref_count++;

        ps_ref_desc = &ps_ref_map->as_ref_desc[ref_count];

        ps_recon_pic = pps_rec_list_l1[i];

        poc = ps_recon_pic->i4_poc;

        i4_idr_gop_num = ps_recon_pic->i4_idr_gop_num;

        ref_id_l1 = i;

        ref_id_l0 = ihevce_me_find_poc_in_list(pps_rec_list_l0, poc, i4_idr_gop_num, num_ref);

        ihevc_me_update_ref_desc(ps_ref_desc, ps_recon_pic, ref_id_l0, ref_id_l1, 2 * i + 1, 0);

        ref_count++;

    }

    if(num_ref_l0_active > min_ref)

    {

        for(i = 0; i < (num_ref_l0_active - min_ref); i++)

        {

            ps_ref_desc = &ps_ref_map->as_ref_desc[ref_count];

            ref_id_l0 = i + min_ref;

            ps_recon_pic = pps_rec_list_l0[ref_id_l0];

            poc = ps_recon_pic->i4_poc;

            i4_idr_gop_num = ps_recon_pic->i4_idr_gop_num;

            ref_id_l1 = ihevce_me_find_poc_in_list(pps_rec_list_l1, poc, i4_idr_gop_num, num_ref);

            ihevc_me_update_ref_desc(

                ps_ref_desc, ps_recon_pic, ref_id_l0, ref_id_l1, 2 * min_ref + i, 1);

            ref_count++;

        }

    }

    else

    {

        for(i = 0; i < (num_ref_l1_active - min_ref); i++)

        {

            ps_ref_desc = &ps_ref_map->as_ref_desc[ref_count];

            ref_id_l1 = i + min_ref;

            ps_recon_pic = pps_rec_list_l1[ref_id_l1];

            poc = ps_recon_pic->i4_poc;

            i4_idr_gop_num = ps_recon_pic->i4_idr_gop_num;

            ref_id_l0 = ihevce_me_find_poc_in_list(pps_rec_list_l0, poc, i4_idr_gop_num, num_ref);

            ihevc_me_update_ref_desc(

                ps_ref_desc, ps_recon_pic, ref_id_l0, ref_id_l1, 2 * min_ref + i, 0);

            ref_count++;

        }

    }

    ps_ref_map->i4_num_ref = ref_count;

    ASSERT(ref_count == (num_ref_l0_active + num_ref_l1_active));

    /* TODO : Fill better values in lambda depending on ref dist */

    for(i = 0; i < ps_ref_map->i4_num_ref; i++)

        ps_ref_map->as_ref_desc[i].lambda = 20;

}

/*!

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

* \if Function name : ihevce_me_process \endif

*

* \brief

*    Frame level ME function

*

* \par Description:

*    Processing of all layers starting from coarse and going

*    to the refinement layers, all layers

*    that are encoded go CTB by CTB. Outputs of this function are populated

*    ctb_analyse_t structures, one per CTB.

*

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

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

* \param[in,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)

* \param[in]  pd_intra_costs : pointerto intra cost buffer

* \param[in]  ps_multi_thrd_ctxt : pointer to multi thread ctxt

* \param[in]  thrd_id : Thread id of the current thrd in which function is executed

*

* \return

*    None

*

* \author

*  Ittiam

*

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

*/

void ihevce_me_process(

    void *pv_me_ctxt,

    ihevce_lap_enc_buf_t *ps_enc_lap_inp,

    ctb_analyse_t *ps_ctb_out,

    me_enc_rdopt_ctxt_t *ps_cur_out_me_prms,

    double *pd_intra_costs,

    ipe_l0_ctb_analyse_for_me_t *ps_ipe_analyse_ctb,

    pre_enc_L0_ipe_encloop_ctxt_t *ps_l0_ipe_input,

    void *pv_coarse_layer,

    multi_thrd_ctxt_t *ps_multi_thrd_ctxt,

    WORD32 i4_frame_parallelism_level,

    WORD32 thrd_id,

    WORD32 i4_me_frm_id)

{

    me_ctxt_t *ps_thrd_ctxt;

    me_frm_ctxt_t *ps_ctxt;

    PF_EXT_UPDATE_FXN_T pf_ext_update_fxn;

    me_master_ctxt_t *ps_master_ctxt = (me_master_ctxt_t *)pv_me_ctxt;

    cur_ctb_cu_tree_t *ps_cu_tree_out = ps_cur_out_me_prms->ps_cur_ctb_cu_tree;

    me_ctb_data_t *ps_me_ctb_data_out = ps_cur_out_me_prms->ps_cur_ctb_me_data;

    layer_ctxt_t *ps_coarse_layer = (layer_ctxt_t *)pv_coarse_layer;

    pf_ext_update_fxn = (PF_EXT_UPDATE_FXN_T)ihevce_me_update_ctb_results;

    /* get the current thread ctxt pointer */

    ps_thrd_ctxt = ps_master_ctxt->aps_me_ctxt[thrd_id];

    ps_ctxt = ps_thrd_ctxt->aps_me_frm_prms[i4_me_frm_id];

    ps_ctxt->thrd_id = thrd_id;

    /* store the ctb out and cu out base pointers */

    ps_ctxt->ps_ctb_analyse_base = ps_ctb_out;

    ps_ctxt->ps_cu_tree_base = ps_cu_tree_out;

    ps_ctxt->ps_ipe_l0_ctb_frm_base = ps_ipe_analyse_ctb;

    ps_ctxt->ps_me_ctb_data_base = ps_me_ctb_data_out;

    ps_ctxt->ps_func_selector = &ps_master_ctxt->s_func_selector;

    /** currently in master context. Copying that to me context **/

    /* frame level processing function */

    hme_process_frm(

        (void *)ps_thrd_ctxt,

        ps_l0_ipe_input,

        &ps_master_ctxt->as_ref_map[i4_me_frm_id],

        &pd_intra_costs,

        &ps_master_ctxt->as_frm_prms[i4_me_frm_id],

        pf_ext_update_fxn,

        ps_coarse_layer,

        ps_multi_thrd_ctxt,

        i4_frame_parallelism_level,

        thrd_id,

        i4_me_frm_id);

}

/*!

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

* \if Function name : ihevce_me_frame_dpb_update \endif

*

* \brief

*    Frame level ME initialisation function

*

* \par Description:

*   Updation of ME's internal DPB

*    based on available ref list information

*

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

* \param[in] num_ref_l0 : Number of reference pics in L0 list

* \param[in] num_ref_l1 : Number of reference pics in L1 list

* \param[in] pps_rec_list_l0 : List of recon pics in L0 list

* \param[in] pps_rec_list_l1 : List of recon pics in L1 list

*

* \return

*    None

*

* \author

*  Ittiam

*

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

*/

void ihevce_me_frame_dpb_update(

    void *pv_me_ctxt,

    WORD32 num_ref_l0,

    WORD32 num_ref_l1,

    recon_pic_buf_t **pps_rec_list_l0,

    recon_pic_buf_t **pps_rec_list_l1,

    WORD32 i4_thrd_id)

{

    me_master_ctxt_t *ps_master_ctxt = (me_master_ctxt_t *)pv_me_ctxt;

    me_ctxt_t *ps_thrd0_ctxt;

    WORD32 a_pocs_to_remove[MAX_NUM_REF + 2];

    WORD32 i, i4_is_buffer_full;

    WORD32 i4_least_POC = 0x7FFFFFFF;

    WORD32 i4_least_GOP_num = 0x7FFFFFFF;

    me_ctxt_t *ps_ctxt;

    /* All processing done using shared / common memory across */

    /* threads is done using thrd ctxt */

    ps_thrd0_ctxt = ps_master_ctxt->aps_me_ctxt[i4_thrd_id];

    ps_ctxt = (me_ctxt_t *)ps_thrd0_ctxt;

    a_pocs_to_remove[0] = INVALID_POC;

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

    /* Updation of ME's DPB list. This involves the following steps:         */

    /* 1. Obtain list of active POCs maintained within ME.                   */

    /* 2. Search each of them in the ref list. Whatever is not found goes to */

    /*     the list to be removed. Note: a_pocs_buffered_in_me holds the     */

    /*    currently active POC list within ME. a_pocs_to_remove holds the    */

    /*    list of POCs to be removed, terminated by -1.                      */

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

    i4_is_buffer_full =

        hme_get_active_pocs_list((void *)ps_thrd0_ctxt, ps_master_ctxt->i4_num_me_frm_pllel);

    if(i4_is_buffer_full)

    {

        /* remove if any non-reference pictures are present */

        for(i = 0;

            i <

            (ps_ctxt->aps_me_frm_prms[0]->max_num_ref * ps_master_ctxt->i4_num_me_frm_pllel) + 1;

            i++)

        {

            if(ps_ctxt->as_ref_descr[i].aps_layers[0]->i4_is_reference == 0 &&

               ps_ctxt->as_ref_descr[i].aps_layers[0]->i4_non_ref_free == 1)

            {

                i4_least_POC = ps_ctxt->as_ref_descr[i].aps_layers[0]->i4_poc;

                i4_least_GOP_num = ps_ctxt->as_ref_descr[i].aps_layers[0]->i4_idr_gop_num;

            }

        }

        /* if all non reference pictures are removed, then find the least poc

        in the least gop number*/

        if(i4_least_POC == 0x7FFFFFFF)

        {

            ASSERT(i4_least_GOP_num == 0x7FFFFFFF);

            for(i = 0; i < (ps_ctxt->aps_me_frm_prms[0]->max_num_ref *

                            ps_master_ctxt->i4_num_me_frm_pllel) +

                               1;

                i++)

            {

                if(i4_least_GOP_num > ps_ctxt->as_ref_descr[i].aps_layers[0]->i4_idr_gop_num)

                {

                    i4_least_GOP_num = ps_ctxt->as_ref_descr[i].aps_layers[0]->i4_idr_gop_num;

                }

            }

            for(i = 0; i < (ps_ctxt->aps_me_frm_prms[0]->max_num_ref *

                            ps_master_ctxt->i4_num_me_frm_pllel) +

                               1;

                i++)

            {

                if(i4_least_POC > ps_ctxt->as_ref_descr[i].aps_layers[0]->i4_poc &&

                   ps_ctxt->as_ref_descr[i].aps_layers[0]->i4_idr_gop_num == i4_least_GOP_num)

                {

                    i4_least_POC = ps_ctxt->as_ref_descr[i].aps_layers[0]->i4_poc;

                }

            }

        }

        ASSERT(i4_least_POC != 0x7FFFFFFF);

        a_pocs_to_remove[0] = i4_least_POC;

        a_pocs_to_remove[1] = INVALID_POC;

    }

    /* Call the ME API to remove "outdated" POCs */

    hme_discard_frm(