xref: /aosp_15_r20/external/libhevc/encoder/hme_interface.h (revision c83a76b084498d55f252f48b2e3786804cdf24b7)

/******************************************************************************
 *
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *****************************************************************************
 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
*/
/*!
******************************************************************************
* \file hme_interface.h
*
* \brief
*    Interfaces exported by ME to the world outside of ME
*
* \date
*    18/09/2012
*
* \author
*    Ittiam
*
******************************************************************************
*/

#ifndef _HME_INTERFACE_H_
#define _HME_INTERFACE_H_

/*****************************************************************************/
/* Constant Macros                                                           */
/*****************************************************************************/

/**
******************************************************************************
 *  @brief      Maximum number of layers allowed
******************************************************************************
 */
#define MAX_NUM_LAYERS 4

/**
******************************************************************************
 *  @brief      layer max dimensions
******************************************************************************
 */
#define HME_MAX_WIDTH 1920
#define HME_MAX_HEIGHT 1088

/**
******************************************************************************
 *  @brief      layer min dimensions
******************************************************************************
 */
#define MIN_WD_COARSE 16
#define MIN_HT_COARSE 16

/**
******************************************************************************
 *  @brief     HME COARSE LAYER STEP SIZE
******************************************************************************
 */

#define HME_COARSE_STEP_SIZE_HIGH_SPEED 4
#define HME_COARSE_STEP_SIZE_HIGH_QUALITY 2

/**
******************************************************************************
 *  @brief      Memtabs required by layer ctxt: each layer ctxt requires 1
 *               memtab for itslf, 1 for mv bank, 1 for ref idx bank, one
 *               for input bufffer and 1 for storing segmentation info in
 *               worst case
******************************************************************************
 */
#define HME_MEMTABS_COARSE_LAYER_CTXT (5 * (MAX_NUM_LAYERS - 1) * (MAX_NUM_REF + 1))

/**
******************************************************************************
 *  @brief      Total number of memtabs reuqired by HME. Atleast 22 memtabs
 *              for different search results structure, 2*MAX_NUM_REF memtabs
 *              for search nodes maintaining coarse layer results in prev
 *              row, and for histograms. Memtabs reqd for layer,me ctxt
 *              ctb node mgr and buf mgr plus some 8 for safety
 *              if multi threaded then some memtabs will be more
******************************************************************************
 */
#define HME_COARSE_TOT_MEMTABS                                                                     \
    (22 + HME_MEMTABS_COARSE_LAYER_CTXT + (3 * MAX_NUM_REF) + 8 * MAX_NUM_FRM_PROC_THRDS_PRE_ENC + \
     1)

/**
******************************************************************************
 *  @brief      Memtabs required by layer ctxt (enc): each layer ctxt requires 1
 *               memtab for itslf, 1 for mv bank, 1 for ref idx bank, one
 *               for input bufffer and 1 for storing segmentation info in
 *               worst case
******************************************************************************
 */
#define MIN_HME_MEMTABS_ENC_LAYER_CTXT (5 * 1 * (MAX_NUM_REF + 1))

#define MAX_HME_MEMTABS_ENC_LAYER_CTXT (5 * 1 * (MAX_NUM_REF + 1 + MAX_NUM_ME_PARALLEL))

/**
******************************************************************************
 *  @brief      Total number of memtabs reuqired by HME. Atleast 22 memtabs
 *              for different search results structure, 2*MAX_NUM_REF memtabs
 *              for search nodes maintaining coarse layer results in prev
 *              row, and for histograms. Memtabs reqd for layer,me ctxt
 *              ctb node mgr and buf mgr plus some 8 for safety
 *              if multi threaded then some memtabs will be more
******************************************************************************
 */

#define MIN_HME_ENC_TOT_MEMTABS                                                                    \
    (22 + MIN_HME_MEMTABS_ENC_LAYER_CTXT + (3 * MAX_NUM_REF) + 28 * MAX_NUM_FRM_PROC_THRDS_ENC +   \
     2 /* Clustering */ + 1 /*traqo*/ + 1 /* ME Optimised Function List */)

#define MAX_HME_ENC_TOT_MEMTABS                                                                    \
    ((22 * MAX_NUM_ME_PARALLEL) + MAX_HME_MEMTABS_ENC_LAYER_CTXT +                                 \
     (3 * MAX_NUM_REF * MAX_NUM_ME_PARALLEL) +                                                     \
     28 * MAX_NUM_FRM_PROC_THRDS_ENC * MAX_NUM_ME_PARALLEL + 2 /* Clustering */ + 1 /*traqo*/ +    \
     1 /* ME Optimised Function List */)

/*****************************************************************************/
/* Enumerations                                                              */
/*****************************************************************************/
/**
******************************************************************************
 *  @enum     HME_MEM_ATTRS_T
 *  @brief      Contains type of memory: scratch, scratch ovly, persistent
******************************************************************************
 */
typedef enum
{
    HME_SCRATCH_MEM,
    HME_SCRATCH_OVLY_MEM,
    HME_PERSISTENT_MEM
} HME_MEM_ATTRS_T;

/**
******************************************************************************
 *  @enum     ME_QUALITY_PRESETS_T
 *  @brief    Describes the source for values in me_quality_params_t struct
******************************************************************************
 */
typedef enum
{
    ME_PRISTINE_QUALITY = 0,
    ME_HIGH_QUALITY = 2,
    ME_MEDIUM_SPEED,
    ME_HIGH_SPEED,
    ME_XTREME_SPEED,
    ME_XTREME_SPEED_25
} ME_QUALITY_PRESETS_T;

/*****************************************************************************/
/* Structures                                                                */
/*****************************************************************************/

/**
******************************************************************************
 *  @struct     hme_ref_buf_info_t
 *  @brief      Contains all required information of a ref picture
 *              Valid for a given layer.
******************************************************************************
 */
typedef struct
{
    /** Amt of padding in X direction both sides. */
    U08 u1_pad_x;

    /** Amt of padding in Y direction both sides */
    U08 u1_pad_y;

    /** Recon stride, in pixels */
    S32 luma_stride;

    /** Offset w.r.t. actual start of the buffer */
    S32 luma_offset;

    /** Src ptrs of the reference pictures*/
    U08 *pu1_ref_src;

    /** Reference ptrs for fpel plane, needed for this layer closed loop ME */
    U08 *pu1_rec_fxfy;

    /** Reference ptrs for hxfy plane (x = k+0.5, y = m) */
    U08 *pu1_rec_hxfy;

    /** Reference ptrs for fxhy plane (x = k, y = m + 0.5 */
    U08 *pu1_rec_fxhy;

    /** Reference ptrs for hxhy plane (x = k + 0.5, y = m + 0.5 */
    U08 *pu1_rec_hxhy;

    /** Reference ptr for u plane */
    U08 *pu1_rec_u;

    /** Reference ptr for v plane */
    U08 *pu1_rec_v;

    /** chroma plane stride in pixels */
    S32 chroma_stride;

    S32 chroma_offset;

    /** Pointer to dependency manager of recon buffer */
    void *pv_dep_mngr;

} hme_ref_buf_info_t;

/**
******************************************************************************
 *  @struct     interp_prms_t
 *  @brief      All parameters for the interpolation function
******************************************************************************
 */
typedef struct
{
    /** Array of ptr of 4 planes in order fxfy, hxfy, fxhy, hxhy */
    U08 **ppu1_ref;

    /**
     *  Array of pointers for ping-pong buffers, used to store interp out
     *  Output during a call goes to any one of these buffers
     */
    U08 *apu1_interp_out[5];

    /**
     *  Working memory to store 16 bit intermediate output. This has to be
     *  of size i4_blk_wd * (i4_blk_ht + 7) * 2
     */
    U08 *pu1_wkg_mem;

    /** Stride of all 4 planes of ref buffers */
    S32 i4_ref_stride;

    /** Width of interpolated output blk desired */
    S32 i4_blk_wd;

    /** Ht of interpolated output blk desired */
    S32 i4_blk_ht;

    /**
     *  Stride of interpolated output bufers,
     *  applicable for both ping and pong
     */
    S32 i4_out_stride;

    /** Final output pointer, which may be one of ping-pong or hpel planes */
    U08 *pu1_final_out;

    /** STride of the output bfufer */
    S32 i4_final_out_stride;

} interp_prms_t;

/*****************************************************************************/
/* Typedefs                                                                  */
/*****************************************************************************/
typedef void (*PF_EXT_UPDATE_FXN_T)(void *, void *, S32, S32);

//typedef void (*PF_GET_INTRA_CU_AND_COST)(void *, S32, S32, S32 *, S32*, double *, S32);

typedef void (*PF_INTERP_FXN_T)(interp_prms_t *ps_prms, S32 i4_mv_x, S32 i4_mv_y, S32 interp_buf_id);

typedef void (*PF_SCALE_FXN_T)(
    U08 *pu1_src, S32 src_stride, U08 *pu1_dst, S32 dst_stride, S32 wd, S32 ht, U08 *pu1_wkg_mem);

/**
******************************************************************************
 *  @struct     hme_ref_desc_t
 *  @brief      Contains all reqd information for ref pics across all layers
 *              but for a given POC/ref id
******************************************************************************
 */
typedef struct
{
    /**
     *  Reference id in LC list. This is a unified list containing both fwd
     *  and backward direction references. Having a unified list just does
     *  a unique mapping of frames to ref id and eases out addressing in the
     *  ME search.
     */
    S08 i1_ref_id_lc;

    /**
     *  Reference id in L0 list. Priority is given to temporally fwd dirn
     *  unless of a scene change like case
     */
    S08 i1_ref_id_l0;

    /**
     *  Reference id in L1 list. Priority to backward dirn unless scene change
     *  like case
    */
    S08 i1_ref_id_l1;

    /** Whether this ref is temporally forward w.r.t. current pic */
    U08 u1_is_fwd;

    /** POC of this ref pic. */
    S32 i4_poc;

    /** display_num of this ref pic. */
    S32 i4_display_num;
    /**
     *  Lambda to be used for S + lambda*bits style cost computations when
     *  using this ref pic. This is a function of ref dist and hence diff
     *  ref has diff lambda
     */
    S32 lambda;

    /** Ref buffer info for all layers */
    hme_ref_buf_info_t as_ref_info[MAX_NUM_LAYERS];

    /** Weights and offset of reference picture
     * used for weighted pred analysis
     */
    S16 i2_weight;

    S16 i2_offset;

    /*
    * IDR GOP number
    */

    WORD32 i4_GOP_num;

} hme_ref_desc_t;

/**
******************************************************************************
 *  @struct     hme_ref_map_t
 *  @brief      Complete ref information across all layers and POCs
 *              Information valid for a given inp frame with a given POC.
******************************************************************************
 */
typedef struct
{
    /** Number of active ref picturs in LC list */
    S32 i4_num_ref;

    /** Recon Pic buffer pointers for L0 list */
    recon_pic_buf_t **pps_rec_list_l0;

    /** Recon Pic buffer pointers for L0 list */
    recon_pic_buf_t **pps_rec_list_l1;

    /** Reference descriptors for all ref pics */
    hme_ref_desc_t as_ref_desc[MAX_NUM_REF];

} hme_ref_map_t;

/**
 ******************************************************************************
 *  @struct me_coding_params_t
 *  @param e_me_quality_presets : Quality preset value
 *  @brief  ME Parameters that affect quality depending on their state
 ******************************************************************************
*/
typedef struct
{
    ME_QUALITY_PRESETS_T e_me_quality_presets;

    S32 i4_num_steps_hpel_refine;

    S32 i4_num_steps_qpel_refine;

    U08 u1_l0_me_controlled_via_cmd_line;

    U08 u1_num_results_per_part_in_l0me;

    U08 u1_num_results_per_part_in_l1me;

    U08 u1_num_results_per_part_in_l2me;

    U08 u1_max_num_coloc_cands;

    U08 u1_max_2nx2n_tu_recur_cands;

    U08 u1_max_num_fpel_refine_centers;

    U08 u1_max_num_subpel_refine_centers;
} me_coding_params_t;

/**
 ******************************************************************************
 *  @struct hme_init_prms_t
 *  @brief  Initialization parameters used during HME instance creation
 ******************************************************************************
*/
typedef struct
{
    /** Pointer to widths of various simulcast layers,
     * starting with biggest resolution
     */
    S32 a_wd[MAX_NUM_LAYERS];

    /** Pointer to heights of various simulcast layers,
     *  starting with biggest resolution
     */
    S32 a_ht[MAX_NUM_LAYERS];

    /** Maximum number of reference frames that a frame ever has to search */
    S32 max_num_ref;

    /** Number of results to be stored in the coarsest layer */
    S32 max_num_results_coarse;

    /**
     *  Number of layers for which explicit ME is to be done
     *  0 or MAX_NUM_LAYERS: encoder will do explicit ME for all layers
     *  anything in between, explicit ME done for that many layers
     */
    S32 num_layers_explicit_search;

    /** Number of simulcast layers to be encoded */
    S32 num_simulcast_layers;

    /** Maximum number of results per reference per partition */
    S32 max_num_results;

    /**
     *  If enabled, all layers store segmentation info at 16x16 lvl
     *  If not enabled, then only finest layer stores this info
     */
    S32 segment_higher_layers;

    /**
     *  If enabled, the non enocde layers use 8x8 blks with 4x4 partial
     *  sads also being evaluated, which is more powerful but computationally
     *  less efficient
     */
    S32 use_4x4;

    /**
     *  Number of B frames allowed between P frames
     */
    S32 num_b_frms;

    /** CTB Size as passed by encoder */
    S32 log_ctb_size;

    /** number of threads created run time */
    S32 i4_num_proc_thrds;

    /* This struct contains fields corresponding to quality knobs for ME */
    me_coding_params_t s_me_coding_tools;

    S32 max_vert_search_range;

    S32 max_horz_search_range;

    S32 is_interlaced;

    U08 u1_max_tr_depth;

    U08 u1_is_stasino_enabled;

    IV_ARCH_T e_arch_type;
} hme_init_prms_t;

/**
 ******************************************************************************
 *  @struct hme_frm_prms_t
 *  @brief  Frame level prms for HME execution
 ******************************************************************************
*/
typedef struct
{
    /** Range of the Motion vector in fpel units at finest layer x dirn */
    S16 i2_mv_range_x;

    /** range of motion vector in fpel units at finest layer y dirn */
    S16 i2_mv_range_y;

    /** Context for computing the cost function */
    void *pv_mv_cost_ctxt;

    /** Interpolation function pointers */
    PF_INTERP_FXN_T pf_interp_fxn;

    U08 is_i_pic;

    S32 bidir_enabled;

    S32 i4_temporal_layer_id;

    /**
      * Lambda values in Q format. 4 values exist: Closed loop SATD/SAD
      * and open loop SATD/SAD
      */
    S32 i4_cl_sad_lambda_qf;
    S32 i4_cl_satd_lambda_qf;
    S32 i4_ol_sad_lambda_qf;
    S32 i4_ol_satd_lambda_qf;

    /** Shift for lambda QFormat */
    S32 lambda_q_shift;

    S32 qstep;
    S32 qstep_ls8;
    S32 i4_frame_qp;
    S32 is_pic_second_field;

    /**
     * Number of active references in l0
     */
    U08 u1_num_active_ref_l0;

    /**
     * Number of active references in l1
     */
    U08 u1_num_active_ref_l1;

    /* Flag that specifies whether CU level QP */
    /* modulation is enabled */
    U08 u1_is_cu_qp_delta_enabled;

} hme_frm_prms_t;

/**
 ******************************************************************************
 *  @struct hme_memtab_t
 *  @brief  Structure to return memory requirements for one buffer.
 ******************************************************************************
*/
typedef struct
{
    /** Base of the memtab. Filled by application */
    U08 *pu1_mem;

    /** Required size of the memtab. Filed by module */
    S32 size;

    /** Alignment required */
    S32 align;

    /** type of memory */
    HME_MEM_ATTRS_T e_mem_attr;

} hme_memtab_t;

/**
 ******************************************************************************
 *  @struct hme_inp_buf_attr_t
 *  @brief  Attributes of input buffer and planes
 ******************************************************************************
*/
typedef struct
{
    /** Luma ptr 0, 0 position */
    U08 *pu1_y;

    /** Cb component or U component, 0, 0 position */
    U08 *pu1_u;

    /** Cr component or V component, 0, 0 position */
    U08 *pu1_v;

    /** Stride of luma component in pixels */
    S32 luma_stride;

    /** Stride of chroma component in pixels */
    S32 chroma_stride;
} hme_inp_buf_attr_t;

/**
 ******************************************************************************
 *  @struct hme_inp_desc_t
 *  @brief  Descriptor of a complete input frames (all simulcast layers incl)
 ******************************************************************************
*/
typedef struct
{
    /** input attributes for all simulcast layers */
    hme_inp_buf_attr_t s_layer_desc[MAX_NUM_LAYERS];

    /** POC of the current input frame */
    S32 i4_poc;

    /** idr GOP number*/
    S32 i4_idr_gop_num;

    /** is refence picture */
    S32 i4_is_reference;

} hme_inp_desc_t;

/*****************************************************************************/
/* Extern Function Declarations                                              */
/*****************************************************************************/

/**
********************************************************************************
*  @fn     hme_enc_num_alloc()
*
*  @brief  returns number of memtabs that is required by hme module
*
*  @return   Number of memtabs required
********************************************************************************
*/
S32 hme_enc_num_alloc(WORD32 i4_num_me_frm_pllel);

/**
********************************************************************************
*  @fn     hme_coarse_num_alloc()
*
*  @brief  returns number of memtabs that is required by hme module
*
*  @return   Number of memtabs required
********************************************************************************
*/
S32 hme_coarse_num_alloc();

/**
********************************************************************************
*  @fn     hme_coarse_dep_mngr_num_alloc()
*
*  @brief  returns number of memtabs that is required by Dep Mngr for hme module
*
*  @return   Number of memtabs required
********************************************************************************
*/
WORD32 hme_coarse_dep_mngr_num_alloc();

/**
********************************************************************************
*  @fn     S32 hme_coarse_alloc(hme_memtab_t *ps_memtabs, hme_init_prms_t *ps_prms)
*
*  @brief  Fills up memtabs with memory information details required by HME
*
*  @param[out] ps_memtabs : Pointre to an array of memtabs where module fills
*              up its requirements of memory
*
*  @param[in] ps_prms : Input parameters to module crucial in calculating reqd
*                       amt of memory
*
*  @return   Number of memtabs required
*******************************************************************************
*/
S32 hme_coarse_alloc(hme_memtab_t *ps_memtabs, hme_init_prms_t *ps_prms);

/**
*******************************************************************************
*  @fn hme_coarse_dep_mngr_alloc
*
*  @brief  Fills up memtabs with memory information details required by Coarse HME
*
* \param[in,out]  ps_mem_tab : pointer to memory descriptors table
* \param[in] ps_init_prms : Create time static parameters
* \param[in] i4_mem_space : memspace in whihc memory request should be done
*
*  @return   Number of memtabs required
*******************************************************************************
*/
WORD32 hme_coarse_dep_mngr_alloc(
    iv_mem_rec_t *ps_mem_tab,
    ihevce_static_cfg_params_t *ps_init_prms,
    WORD32 i4_mem_space,
    WORD32 i4_num_proc_thrds,
    WORD32 i4_resolution_id);

/**
********************************************************************************
*  @fn     S32 hme_enc_alloc(hme_memtab_t *ps_memtabs, hme_init_prms_t *ps_prms)
*
*  @brief  Fills up memtabs with memory information details required by HME
*
*  @param[out] ps_memtabs : Pointer to an array of memtabs where module fills
*              up its requirements of memory
*
*  @param[in] ps_prms : Input parameters to module crucial in calculating reqd
*                       amt of memory
*
*  @return   Number of memtabs required
*******************************************************************************
*/
S32 hme_enc_alloc(hme_memtab_t *ps_memtabs, hme_init_prms_t *ps_prms, WORD32 i4_num_me_frm_pllel);

/**
********************************************************************************
*  @fn     S32 hme_enc_init(void *pv_ctxt,
*                       hme_memtab_t *ps_memtabs,
*                       hme_init_prms_t *ps_prms);
*
*  @brief  Initialization (one time) of HME
*
*  @param[in,out] pv_ctxt : Pointer to context of HME
*
*  @param[in] ps_memtabs : updated memtabs by application (allocated memory)
*
*  @param[in] ps_prms : Initialization parametres
*
*  @return   0 : success, -1 : failure
*******************************************************************************
*/
S32 hme_enc_init(
    void *pv_ctxt,
    hme_memtab_t *ps_memtabs,
    hme_init_prms_t *ps_prms,
    rc_quant_t *ps_rc_quant_ctxt,
    WORD32 i4_num_me_frm_pllel);

/**
********************************************************************************
*  @fn     S32 hme_coarse_init(void *pv_ctxt,
*                       hme_memtab_t *ps_memtabs,
*                       hme_init_prms_t *ps_prms);
*
*  @brief  Initialization (one time) of HME
*
*  @param[in,out] pv_ctxt : Pointer to context of HME
*
*  @param[in] ps_memtabs : updated memtabs by application (allocated memory)
*
*  @param[in] ps_prms : Initialization parametres
*
*  @return   0 : success, -1 : failure
*******************************************************************************
*/
S32 hme_coarse_init(void *pv_ctxt, hme_memtab_t *ps_memtabs, hme_init_prms_t *ps_prms);

/*!
******************************************************************************
* \if Function name : ihevce_coarse_me_get_lyr_prms_dep_mngr \endif
*
* \brief Returns to the caller key attributes relevant for dependency manager,
*        ie, the number of vertical units in each layer
*
* \par Description:
*    This function requires the precondition that the width and ht of encode
*    layer is known.
*    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] num_layers : Number of ME Layers
* \param[in] pai4_ht    : Array storing ht at each layer
* \param[in] pai4_wd    : Array storing wd at each layer
* \param[out] pi4_num_vert_units_in_lyr : Array of size N (num layers), each
*                     entry has num vertical units in that particular layer
*
* \return
*    None
*
* \author
*  Ittiam
*
*****************************************************************************
*/
void ihevce_coarse_me_get_lyr_prms_dep_mngr(
    WORD32 num_layers, WORD32 *pai4_ht, WORD32 *pai4_wd, WORD32 *pai4_num_vert_units_in_lyr);

/**
********************************************************************************
*  @fn     hme_coarse_dep_mngr_alloc_mem()
*
*  @brief  Requests/ assign memory for HME Dep Mngr
*
* \param[in,out]  ps_mem_tab : pointer to memory descriptors table
* \param[in] ps_init_prms : Create time static parameters
* \param[in] i4_mem_space : memspace in whihc memory request should be done
*
*  @return  number of memtabs
********************************************************************************
*/
WORD32 hme_coarse_dep_mngr_alloc_mem(
    iv_mem_rec_t *ps_mem_tab,
    ihevce_static_cfg_params_t *ps_init_prms,
    WORD32 i4_mem_space,
    WORD32 i4_num_proc_thrds,
    WORD32 i4_resolution_id);

/**
********************************************************************************
*  @fn     hme_coarse_dep_mngr_init()
*
*  @brief  Assign memory for HME Dep Mngr
*
* \param[in,out]  ps_mem_tab : pointer to memory descriptors table
* \param[in] ps_init_prms : Create time static parameters
*  @param[in] pv_ctxt : ME ctxt
* \param[in] pv_osal_handle : Osal handle
*
*  @return  number of memtabs
********************************************************************************
*/
WORD32 hme_coarse_dep_mngr_init(
    iv_mem_rec_t *ps_mem_tab,
    ihevce_static_cfg_params_t *ps_init_prms,
    void *pv_ctxt,
    void *pv_osal_handle,
    WORD32 i4_num_proc_thrds,
    WORD32 i4_resolution_id);

/**
********************************************************************************
*  @fn     hme_coarse_dep_mngr_reg_sem()
*
*  @brief  Assign semaphores for HME Dep Mngr
*
* \param[in] pv_me_ctxt : pointer to Coarse ME ctxt
* \param[in] ppv_sem_hdls : Arry of semaphore handles
* \param[in] i4_num_proc_thrds : Number of processing threads
*
*  @return  number of memtabs
********************************************************************************
*/
void hme_coarse_dep_mngr_reg_sem(void *pv_ctxt, void **ppv_sem_hdls, WORD32 i4_num_proc_thrds);

/**
********************************************************************************
*  @fn     hme_coarse_dep_mngr_delete()
*
*    Destroy Coarse ME Dep Mngr 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
*
*  @return  none
********************************************************************************
*/
void hme_coarse_dep_mngr_delete(
    void *pv_me_ctxt, ihevce_static_cfg_params_t *ps_init_prms, WORD32 i4_resolution_id);

void hme_coarse_get_layer1_mv_bank_ref_idx_size(
    S32 n_tot_layers,
    S32 *a_wd,
    S32 *a_ht,
    S32 max_num_ref,
    S32 *pi4_mv_bank_size,
    S32 *pi4_ref_idx_size);

/**
********************************************************************************
*  @fn     S32 hme_add_inp(void *pv_ctxt,
*                       hme_inp_desc_t *ps_inp_desc);
*
*  @brief  Updates the HME context with details of the input buffers and POC.
*          Layers that are not encoded are processed further in terms of
*          pyramid generation.
*
*  @param[in,out] pv_ctxt : Pointer to context of HME
*
*  @param[in] ps_inp_desc : Input descriptor containing information of all
*             simulcast layers of input.
*
*  @return   void
*******************************************************************************
*/
void hme_add_inp(void *pv_ctxt, hme_inp_desc_t *ps_inp_desc, S32 me_frm_id, WORD32 thrd_id);

void hme_coarse_add_inp(void *pv_me_ctxt, hme_inp_desc_t *ps_inp_desc, WORD32 i4_curr_idx);

/**
********************************************************************************
*  @fn     hme_process_frm_init
*
*  @brief  HME frame level initialsation processing function
*
*  @param[in] pv_me_ctxt : ME ctxt pointer
*
*  @param[in] ps_ref_map : Reference map prms pointer
*
*  @param[in] ps_frm_prms :Pointer to frame params
*
*  @return Scale factor in Q8 format
********************************************************************************
*/

void hme_process_frm_init(
    void *pv_me_ctxt,
    hme_ref_map_t *ps_ref_map,
    hme_frm_prms_t *ps_frm_prms,
    WORD32 me_frm_id,
    WORD32 i4_num_me_frm_pllel);

void hme_coarse_process_frm_init(
    void *pv_me_ctxt, hme_ref_map_t *ps_ref_map, hme_frm_prms_t *ps_frm_prms);

/**
********************************************************************************
*  @fn     void hme_process_frm(void *pv_ctxt,
*                    hme_ref_map_t *ps_ref_map,
*                    U16 **ppu2_intra_cost,
*                    hme_frm_prms_t *ps_frm_prms);
*
*  @brief  Processes all the layers of the input, and updates the MV Banks.
*          Note that this function is not to be called if processing of a single
*          layer is desired.
*
*  @param[in,out] pv_ctxt : Pointer to context of HME
*
*  @param[in] ps_ref_map : Map structure that has for current input, lists of
*             ref pics (POC) mapping to LC, L0 and L1, and buffer ptrs as well
*             Informatino for all simulcast layers present.
*
*  @param[in] ppu2_intra_cost : array of Pointer to intra cost evaluated at an
*              8x8 level, stored in raster order. At each layer, the
*              corresponding ptr points to raster ordered array of wdxht/64,
*              wd and ht are layer width and ht respectively. Also, note that
*              ppu2_intra_cost[0] points to biggest resolution layer,
*              and from there on in decreasing order of size.
*
* @param[in]  ps_frm_prms : input frame parameters (excluding ref info) that
*             control the search complexity. Refer to hme_frm_prms_t for more
*              info regards the same.
*
*  @return   void
*******************************************************************************
*/

void hme_process_frm(
    void *pv_me_ctxt,
    pre_enc_L0_ipe_encloop_ctxt_t *ps_l0_ipe_input,
    hme_ref_map_t *ps_ref_map,
    double **ppd_intra_costs,
    hme_frm_prms_t *ps_frm_prms,
    PF_EXT_UPDATE_FXN_T pf_ext_update_fxn,
    //PF_GET_INTRA_CU_AND_COST pf_get_intra_cu_and_cost,
    void *pv_coarse_layer,
    void *pv_multi_thrd_ctxt,
    WORD32 i4_frame_parallelism_level,
    S32 thrd_id,
    S32 i4_me_frm_id);

void hme_coarse_process_frm(
    void *pv_me_ctxt,
    hme_ref_map_t *ps_ref_map,
    hme_frm_prms_t *ps_frm_prms,
    void *pv_multi_thrd_ctxt,
    WORD32 i4_ping_pong,
    void **ppv_dep_mngr_hme_sync);

void hme_discard_frm(
    void *pv_ctxt, S32 *p_pocs_to_remove, S32 i4_idr_gop_num, S32 i4_num_me_frm_pllel);

void hme_coarse_discard_frm(void *pv_me_ctxt, S32 *p_pocs_to_remove);

/**
*******************************************************************************
*  @fn     S32 hme_set_resolution(void *pv_me_ctxt,
*                                   S32 n_enc_layers,
*                                   S32 *p_wd,
*                                   S32 *p_ht
*
*  @brief  Sets up the layers based on resolution information.
*
*  @param[in, out] pv_me_ctxt : ME handle, updated with the resolution info
*
*  @param[in] n_enc_layers : Number of layers encoded
*
*  @param[in] p_wd : Pointer to an array having widths for each encode layer
*
*  @param[in] p_ht : Pointer to an array having heights for each encode layer
*
*  @return   void
*******************************************************************************
*/

void hme_set_resolution(void *pv_me_ctxt, S32 n_enc_layers, S32 *p_wd, S32 *p_ht, S32 me_frm_id);

void hme_coarse_set_resolution(void *pv_me_ctxt, S32 n_enc_layers, S32 *p_wd, S32 *p_ht);

/**
*******************************************************************************
*  @fn     WORD32 hme_get_active_pocs_list(void *pv_me_ctxt)
*
*  @brief  Returns the list of active POCs in ME ctxt
*
*  @param[in] pv_me_ctxt : handle to ME context
*
*  @param[out] p_pocs_buffered_in_me : pointer to an array which this fxn
*                                      populates with pocs active
*
*  @return   void
*******************************************************************************
*/
WORD32 hme_get_active_pocs_list(void *pv_me_ctxt, S32 i4_num_me_frm_pllel);

void hme_coarse_get_active_pocs_list(void *pv_me_ctxt, S32 *p_pocs_buffered_in_me);

S32 hme_get_blk_size(S32 use_4x4, S32 layer_id, S32 n_layers, S32 encode);

/**
********************************************************************************
*  @fn     hme_get_mv_blk_size()
*
*  @brief  returns whether blk uses 4x4 size or something else.
*
*  @param[in] enable_4x4 : input param from application to enable 4x4
*
*  @param[in] layer_id : id of current layer (0 finest)
*
*  @param[in] num_layeers : total num layers
*
*  @param[in] is_enc : Whether encoding enabled for layer
*
*  @return   1 for 4x4 blks, 0 for 8x8
********************************************************************************
*/
S32 hme_get_mv_blk_size(S32 enable_4x4, S32 layer_id, S32 num_layers, S32 is_enc);

void hme_set_refine_prms(
    void *pv_refine_prms,
    U08 u1_encode,
    S32 num_ref,
    S32 layer_id,
    S32 num_layers,
    S32 num_layers_explicit_search,
    S32 use_4x4,
    hme_frm_prms_t *ps_frm_prms,
    double **ppd_intra_costs,
    me_coding_params_t *ps_me_coding_tools);

S32 hme_coarse_find_free_descr_idx(void *pv_ctxt);

S32 hme_derive_num_layers(S32 n_enc_layers, S32 *p_wd, S32 *p_ht, S32 *p_disp_wd, S32 *p_disp_ht);

#endif /* #ifndef _HME_INTERFACE_H_ */