You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1036 lines
34 KiB
1036 lines
34 KiB
/******************************************************************************
|
|
*
|
|
* 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_ */
|