/******************************************************************************
|
*
|
* 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_utils.h
|
*
|
* \brief
|
* Prototypes for various utilities used by coarse/refinement/subpel fxns
|
*
|
* \date
|
* 18/09/2012
|
*
|
* \author
|
* Ittiam
|
*
|
******************************************************************************
|
*/
|
|
#ifndef _HME_UTILS_H_
|
#define _HME_UTILS_H_
|
|
/*****************************************************************************/
|
/* Functions */
|
/*****************************************************************************/
|
|
/**
|
********************************************************************************
|
* @fn hme_init_histogram(
|
*
|
* @brief Top level entry point for Coarse ME. Runs across blocks and does the
|
* needful by calling other low level routines.
|
*
|
* @param[in,out] ps_hist : the histogram structure
|
*
|
* @param[in] i4_max_mv_x : Maximum mv allowed in x direction (fpel units)
|
*
|
* @param[in] i4_max_mv_y : Maximum mv allowed in y direction (fpel units)
|
*
|
* @return None
|
********************************************************************************
|
*/
|
void hme_init_histogram(mv_hist_t *ps_hist, S32 i4_max_mv_x, S32 i4_max_mv_y);
|
|
/**
|
********************************************************************************
|
* @fn hme_update_histogram(
|
*
|
* @brief Updates the histogram given an mv entry
|
*
|
* @param[in,out] ps_hist : the histogram structure
|
*
|
* @param[in] i4_mv_x : x component of the mv (fpel units)
|
*
|
* @param[in] i4_mv_y : y component of the mv (fpel units)
|
*
|
* @return None
|
********************************************************************************
|
*/
|
void hme_update_histogram(mv_hist_t *ps_hist, S32 i4_mv_x, S32 i4_mv_y);
|
|
/**
|
********************************************************************************
|
* @fn hme_get_global_mv(
|
*
|
* @brief returns the global mv of a previous picture. Accounts for the fact
|
* that the delta poc of the previous picture may have been different
|
* from delta poc of current picture. Delta poc is POC difference
|
* between a picture and its reference.
|
*
|
* @param[out] ps_mv: mv_t structure where the motion vector is returned
|
*
|
* @param[in] i4_delta_poc: the delta poc for the current pic w.r.t. reference
|
*
|
* @return None
|
********************************************************************************
|
*/
|
void hme_get_global_mv(layer_ctxt_t *ps_prev_layer, hme_mv_t *ps_mv, S32 i4_delta_poc);
|
|
/**
|
********************************************************************************
|
* @fn hme_calculate_global_mv(
|
*
|
* @brief Calculates global mv for a given histogram
|
*
|
* @param[in] ps_hist : the histogram structure
|
*
|
* @param[in] ps_mv : used to return the global mv
|
*
|
* @param[in] e_lobe_type : refer to GMV_MVTYPE_T
|
*
|
* @return None
|
********************************************************************************
|
*/
|
void hme_calculate_global_mv(mv_hist_t *ps_hist, hme_mv_t *ps_mv, GMV_MVTYPE_T e_lobe_type);
|
|
/**
|
********************************************************************************
|
* @fn hme_collate_fpel_results(search_results_t *ps_search_results,
|
* S32 i1_ref_idx, S32 i1_idx_to_merge)
|
*
|
* @brief After full pel search and result seeding in every search iteration
|
* results, this function called to collapse a given search iteration
|
* results into another.
|
*
|
* @param[in,out] ps_search_results : Search results data structure
|
* @param[in] i1_ref_idx: id of the search iteration where the results
|
will be collapsed
|
* @param[in] i1_idx_to_merge : id of the search iteration from which the
|
* results are picked up.
|
|
*
|
* @return None
|
********************************************************************************
|
*/
|
void hme_collate_fpel_results(
|
search_results_t *ps_search_results, S08 i1_ref_idx, S08 i1_idx_to_merge);
|
|
/**
|
********************************************************************************
|
* @fn hme_map_mvs_to_grid(mv_grid_t **pps_mv_grid,
|
search_results_t *ps_search_results, S32 i4_num_ref)
|
*
|
* @brief For a given CU whose results are in ps_search_results, the 17x17
|
* mv grid is updated for future use within the CTB
|
*
|
* @param[in] ps_search_results : Search results data structure
|
*
|
* @param[out] pps_mv_grid: The mv grid (as many as num ref)
|
*
|
* @param[in] i4_num_ref: nuber of search iterations to update
|
*
|
* @param[in] mv_res_shift: Shift for resolution of mv (fpel/qpel)
|
*
|
* @return None
|
********************************************************************************
|
*/
|
void hme_map_mvs_to_grid(
|
mv_grid_t **pps_mv_grid,
|
search_results_t *ps_search_results,
|
U08 *pu1_pred_dir_searched,
|
S32 i4_num_pred_dir);
|
|
/**
|
********************************************************************************
|
* @fn hme_create_valid_part_ids(S32 i4_part_mask, S32 *pi4_valid_part_ids)
|
*
|
* @brief Expands the part mask to a list of valid part ids terminated by -1
|
*
|
* @param[in] i4_part_mask : bit mask of active partitino ids
|
*
|
* @param[out] pi4_valid_part_ids : array, each entry has one valid part id
|
* Terminated by -1 to signal end.
|
*
|
* @return number of partitions
|
********************************************************************************
|
*/
|
S32 hme_create_valid_part_ids(S32 i4_part_mask, S32 *pi4_valid_part_ids);
|
|
/**
|
********************************************************************************
|
* @fn get_num_blks_in_ctb(S32 i4_ctb_x,
|
S32 i4_ctb_y,
|
S32 i4_pic_wd,
|
S32 i4_pic_ht,
|
S32 i4_blk_size)
|
*
|
* @brief returns the number of blks in the ctb (64x64 ctb)
|
*
|
* @param[in] i4_ctb_x : pixel x offset of the top left corner of ctb in pic
|
*
|
* @param[in] i4_ctb_y : pixel y offset of the top left corner of ctb in pic
|
*
|
* @param[in] i4_ctb_x : width of the picture in pixels
|
*
|
* @param[in] i4_pic_ht : height of hte picture in pixels
|
*
|
* @param[in] i4_blk_size : Size of the blk in pixels
|
*
|
* @return number of blks in the ctb
|
********************************************************************************
|
*/
|
S32 get_num_blks_in_ctb(S32 i4_ctb_x, S32 i4_ctb_y, S32 i4_pic_wd, S32 i4_pic_ht, S32 i4_blk_size);
|
|
/**
|
********************************************************************************
|
* @fn hevc_avg_2d(U08 *pu1_src1,
|
* U08 *pu1_src2,
|
* S32 i4_src1_stride,
|
* S32 i4_src2_stride,
|
* S32 i4_blk_wd,
|
* S32 i4_blk_ht,
|
* U08 *pu1_dst,
|
* S32 i4_dst_stride)
|
*
|
*
|
* @brief point wise average of two buffers into a third buffer
|
*
|
* @param[in] pu1_src1 : first source buffer
|
*
|
* @param[in] pu1_src2 : 2nd source buffer
|
*
|
* @param[in] i4_src1_stride : stride of source 1 buffer
|
*
|
* @param[in] i4_src2_stride : stride of source 2 buffer
|
*
|
* @param[in] i4_blk_wd : block width
|
*
|
* @param[in] i4_blk_ht : block height
|
*
|
* @param[out] pu1_dst : destination buffer
|
*
|
* @param[in] i4_dst_stride : stride of the destination buffer
|
*
|
* @return void
|
********************************************************************************
|
*/
|
void hevc_avg_2d(
|
U08 *pu1_src1,
|
U08 *pu1_src2,
|
S32 i4_src1_stride,
|
S32 i4_src2_stride,
|
S32 i4_blk_wd,
|
S32 i4_blk_ht,
|
U08 *pu1_dst,
|
S32 i4_dst_stride);
|
|
/**
|
********************************************************************************
|
* @fn hme_pick_back_search_node(search_results_t *ps_search_results,
|
* search_node_t *ps_search_node_fwd,
|
* S32 i4_part_idx,
|
* layer_ctxt_t *ps_curr_layer)
|
*
|
*
|
* @brief returns the search node corresponding to a ref idx in same or
|
* opp direction. Preference is given to opp direction, but if that
|
* does not yield results, same direction is attempted.
|
*
|
* @param[in] ps_search_results: search results overall
|
*
|
* @param[in] ps_search_node_fwd: search node corresponding to "fwd" direction
|
*
|
* @param[in] i4_part_idx : partition id
|
*
|
* @param[in] ps_curr_layer : layer context for current layer.
|
*
|
* @return search node corresponding to hte "other direction"
|
********************************************************************************
|
*/
|
search_node_t *hme_pick_back_search_node(
|
search_results_t *ps_search_results,
|
search_node_t *ps_search_node_fwd,
|
S32 i4_part_idx,
|
layer_ctxt_t *ps_curr_layer);
|
|
/**
|
********************************************************************************
|
* @fn hme_study_input_segmentation(U08 *pu1_inp,
|
* S32 i4_inp_stride,
|
* S32 limit_active_partitions)
|
*
|
*
|
* @brief Examines input 16x16 for possible edges and orientations of those,
|
* and returns a bit mask of partitions that should be searched for
|
*
|
* @param[in] pu1_inp : input buffer
|
*
|
* @param[in] i4_inp_stride: input stride
|
*
|
* @param[in] limit_active_partitions : 1: Edge algo done and partitions are
|
* limited, 0 : Brute force, all partitions considered
|
*
|
* @return part mask (bit mask of active partitions to search)
|
********************************************************************************
|
*/
|
S32 hme_study_input_segmentation(U08 *pu1_inp, S32 i4_inp_stride, S32 limit_active_partitions);
|
|
/**
|
********************************************************************************
|
* @fn hme_init_search_results(search_results_t *ps_search_results,
|
* S32 i4_num_ref,
|
* S32 i4_num_best_results,
|
* S32 i4_num_results_per_part,
|
* BLK_SIZE_T e_blk_size,
|
* S32 i4_x_off,
|
* S32 i4_y_off)
|
*
|
* @brief Initializes the search results structure with some key attributes
|
*
|
* @param[out] ps_search_results : search results structure to initialise
|
*
|
* @param[in] i4_num_Ref: corresponds to the number of ref ids searched
|
*
|
* @param[in] i4_num_best_results: Number of best results for the CU to
|
* be maintained in the result structure
|
*
|
* @param[in] i4_num_results_per_part: Per active partition the number of best
|
* results to be maintained
|
*
|
* @param[in] e_blk_size: blk size of the CU for which this structure used
|
*
|
* @param[in] i4_x_off: x offset of the top left of CU from CTB top left
|
*
|
* @param[in] i4_y_off: y offset of the top left of CU from CTB top left
|
*
|
* @return void
|
********************************************************************************
|
*/
|
void hme_init_search_results(
|
search_results_t *ps_search_results,
|
S32 i4_num_ref,
|
S32 i4_num_best_results,
|
S32 i4_num_results_per_part,
|
BLK_SIZE_T e_blk_size,
|
S32 i4_x_off,
|
S32 i4_y_off,
|
U08 *pu1_is_past);
|
|
/**
|
********************************************************************************
|
* @fn hme_reset_search_results((search_results_t *ps_search_results,
|
* S32 i4_part_mask)
|
*
|
*
|
* @brief Resets the best results to maximum values, so as to allow search
|
* for the new CU's partitions. The existing results may be from an
|
* older CU using same structure.
|
*
|
* @param[in] ps_search_results: search results structure
|
*
|
* @param[in] i4_part_mask : bit mask of active partitions
|
*
|
* @param[in] mv_res : Resolution of the mv predictors (fpel/qpel)
|
*
|
* @return void
|
********************************************************************************
|
*/
|
void hme_reset_search_results(search_results_t *ps_search_results, S32 i4_part_mask, S32 mv_res);
|
|
/**
|
********************************************************************************
|
* @fn hme_clamp_grid_by_mvrange(search_node_t *ps_search_node,
|
* S32 i4_step,
|
* range_prms_t *ps_mvrange)
|
*
|
* @brief Given a central pt within mv range, and a grid of points surrounding
|
* this pt, this function returns a grid mask of pts within search rng
|
*
|
* @param[in] ps_search_node: the centre pt of the grid
|
*
|
* @param[in] i4_step: step size of grid
|
*
|
* @param[in] ps_mvrange: structure containing the current mv range
|
*
|
* @return bitmask of the pts in grid within search range
|
********************************************************************************
|
*/
|
S32 hme_clamp_grid_by_mvrange(search_node_t *ps_search_node, S32 i4_step, range_prms_t *ps_mvrange);
|
|
/**
|
********************************************************************************
|
* @fn layer_ctxt_t *hme_get_past_layer_ctxt(me_ctxt_t *ps_ctxt,
|
S32 i4_layer_id)
|
*
|
* @brief returns the layer ctxt of the layer with given id from the temporally
|
* previous frame
|
*
|
* @param[in] ps_ctxt : ME context
|
*
|
* @param[in] i4_layer_id : id of layer required
|
*
|
* @return layer ctxt of given layer id in temporally previous frame
|
********************************************************************************
|
*/
|
layer_ctxt_t *hme_get_past_layer_ctxt(
|
me_ctxt_t *ps_ctxt, me_frm_ctxt_t *ps_frm_ctxt, S32 i4_layer_id, S32 i4_num_me_frm_pllel);
|
|
layer_ctxt_t *hme_coarse_get_past_layer_ctxt(coarse_me_ctxt_t *ps_ctxt, S32 i4_layer_id);
|
|
/**
|
********************************************************************************
|
* @fn void hme_init_mv_bank(layer_ctxt_t *ps_layer_ctxt,
|
BLK_SIZE_T e_blk_size,
|
S32 i4_num_ref,
|
S32 i4_num_results_per_part)
|
*
|
* @brief Given a blk size to be used for this layer, this function initialize
|
* the mv bank to make it ready to store and return results.
|
*
|
* @param[in, out] ps_layer_ctxt: pointer to layer ctxt
|
*
|
* @param[in] e_blk_size : resolution at which mvs are stored
|
*
|
* @param[in] i4_num_ref: number of reference frames corresponding to which
|
* results are stored.
|
*
|
* @param[in] e_blk_size : resolution at which mvs are stored
|
*
|
* @param[in] i4_num_results_per_part : Number of results to be stored per
|
* ref idx. So these many best results stored
|
*
|
* @return void
|
********************************************************************************
|
*/
|
void hme_init_mv_bank(
|
layer_ctxt_t *ps_layer_ctxt,
|
BLK_SIZE_T e_blk_size,
|
S32 i4_num_ref,
|
S32 i4_num_results_per_part,
|
U08 u1_enc);
|
|
/**
|
********************************************************************************
|
* @fn void hme_derive_search_range(range_prms_t *ps_range,
|
* range_prms_t *ps_pic_limit,
|
* range_prms_t *ps_mv_limit,
|
* S32 i4_x,
|
* S32 i4_y,
|
* S32 blk_wd,
|
* S32 blk_ht)
|
*
|
* @brief given picture limits and blk dimensions and mv search limits, obtains
|
* teh valid search range such that the blk stays within pic boundaries,
|
* where picture boundaries include padded portions of picture
|
*
|
* @param[out] ps_range: updated with actual search range
|
*
|
* @param[in] ps_pic_limit : picture boundaries
|
*
|
* @param[in] ps_mv_limit: Search range limits for the mvs
|
*
|
* @param[in] i4_x : x coordinate of the blk
|
*
|
* @param[in] i4_y : y coordinate of the blk
|
*
|
* @param[in] blk_wd : blk width
|
*
|
* @param[in] blk_ht : blk height
|
*
|
* @return void
|
********************************************************************************
|
*/
|
void hme_derive_search_range(
|
range_prms_t *ps_range,
|
range_prms_t *ps_pic_limit,
|
range_prms_t *ps_mv_limit,
|
S32 i4_x,
|
S32 i4_y,
|
S32 blk_wd,
|
S32 blk_ht);
|
|
/**
|
********************************************************************************
|
* @fn void hme_get_spatial_candt(layer_ctxt_t *ps_curr_layer,
|
* BLK_SIZE_T e_search_blk_size,
|
* S32 blk_x,
|
* S32 blk_y,
|
* S08 i1_ref_idx,
|
* search_node_t *ps_top_neighbours,
|
* search_node_t *ps_left_neighbours,
|
* S32 i4_result_id);
|
*
|
* @brief Obtains top, top left, top right and left adn bottom left candts
|
*
|
* @param[in] ps_curr_layer: layer ctxt, has the mv bank structure pointer
|
*
|
* @param[in] e_search_blk_size : search blk size of current layer
|
*
|
* @param[in] i4_blk_x : x coordinate of the block in mv bank
|
*
|
* @param[in] i4_blk_y : y coordinate of the block in mv bank
|
*
|
* @param[in] i1_ref_idx : Corresponds to ref idx from which to pick up mv
|
* results, useful if multiple ref idx candts maintained separately.
|
*
|
* @param[out] ps_top_neighbours : T, TL, TR candts are output here
|
*
|
* @param[out] ps_left_neighbours : L BL candts outptu here
|
*
|
* @param[in] i4_result_id : If multiple results stored per ref idx, this
|
* pts to the id of the result
|
*
|
* @return void
|
********************************************************************************
|
*/
|
void hme_get_spatial_candt(
|
layer_ctxt_t *ps_curr_layer,
|
BLK_SIZE_T e_search_blk_size,
|
S32 blk_x,
|
S32 blk_y,
|
S08 i1_ref_idx,
|
search_node_t *ps_top_neighbours,
|
search_node_t *ps_left_neighbours,
|
S32 i4_result_id,
|
S32 i4_tr_avail,
|
S32 i4_bl_avail,
|
S32 encode);
|
|
void hme_get_spatial_candt_in_l1_me(
|
layer_ctxt_t *ps_curr_layer,
|
BLK_SIZE_T e_search_blk_size,
|
S32 i4_blk_x,
|
S32 i4_blk_y,
|
S08 i1_ref_idx,
|
U08 u1_pred_dir,
|
search_node_t *ps_top_neighbours,
|
search_node_t *ps_left_neighbours,
|
S32 i4_result_id,
|
S32 tr_avail,
|
S32 bl_avail,
|
S32 i4_num_act_ref_l0,
|
S32 i4_num_act_ref_l1);
|
|
/**
|
********************************************************************************
|
* @fn void hme_fill_ctb_neighbour_mvs(layer_ctxt_t *ps_curr_layer,
|
* S32 i4_blk_x,
|
* S32 i4_blk_y,
|
* mvgrid_t *ps_mv_grid ,
|
* S32 i1_ref_id)
|
*
|
* @brief The 18x18 MV grid for a ctb, is filled in first row and 1st col
|
* this corresponds to neighbours (TL, T, TR, L, BL)
|
*
|
* @param[in] ps_curr_layer: layer ctxt, has the mv bank structure pointer
|
*
|
* @param[in] blk_x : x coordinate of the block in mv bank
|
*
|
* @param[in] blk_y : y coordinate of the block in mv bank
|
*
|
* @param[in] ps_mv_grid : Grid (18x18 mvs at 4x4 level)
|
*
|
* @param[in] u1_pred_lx : Corresponds to pred dir from which to pick up mv
|
* results
|
*
|
* @return void
|
********************************************************************************
|
*/
|
void hme_fill_ctb_neighbour_mvs(
|
layer_ctxt_t *ps_curr_layer,
|
S32 blk_x,
|
S32 blk_y,
|
mv_grid_t *ps_mv_grid,
|
U08 u1_pred_dir_ctr,
|
U08 u1_default_ref_id,
|
S32 i4_num_act_ref_l0);
|
|
/**
|
********************************************************************************
|
* @fn void *hme_get_wkg_mem(buf_mgr_t *ps_buf_mgr, S32 i4_size)
|
*
|
* @brief Allocates a block of size = i4_size from working memory and returns
|
*
|
* @param[in,out] ps_buf_mgr: Buffer manager for wkg memory
|
*
|
* @param[in] i4_size : size required
|
*
|
* @return void pointer to allocated memory, NULL if failure
|
********************************************************************************
|
*/
|
void *hme_get_wkg_mem(buf_mgr_t *ps_buf_mgr, S32 i4_size);
|
|
void hme_reset_wkg_mem(buf_mgr_t *ps_buf_mgr);
|
|
void hme_init_wkg_mem(buf_mgr_t *ps_buf_mgr, U08 *pu1_mem, S32 size);
|
|
void hme_reset_ctb_mem_mgr(ctb_mem_mgr_t *ps_ctb_mem_mgr);
|
|
void hme_init_ctb_mem_mgr(ctb_mem_mgr_t *ps_ctb_mem_mgr, U08 *pu1_mem, S32 size);
|
|
void hme_fill_mvbank_intra(layer_ctxt_t *ps_layer_ctxt);
|
|
void hme_scale_mv_grid(mv_grid_t *ps_mv_grid);
|
|
void hme_downscale_mv_grid(mv_grid_t *ps_mv_grid);
|
|
void hme_create_parent_ctb(
|
ctb_node_t *ps_ctb_node_parent,
|
ctb_node_t *ps_ctb_child_tl,
|
ctb_node_t *ps_ctb_child_tr,
|
ctb_node_t *ps_ctb_child_bl,
|
ctb_node_t *ps_ctb_child_br,
|
CU_SIZE_T e_cu_size_parent,
|
buf_mgr_t *ps_buf_mgr);
|
|
void hme_create_merged_ctbs(
|
search_results_t *ps_results_merged,
|
ctb_mem_mgr_t *ps_ctb_mem_mgr,
|
buf_mgr_t *ps_buf_mgr,
|
ctb_node_t **pps_ctb_list_unified,
|
S32 num_candts);
|
|
void hme_init_mv_grid(mv_grid_t *ps_mv_grid);
|
|
typedef void (*pf_get_wt_inp)(
|
layer_ctxt_t *ps_curr_layer,
|
wgt_pred_ctxt_t *ps_wt_inp_prms,
|
S32 dst_stride,
|
S32 pos_x,
|
S32 pos_y,
|
S32 size,
|
S32 num_ref,
|
U08 u1_is_wt_pred_on);
|
|
/**
|
********************************************************************************
|
* @fn void hme_pad_left(U08 *pu1_dst, S32 stride, S32 pad_wd, S32 pad_ht)
|
*
|
* @brief Pads horizontally to left side. Each pixel replicated across a line
|
*
|
* @param[in] pu1_dst : destination pointer. Points to the pixel to be repeated
|
*
|
* @param[in] stride : stride of destination buffer
|
*
|
* @param[in] pad_wd : Amt of horizontal padding to be done
|
*
|
* @param[in] pad_ht : Number of lines for which horizontal padding to be done
|
*
|
* @return void
|
********************************************************************************
|
*/
|
void hme_pad_left(U08 *pu1_dst, S32 stride, S32 pad_wd, S32 pad_ht);
|
|
/**
|
********************************************************************************
|
* @fn void hme_pad_right(U08 *pu1_dst, S32 stride, S32 pad_wd, S32 pad_ht)
|
*
|
* @brief Pads horizontally to rt side. Each pixel replicated across a line
|
*
|
* @param[in] pu1_dst : destination pointer. Points to the pixel to be repeated
|
*
|
* @param[in] stride : stride of destination buffer
|
*
|
* @param[in] pad_wd : Amt of horizontal padding to be done
|
*
|
* @param[in] pad_ht : Number of lines for which horizontal padding to be done
|
*
|
* @return void
|
********************************************************************************
|
*/
|
void hme_pad_right(U08 *pu1_dst, S32 stride, S32 pad_wd, S32 pad_ht);
|
|
/**
|
********************************************************************************
|
* @fn void hme_pad_top(U08 *pu1_dst, S32 stride, S32 pad_ht, S32 pad_wd)
|
*
|
* @brief Pads vertically on the top. Repeats the top line for top padding
|
*
|
* @param[in] pu1_dst : destination pointer. Points to the line to be repeated
|
*
|
* @param[in] stride : stride of destination buffer
|
*
|
* @param[in] pad_ht : Amt of vertical padding to be done
|
*
|
* @param[in] pad_wd : Number of columns for which vertical padding to be done
|
*
|
* @return void
|
********************************************************************************
|
*/
|
void hme_pad_top(U08 *pu1_dst, S32 stride, S32 pad_ht, S32 pad_wd);
|
|
/**
|
********************************************************************************
|
* @fn void hme_pad_bot(U08 *pu1_dst, S32 stride, S32 pad_ht, S32 pad_wd)
|
*
|
* @brief Pads vertically on the bot. Repeats the top line for top padding
|
*
|
* @param[in] pu1_dst : destination pointer. Points to the line to be repeated
|
*
|
* @param[in] stride : stride of destination buffer
|
*
|
* @param[in] pad_ht : Amt of vertical padding to be done
|
*
|
* @param[in] pad_wd : Number of columns for which vertical padding to be done
|
*
|
* @return void
|
********************************************************************************
|
*/
|
void hme_pad_bot(U08 *pu1_dst, S32 stride, S32 pad_ht, S32 pad_wd);
|
|
/**
|
**************************************************************************************************
|
* @fn hme_populate_pus(search_results_t *ps_search_results, inter_cu_results_t *ps_cu_results)
|
*
|
* @brief Population the pu_results structure with the results after the subpel refinement
|
*
|
* This is called post subpel refinmenent for 16x16s, 8x8s and
|
* for post merge evaluation for 32x32,64x64 CUs
|
*
|
* @param[in,out] ps_search_results : Search results data structure
|
* - ps_cu_results : cu_results data structure
|
* ps_pu_result : Pointer to the memory for storing PU's
|
*
|
****************************************************************************************************
|
*/
|
void hme_populate_pus(
|
me_ctxt_t *ps_thrd_ctxt,
|
me_frm_ctxt_t *ps_ctxt,
|
hme_subpel_prms_t *ps_subpel_prms,
|
search_results_t *ps_search_results,
|
inter_cu_results_t *ps_cu_results,
|
inter_pu_results_t *ps_pu_results,
|
pu_result_t *ps_pu_result,
|
inter_ctb_prms_t *ps_inter_ctb_prms,
|
wgt_pred_ctxt_t *ps_wt_prms,
|
layer_ctxt_t *ps_curr_layer,
|
U08 *pu1_pred_dir_searched,
|
WORD32 i4_num_active_ref);
|
|
void hme_populate_pus_8x8_cu(
|
me_ctxt_t *ps_thrd_ctxt,
|
me_frm_ctxt_t *ps_ctxt,
|
hme_subpel_prms_t *ps_subpel_prms,
|
search_results_t *ps_search_results,
|
inter_cu_results_t *ps_cu_results,
|
inter_pu_results_t *ps_pu_results,
|
pu_result_t *ps_pu_result,
|
inter_ctb_prms_t *ps_inter_ctb_prms,
|
U08 *pu1_pred_dir_searched,
|
WORD32 i4_num_active_ref,
|
U08 u1_blk_8x8_mask);
|
|
S32 hme_recompute_lambda_from_min_8x8_act_in_ctb(
|
me_frm_ctxt_t *ps_ctxt, ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb);
|
|
/**
|
********************************************************************************
|
* @fn hme_update_dynamic_search_params
|
*
|
* @brief Update the Dynamic search params based on the current MVs
|
*
|
* @param[in,out] ps_dyn_range_prms [inout] : Dyn. Range Param str.
|
* i2_mvy [in] : current MV y comp.
|
*
|
* @return None
|
********************************************************************************
|
*/
|
void hme_update_dynamic_search_params(dyn_range_prms_t *ps_dyn_range_prms, WORD16 i2_mvy);
|
|
S32 hme_create_child_nodes_cu_tree(
|
cur_ctb_cu_tree_t *ps_cu_tree_root,
|
cur_ctb_cu_tree_t *ps_cu_tree_cur_node,
|
S32 nodes_already_created);
|
|
void hme_add_new_node_to_a_sorted_array(
|
search_node_t *ps_result_node,
|
search_node_t **pps_sorted_array,
|
U08 *pu1_shifts,
|
U32 u4_num_results_updated,
|
U08 u1_shift);
|
|
S32 hme_find_pos_of_implicitly_stored_ref_id(
|
S08 *pi1_ref_idx, S08 i1_ref_idx, S32 i4_result_id, S32 i4_num_results);
|
|
S32 hme_populate_search_candidates(fpel_srch_cand_init_data_t *ps_ctxt);
|
|
void hme_init_pred_buf_info(
|
hme_pred_buf_info_t (*ps_info)[MAX_NUM_INTER_PARTS],
|
hme_pred_buf_mngr_t *ps_buf_mngr,
|
U08 u1_pu1_wd,
|
U08 u1_pu1_ht,
|
PART_TYPE_T e_part_type);
|
|
void hme_debrief_bipred_eval(
|
part_type_results_t *ps_part_type_result,
|
hme_pred_buf_info_t (*ps_pred_buf_info)[MAX_NUM_INTER_PARTS],
|
hme_pred_buf_mngr_t *ps_pred_buf_mngr,
|
U08 *pu1_allocated_pred_buf_array_indixes,
|
ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list);
|
|
U08 hme_decide_search_candidate_priority_in_l1_and_l2_me(
|
SEARCH_CANDIDATE_TYPE_T e_cand_type, ME_QUALITY_PRESETS_T e_quality_preset);
|
|
U08 hme_decide_search_candidate_priority_in_l0_me(SEARCH_CANDIDATE_TYPE_T e_cand_type, U08 u1_index);
|
|
void hme_search_cand_data_init(
|
S32 *pi4_id_Z,
|
S32 *pi4_id_coloc,
|
S32 *pi4_num_coloc_cands,
|
U08 *pu1_search_candidate_list_index,
|
S32 i4_num_act_ref_l0,
|
S32 i4_num_act_ref_l1,
|
U08 u1_is_bidir_enabled,
|
U08 u1_4x4_blk_in_l1me);
|
|
void hme_compute_variance_for_all_parts(
|
U08 *pu1_data,
|
S32 i4_data_stride,
|
S32 *pi4_valid_part_array,
|
U32 *pu4_variance,
|
S32 i4_num_valid_parts,
|
U08 u1_cu_size);
|
|
void hme_compute_sigmaX_and_sigmaXSquared(
|
U08 *pu1_data,
|
S32 i4_buf_stride,
|
void *pv_sigmaX,
|
void *pv_sigmaXSquared,
|
U08 u1_base_blk_wd,
|
U08 u1_base_blk_ht,
|
U08 u1_blk_wd,
|
U08 u1_blk_ht,
|
U08 u1_is_sigma_pointer_size_32_bit,
|
U08 u1_array_stride);
|
|
void hme_compute_final_sigma_of_pu_from_base_blocks(
|
U32 *pu4_SigmaX,
|
U32 *pu4_SigmaXSquared,
|
ULWORD64 *pu8_final_sigmaX,
|
ULWORD64 *pu8_final_sigmaX_Squared,
|
U08 u1_cu_size,
|
U08 u1_base_block_size,
|
S32 i4_part_id,
|
U08 u1_base_blk_array_stride);
|
|
void hme_compute_stim_injected_distortion_for_all_parts(
|
U08 *pu1_pred,
|
S32 i4_pred_stride,
|
S32 *pi4_valid_part_array,
|
ULWORD64 *pu8_src_sigmaX,
|
ULWORD64 *pu8_src_sigmaXSquared,
|
S32 *pi4_sad_array,
|
S32 i4_alpha_stim_multiplier,
|
S32 i4_inv_wt,
|
S32 i4_inv_wt_shift_val,
|
S32 i4_num_valid_parts,
|
S32 i4_wpred_log_wdc,
|
U08 u1_cu_size);
|
|
void sigma_for_cusize_16_and_baseblock_size_16(
|
U08 *pu1_data, S32 i4_data_stride, U32 *pu4_sigmaX, U32 *pu4_sigmaXSquared);
|
|
void sigma_for_cusize_16_and_baseblock_size_8(
|
U08 *pu1_data, S32 i4_data_stride, U32 *pu4_sigmaX, U32 *pu4_sigmaXSquared, U08 diff_cu_size);
|
|
void sigma_for_cusize_16_and_baseblock_size_4(
|
U08 *pu1_data, S32 i4_data_stride, U32 *pu4_sigmaX, U32 *pu4_sigmaXSquared);
|
|
void sigma_for_cusize_32_and_baseblock_size_32(
|
U08 *pu1_data, S32 i4_data_stride, U32 *pu4_sigmaX, U32 *pu4_sigmaXSquared);
|
|
void sigma_for_cusize_64_and_baseblock_size_64(
|
U08 *pu1_data, S32 i4_data_stride, U32 *pu4_sigmaX, U32 *pu4_sigmaXSquared);
|
|
void hme_choose_best_noise_preserver_amongst_fpel_and_subpel_winners(
|
fullpel_refine_ctxt_t *ps_fullpel_winner_data,
|
search_node_t **pps_part_results,
|
layer_ctxt_t *ps_curr_layer,
|
wgt_pred_ctxt_t *ps_wt_inp_prms,
|
U32 *pu4_src_variance,
|
S32 i4_cu_x_off_in_ctb,
|
S32 i4_cu_y_off_in_ctb,
|
S32 i4_ctb_x_off,
|
S32 i4_ctb_y_off,
|
S32 i4_inp_stride,
|
S32 i4_alpha_stim_multiplier,
|
U08 u1_subpel_uses_satd);
|
|
#if TEMPORAL_NOISE_DETECT
|
WORD32 ihevce_16x16block_temporal_noise_detect(
|
WORD32 had_block_size,
|
WORD32 ctb_width,
|
WORD32 ctb_height,
|
ihevce_ctb_noise_params *ps_ctb_noise_params,
|
fpel_srch_cand_init_data_t *s_proj_srch_cand_init_data,
|
hme_search_prms_t *s_search_prms_blk,
|
me_frm_ctxt_t *ps_ctxt,
|
WORD32 num_pred_dir,
|
WORD32 i4_num_act_ref_l0,
|
WORD32 i4_num_act_ref_l1,
|
WORD32 i4_cu_x_off,
|
WORD32 i4_cu_y_off,
|
wgt_pred_ctxt_t *ps_wt_inp_prms,
|
WORD32 input_stride,
|
WORD32 index_8x8_block,
|
WORD32 num_horz_blocks,
|
WORD32 num_8x8_in_ctb_row,
|
WORD32 i4_index_variance);
|
#endif
|
|
/**
|
********************************************************************************
|
* @fn hme_decide_part_types(search_results_t *ps_search_results)
|
*
|
* @brief Does uni/bi evaluation accross various partition types,
|
* decides best inter partition types for the CU, compares
|
* intra cost and decides the best K results for the CU
|
*
|
* This is called post subpel refinmenent for 16x16s, 8x8s and
|
* for post merge evaluation for 32x32,64x64 CUs
|
*
|
* @param[in,out] ps_search_results : Search results data structure
|
* - In : 2 lists of upto 2mvs & refids, active partition mask
|
* - Out: Best results for final rdo evaluation of the cu
|
*
|
* @param[in] ps_subpel_prms : Sub pel params data structure
|
|
*
|
* @par Description
|
* --------------------------------------------------------------------------------
|
* Flow:
|
* for each category (SMP,AMP,2Nx2N based on part mask)
|
* {
|
* for each part_type
|
* {
|
* for each part
|
* pick best candidate from each list
|
* combine uni part type
|
* update best results for part type
|
* }
|
* pick the best part type for given category (for SMP & AMP)
|
* }
|
* ||
|
* ||
|
* \/
|
* for upto 3 best part types
|
* {
|
* for each part
|
* {
|
* compute fixed size had for all uni and remember coeffs
|
* compute bisatd
|
* uni vs bi and gives upto two results
|
* also gives the pt level pred buffer
|
* }
|
* }
|
* ||
|
* ||
|
* \/
|
* select X candidates for tu recursion as per the Note below
|
* tu_rec_on_part_type (reuse transform coeffs)
|
* ||
|
* ||
|
* \/
|
* insert intra nodes at appropriate result id
|
* ||
|
* ||
|
* \/
|
* populate y best resuls for rdo based on preset
|
*
|
* Note :
|
* number of TU rec for P pics : 2 2nx2n + 1 smp + 1 amp for ms or 9 for hq
|
* number of TU rec for B pics : 1 2nx2n + 1 smp + 1 amp for ms or 2 uni 2nx2n + 1 smp + 1 amp for ms or 9 for hq
|
* --------------------------------------------------------------------------------
|
*
|
* @return None
|
********************************************************************************
|
*/
|
void hme_decide_part_types(
|
inter_cu_results_t *ps_cu_results,
|
inter_pu_results_t *ps_pu_results,
|
inter_ctb_prms_t *ps_inter_ctb_prms,
|
me_frm_ctxt_t *ps_ctxt,
|
ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list,
|
ihevce_me_optimised_function_list_t *ps_me_optimised_function_list);
|
|
void hme_compute_pred_and_evaluate_bi(
|
inter_cu_results_t *ps_cu_results,
|
inter_pu_results_t *ps_pu_results,
|
inter_ctb_prms_t *ps_inter_ctb_prms,
|
part_type_results_t *ps_part_type_result,
|
ULWORD64 *pu8_winning_pred_sigmaXSquare,
|
ULWORD64 *pu8_winning_pred_sigmaX,
|
ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list,
|
ihevce_me_optimised_function_list_t *ps_me_optimised_function_list);
|
|
/**
|
********************************************************************************
|
* @fn hme_insert_intra_nodes_post_bipred
|
*
|
* @brief Compares intra costs (populated by IPE) with the best inter costs
|
* (populated after evaluating bi-pred) and updates the best results
|
* if intra cost is better
|
*
|
* @param[in,out] ps_cu_results [inout] : Best results structure of CU
|
* ps_cur_ipe_ctb [in] : intra results for the current CTB
|
* i4_frm_qstep [in] : current frame quantizer(qscale)*
|
*
|
* @return None
|
********************************************************************************
|
*/
|
void hme_insert_intra_nodes_post_bipred(
|
inter_cu_results_t *ps_cu_results,
|
ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb,
|
WORD32 i4_frm_qstep);
|
|
void hme_set_mv_limit_using_dvsr_data(
|
me_frm_ctxt_t *ps_ctxt,
|
layer_ctxt_t *ps_curr_layer,
|
range_prms_t *ps_mv_limit,
|
S16 *pi2_prev_enc_frm_max_mv_y,
|
U08 u1_num_act_ref_pics);
|
|
S32 hme_part_mask_populator(
|
U08 *pu1_inp,
|
S32 i4_inp_stride,
|
U08 u1_limit_active_partitions,
|
U08 u1_is_bPic,
|
U08 u1_is_refPic,
|
U08 u1_blk_8x8_mask,
|
ME_QUALITY_PRESETS_T e_me_quality_preset);
|
|
#endif /* #ifndef _HME_UTILS_H_ */
|
