/******************************************************************************
 *
 * 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_coarse_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_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_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 "ihevce_ipe_instr_set_router.h"
#include "ihevce_ipe_structs.h"
#include "hme_globals.h"
#include "hme_utils.h"
#include "hme_coarse.h"
#include "hme_refine.h"
#include "ihevce_me_pass.h"
#include "ihevce_coarse_me_pass.h"

/*****************************************************************************/
/* Function Definitions                                                      */
/*****************************************************************************/

/*!
******************************************************************************
* \if Function name : ihevce_coarse_me_get_num_mem_recs \endif
*
* \brief
*    Number of memory records are returned for ME module
*    Note : Include total mem. req. for HME + Total mem. req. for Dep Mngr for HME
*
* \return
*    Number of memory records
*
* \author
*  Ittiam
*
*****************************************************************************
*/
WORD32 ihevce_coarse_me_get_num_mem_recs()
{
    WORD32 hme_mem_recs = hme_coarse_num_alloc();
    WORD32 hme_dep_mngr_mem_recs = hme_coarse_dep_mngr_num_alloc();

    return ((hme_mem_recs + hme_dep_mngr_mem_recs));
}

/*!
******************************************************************************
* \if Function name : ihevce_coarse_me_get_mem_recs \endif
*
* \brief
*    Memory requirements are returned for coarse 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_coarse_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)
{
    hme_memtab_t as_memtabs[HME_COARSE_TOT_MEMTABS];
    WORD32 n_tabs, i;

    /* Init prms structure specific to HME */
    hme_init_prms_t s_hme_init_prms;

    //return (ihevce_coarse_me_get_num_mem_recs());
    /*************************************************************************/
    /* code flow: we call hme alloc function and then remap those memtabs    */
    /* to a different type of memtab structure.                              */
    /*************************************************************************/
    ASSERT(HME_COARSE_TOT_MEMTABS >= hme_coarse_num_alloc());

    /*************************************************************************/
    /* 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_coarse_alloc(&as_memtabs[0], &s_hme_init_prms);
    ASSERT(n_tabs == hme_coarse_num_alloc());

    /*************************************************************************/
    /* 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);
    }

    /*************************************************************************/
    /* --- HME Coarse sync Dep Mngr Mem requests --                          */
    /*************************************************************************/
    {
        WORD32 n_dep_tabs;

        ps_mem_tab += n_tabs;

        n_dep_tabs = hme_coarse_dep_mngr_alloc(
            ps_mem_tab, ps_init_prms, i4_mem_space, i4_num_proc_thrds, i4_resolution_id);

        ASSERT(n_dep_tabs == hme_coarse_dep_mngr_num_alloc());

        /* Update the total no. of mem tabs */
        n_tabs += n_dep_tabs;
    }

    return (n_tabs);
}

/*!
******************************************************************************
* \if Function name : ihevce_coarse_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_coarse_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,
    WORD32 i4_resolution_id,
    UWORD8 u1_is_popcnt_available)
{
    /* ME handle to be returned */
    void *pv_me_ctxt;
    WORD32 status;
    coarse_me_master_ctxt_t *ps_ctxt;

    /* 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[HME_COARSE_TOT_MEMTABS];
    WORD32 n_tabs, n_dep_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_coarse_num_alloc();
    ASSERT(HME_COARSE_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;
    status = hme_coarse_init(pv_me_ctxt, &as_memtabs[0], &s_hme_init_prms);
    ps_ctxt = (coarse_me_master_ctxt_t *)pv_me_ctxt;
    if(status == -1)
        return NULL;

    /*************************************************************************/
    /* --- HME sync Dep Mngr Mem init --                                     */
    /*************************************************************************/

    ps_mem_tab += n_tabs;

    n_dep_tabs = hme_coarse_dep_mngr_init(
        ps_mem_tab, ps_init_prms, pv_me_ctxt, pv_osal_handle, i4_num_proc_thrds, i4_resolution_id);
    ASSERT(n_dep_tabs <= hme_coarse_dep_mngr_num_alloc());

    n_tabs += n_dep_tabs;

    ihevce_me_instr_set_router(
        (ihevce_me_optimised_function_list_t *)ps_ctxt->pv_me_optimised_function_list,
        ps_init_prms->e_arch_type);

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

    return (pv_me_ctxt);
}

/*!
******************************************************************************
* \if Function name : ihevce_coarse_me_reg_thrds_sem \endif
*
* \brief
*    Intialization for ME context state structure with semaphores .
*
* \param[in] pv_me_ctxt : pointer to Coarse ME ctxt
* \param[in] ppv_sem_hdls : Array of semaphore handles
* \param[in] i4_num_proc_thrds : Number of processing threads
*
* \return
*   none
*
* \author
*  Ittiam
*
*****************************************************************************
*/
void ihevce_coarse_me_reg_thrds_sem(void *pv_me_ctxt, void **ppv_sem_hdls, WORD32 i4_num_proc_thrds)
{
    hme_coarse_dep_mngr_reg_sem(pv_me_ctxt, ppv_sem_hdls, i4_num_proc_thrds);

    return;
}

/*!
******************************************************************************
* \if Function name : ihevce_coarse_me_delete \endif
*
* \brief
*    Destroy Coarse ME module
* Note : Only Destroys the resources allocated in the module like
*   semaphore,etc. Memory free is done Separately using memtabs
*
* \param[in] pv_me_ctxt : pointer to Coarse ME ctxt
* \param[in] ps_init_prms : Create time static parameters
* \param[in] pv_osal_handle : Osal handle
*
* \return
*    None
*
* \author
*  Ittiam
*
*****************************************************************************
*/
void ihevce_coarse_me_delete(
    void *pv_me_ctxt, ihevce_static_cfg_params_t *ps_init_prms, WORD32 i4_resolution_id)
{
    /* --- HME sync Dep Mngr Delete --*/
    hme_coarse_dep_mngr_delete(pv_me_ctxt, ps_init_prms, i4_resolution_id);
}

/**
*******************************************************************************
* \if Function name : ihevce_coarse_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_coarse_me_set_resolution(
    void *pv_me_ctxt, WORD32 n_enc_layers, WORD32 *p_wd, WORD32 *p_ht)
{
    /* local variables */
    coarse_me_master_ctxt_t *ps_master_ctxt = (coarse_me_master_ctxt_t *)pv_me_ctxt;
    WORD32 thrds;

    for(thrds = 0; thrds < ps_master_ctxt->i4_num_proc_thrds; thrds++)
    {
        coarse_me_ctxt_t *ps_me_thrd_ctxt;

        ps_me_thrd_ctxt = ps_master_ctxt->aps_me_ctxt[thrds];

        hme_coarse_set_resolution((void *)ps_me_thrd_ctxt, n_enc_layers, p_wd, p_ht);
    }
}
void ihevce_coarse_me_get_rc_param(
    void *pv_me_ctxt,
    LWORD64 *i8_acc_frame_hme_cost,
    LWORD64 *i8_acc_frame_hme_sad,
    LWORD64 *i8_acc_num_blks_higher_sad,
    LWORD64 *i8_total_blks,
    WORD32 i4_is_prev_pic_same_scene)
{
    coarse_me_master_ctxt_t *ps_master_ctxt = (coarse_me_master_ctxt_t *)pv_me_ctxt;
    WORD32 thrds;
    coarse_me_ctxt_t *ps_me_thrd_ctxt;

    *i8_acc_frame_hme_cost = 0;
    *i8_acc_frame_hme_sad = 0;

    for(thrds = 0; thrds < ps_master_ctxt->i4_num_proc_thrds; thrds++)
    {
        ps_me_thrd_ctxt = ps_master_ctxt->aps_me_ctxt[thrds];
        *i8_acc_frame_hme_cost += ps_me_thrd_ctxt->i4_L1_hme_best_cost;

        /*Calculate me cost wrt. to ref only for P frame */
        if(ps_me_thrd_ctxt->s_frm_prms.is_i_pic == ps_me_thrd_ctxt->s_frm_prms.bidir_enabled)
        {
            *i8_acc_num_blks_higher_sad += ps_me_thrd_ctxt->i4_num_blks_high_sad;
            *i8_total_blks += ps_me_thrd_ctxt->i4_num_blks;
        }

        *i8_acc_frame_hme_sad += ps_me_thrd_ctxt->i4_L1_hme_sad;
    }
}

/*!
******************************************************************************
* \if Function name : ihevce_coarse_me_process \endif
*
* \brief
*    Frame level ME function
*
* \par Description:
*    Processing of all layers starting from coarse and going
*    to the refinement layers, except enocde layer
*
* \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_coarse_me_process(
    void *pv_me_ctxt,
    ihevce_lap_enc_buf_t *ps_enc_lap_inp,
    multi_thrd_ctxt_t *ps_multi_thrd_ctxt,
    WORD32 thrd_id,
    WORD32 i4_ping_pong)

{
    /* local variables */
    coarse_me_master_ctxt_t *ps_master_ctxt = (coarse_me_master_ctxt_t *)pv_me_ctxt;
    coarse_me_ctxt_t *ps_thrd_ctxt;

    /* get the current thread ctxt pointer */
    ps_thrd_ctxt = ps_master_ctxt->aps_me_ctxt[thrd_id];
    ps_thrd_ctxt->thrd_id = thrd_id;

    /* frame level processing function */
    hme_coarse_process_frm(
        (void *)ps_thrd_ctxt,
        &ps_master_ctxt->s_ref_map,
        &ps_master_ctxt->s_frm_prms,
        ps_multi_thrd_ctxt,
        i4_ping_pong,
        &ps_master_ctxt->apv_dep_mngr_hme_sync[0]);

    return;
}

/*!
******************************************************************************
* \if Function name : ihevce_coarse_me_frame_end \endif
*
* \brief
*    End of frame update function performs
*       - GMV collation
*       - Dynamic Search Range collation
*
* \param[in] pv_ctxt : pointer to ME module
*
* \return
*    None
*
* \author
*  Ittiam
*
*****************************************************************************
*/
void ihevce_coarse_me_frame_end(void *pv_me_ctxt)
{
    /* local variables */
    coarse_me_master_ctxt_t *ps_master_ctxt = (coarse_me_master_ctxt_t *)pv_me_ctxt;
    coarse_me_ctxt_t *ps_thrd0_ctxt;
    layer_ctxt_t *ps_curr_layer;
    WORD32 num_ref, num_thrds, cur_poc;
    WORD32 coarse_layer_id;
    WORD32 i4_num_ref;
    ME_QUALITY_PRESETS_T e_me_quality_preset;

    /* GMV collation is done for coarse Layer only */
    ps_thrd0_ctxt = ps_master_ctxt->aps_me_ctxt[0];
    coarse_layer_id = ps_thrd0_ctxt->num_layers - 1;
    ps_curr_layer = ps_thrd0_ctxt->ps_curr_descr->aps_layers[coarse_layer_id];
    i4_num_ref = ps_master_ctxt->s_ref_map.i4_num_ref;
    e_me_quality_preset = ps_thrd0_ctxt->s_init_prms.s_me_coding_tools.e_me_quality_presets;

    /* No processing is required if current pic is I pic */
    if(1 == ps_master_ctxt->s_frm_prms.is_i_pic)
    {
        return;
    }

    /* use thrd 0 ctxt to collate the GMVs histogram and Dynamic Search Range */
    /* across all threads */
    for(num_ref = 0; num_ref < i4_num_ref; num_ref++)
    {
        WORD32 i4_offset, i4_lobe_size, i4_layer_id;
        mv_hist_t *ps_hist_thrd0;
        dyn_range_prms_t *aps_dyn_range_prms_thrd0[MAX_NUM_LAYERS];

        ps_hist_thrd0 = ps_thrd0_ctxt->aps_mv_hist[num_ref];

        /* Only for P pic. For P, both are 0, I&B has them mut. exclusive */
        if(ps_thrd0_ctxt->s_frm_prms.is_i_pic == ps_thrd0_ctxt->s_frm_prms.bidir_enabled)
        {
            for(i4_layer_id = coarse_layer_id; i4_layer_id > 0; i4_layer_id--)
            {
                aps_dyn_range_prms_thrd0[i4_layer_id] =
                    &ps_thrd0_ctxt->s_coarse_dyn_range_prms.as_dyn_range_prms[i4_layer_id][num_ref];
            }
        }

        i4_lobe_size = ps_hist_thrd0->i4_lobe1_size;
        i4_offset = i4_lobe_size >> 1;

        /* run a loop over all the other threads to add up the histogram */
        /* and to update the dynamical search range                      */
        for(num_thrds = 1; num_thrds < ps_master_ctxt->i4_num_proc_thrds; num_thrds++)
        {
            dyn_range_prms_t *ps_dyn_range_prms;

            if(ME_XTREME_SPEED_25 != e_me_quality_preset)
            {
                mv_hist_t *ps_hist;
                WORD32 i4_y, i4_x;
                /* get current thrd histogram pointer */
                ps_hist = ps_master_ctxt->aps_me_ctxt[num_thrds]->aps_mv_hist[num_ref];

                /* Accumalate the Bin count for all the thread */
                for(i4_y = 0; i4_y < ps_hist_thrd0->i4_num_rows; i4_y++)
                {
                    for(i4_x = 0; i4_x < ps_hist_thrd0->i4_num_cols; i4_x++)
                    {
                        S32 i4_bin_id;

                        i4_bin_id = i4_x + (i4_y * ps_hist_thrd0->i4_num_cols);

                        ps_hist_thrd0->ai4_bin_count[i4_bin_id] +=
                            ps_hist->ai4_bin_count[i4_bin_id];
                    }
                }
            }

            /* Update the dynamical search range for each Layer              */
            /* Only for P pic. For P, both are 0, I&B has them mut. exclusive */
            if(ps_thrd0_ctxt->s_frm_prms.is_i_pic == ps_thrd0_ctxt->s_frm_prms.bidir_enabled)
            {
                for(i4_layer_id = coarse_layer_id; i4_layer_id > 0; i4_layer_id--)
                {
                    /* get current thrd, layer dynamical search range param. pointer */
                    ps_dyn_range_prms =
                        &ps_master_ctxt->aps_me_ctxt[num_thrds]
                             ->s_coarse_dyn_range_prms.as_dyn_range_prms[i4_layer_id][num_ref];
                    /* TODO : This calls can be optimized further. No need for min in 1st call and max in 2nd call */
                    hme_update_dynamic_search_params(
                        aps_dyn_range_prms_thrd0[i4_layer_id], ps_dyn_range_prms->i2_dyn_max_y);

                    hme_update_dynamic_search_params(
                        aps_dyn_range_prms_thrd0[i4_layer_id], ps_dyn_range_prms->i2_dyn_min_y);
                }
            }
        }
    }

    /*************************************************************************/
    /* Get the MAX/MIN per POC distance based on the all the ref. pics       */
    /*************************************************************************/
    /* Only for P pic. For P, both are 0, I&B has them mut. exclusive */
    if(ps_thrd0_ctxt->s_frm_prms.is_i_pic == ps_thrd0_ctxt->s_frm_prms.bidir_enabled)
    {
        WORD32 i4_layer_id;
        cur_poc = ps_thrd0_ctxt->i4_curr_poc;

        for(i4_layer_id = coarse_layer_id; i4_layer_id > 0; i4_layer_id--)
        {
            ps_thrd0_ctxt->s_coarse_dyn_range_prms.i2_dyn_max_y_per_poc[i4_layer_id] = 0;
            ps_thrd0_ctxt->s_coarse_dyn_range_prms.i2_dyn_min_y_per_poc[i4_layer_id] = 0;
        }

        for(num_ref = 0; num_ref < i4_num_ref; num_ref++)
        {
            for(i4_layer_id = coarse_layer_id; i4_layer_id > 0; i4_layer_id--)
            {
                WORD16 i2_mv_per_poc;
                WORD32 ref_poc, poc_diff;
                dyn_range_prms_t *ps_dyn_range_prms_thrd0;

                ps_dyn_range_prms_thrd0 =
                    &ps_thrd0_ctxt->s_coarse_dyn_range_prms.as_dyn_range_prms[i4_layer_id][num_ref];

                ref_poc = ps_dyn_range_prms_thrd0->i4_poc;
                ASSERT(ref_poc < cur_poc);
                poc_diff = (cur_poc - ref_poc);

                /* cur. ref. pic. max y per POC */
                i2_mv_per_poc = (ps_dyn_range_prms_thrd0->i2_dyn_max_y + (poc_diff - 1)) / poc_diff;
                /* update the max y per POC */
                ps_thrd0_ctxt->s_coarse_dyn_range_prms.i2_dyn_max_y_per_poc[i4_layer_id] =
                    MAX(ps_thrd0_ctxt->s_coarse_dyn_range_prms.i2_dyn_max_y_per_poc[i4_layer_id],
                        i2_mv_per_poc);

                /* cur. ref. pic. min y per POC */
                i2_mv_per_poc = (ps_dyn_range_prms_thrd0->i2_dyn_min_y - (poc_diff - 1)) / poc_diff;
                /* update the min y per POC */
                ps_thrd0_ctxt->s_coarse_dyn_range_prms.i2_dyn_min_y_per_poc[i4_layer_id] =
                    MIN(ps_thrd0_ctxt->s_coarse_dyn_range_prms.i2_dyn_min_y_per_poc[i4_layer_id],
                        i2_mv_per_poc);
            }
        }

        /*************************************************************************/
        /* Populate the results to all thread ctxt                               */
        /*************************************************************************/
        for(num_thrds = 1; num_thrds < ps_master_ctxt->i4_num_proc_thrds; num_thrds++)
        {
            for(i4_layer_id = coarse_layer_id; i4_layer_id > 0; i4_layer_id--)
            {
                ps_master_ctxt->aps_me_ctxt[num_thrds]
                    ->s_coarse_dyn_range_prms.i2_dyn_max_y_per_poc[i4_layer_id] =
                    ps_thrd0_ctxt->s_coarse_dyn_range_prms.i2_dyn_max_y_per_poc[i4_layer_id];

                ps_master_ctxt->aps_me_ctxt[num_thrds]
                    ->s_coarse_dyn_range_prms.i2_dyn_min_y_per_poc[i4_layer_id] =
                    ps_thrd0_ctxt->s_coarse_dyn_range_prms.i2_dyn_min_y_per_poc[i4_layer_id];
            }
        }
    }

    if(ME_XTREME_SPEED_25 != e_me_quality_preset)
    {
        /* call the function which calcualtes the GMV    */
        /* layer pointer is shared across all threads    */
        /* hence all threads will have access to updated */
        /* GMVs populated using thread 0 ctxt            */
        for(num_ref = 0; num_ref < i4_num_ref; num_ref++)
        {
            hme_calculate_global_mv(
                ps_thrd0_ctxt->aps_mv_hist[num_ref],
                &ps_curr_layer->s_global_mv[num_ref][GMV_THICK_LOBE],
                GMV_THICK_LOBE);
        }
    }
    return;
}

/*!
******************************************************************************
* \if Function name : ihevce_coarse_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_coarse_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)
{
    coarse_me_master_ctxt_t *ps_master_ctxt = (coarse_me_master_ctxt_t *)pv_me_ctxt;
    coarse_me_ctxt_t *ps_thrd0_ctxt;
    WORD32 a_pocs_buffered_in_me[MAX_NUM_REF + 1];
    WORD32 a_pocs_to_remove[MAX_NUM_REF + 2];
    WORD32 poc_remove_id = 0;
    WORD32 i, count;

    /* All processing done using shared / common memory across */
    /* threads is done using thrd ctxt */
    ps_thrd0_ctxt = ps_master_ctxt->aps_me_ctxt[0];

    /*************************************************************************/
    /* 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.                      */
    /*************************************************************************/
    hme_coarse_get_active_pocs_list((void *)ps_thrd0_ctxt, a_pocs_buffered_in_me);

    count = 0;
    while(a_pocs_buffered_in_me[count] != -1)
    {
        WORD32 poc_to_search = a_pocs_buffered_in_me[count];
        WORD32 match_found_flag = 0;

        /*********************************************************************/
        /* Search in any one list (L0/L1) since both lists contain all the   */
        /* active ref pics.                                                  */
        /*********************************************************************/
        for(i = 0; i < num_ref_l0; i++)
        {
            if(poc_to_search == pps_rec_list_l0[i]->i4_poc)
            {
                match_found_flag = 1;
                break;
            }
        }
        for(i = 0; i < num_ref_l1; i++)
        {
            if(poc_to_search == pps_rec_list_l1[i]->i4_poc)
            {
                match_found_flag = 1;
                break;
            }
        }

        if(0 == match_found_flag)
        {
            /*****************************************************************/
            /* POC buffered inside ME but not part of ref list given by DPB  */
            /* Hence this needs to be flagged to ME for removal.             */
            /*****************************************************************/
            a_pocs_to_remove[poc_remove_id] = poc_to_search;
            poc_remove_id++;
        }
        count++;
    }

    /* List termination */
    a_pocs_to_remove[poc_remove_id] = -1;

    /* Call the ME API to remove "outdated" POCs */
    hme_coarse_discard_frm(ps_thrd0_ctxt, a_pocs_to_remove);
}

/*!
******************************************************************************
* \if Function name : ihevce_coarse_me_frame_init \endif
*
* \brief
*    Coarse Frame level ME initialisation function
*
* \par Description:
*    The following pre-conditions exist for this function: a. We have the input
*    pic ready for encode, b. We have the reference list with POC, L0/L1 IDs
*    and ref ptrs ready for this picture and c. ihevce_me_set_resolution has
*    been called atleast once. Once these are supplied, the following are
*    done here: a. Input pyramid creation, b. Updation of ME's internal DPB
*    based on available ref list information
*
* \param[in] pv_ctxt : pointer to ME module
* \param[in] ps_frm_ctb_prms : CTB characteristics parameters
* \param[in] ps_frm_lamda : Frame level Lambda params
* \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] num_ref_l0_active : Active reference pics in L0 dir for current frame (shall be <= num_ref_l0)
* \param[in] num_ref_l1_active : Active reference pics in L1 dir for current frame (shall be <= num_ref_l1)
* \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
* \param[in] ps_enc_lap_inp  : pointer to input yuv buffer (frame buffer)
* \param[in] i4_frm_qp       : current picture QP
*
* \return
*    None
*
* \author
*  Ittiam
*
*****************************************************************************
*/
void ihevce_coarse_me_frame_init(
    void *pv_me_ctxt,
    ihevce_static_cfg_params_t *ps_stat_prms,
    frm_ctb_ctxt_t *ps_frm_ctb_prms,
    frm_lambda_ctxt_t *ps_frm_lamda,
    WORD32 num_ref_l0,
    WORD32 num_ref_l1,
    WORD32 num_ref_l0_active,
    WORD32 num_ref_l1_active,
    recon_pic_buf_t **pps_rec_list_l0,
    recon_pic_buf_t **pps_rec_list_l1,
    ihevce_lap_enc_buf_t *ps_enc_lap_inp,
    WORD32 i4_frm_qp,
    ihevce_ed_blk_t *ps_layer1_buf,  //EIID
    ihevce_ed_ctb_l1_t *ps_ed_ctb_l1,
    UWORD8 *pu1_me_reverse_map_info,
    WORD32 i4_temporal_layer_id)
{
    /* local variables */
    coarse_me_master_ctxt_t *ps_master_ctxt = (coarse_me_master_ctxt_t *)pv_me_ctxt;
    coarse_me_ctxt_t *ps_ctxt;
    coarse_me_ctxt_t *ps_thrd0_ctxt;
    WORD32 inp_poc, num_ref;
    WORD32 i;

    /* Input POC is derived from input buffer */
    inp_poc = ps_enc_lap_inp->s_lap_out.i4_poc;
    num_ref = num_ref_l0 + num_ref_l1;

    /* All processing done using shared / common memory across */
    /* threads is done using thrd 0 ctxt */
    ps_thrd0_ctxt = ps_master_ctxt->aps_me_ctxt[0];

    ps_master_ctxt->s_frm_prms.u1_num_active_ref_l0 = num_ref_l0_active;
    ps_master_ctxt->s_frm_prms.u1_num_active_ref_l1 = num_ref_l1_active;

    /* store the frm ctb ctxt to all the thrd ctxt */
    {
        WORD32 num_thrds;

        /* initialise the parameters for all the threads */
        for(num_thrds = 0; num_thrds < ps_master_ctxt->i4_num_proc_thrds; num_thrds++)
        {
            ps_ctxt = ps_master_ctxt->aps_me_ctxt[num_thrds];
            ps_ctxt->pv_ext_frm_prms = (void *)ps_frm_ctb_prms;
            /*EIID: early decision buffer pointer */
            ps_ctxt->ps_ed_blk = ps_layer1_buf;
            ps_ctxt->ps_ed_ctb_l1 = ps_ed_ctb_l1;

            /* weighted pred enable flag */
            ps_ctxt->i4_wt_pred_enable_flag = ps_enc_lap_inp->s_lap_out.i1_weighted_pred_flag |
                                              ps_enc_lap_inp->s_lap_out.i1_weighted_bipred_flag;

            if(1 == ps_ctxt->i4_wt_pred_enable_flag)
            {
                /* log2 weight denom  */
                ps_ctxt->s_wt_pred.wpred_log_wdc =
                    ps_enc_lap_inp->s_lap_out.i4_log2_luma_wght_denom;
            }
            else
            {
                /* default value */
                ps_ctxt->s_wt_pred.wpred_log_wdc = DENOM_DEFAULT;
            }
            ps_ctxt->i4_L1_hme_best_cost = 0;
            ps_ctxt->i4_L1_hme_sad = 0;
            ps_ctxt->i4_num_blks_high_sad = 0;
            ps_ctxt->i4_num_blks = 0;

            ps_ctxt->pv_me_optimised_function_list = ps_master_ctxt->pv_me_optimised_function_list;
            ps_ctxt->ps_cmn_utils_optimised_function_list = &ps_master_ctxt->s_cmn_opt_func;
        }
    }
    /* Create the reference map for ME */
    ihevce_me_create_ref_map(
        pps_rec_list_l0,
        pps_rec_list_l1,
        num_ref_l0_active,
        num_ref_l1_active,
        num_ref,
        &ps_master_ctxt->s_ref_map);
    /*************************************************************************/
    /* Call the ME frame level processing for further actiion.               */
    /* ToDo: Support Row Level API.                                          */
    /*************************************************************************/
    ps_master_ctxt->s_frm_prms.i2_mv_range_x = ps_thrd0_ctxt->s_init_prms.max_horz_search_range;
    ps_master_ctxt->s_frm_prms.i2_mv_range_y = ps_thrd0_ctxt->s_init_prms.max_vert_search_range;

    ps_master_ctxt->s_frm_prms.is_i_pic = 0;
    ps_master_ctxt->s_frm_prms.i4_temporal_layer_id = i4_temporal_layer_id;

    ps_master_ctxt->s_frm_prms.is_pic_second_field =
        (!(ps_enc_lap_inp->s_input_buf.i4_bottom_field ^
           ps_enc_lap_inp->s_input_buf.i4_topfield_first));
    {
        S32 pic_type = ps_enc_lap_inp->s_lap_out.i4_pic_type;

        /*********************************************************************/
        /* For I Pic, we do not call update fn at ctb level, instead we do   */
        /* one shot update for entire picture.                               */
        /*********************************************************************/
        if((pic_type == IV_I_FRAME) || (pic_type == IV_II_FRAME) || (pic_type == IV_IDR_FRAME))
        {
            ps_master_ctxt->s_frm_prms.is_i_pic = 1;
            ps_master_ctxt->s_frm_prms.bidir_enabled = 0;
        }
        else if((pic_type == IV_P_FRAME) || (pic_type == IV_PP_FRAME))
        {
            ps_master_ctxt->s_frm_prms.bidir_enabled = 0;
        }
        else if((pic_type == IV_B_FRAME) || (pic_type == IV_BB_FRAME))
        {
            ps_master_ctxt->s_frm_prms.bidir_enabled = 1;
        }
        else
        {
            /* not sure whether we need to handle mixed frames like IP, */
            /* they should ideally come as single field. */
            /* TODO : resolve thsi ambiguity */
            ASSERT(0);
        }
    }
    /************************************************************************/
    /* Lambda calculations moved outside ME and to one place, so as to have */
    /* consistent lambda across ME, IPE, CL RDOPT etc                       */
    /************************************************************************/

    {
#define CLIP3_F(min, max, val) (((val) < (min)) ? (min) : (((val) > (max)) ? (max) : (val)))
        double q_steps[6] = { 0.625, 0.703, 0.79, 0.889, 1.0, 1.125 };
        double d_b_pic_factor;
        double d_q_factor;
        //double d_lambda;
        UWORD8 u1_temp_hier = ps_enc_lap_inp->s_lap_out.i4_temporal_lyr_id;

        if(u1_temp_hier)
        {
            d_b_pic_factor = CLIP3_F(2.0, 4.0, (i4_frm_qp - 12.0) / 6.0);
        }
        else
            d_b_pic_factor = 1.0;

        d_q_factor = (1 << (i4_frm_qp / 6)) * q_steps[i4_frm_qp % 6];
        ps_master_ctxt->s_frm_prms.qstep = (WORD32)d_q_factor;
        ps_master_ctxt->s_frm_prms.i4_frame_qp = i4_frm_qp;
    }

    /* HME Dependency Manager : Reset the num ctb processed in every row */
    /* for ME sync in every layer                                        */
    {
        WORD32 ctr;
        for(ctr = 1; ctr < ps_thrd0_ctxt->num_layers; ctr++)
        {
            void *pv_dep_mngr_state;
            pv_dep_mngr_state = ps_master_ctxt->apv_dep_mngr_hme_sync[ctr - 1];

            ihevce_dmgr_rst_row_row_sync(pv_dep_mngr_state);
        }
    }

    /* Frame level init of all threads of ME */
    {
        WORD32 num_thrds;

        /* initialise the parameters for all the threads */
        for(num_thrds = 0; num_thrds < ps_master_ctxt->i4_num_proc_thrds; num_thrds++)
        {
            ps_ctxt = ps_master_ctxt->aps_me_ctxt[num_thrds];

            hme_coarse_process_frm_init(
                (void *)ps_ctxt, ps_ctxt->ps_hme_ref_map, ps_ctxt->ps_hme_frm_prms);
        }
    }

    ps_master_ctxt->s_frm_prms.i4_cl_sad_lambda_qf = ps_frm_lamda->i4_cl_sad_lambda_qf;
    ps_master_ctxt->s_frm_prms.i4_cl_satd_lambda_qf = ps_frm_lamda->i4_cl_satd_lambda_qf;
    ps_master_ctxt->s_frm_prms.i4_ol_sad_lambda_qf = ps_frm_lamda->i4_ol_sad_lambda_qf;
    ps_master_ctxt->s_frm_prms.i4_ol_satd_lambda_qf = ps_frm_lamda->i4_ol_satd_lambda_qf;
    ps_master_ctxt->s_frm_prms.lambda_q_shift = LAMBDA_Q_SHIFT;

    ps_master_ctxt->s_frm_prms.pf_interp_fxn = NULL;

    /*************************************************************************/
    /* If num ref is 0, that means that it has to be coded as I. Do nothing  */
    /* However mv bank update needs to happen with "intra" mv.               */
    /*************************************************************************/
    if(ps_master_ctxt->s_ref_map.i4_num_ref == 0 || ps_master_ctxt->s_frm_prms.is_i_pic)
    {
        for(i = 1; i < ps_thrd0_ctxt->num_layers; i++)
        {
            layer_ctxt_t *ps_layer_ctxt = ps_thrd0_ctxt->ps_curr_descr->aps_layers[i];
            BLK_SIZE_T e_blk_size;
            S32 use_4x4;

            /* The mv bank is filled with "intra" mv */
            use_4x4 = hme_get_mv_blk_size(
                ps_thrd0_ctxt->s_init_prms.use_4x4,
                i,
                ps_thrd0_ctxt->num_layers,
                ps_thrd0_ctxt->u1_encode[i]);
            e_blk_size = use_4x4 ? BLK_4x4 : BLK_8x8;
            hme_init_mv_bank(ps_layer_ctxt, e_blk_size, 2, 1, ps_ctxt->u1_encode[i]);
            hme_fill_mvbank_intra(ps_layer_ctxt);

            /* Clear out the global mvs */
            memset(
                ps_layer_ctxt->s_global_mv,
                0,
                sizeof(hme_mv_t) * ps_thrd0_ctxt->max_num_ref * NUM_GMV_LOBES);
        }

        return;
    }

    /*************************************************************************/
    /* Coarse & refine Layer frm init (layer mem is common across thrds)     */
    /*************************************************************************/
    {
        coarse_prms_t s_coarse_prms;
        refine_prms_t s_refine_prms;
        S16 i2_max;
        S32 layer_id;

        layer_id = ps_thrd0_ctxt->num_layers - 1;
        i2_max = ps_thrd0_ctxt->ps_curr_descr->aps_layers[layer_id]->i2_max_mv_x;
        i2_max = MAX(i2_max, ps_thrd0_ctxt->ps_curr_descr->aps_layers[layer_id]->i2_max_mv_y);
        s_coarse_prms.i4_layer_id = layer_id;

        {
            S32 log_start_step;
            /* Based on Preset, set the starting step size for Refinement */
            if(ME_MEDIUM_SPEED > ps_ctxt->s_init_prms.s_me_coding_tools.e_me_quality_presets)
            {
                log_start_step = 0;
            }
            else
            {
                log_start_step = 1;
            }
            s_coarse_prms.i4_max_iters = i2_max >> log_start_step;
            s_coarse_prms.i4_start_step = 1 << log_start_step;
        }
        s_coarse_prms.i4_num_ref = ps_master_ctxt->s_ref_map.i4_num_ref;
        s_coarse_prms.do_full_search = 1;
        s_coarse_prms.num_results = ps_thrd0_ctxt->max_num_results_coarse;

        hme_coarse_frm_init(ps_thrd0_ctxt, &s_coarse_prms);

        layer_id--;

        /*************************************************************************/
        /* This loop will run for all refine layers (non- encode layers)          */
        /*************************************************************************/
        while(layer_id > 0)
        {
            layer_ctxt_t *ps_curr_layer;
            layer_ctxt_t *ps_coarse_layer;

            ps_coarse_layer = ps_thrd0_ctxt->ps_curr_descr->aps_layers[layer_id + 1];

            ps_curr_layer = ps_thrd0_ctxt->ps_curr_descr->aps_layers[layer_id];

            hme_set_refine_prms(
                &s_refine_prms,
                ps_thrd0_ctxt->u1_encode[layer_id],
                ps_master_ctxt->s_ref_map.i4_num_ref,
                layer_id,
                ps_thrd0_ctxt->num_layers,
                ps_thrd0_ctxt->num_layers_explicit_search,
                ps_thrd0_ctxt->s_init_prms.use_4x4,
                &ps_master_ctxt->s_frm_prms,
                NULL,
                &ps_thrd0_ctxt->s_init_prms.s_me_coding_tools);

            hme_refine_frm_init(ps_curr_layer, &s_refine_prms, ps_coarse_layer);

            layer_id--;
        }
    }

    return;
}

/*!
******************************************************************************
* \if Function name : ihevce_decomp_pre_intra_frame_init \endif
*
* \brief
*    Frame Intialization for Decomp intra pre analysis.
*
* \param[in] pv_ctxt : pointer to module ctxt
* \param[in] ppu1_decomp_lyr_bufs : pointer to array of layer buffer pointers
* \param[in] pi4_lyr_buf_stride : pointer to array of layer buffer strides
*
* \return
*    None
*
* \author
*  Ittiam
*
*****************************************************************************
*/
WORD32 ihevce_coarse_me_get_lyr_buf_desc(
    void *pv_me_ctxt, UWORD8 **ppu1_decomp_lyr_bufs, WORD32 *pi4_lyr_buf_stride)
{
    /* local variables */
    coarse_me_master_ctxt_t *ps_master_ctxt = (coarse_me_master_ctxt_t *)pv_me_ctxt;
    coarse_me_ctxt_t *ps_thrd0_ctxt;
    WORD32 lyr_no;
    layers_descr_t *ps_curr_descr;
    WORD32 i4_free_idx;

    /* All processing done using shared / common memory across */
    /* threads is done using thrd0  ctxt */
    ps_thrd0_ctxt = ps_master_ctxt->aps_me_ctxt[0];

    /* Obtain an empty layer descriptor */
    i4_free_idx = hme_coarse_find_free_descr_idx((void *)ps_thrd0_ctxt);

    ps_curr_descr = &ps_thrd0_ctxt->as_ref_descr[i4_free_idx];

    /* export all the layer buffers except Layer 0 (encode layer) */
    for(lyr_no = 1; lyr_no < ps_thrd0_ctxt->num_layers; lyr_no++)
    {
        pi4_lyr_buf_stride[lyr_no - 1] = ps_curr_descr->aps_layers[lyr_no]->i4_inp_stride;
        ppu1_decomp_lyr_bufs[lyr_no - 1] = ps_curr_descr->aps_layers[lyr_no]->pu1_inp;
    }

    return (i4_free_idx);
}

/*!
******************************************************************************
* \if Function name : ihevce_coarse_me_get_lyr_prms_job_que \endif
*
* \brief Returns to the caller key attributes related to dependency between layers
*          for multi-thread execution
*
*
* \par Description:
*    This function requires the precondition that the width and ht of encode
*    layer is known, and ME API ihevce_me_set_resolution() API called with
*    this info. Based on this, ME populates useful information for the encoder
*    to execute the multi-thread (concurrent across layers) in this API.
*    The number of layers, number of vertical units in each layer, and for
*    each vertial unit in each layer, its dependency on previous layer's units
*    From ME's perspective, a vertical unit is one which is smallest min size
*    vertically (and spans the entire row horizontally). This is CTB for encode
*    layer, and 8x8 / 4x4 for non encode layers.
*
* \param[in] pv_ctxt : ME handle
* \param[in] ps_curr_inp : Input buffer descriptor
* \param[out] pi4_num_hme_lyrs : Num of HME layers (ME updates)
* \param[out] pi4_num_vert_units_in_lyr : Array of size N (num layers), each
*                     entry has num vertical units in that particular layer
* \param[in] ps_me_job_q_prms : Array of job queue prms, one for each unit in a
*                 layer. Note that this is contiguous in order of processing
*                 All k units of layer N-1 from top to bottom, followed by
*                 all m units of layer N-2 .... ends with X units of layer 0
*
* \return
*    None
*
* \author
*  Ittiam
*
*****************************************************************************
*/
void ihevce_coarse_me_get_lyr_prms_job_que(
    void *pv_me_ctxt,
    ihevce_lap_enc_buf_t *ps_curr_inp,
    WORD32 *pi4_num_hme_lyrs,
    WORD32 *pi4_num_vert_units_in_lyr,
    multi_thrd_me_job_q_prms_t *ps_me_job_q_prms)
{
    coarse_me_ctxt_t *ps_ctxt;
    coarse_me_master_ctxt_t *ps_master_ctxt = (coarse_me_master_ctxt_t *)pv_me_ctxt;

    /* These arrays and ptrs track input dependencies for units of a layer */
    /* This is a ping poing design, while using one part, we update other part */
    U08 au1_inp_dep[2][MAX_NUM_VERT_UNITS_FRM];
    U08 *pu1_inp_dep_c, *pu1_inp_dep_n;

    /* Height of current and next layers */
    S32 ht_c, ht_n;

    /* Blk ht at a given layer and next layer*/
    S32 unit_ht_c, unit_ht_n, blk_ht_c, blk_ht_n;

    /* Number of vertical units in current and next layer */
    S32 num_vert_c, num_vert_n;

    S32 ctb_size = 64, num_layers, i, j, k;

    /* since same layer desc pointer is stored in all thread ctxt */
    /* a free idx is obtained using 0th thread ctxt pointer */
    ps_ctxt = ps_master_ctxt->aps_me_ctxt[0];

    /* Set the number of layers */
    num_layers = ps_ctxt->num_layers;
    *pi4_num_hme_lyrs = num_layers;

    pu1_inp_dep_c = &au1_inp_dep[0][0];
    pu1_inp_dep_n = &au1_inp_dep[1][0];

    ASSERT(num_layers >= 2);

    ht_n = ps_ctxt->a_ht[num_layers - 2];
    ht_c = ps_ctxt->a_ht[num_layers - 1];

    /* compute blk ht and unit ht for c and n */
    if(ps_ctxt->u1_encode[num_layers - 1])
    {
        blk_ht_c = 16;
        unit_ht_c = ctb_size;
    }
    else
    {
        blk_ht_c = hme_get_blk_size(ps_ctxt->s_init_prms.use_4x4, num_layers - 1, num_layers, 0);
        unit_ht_c = blk_ht_c;
    }

    num_vert_c = (ht_c + unit_ht_c - 1) / unit_ht_c;

    /* For new design in Coarsest HME layer we need */
    /* one additional row extra at the end of frame */
    /* hence num_vert_c is incremented by 1         */
    num_vert_c++;

    /* Dummy initialization outside loop, not used first time */
    memset(pu1_inp_dep_c, 0, num_vert_c);

    /*************************************************************************/
    /* Run through each layer, set the number of vertical units and job queue*/
    /* attrs for each vert unit in the layer                                 */
    /*************************************************************************/
    for(i = num_layers - 1; i > 0; i--)
    {
        /* 0th entry is actually layer id num_layers - 1 */
        /* and entry num_layers-1 equals the biggest layer (id = 0) */
        pi4_num_vert_units_in_lyr[num_layers - 1 - i] = num_vert_c;
        /* "n" is computed for first time */
        ht_n = ps_ctxt->a_ht[i - 1];
        blk_ht_n = hme_get_blk_size(ps_ctxt->s_init_prms.use_4x4, i - 1, num_layers, 0);
        unit_ht_n = blk_ht_n;
        if(ps_ctxt->u1_encode[i - 1])
            unit_ht_n = ctb_size;

        num_vert_n = (ht_n + unit_ht_n - 1) / unit_ht_n;
        /* Initialize all units' inp dep in next layer to 0 */
        memset(pu1_inp_dep_n, 0, num_vert_n * sizeof(U08));

        /* Evaluate dependencies for this layer */
        for(j = 0; j < num_vert_c; j++)
        {
            S32 v1, v2;

            /* Output dependencies. When one unit in current layer finishes, */
            /* how many in the next layer it affects?. Assuming that the top */
            /* of this vertical unit and bottom of this vertical unit project*/
            /* somewhere in the next layer. The top of this vertical unit    */
            /* becomes the bottom right point for somebody, and the bottom of*/
            /* this vertical unit becomes the colocated pt for somebody, this*/
            /* is the extremum.                                              */

            /* for the initial unit affected by j in "c" layer, take j-1th   */
            /* unit top and project it.                                      */
            v1 = (j - 1) * unit_ht_c * ht_n;
            v1 /= (ht_c * unit_ht_n);
            v1 -= 1;

            /* for the final unit affected by j in "c" layer, take jth unit  */
            /* bottom and project it.                                        */

            v2 = (j + 1) * unit_ht_c * ht_n;
            v2 /= (ht_c * unit_ht_n);
            v2 += 1;

            /* Clip to be within valid limits */
            v1 = HME_CLIP(v1, 0, (num_vert_n - 1));
            v2 = HME_CLIP(v2, 0, (num_vert_n - 1));

            /* In the layer "n", units starting at offset v1, and upto v2 are*/
            /* dependent on unit j of layer "c". So for each of these units  */
            /* increment the dependency by 1 corresponding to "jth" unit in  */
            /* layer "c"                                                     */
            ps_me_job_q_prms->i4_num_output_dep = v2 - v1 + 1;
            ASSERT(ps_me_job_q_prms->i4_num_output_dep <= MAX_OUT_DEP);
            for(k = v1; k <= v2; k++)
                pu1_inp_dep_n[k]++;

            /* Input dependency would have been calculated in prev run */
            ps_me_job_q_prms->i4_num_inp_dep = pu1_inp_dep_c[j];
            ASSERT(ps_me_job_q_prms->i4_num_inp_dep <= MAX_OUT_DEP);

            /* Offsets */
            for(k = v1; k <= v2; k++)
                ps_me_job_q_prms->ai4_out_dep_unit_off[k - v1] = k;

            ps_me_job_q_prms++;
        }

        /* Compute the blk size and vert unit size in each layer             */
        /* "c" denotes curr layer, and "n" denotes the layer to which result */
        /* is projected to                                                   */
        ht_c = ht_n;
        blk_ht_c = blk_ht_n;
        unit_ht_c = unit_ht_n;
        num_vert_c = num_vert_n;

        /* Input dep count for next layer was computed this iteration. */
        /* Swap so that p_inp_dep_n becomes current for next iteration, */
        /* and p_inp_dep_c will become update area during next iteration */
        /* for next to next.                                             */
        {
            U08 *pu1_tmp = pu1_inp_dep_n;
            pu1_inp_dep_n = pu1_inp_dep_c;
            pu1_inp_dep_c = pu1_tmp;
        }
    }

    /* LAYER 0 OR ENCODE LAYER UPDATE : NO OUTPUT DEPS */

    /* set the numebr of vertical units */
    pi4_num_vert_units_in_lyr[num_layers - 1] = num_vert_c;
    for(j = 0; j < num_vert_c; j++)
    {
        /* Here there is no output dependency for ME. However this data is used for encode, */
        /* and there is a 1-1 correspondence between this and the encode     */
        /* Hence we set output dependency of 1 */
        ps_me_job_q_prms->i4_num_output_dep = 1;
        ps_me_job_q_prms->ai4_out_dep_unit_off[0] = j;
        ps_me_job_q_prms->i4_num_inp_dep = pu1_inp_dep_c[j];
        ASSERT(ps_me_job_q_prms->i4_num_inp_dep <= MAX_OUT_DEP);
        ps_me_job_q_prms++;
    }

    return;
}

/*!
******************************************************************************
* \if Function name : ihevce_coarse_me_set_lyr1_mv_bank \endif
*
* \brief
*    Frame level ME initialisation of MV bank of penultimate layer
*
* \par Description:
*    Updates the Layer1 context with the given buffers
*
* \param[in] pv_me_ctxt : pointer to ME module
* \param[in] pu1_mv_bank : MV bank buffer pointer
* \param[in] pu1_ref_idx_bank : refrence bank buffer pointer
*
* \return
*    None
*
* \author
*  Ittiam
*
*****************************************************************************
*/
void ihevce_coarse_me_set_lyr1_mv_bank(
    void *pv_me_ctxt,
    ihevce_lap_enc_buf_t *ps_enc_lap_inp,
    void *pv_mv_bank,
    void *pv_ref_idx_bank,
    WORD32 i4_curr_idx)
{
    coarse_me_ctxt_t *ps_thrd0_ctxt;
    coarse_me_master_ctxt_t *ps_master_ctxt = (coarse_me_master_ctxt_t *)pv_me_ctxt;
    layer_ctxt_t *ps_lyr1_ctxt;

    /* Input descriptor that is updated and passed to ME */
    hme_inp_desc_t s_inp_desc;

    /*************************************************************************/
    /* Add the current input to ME's DPB. This will also create the pyramids */
    /* for the HME layers tha are not "encoded".                             */
    /*************************************************************************/
    s_inp_desc.i4_poc = ps_enc_lap_inp->s_lap_out.i4_poc;
    s_inp_desc.s_layer_desc[0].pu1_y = (UWORD8 *)ps_enc_lap_inp->s_lap_out.s_input_buf.pv_y_buf;
    s_inp_desc.s_layer_desc[0].pu1_u = (UWORD8 *)ps_enc_lap_inp->s_lap_out.s_input_buf.pv_u_buf;
    s_inp_desc.s_layer_desc[0].pu1_v = (UWORD8 *)ps_enc_lap_inp->s_lap_out.s_input_buf.pv_v_buf;

    s_inp_desc.s_layer_desc[0].luma_stride = ps_enc_lap_inp->s_lap_out.s_input_buf.i4_y_strd;
    s_inp_desc.s_layer_desc[0].chroma_stride = ps_enc_lap_inp->s_lap_out.s_input_buf.i4_uv_strd;

    hme_coarse_add_inp(pv_me_ctxt, &s_inp_desc, i4_curr_idx);

    /* All processing done using shared / common memory across */
    /* threads is done using thrd 0 ctxt since layer ctxt is shared accross all threads */
    ps_thrd0_ctxt = ps_master_ctxt->aps_me_ctxt[0];

    ps_lyr1_ctxt = ps_thrd0_ctxt->ps_curr_descr->aps_layers[1];

    /* register the mv bank & ref idx bank pointer */
    ps_lyr1_ctxt->ps_layer_mvbank->pi1_ref_idx_base = (S08 *)pv_ref_idx_bank;
    ps_lyr1_ctxt->ps_layer_mvbank->ps_mv_base = (hme_mv_t *)pv_mv_bank;

    return;
}

/*!
******************************************************************************
* \if Function name : ihevce_coarse_me_get_lyr1_ctxt \endif
*
* \brief
*    function to get teh Layer 1 properties to be passed on the encode layer
*
* \par Description:
*    Ucopies the enitre layer ctxt emory to the destination
*
* \param[in] pv_me_ctxt : pointer to ME module
* \param[in] pu1_mv_bank : MV bank buffer pointer
* \param[in] pu1_ref_idx_bank : refrence bank buffer pointer
*
* \return
*    None
*
* \author
*  Ittiam
*
*****************************************************************************
*/
void ihevce_coarse_me_get_lyr1_ctxt(
    void *pv_me_ctxt, void *pv_layer_ctxt, void *pv_layer_mv_bank_ctxt)
{
    coarse_me_ctxt_t *ps_thrd0_ctxt;
    coarse_me_master_ctxt_t *ps_master_ctxt = (coarse_me_master_ctxt_t *)pv_me_ctxt;
    layer_ctxt_t *ps_lyr1_ctxt;

    /* All processing done using shared / common memory across */
    /* threads is done using thrd 0 ctxt since layer ctxt is shared accross all threads */
    ps_thrd0_ctxt = ps_master_ctxt->aps_me_ctxt[0];

    /* get the context of layer 1 */
    ps_lyr1_ctxt = ps_thrd0_ctxt->ps_curr_descr->aps_layers[1];

    /* copy the layer ctxt eve registerd mv bank & ref idx bank also goes in */
    memcpy(pv_layer_ctxt, ps_lyr1_ctxt, sizeof(layer_ctxt_t));

    /* copy the layer mv bank contents */
    memcpy(pv_layer_mv_bank_ctxt, ps_lyr1_ctxt->ps_layer_mvbank, sizeof(layer_mv_t));

    /* register the MV bank pointer in the layer ctxt*/
    ((layer_ctxt_t *)pv_layer_ctxt)->ps_layer_mvbank = (layer_mv_t *)pv_layer_mv_bank_ctxt;

    return;
}