| /****************************************************************************** |
| * |
| * 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_USER_DEFINED |
| } 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_ */ |