p71924506
/
aosp12
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
aosp12/external/libhevc/encoder/hme_utils.c

5708 lines
203 KiB
C
Raw Permalink Blame History

/******************************************************************************
*
* 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 Includes */
/*****************************************************************************/
/* System include files */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <stdarg.h>
#include <math.h>
#include <limits.h>
/* User include files */
#include "ihevc_typedefs.h"
#include "itt_video_api.h"
#include "ihevce_api.h"
#include "rc_cntrl_param.h"
#include "rc_frame_info_collector.h"
#include "rc_look_ahead_params.h"
#include "ihevc_defs.h"
#include "ihevc_structs.h"
#include "ihevc_platform_macros.h"
#include "ihevc_deblk.h"
#include "ihevc_itrans_recon.h"
#include "ihevc_chroma_itrans_recon.h"
#include "ihevc_chroma_intra_pred.h"
#include "ihevc_intra_pred.h"
#include "ihevc_inter_pred.h"
#include "ihevc_mem_fns.h"
#include "ihevc_padding.h"
#include "ihevc_weighted_pred.h"
#include "ihevc_sao.h"
#include "ihevc_resi_trans.h"
#include "ihevc_quant_iquant_ssd.h"
#include "ihevc_cabac_tables.h"
#include "ihevce_defs.h"
#include "ihevce_lap_enc_structs.h"
#include "ihevce_multi_thrd_structs.h"
#include "ihevce_multi_thrd_funcs.h"
#include "ihevce_me_common_defs.h"
#include "ihevce_had_satd.h"
#include "ihevce_error_codes.h"
#include "ihevce_bitstream.h"
#include "ihevce_cabac.h"
#include "ihevce_rdoq_macros.h"
#include "ihevce_function_selector.h"
#include "ihevce_enc_structs.h"
#include "ihevce_entropy_structs.h"
#include "ihevce_cmn_utils_instr_set_router.h"
#include "ihevce_enc_loop_structs.h"
#include "ihevce_inter_pred.h"
#include "ihevce_global_tables.h"
#include "ihevce_dep_mngr_interface.h"
#include "hme_datatype.h"
#include "hme_interface.h"
#include "hme_common_defs.h"
#include "hme_defs.h"
#include "ihevce_me_instr_set_router.h"
#include "hme_globals.h"
#include "hme_utils.h"
#include "hme_coarse.h"
#include "hme_fullpel.h"
#include "hme_subpel.h"
#include "hme_refine.h"
#include "hme_err_compute.h"
#include "hme_common_utils.h"
#include "hme_search_algo.h"
#include "ihevce_stasino_helpers.h"
#include "ihevce_common_utils.h"
/*****************************************************************************/
/* Macros */
/*****************************************************************************/
#define UNI_SATD_SCALE 1
/*****************************************************************************/
/* Function Definitions */
/*****************************************************************************/
void ihevce_open_loop_pred_data(
me_frm_ctxt_t *ps_ctxt,
inter_pu_results_t *ps_pu_results,
U08 *pu1_src,
U08 *pu1_temp_pred,
S32 stride,
S32 src_strd,
UWORD8 e_part_id)
{
S32 best_sad_l0 = -1, best_sad_l1 = -1;
S32 sad_diff, status;
inter_pred_me_ctxt_t *ps_inter_pred_me_ctxt;
U08 enable_bi = 0;
pu_t s_pu;
ps_inter_pred_me_ctxt = &ps_ctxt->s_mc_ctxt;
ps_ctxt->i4_count++;
/* L0*/
if(ps_pu_results->u1_num_results_per_part_l0[e_part_id])
{
pu_result_t *ps_best_l0_pu;
ps_best_l0_pu = ps_pu_results->aps_pu_results[0][PRT_2Nx2N];
best_sad_l0 = ps_best_l0_pu->i4_tot_cost - ps_best_l0_pu->i4_mv_cost;
s_pu.b2_pred_mode = PRED_L0;
s_pu.b4_ht = ps_best_l0_pu->pu.b4_ht;
s_pu.b4_wd = ps_best_l0_pu->pu.b4_wd;
s_pu.b4_pos_x = ps_best_l0_pu->pu.b4_pos_x;
s_pu.b4_pos_y = ps_best_l0_pu->pu.b4_pos_y;
s_pu.b1_intra_flag = 0;
s_pu.mv.s_l0_mv.i2_mvx = ps_best_l0_pu->pu.mv.s_l0_mv.i2_mvx;
s_pu.mv.s_l0_mv.i2_mvy = ps_best_l0_pu->pu.mv.s_l0_mv.i2_mvy;
s_pu.mv.i1_l0_ref_idx = ps_best_l0_pu->pu.mv.i1_l0_ref_idx;
}
/*L1*/
if(ps_pu_results->u1_num_results_per_part_l1[e_part_id])
{
pu_result_t *ps_best_l1_pu;
ps_best_l1_pu = ps_pu_results->aps_pu_results[1][PRT_2Nx2N];
best_sad_l1 = ps_best_l1_pu->i4_tot_cost - ps_best_l1_pu->i4_mv_cost;
s_pu.b2_pred_mode = PRED_L1;
s_pu.b4_ht = ps_best_l1_pu->pu.b4_ht;
s_pu.b4_wd = ps_best_l1_pu->pu.b4_wd;
s_pu.b4_pos_x = ps_best_l1_pu->pu.b4_pos_x;
s_pu.b4_pos_y = ps_best_l1_pu->pu.b4_pos_y;
s_pu.b1_intra_flag = 0;
s_pu.mv.s_l1_mv.i2_mvx = ps_best_l1_pu->pu.mv.s_l1_mv.i2_mvx;
s_pu.mv.s_l1_mv.i2_mvy = ps_best_l1_pu->pu.mv.s_l1_mv.i2_mvy;
s_pu.mv.i1_l1_ref_idx = ps_best_l1_pu->pu.mv.i1_l1_ref_idx;
}
ASSERT((best_sad_l0 != -1) || (best_sad_l1 != -1));
/*bi selection*/
if((best_sad_l0 != -1) && (best_sad_l1 != -1))
{
sad_diff = abs(best_sad_l0 - best_sad_l1);
if((sad_diff < (best_sad_l0 * 0.15)) && (sad_diff < (best_sad_l1 * 0.15)))
{
enable_bi = 1;
s_pu.b2_pred_mode = PRED_BI;
}
if(!enable_bi)
{
if(best_sad_l0 < best_sad_l1)
{
s_pu.b2_pred_mode = PRED_L0;
}
else
{
s_pu.b2_pred_mode = PRED_L1;
}
}
}
status = ihevce_luma_inter_pred_pu(ps_inter_pred_me_ctxt, &s_pu, pu1_temp_pred, stride, 1);
if(status == -1)
{
ASSERT(0);
}
}
/**
********************************************************************************
* @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)
{
U08 *pu1_mem;
if(ps_buf_mgr->i4_used + i4_size > ps_buf_mgr->i4_total)
return NULL;
pu1_mem = ps_buf_mgr->pu1_wkg_mem + ps_buf_mgr->i4_used;
ps_buf_mgr->i4_used += i4_size;
return ((void *)pu1_mem);
}
/**
********************************************************************************
* @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)
{
S32 i4_num_bins, i4_num_cols, i4_num_rows;
S32 i4_shift_x, i4_shift_y, i, i4_range, i4_val;
/*************************************************************************/
/* Evaluate the shift_x and shift_y. For this, we use the following logic*/
/* Assuming that we use up all MAX_NUM_BINS. Then the number of bins is */
/* given by formula ((max_mv_x * 2) >> shift_x)*((max_mv_y * 2)>>shift_y)*/
/* or shift_x + shift_y is log ((max_mv_x * max_mv_y * 4) / MAX_NUM_BINS)*/
/* if above quantity is negative, then we make it zero. */
/* If result is odd, then shift_y is result >> 1, shift_x is shift_y + 1 */
/*************************************************************************/
i4_val = i4_max_mv_x * i4_max_mv_y * 4;
i4_range = (hme_get_range(i4_val - 1)) + 1;
if(i4_range > LOG_MAX_NUM_BINS)
{
i4_shift_y = (i4_range - LOG_MAX_NUM_BINS);
i4_shift_x = (i4_shift_y + 1) >> 1;
i4_shift_y >>= 1;
}
else
{
i4_shift_y = 0;
i4_shift_x = 0;
}
/* we assume the mv range is -max_mv_x to +max_mv_x, ditto for y */
/* So number of columns is 2*max_mv_x >> i4_shift_x. Ditto for rows */
/* this helps us compute num bins that are active for this histo session */
i4_num_cols = (i4_max_mv_x << 1) >> i4_shift_x;
i4_num_rows = (i4_max_mv_y << 1) >> i4_shift_y;
i4_num_bins = i4_num_rows * i4_num_cols;
ASSERT(i4_num_bins <= MAX_NUM_BINS);
ps_hist->i4_num_rows = i4_num_rows;
ps_hist->i4_num_cols = i4_num_cols;
ps_hist->i4_min_x = -i4_max_mv_x;
ps_hist->i4_min_y = -i4_max_mv_y;
ps_hist->i4_shift_x = i4_shift_x;
ps_hist->i4_shift_y = i4_shift_y;
ps_hist->i4_lobe1_size = 5;
ps_hist->i4_lobe2_size = 3;
ps_hist->i4_num_bins = i4_num_bins;
for(i = 0; i < i4_num_bins; i++)
{
ps_hist->ai4_bin_count[i] = 0;
}
}
/**
********************************************************************************
* @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)
{
S32 i4_bin_index, i4_col, i4_row;
i4_col = (i4_mv_x - ps_hist->i4_min_x) >> ps_hist->i4_shift_x;
i4_row = (i4_mv_y - ps_hist->i4_min_y) >> ps_hist->i4_shift_y;
i4_bin_index = i4_col + (i4_row * ps_hist->i4_num_cols);
/* Sanity Check */
ASSERT(i4_bin_index < MAX_NUM_BINS);
ps_hist->ai4_bin_count[i4_bin_index]++;
}
/**
********************************************************************************
* @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)
{
S16 i2_mv_x, i2_mv_y;
S32 i4_delta_poc_prev;
S32 i4_poc_prev = ps_prev_layer->i4_poc;
S32 i4_poc_prev_ref = ps_prev_layer->ai4_ref_id_to_poc_lc[0];
i4_delta_poc_prev = i4_poc_prev - i4_poc_prev_ref;
i2_mv_x = ps_prev_layer->s_global_mv[0][GMV_THICK_LOBE].i2_mv_x;
i2_mv_y = ps_prev_layer->s_global_mv[0][GMV_THICK_LOBE].i2_mv_y;
i2_mv_x = (S16)((i2_mv_x * i4_delta_poc) / i4_delta_poc_prev);
i2_mv_y = (S16)((i2_mv_y * i4_delta_poc) / i4_delta_poc_prev);
ps_mv->i2_mv_x = i2_mv_x;
ps_mv->i2_mv_y = i2_mv_y;
}
/**
********************************************************************************
* @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)
{
S32 i4_offset, i4_lobe_size, i4_y, i4_x, *pi4_bin_count;
S32 i4_max_sum = -1;
S32 i4_max_x = 0, i4_max_y = 0;
if(e_lobe_type == GMV_THICK_LOBE)
i4_lobe_size = ps_hist->i4_lobe1_size;
else
i4_lobe_size = ps_hist->i4_lobe2_size;
i4_offset = i4_lobe_size >> 1;
for(i4_y = i4_offset; i4_y < ps_hist->i4_num_rows - i4_offset; i4_y++)
{
for(i4_x = i4_offset; i4_x < ps_hist->i4_num_cols - i4_offset; i4_x++)
{
S32 i4_bin_id, i4_sum;
i4_bin_id = (i4_x - 2) + ((i4_y - 2) * ps_hist->i4_num_cols);
pi4_bin_count = &ps_hist->ai4_bin_count[i4_bin_id];
i4_sum = hme_compute_2d_sum_unsigned(
(void *)pi4_bin_count,
i4_lobe_size,
i4_lobe_size,
ps_hist->i4_num_cols,
sizeof(U32));
if(i4_sum > i4_max_sum)
{
i4_max_x = i4_x;
i4_max_y = i4_y;
i4_max_sum = i4_sum;
}
}
}
ps_mv->i2_mv_y = (S16)((i4_max_y << ps_hist->i4_shift_y) + ps_hist->i4_min_y);
ps_mv->i2_mv_x = (S16)((i4_max_x << ps_hist->i4_shift_x) + ps_hist->i4_min_x);
}
/**
********************************************************************************
* @fn ctb_node_t *hme_get_ctb_node(ctb_mem_mgr_t *ps_mem_mgr)
*
* @brief returns a new ctb node usable for creating a new ctb candidate
*
* @param[in] ps_mem_mgr : memory manager holding all ctb nodes
*
* @return NULL if no free nodes, else ptr to the new ctb node
********************************************************************************
*/
ctb_node_t *hme_get_ctb_node(ctb_mem_mgr_t *ps_mem_mgr)
{
U08 *pu1_ret;
if((ps_mem_mgr->i4_used + ps_mem_mgr->i4_size) > ps_mem_mgr->i4_tot)
return (NULL);
pu1_ret = ps_mem_mgr->pu1_mem + ps_mem_mgr->i4_used;
ps_mem_mgr->i4_used += ps_mem_mgr->i4_size;
return ((ctb_node_t *)pu1_ret);
}
/**
********************************************************************************
* @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
*
* @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)
{
S32 i4_cu_start_offset;
/*************************************************************************/
/* Start x, y offset of CU relative to CTB. To update the mv grid which */
/* stores 1 mv per 4x4, we convert pixel offset to 4x4 blk offset */
/*************************************************************************/
S32 i4_cu_offset_x = (S32)ps_search_results->u1_x_off >> 2;
S32 i4_cu_offset_y = (S32)ps_search_results->u1_y_off >> 2;
/* Controls the attribute of a given partition within CU */
/* , i.e. start locn, size */
part_attr_t *ps_part_attr;
S32 i4_part, i4_part_id, num_parts, i4_stride;
S16 i2_mv_x, i2_mv_y;
S08 i1_ref_idx;
/* Per partition, attributes w.r.t. CU start */
S32 x_start, y_start, x_end, y_end, i4_x, i4_y;
PART_TYPE_T e_part_type;
/* Points to exact mv structures within the grid to be udpated */
search_node_t *ps_grid_node, *ps_grid_node_tmp;
/* points to exact mv grid (based on search iteration) to be updated */
mv_grid_t *ps_mv_grid;
search_node_t *ps_search_node;
S32 shift, i, mv_shift = 2;
/* Proportional to the size of CU, controls the number of 4x4 blks */
/* to be updated */
shift = ps_search_results->e_cu_size;
ASSERT(i4_num_pred_dir <= 2);
e_part_type = (PART_TYPE_T)ps_search_results->ps_cu_results->ps_best_results[0].u1_part_type;
if((ps_search_results->e_cu_size == CU_16x16) && (ps_search_results->u1_split_flag) &&
(ps_search_results->i4_part_mask & ENABLE_NxN))
{
e_part_type = PRT_NxN;
}
for(i = 0; i < i4_num_pred_dir; i++)
{
num_parts = gau1_num_parts_in_part_type[e_part_type];
ps_mv_grid = pps_mv_grid[pu1_pred_dir_searched[i]];
i4_stride = ps_mv_grid->i4_stride;
i4_cu_start_offset =
i4_cu_offset_x + i4_cu_offset_y * i4_stride + ps_mv_grid->i4_start_offset;
/* Move to the appropriate 2d locn of CU start within Grid */
ps_grid_node = &ps_mv_grid->as_node[i4_cu_start_offset];
for(i4_part = 0; i4_part < num_parts; i4_part++)
{
i4_part_id = ge_part_type_to_part_id[e_part_type][i4_part];
/* Pick the mvx and y and ref id corresponding to this partition */
ps_search_node =
ps_search_results->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id];
i2_mv_x = ps_search_node->s_mv.i2_mvx;
i2_mv_y = ps_search_node->s_mv.i2_mvy;
i1_ref_idx = ps_search_node->i1_ref_idx;
/* Move to the appropriate location within the CU */
ps_part_attr = &gas_part_attr_in_cu[i4_part_id];
x_start = ps_part_attr->u1_x_start;
x_end = x_start + ps_part_attr->u1_x_count;
y_start = ps_part_attr->u1_y_start;
y_end = y_start + ps_part_attr->u1_y_count;
/* Convert attributes from 8x8 CU size to given CU size */
x_start = (x_start << shift) >> mv_shift;
x_end = (x_end << shift) >> mv_shift;
y_start = (y_start << shift) >> mv_shift;
y_end = (y_end << shift) >> mv_shift;
ps_grid_node_tmp = ps_grid_node + y_start * i4_stride;
/* Update all 4x4 blk mvs with the part mv */
/* For e.g. we update 4 units in case of NxN for 16x16 CU */
for(i4_y = y_start; i4_y < y_end; i4_y++)
{
for(i4_x = x_start; i4_x < x_end; i4_x++)
{
ps_grid_node_tmp[i4_x].s_mv.i2_mvx = i2_mv_x;
ps_grid_node_tmp[i4_x].s_mv.i2_mvy = i2_mv_y;
ps_grid_node_tmp[i4_x].i1_ref_idx = i1_ref_idx;
ps_grid_node_tmp[i4_x].u1_subpel_done = 1;
}
ps_grid_node_tmp += i4_stride;
}
}
}
}
void hme_set_ctb_pred_attr(ctb_node_t *ps_parent, U08 *pu1_pred0, U08 *pu1_pred1, S32 i4_stride)
{
ps_parent->apu1_pred[0] = pu1_pred0;
ps_parent->apu1_pred[1] = pu1_pred1;
ps_parent->i4_pred_stride = i4_stride;
if(ps_parent->ps_tl != NULL)
{
S32 blk_wd = (S32)ps_parent->ps_tr->u1_x_off;
blk_wd -= (S32)ps_parent->u1_x_off;
hme_set_ctb_pred_attr(ps_parent->ps_tl, pu1_pred0, pu1_pred1, i4_stride >> 1);
hme_set_ctb_pred_attr(
ps_parent->ps_tr, pu1_pred0 + blk_wd, pu1_pred1 + blk_wd, i4_stride >> 1);
hme_set_ctb_pred_attr(
ps_parent->ps_bl,
pu1_pred0 + (blk_wd * i4_stride),
pu1_pred1 + (blk_wd * i4_stride),
i4_stride >> 1);
hme_set_ctb_pred_attr(
ps_parent->ps_tr,
pu1_pred0 + (blk_wd * (1 + i4_stride)),
pu1_pred1 + (blk_wd * (1 + i4_stride)),
i4_stride >> 1);
}
}
/**
********************************************************************************
* @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)
{
S32 id = 0, i;
for(i = 0; i < TOT_NUM_PARTS; i++)
{
if(i4_part_mask & (1 << i))
{
pi4_valid_part_ids[id] = i;
id++;
}
}
pi4_valid_part_ids[id] = -1;
return id;
}
ctb_boundary_attrs_t *
get_ctb_attrs(S32 ctb_start_x, S32 ctb_start_y, S32 pic_wd, S32 pic_ht, me_frm_ctxt_t *ps_ctxt)
{
S32 horz_crop, vert_crop;
ctb_boundary_attrs_t *ps_attrs;
horz_crop = ((ctb_start_x + 64) > pic_wd) ? 2 : 0;
vert_crop = ((ctb_start_y + 64) > pic_ht) ? 1 : 0;
switch(horz_crop + vert_crop)
{
case 0:
ps_attrs = &ps_ctxt->as_ctb_bound_attrs[CTB_CENTRE];
break;
case 1:
ps_attrs = &ps_ctxt->as_ctb_bound_attrs[CTB_BOT_PIC_BOUNDARY];
break;
case 2:
ps_attrs = &ps_ctxt->as_ctb_bound_attrs[CTB_RT_PIC_BOUNDARY];
break;
case 3:
ps_attrs = &ps_ctxt->as_ctb_bound_attrs[CTB_BOT_RT_PIC_BOUNDARY];
break;
}
return (ps_attrs);
}
/**
********************************************************************************
* @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)
{
S32 i, j;
for(i = 0; i < i4_blk_ht; i++)
{
for(j = 0; j < i4_blk_wd; j++)
{
pu1_dst[j] = (pu1_src1[j] + pu1_src2[j] + 1) >> 1;
}
pu1_src1 += i4_src1_stride;
pu1_src2 += i4_src2_stride;
pu1_dst += 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"
********************************************************************************
*/
//#define PICK_L1_REF_SAME_DIR
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)
{
S32 is_past_l0, is_past_l1, id, i, i4_poc;
S32 *pi4_ref_id_to_poc_lc = ps_curr_layer->ai4_ref_id_to_poc_lc;
//ref_attr_t *ps_ref_attr_lc;
S08 i1_ref_idx_fwd;
S16 i2_mv_x, i2_mv_y;
search_node_t *ps_search_node;
i1_ref_idx_fwd = ps_search_node_fwd->i1_ref_idx;
i2_mv_x = ps_search_node_fwd->s_mv.i2_mvx;
i2_mv_y = ps_search_node_fwd->s_mv.i2_mvy;
i4_poc = ps_curr_layer->i4_poc;
//ps_ref_attr_lc = &ps_curr_layer->as_ref_attr_lc[0];
/* If the ref id already picked up maps to a past pic, then we pick */
/* a result corresponding to future pic. If such a result is not */
/* to be found, then we pick a result corresponding to a past pic */
//is_past = ps_ref_attr_lc[i1_ref_idx_fwd].u1_is_past;
is_past_l0 = (i4_poc > pi4_ref_id_to_poc_lc[i1_ref_idx_fwd]) ? 1 : 0;
ASSERT(ps_search_results->u1_num_active_ref <= 2);
/* pick the right iteration of search nodes to pick up */
#ifdef PICK_L1_REF_SAME_DIR
if(ps_search_results->u1_num_active_ref == 2)
id = !is_past_l0;
#else
if(ps_search_results->u1_num_active_ref == 2)
id = is_past_l0;
#endif
else
id = 0;
ps_search_node = ps_search_results->aps_part_results[id][i4_part_idx];
for(i = 0; i < ps_search_results->u1_num_results_per_part; i++)
{
S08 i1_ref_test = ps_search_node[i].i1_ref_idx;
is_past_l1 = (pi4_ref_id_to_poc_lc[i1_ref_test] < i4_poc) ? 1 : 0;
//if (ps_ref_attr_lc[ps_search_node[i].i1_ref_idx].u1_is_past != is_past)
#ifdef PICK_L1_REF_SAME_DIR
if(is_past_l1 == is_past_l0)
#else
if(is_past_l1 != is_past_l0)
#endif
{
/* belongs to same direction as the ref idx passed, so continue */
return (ps_search_node + i);
}
}
/* Unable to find best result in opp direction, so try same direction */
/* However we need to ensure that we do not pick up same result */
for(i = 0; i < ps_search_results->u1_num_results_per_part; i++)
{
if((ps_search_node->i1_ref_idx != i1_ref_idx_fwd) ||
(ps_search_node->s_mv.i2_mvx != i2_mv_x) || (ps_search_node->s_mv.i2_mvy != i2_mv_y))
{
return (ps_search_node);
}
ps_search_node++;
}
//ASSERT(0);
return (ps_search_results->aps_part_results[id][i4_part_idx]);
//return (NULL);
}
/**
********************************************************************************
* @fn hme_study_input_segmentation(U08 *pu1_inp, S32 i4_inp_stride)
*
*
* @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
*
* @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)
{
S32 i4_rsum[16], i4_csum[16];
U08 *pu1_tmp, u1_tmp;
S32 i4_max_ridx, i4_max_cidx, i4_tmp;
S32 i, j, i4_ret;
S32 i4_max_rp[4], i4_max_cp[4];
S32 i4_seg_lutc[4] = { 0, ENABLE_nLx2N, ENABLE_Nx2N, ENABLE_nRx2N };
S32 i4_seg_lutr[4] = { 0, ENABLE_2NxnU, ENABLE_2NxN, ENABLE_2NxnD };
#define EDGE_THR (15 * 16)
#define HI_PASS(ptr, i) (2 * (ptr[i] - ptr[i - 1]) + (ptr[i + 1] - ptr[i - 2]))
if(0 == limit_active_partitions)
{
/*********************************************************************/
/* In this case, we do not optimize on active partitions and search */
/* brute force. This way, 17 partitinos would be enabled. */
/*********************************************************************/
return (ENABLE_ALL_PARTS);
}
/*************************************************************************/
/* Control passes below in case we wish to optimize on active partitions.*/
/* This is based on input characteristics, check how an edge passes along*/
/* an input 16x16 area, if at all, and decide active partitinos. */
/*************************************************************************/
/* Initialize row and col sums */
for(i = 0; i < 16; i++)
{
i4_rsum[i] = 0;
i4_csum[i] = 0;
}
pu1_tmp = pu1_inp;
for(i = 0; i < 16; i++)
{
for(j = 0; j < 16; j++)
{
u1_tmp = *pu1_tmp++;
i4_rsum[i] += u1_tmp;
i4_csum[j] += u1_tmp;
}
pu1_tmp += (i4_inp_stride - 16);
}
/* 0 is dummy; 1 is 4; 2 is 8; 3 is 12 */
i4_max_rp[0] = 0;
i4_max_cp[0] = 0;
i4_max_rp[1] = 0;
i4_max_cp[1] = 0;
i4_max_rp[2] = 0;
i4_max_cp[2] = 0;
i4_max_rp[3] = 0;
i4_max_cp[3] = 0;
/* Get Max edge strength across (2,3) (3,4) (4,5) */
for(i = 3; i < 6; i++)
{
/* Run [-1 -2 2 1] filter through rsum/csum */
i4_tmp = HI_PASS(i4_rsum, i);
if(ABS(i4_tmp) > i4_max_rp[1])
i4_max_rp[1] = i4_tmp;
i4_tmp = HI_PASS(i4_csum, i);
if(ABS(i4_tmp) > i4_max_cp[1])
i4_max_cp[1] = i4_tmp;
}
/* Get Max edge strength across (6,7) (7,8) (8,9) */
for(i = 7; i < 10; i++)
{
/* Run [-1 -2 2 1] filter through rsum/csum */
i4_tmp = HI_PASS(i4_rsum, i);
if(ABS(i4_tmp) > i4_max_rp[2])
i4_max_rp[2] = i4_tmp;
i4_tmp = HI_PASS(i4_csum, i);
if(ABS(i4_tmp) > i4_max_cp[2])
i4_max_cp[2] = i4_tmp;
}
/* Get Max edge strength across (10,11) (11,12) (12,13) */
for(i = 11; i < 14; i++)
{
/* Run [-1 -2 2 1] filter through rsum/csum */
i4_tmp = HI_PASS(i4_rsum, i);
if(ABS(i4_tmp) > i4_max_rp[3])
i4_max_rp[3] = i4_tmp;
i4_tmp = HI_PASS(i4_csum, i);
if(ABS(i4_tmp) > i4_max_cp[3])
i4_max_cp[3] = i4_tmp;
}
/* Find the maximum across the 3 and see whether the strength qualifies as edge */
i4_max_ridx = 1;
i4_max_cidx = 1;
for(i = 2; i <= 3; i++)
{
if(i4_max_rp[i] > i4_max_rp[i4_max_ridx])
i4_max_ridx = i;
if(i4_max_cp[i] > i4_max_cp[i4_max_cidx])
i4_max_cidx = i;
}
if(EDGE_THR > i4_max_rp[i4_max_ridx])
{
i4_max_ridx = 0;
}
if(EDGE_THR > i4_max_cp[i4_max_cidx])
{
i4_max_cidx = 0;
}
i4_ret = ENABLE_2Nx2N;
/* If only vertical discontinuity, go with one of 2Nx? */
if(0 == (i4_max_ridx + i4_max_cidx))
{
//num_me_parts++;
return i4_ret;
}
if(i4_max_ridx && (i4_max_cidx == 0))
{
//num_me_parts += 3;
return ((i4_ret | i4_seg_lutr[i4_max_ridx]));
}
/* If only horizontal discontinuity, go with one of ?x2N */
if(i4_max_cidx && (i4_max_ridx == 0))
{
//num_me_parts += 3;
return ((i4_ret | i4_seg_lutc[i4_max_cidx]));
}
/* If middle is dominant in both directions, go with NxN */
if((2 == i4_max_cidx) && (2 == i4_max_ridx))
{
//num_me_parts += 5;
return ((i4_ret | ENABLE_NxN));
}
/* Otherwise, conservatively, enable NxN and the 2 AMPs */
//num_me_parts += 9;
return (i4_ret | ENABLE_NxN | i4_seg_lutr[i4_max_ridx] | i4_seg_lutc[i4_max_cidx]);
}
/**
********************************************************************************
* @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
*
* @param[in] pu1_is_past : points ot an array that tells whether a given ref id
* has prominence in L0 or in L1 list (past or future )
*
* @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)
{
CU_SIZE_T e_cu_size = ge_blk_size_to_cu_size[e_blk_size];
ASSERT(e_cu_size != -1);
ps_search_results->e_cu_size = e_cu_size;
ps_search_results->u1_x_off = (U08)i4_x_off;
ps_search_results->u1_y_off = (U08)i4_y_off;
ps_search_results->u1_num_active_ref = (U08)i4_num_ref;
ps_search_results->u1_num_best_results = (U08)i4_num_best_results;
ps_search_results->u1_num_results_per_part = (U08)i4_num_results_per_part;
ps_search_results->pu1_is_past = pu1_is_past;
ps_search_results->u1_split_flag = 0;
ps_search_results->best_cu_cost = MAX_32BIT_VAL;
}
/**
********************************************************************************
* @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
*
* @return part mask (bit mask of active partitions to search)
********************************************************************************
*/
void hme_reset_search_results(search_results_t *ps_search_results, S32 i4_part_mask, S32 mv_res)
{
S32 i4_num_ref = (S32)ps_search_results->u1_num_active_ref;
S08 i1_ref_idx;
S32 i, j;
search_node_t *ps_search_node;
/* store this for future use */
ps_search_results->i4_part_mask = i4_part_mask;
/* Reset the spli_flag to zero */
ps_search_results->u1_split_flag = 0;
HME_SET_MVPRED_RES((&ps_search_results->as_pred_ctxt[0]), mv_res);
HME_SET_MVPRED_RES((&ps_search_results->as_pred_ctxt[1]), mv_res);
for(i1_ref_idx = 0; i1_ref_idx < i4_num_ref; i1_ref_idx++)
{
/* Reset the individual partitino results */
for(i = 0; i < TOT_NUM_PARTS; i++)
{
if(!(i4_part_mask & (1 << i)))
continue;
ps_search_node = ps_search_results->aps_part_results[i1_ref_idx][i];
for(j = 0; j < ps_search_results->u1_num_results_per_part; j++)
{
ps_search_node[j].s_mv.i2_mvx = 0;
ps_search_node[j].s_mv.i2_mvy = 0;
ps_search_node[j].i4_tot_cost = MAX_32BIT_VAL;
ps_search_node[j].i4_sad = MAX_32BIT_VAL;
ps_search_node[j].i4_sdi = 0;
ps_search_node[j].i1_ref_idx = -1;
ps_search_node[j].u1_subpel_done = 0;
ps_search_node[j].u1_is_avail = 1;
ps_search_node[j].i4_mv_cost = 0;
}
}
}
}
/**
********************************************************************************
* @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)
{
S32 i4_mask = GRID_ALL_PTS_VALID;
if(ps_search_node->s_mv.i2_mvx + i4_step >= ps_mvrange->i2_max_x)
{
i4_mask &= (GRID_RT_3_INVALID);
}
if(ps_search_node->s_mv.i2_mvx - i4_step < ps_mvrange->i2_min_x)
{
i4_mask &= (GRID_LT_3_INVALID);
}
if(ps_search_node->s_mv.i2_mvy + i4_step >= ps_mvrange->i2_max_y)
{
i4_mask &= (GRID_BOT_3_INVALID);
}
if(ps_search_node->s_mv.i2_mvy - i4_step < ps_mvrange->i2_min_y)
{
i4_mask &= (GRID_TOP_3_INVALID);
}
return i4_mask;
}
/**
********************************************************************************
* @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)
{
S32 i4_poc = ps_frm_ctxt->ai4_ref_idx_to_poc_lc[0];
S32 i;
layers_descr_t *ps_desc;
for(i = 0; i < (ps_ctxt->aps_me_frm_prms[0]->max_num_ref * i4_num_me_frm_pllel) + 1; i++)
{
ps_desc = &ps_ctxt->as_ref_descr[i];
if(i4_poc == ps_desc->aps_layers[i4_layer_id]->i4_poc)
return (ps_desc->aps_layers[i4_layer_id]);
}
return NULL;
}
/**
********************************************************************************
* @fn layer_ctxt_t *hme_coarse_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_coarse_get_past_layer_ctxt(coarse_me_ctxt_t *ps_ctxt, S32 i4_layer_id)
{
S32 i4_poc = ps_ctxt->ai4_ref_idx_to_poc_lc[0];
S32 i;
layers_descr_t *ps_desc;
for(i = 0; i < ps_ctxt->max_num_ref + 1 + NUM_BUFS_DECOMP_HME; i++)
{
ps_desc = &ps_ctxt->as_ref_descr[i];
if(i4_poc == ps_desc->aps_layers[i4_layer_id]->i4_poc)
return (ps_desc->aps_layers[i4_layer_id]);
}
return NULL;
}
/**
********************************************************************************
* @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)
{
layer_mv_t *ps_mv_bank;
hme_mv_t *ps_mv1, *ps_mv2;
S08 *pi1_ref_id1, *pi1_ref_id2;
S32 blk_wd, mvs_in_blk, blks_in_row, mvs_in_row, blks_in_col;
S32 i4_i, i4_j, blk_ht;
ps_mv_bank = ps_layer_ctxt->ps_layer_mvbank;
ps_mv_bank->i4_num_mvs_per_ref = i4_num_results_per_part;
ps_mv_bank->i4_num_ref = i4_num_ref;
mvs_in_blk = i4_num_ref * i4_num_results_per_part;
ps_mv_bank->i4_num_mvs_per_blk = mvs_in_blk;
/*************************************************************************/
/* Store blk size, from blk size derive blk width and use this to compute*/
/* number of blocks every row. We also pad to left and top by 1, to */
/* support the prediction mechanism. */
/*************************************************************************/
ps_mv_bank->e_blk_size = e_blk_size;
blk_wd = gau1_blk_size_to_wd[e_blk_size];
blk_ht = gau1_blk_size_to_ht[e_blk_size];
blks_in_row = (ps_layer_ctxt->i4_wd + (blk_wd - 1)) / blk_wd;
blks_in_col = (ps_layer_ctxt->i4_ht + (blk_ht - 1)) / blk_ht;
if(u1_enc)
{
/* TODO: CTB64x64 is assumed. FIX according to actual CTB */
WORD32 num_ctb_cols = ((ps_layer_ctxt->i4_wd + 63) >> 6);
WORD32 num_ctb_rows = ((ps_layer_ctxt->i4_ht + 63) >> 6);
blks_in_row = (num_ctb_cols << 3);
blks_in_col = (num_ctb_rows << 3);
}
blks_in_row += 2;
mvs_in_row = blks_in_row * mvs_in_blk;
ps_mv_bank->i4_num_blks_per_row = blks_in_row;
ps_mv_bank->i4_num_mvs_per_row = mvs_in_row;
/* To ensure run time requirements fall within allocation time request */
ASSERT(ps_mv_bank->i4_num_mvs_per_row <= ps_mv_bank->max_num_mvs_per_row);
/*************************************************************************/
/* Increment by one full row at top for padding and one column in left */
/* this gives us the actual start of mv for 0,0 blk */
/*************************************************************************/
ps_mv_bank->ps_mv = ps_mv_bank->ps_mv_base + mvs_in_row + mvs_in_blk;
ps_mv_bank->pi1_ref_idx = ps_mv_bank->pi1_ref_idx_base + mvs_in_row + mvs_in_blk;
memset(ps_mv_bank->ps_mv_base, 0, mvs_in_row * sizeof(hme_mv_t));
memset(ps_mv_bank->pi1_ref_idx_base, -1, mvs_in_row * sizeof(U08));
/*************************************************************************/
/* Initialize top row, left col and right col with zeros since these are */
/* used as candidates during searches. */
/*************************************************************************/
ps_mv1 = ps_mv_bank->ps_mv_base + mvs_in_row;
ps_mv2 = ps_mv1 + mvs_in_row - mvs_in_blk;
pi1_ref_id1 = ps_mv_bank->pi1_ref_idx_base + mvs_in_row;
pi1_ref_id2 = pi1_ref_id1 + mvs_in_row - mvs_in_blk;
for(i4_i = 0; i4_i < blks_in_col; i4_i++)
{
for(i4_j = 0; i4_j < mvs_in_blk; i4_j++)
{
ps_mv1[i4_j].i2_mv_x = 0;
ps_mv1[i4_j].i2_mv_y = 0;
ps_mv2[i4_j].i2_mv_x = 0;
ps_mv2[i4_j].i2_mv_y = 0;
pi1_ref_id1[i4_j] = -1;
pi1_ref_id2[i4_j] = -1;
}
ps_mv1 += mvs_in_row;
ps_mv2 += mvs_in_row;
pi1_ref_id1 += mvs_in_row;
pi1_ref_id2 += mvs_in_row;
}
}
void hme_fill_mvbank_intra(layer_ctxt_t *ps_layer_ctxt)
{
layer_mv_t *ps_mv_bank;
hme_mv_t *ps_mv;
S08 *pi1_ref_id;
S32 blk_wd, blks_in_row, mvs_in_row, blks_in_col;
S32 i, j, blk_ht;
BLK_SIZE_T e_blk_size;
ps_mv_bank = ps_layer_ctxt->ps_layer_mvbank;
/*************************************************************************/
/* Store blk size, from blk size derive blk width and use this to compute*/
/* number of blocks every row. We also pad to left and top by 1, to */
/* support the prediction mechanism. */
/*************************************************************************/
e_blk_size = ps_mv_bank->e_blk_size;
blk_wd = gau1_blk_size_to_wd[e_blk_size];
blk_ht = gau1_blk_size_to_wd[e_blk_size];
blks_in_row = ps_layer_ctxt->i4_wd / blk_wd;
blks_in_col = ps_layer_ctxt->i4_ht / blk_ht;
mvs_in_row = blks_in_row * ps_mv_bank->i4_num_mvs_per_blk;
/*************************************************************************/
/* Increment by one full row at top for padding and one column in left */
/* this gives us the actual start of mv for 0,0 blk */
/*************************************************************************/
ps_mv = ps_mv_bank->ps_mv;
pi1_ref_id = ps_mv_bank->pi1_ref_idx;
for(i = 0; i < blks_in_col; i++)
{
for(j = 0; j < blks_in_row; j++)
{
ps_mv[j].i2_mv_x = INTRA_MV;
ps_mv[j].i2_mv_y = INTRA_MV;
pi1_ref_id[j] = -1;
}
ps_mv += ps_mv_bank->i4_num_mvs_per_row;
pi1_ref_id += ps_mv_bank->i4_num_mvs_per_row;
}
}
/**
********************************************************************************
* @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)
{
ps_range->i2_max_x =
MIN((ps_pic_limit->i2_max_x - (S16)blk_wd - (S16)i4_x), ps_mv_limit->i2_max_x);
ps_range->i2_min_x = MAX((ps_pic_limit->i2_min_x - (S16)i4_x), ps_mv_limit->i2_min_x);
ps_range->i2_max_y =
MIN((ps_pic_limit->i2_max_y - (S16)blk_ht - (S16)i4_y), ps_mv_limit->i2_max_y);
ps_range->i2_min_y = MAX((ps_pic_limit->i2_min_y - (S16)i4_y), ps_mv_limit->i2_min_y);
}
/**
********************************************************************************
* @fn void hme_get_spatial_candt(search_node_t *ps_search_node,
* layer_ctxt_t *ps_curr_layer,
* S32 i4_blk_x,
* S32 i4_blk_y,
* S08 i1_ref_id,
* S32 i4_result_id)
*
* @brief obtains a candt from the same mv bank as the current one, its called
* spatial candt as it does not require scaling for temporal distances
*
* @param[out] ps_search_node: mv and ref id updated here of the candt
*
* @param[in] ps_curr_layer: layer ctxt, has the mv bank structure pointer
*
* @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_id : Corresponds to ref idx from which to pick up mv
* results, useful if multiple ref idx candts maintained separately.
*
* @param[in] i4_result_id : If multiple results stored per ref idx, this
* pts to the id of the result
*
* @param[in] tr_avail : top right availability of the block
*
* @param[in] bl_avail : bottom left availability of the block
*
* @return void
********************************************************************************
*/
void hme_get_spatial_candt(
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,
search_node_t *ps_top_neighbours,
search_node_t *ps_left_neighbours,
S32 i4_result_id,
S32 tr_avail,
S32 bl_avail,
S32 encode)
{
layer_mv_t *ps_layer_mvbank = ps_curr_layer->ps_layer_mvbank;
S32 i4_blk_size1 = gau1_blk_size_to_wd[ps_layer_mvbank->e_blk_size];
S32 i4_blk_size2 = gau1_blk_size_to_wd[e_search_blk_size];
search_node_t *ps_search_node;
S32 i4_offset;
hme_mv_t *ps_mv, *ps_mv_base;
S08 *pi1_ref_idx, *pi1_ref_idx_base;
S32 jump = 1, mvs_in_blk, mvs_in_row;
S32 shift = (encode ? 2 : 0);
if(i4_blk_size1 != i4_blk_size2)
{
i4_blk_x <<= 1;
i4_blk_y <<= 1;
jump = 2;
if((i4_blk_size1 << 2) == i4_blk_size2)
{
i4_blk_x <<= 1;
i4_blk_y <<= 1;
jump = 4;
}
}
mvs_in_blk = ps_layer_mvbank->i4_num_mvs_per_blk;
mvs_in_row = ps_layer_mvbank->i4_num_mvs_per_row;
/* Adjust teh blk coord to point to top left locn */
i4_blk_x -= 1;
i4_blk_y -= 1;
/* Pick up the mvs from the location */
i4_offset = (i4_blk_x * ps_layer_mvbank->i4_num_mvs_per_blk);
i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * i4_blk_y);
ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;
ps_mv += (i1_ref_idx * ps_layer_mvbank->i4_num_mvs_per_ref) + i4_result_id;
pi1_ref_idx += (i1_ref_idx * ps_layer_mvbank->i4_num_mvs_per_ref) + i4_result_id;
ps_mv_base = ps_mv;
pi1_ref_idx_base = pi1_ref_idx;
/* ps_mv and pi1_ref_idx now point to the top left locn */
/* Get 4 mvs as follows: */
ps_search_node = ps_top_neighbours;
COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);
/* Move to top */
ps_search_node++;
ps_mv += mvs_in_blk;
pi1_ref_idx += mvs_in_blk;
COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);
/* Move to t1 : relevant for 4x4 part searches or for partitions i 16x16 */
if(ps_layer_mvbank->i4_num_mvs_per_ref > 1)
{
ps_search_node++;
ps_mv += (mvs_in_blk * (jump >> 1));
pi1_ref_idx += (mvs_in_blk * (jump >> 1));
COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);
}
else
{
ps_search_node++;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
ps_search_node->u1_is_avail = 0;
ps_search_node->u1_subpel_done = 0;
}
/* Move to tr: this will be tr w.r.t. the blk being searched */
ps_search_node++;
if(tr_avail == 0)
{
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
ps_search_node->u1_is_avail = 0;
ps_search_node->u1_subpel_done = 0;
}
else
{
ps_mv = ps_mv_base + (mvs_in_blk * (1 + jump));
pi1_ref_idx = pi1_ref_idx_base + (mvs_in_blk * (1 + jump));
COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);
}
/* Move to left */
ps_search_node = ps_left_neighbours;
ps_mv = ps_mv_base + mvs_in_row;
pi1_ref_idx = pi1_ref_idx_base + mvs_in_row;
COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);
/* Move to l1 */
if(ps_layer_mvbank->i4_num_mvs_per_ref > 1)
{
ps_search_node++;
ps_mv += (mvs_in_row * (jump >> 1));
pi1_ref_idx += (mvs_in_row * (jump >> 1));
COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);
}
else
{
ps_search_node++;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
ps_search_node->u1_is_avail = 0;
ps_search_node->u1_subpel_done = 0;
}
/* Move to bl */
ps_search_node++;
if(bl_avail == 0)
{
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
ps_search_node->u1_is_avail = 0;
}
else
{
ps_mv = ps_mv_base + (mvs_in_row * (1 + jump));
pi1_ref_idx = pi1_ref_idx_base + (mvs_in_row * (1 + jump));
COPY_MV_TO_SEARCH_NODE(ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);
}
}
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)
{
search_node_t *ps_search_node;
hme_mv_t *ps_mv, *ps_mv_base;
S32 i4_offset;
S32 mvs_in_blk, mvs_in_row;
S08 *pi1_ref_idx, *pi1_ref_idx_base;
S32 i4_mv_pos_in_implicit_array;
layer_mv_t *ps_layer_mvbank = ps_curr_layer->ps_layer_mvbank;
S32 i4_blk_size1 = gau1_blk_size_to_wd[ps_layer_mvbank->e_blk_size];
S32 i4_blk_size2 = gau1_blk_size_to_wd[e_search_blk_size];
S32 jump = 1;
S32 shift = 0;
S32 i4_num_results_in_given_dir =
((u1_pred_dir == 1) ? (ps_layer_mvbank->i4_num_mvs_per_ref * i4_num_act_ref_l1)
: (ps_layer_mvbank->i4_num_mvs_per_ref * i4_num_act_ref_l0));
if(i4_blk_size1 != i4_blk_size2)
{
i4_blk_x <<= 1;
i4_blk_y <<= 1;
jump = 2;
if((i4_blk_size1 << 2) == i4_blk_size2)
{
i4_blk_x <<= 1;
i4_blk_y <<= 1;
jump = 4;
}
}
mvs_in_blk = ps_layer_mvbank->i4_num_mvs_per_blk;
mvs_in_row = ps_layer_mvbank->i4_num_mvs_per_row;
/* Adjust the blk coord to point to top left locn */
i4_blk_x -= 1;
i4_blk_y -= 1;
/* Pick up the mvs from the location */
i4_offset = (i4_blk_x * ps_layer_mvbank->i4_num_mvs_per_blk);
i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * i4_blk_y);
i4_offset +=
((u1_pred_dir == 1) ? (ps_layer_mvbank->i4_num_mvs_per_ref * i4_num_act_ref_l0) : 0);
ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;
ps_mv_base = ps_mv;
pi1_ref_idx_base = pi1_ref_idx;
/* TL */
{
/* ps_mv and pi1_ref_idx now point to the top left locn */
ps_search_node = ps_top_neighbours;
i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);
if(-1 != i4_mv_pos_in_implicit_array)
{
COPY_MV_TO_SEARCH_NODE(
ps_search_node,
&ps_mv[i4_mv_pos_in_implicit_array],
&pi1_ref_idx[i4_mv_pos_in_implicit_array],
i1_ref_idx,
shift);
}
else
{
ps_search_node->u1_is_avail = 0;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
}
}
/* Move to top */
{
/* ps_mv and pi1_ref_idx now point to the top left locn */
ps_search_node++;
ps_mv += mvs_in_blk;
pi1_ref_idx += mvs_in_blk;
i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);
if(-1 != i4_mv_pos_in_implicit_array)
{
COPY_MV_TO_SEARCH_NODE(
ps_search_node,
&ps_mv[i4_mv_pos_in_implicit_array],
&pi1_ref_idx[i4_mv_pos_in_implicit_array],
i1_ref_idx,
shift);
}
else
{
ps_search_node->u1_is_avail = 0;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
}
}
/* Move to t1 : relevant for 4x4 part searches or for partitions i 16x16 */
if(ps_layer_mvbank->i4_num_mvs_per_ref > 1)
{
ps_search_node++;
ps_mv += (mvs_in_blk * (jump >> 1));
pi1_ref_idx += (mvs_in_blk * (jump >> 1));
i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);
if(-1 != i4_mv_pos_in_implicit_array)
{
COPY_MV_TO_SEARCH_NODE(
ps_search_node,
&ps_mv[i4_mv_pos_in_implicit_array],
&pi1_ref_idx[i4_mv_pos_in_implicit_array],
i1_ref_idx,
shift);
}
else
{
ps_search_node->u1_is_avail = 0;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
}
}
else
{
ps_search_node++;
ps_search_node->u1_is_avail = 0;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
}
/* Move to tr: this will be tr w.r.t. the blk being searched */
ps_search_node++;
if(tr_avail == 0)
{
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
ps_search_node->u1_is_avail = 0;
ps_search_node->u1_subpel_done = 0;
}
else
{
/* ps_mv and pi1_ref_idx now point to the top left locn */
ps_mv = ps_mv_base + (mvs_in_blk * (1 + jump));
pi1_ref_idx = pi1_ref_idx_base + (mvs_in_blk * (1 + jump));
i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);
if(-1 != i4_mv_pos_in_implicit_array)
{
COPY_MV_TO_SEARCH_NODE(
ps_search_node,
&ps_mv[i4_mv_pos_in_implicit_array],
&pi1_ref_idx[i4_mv_pos_in_implicit_array],
i1_ref_idx,
shift);
}
else
{
ps_search_node->u1_is_avail = 0;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
}
}
/* Move to left */
{
/* ps_mv and pi1_ref_idx now point to the top left locn */
ps_search_node = ps_left_neighbours;
ps_mv = ps_mv_base + mvs_in_row;
pi1_ref_idx = pi1_ref_idx_base + mvs_in_row;
i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);
if(-1 != i4_mv_pos_in_implicit_array)
{
COPY_MV_TO_SEARCH_NODE(
ps_search_node,
&ps_mv[i4_mv_pos_in_implicit_array],
&pi1_ref_idx[i4_mv_pos_in_implicit_array],
i1_ref_idx,
shift);
}
else
{
ps_search_node->u1_is_avail = 0;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
}
}
/* Move to l1 */
if(ps_layer_mvbank->i4_num_mvs_per_ref > 1)
{
/* ps_mv and pi1_ref_idx now point to the top left locn */
ps_search_node++;
ps_mv += (mvs_in_row * (jump >> 1));
pi1_ref_idx += (mvs_in_row * (jump >> 1));
i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);
if(-1 != i4_mv_pos_in_implicit_array)
{
COPY_MV_TO_SEARCH_NODE(
ps_search_node,
&ps_mv[i4_mv_pos_in_implicit_array],
&pi1_ref_idx[i4_mv_pos_in_implicit_array],
i1_ref_idx,
shift);
}
else
{
ps_search_node->u1_is_avail = 0;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
}
}
else
{
ps_search_node++;
ps_search_node->u1_is_avail = 0;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
}
/* Move to bl */
ps_search_node++;
if(bl_avail == 0)
{
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
ps_search_node->u1_is_avail = 0;
}
else
{
/* ps_mv and pi1_ref_idx now point to the top left locn */
ps_mv = ps_mv_base + (mvs_in_row * (1 + jump));
pi1_ref_idx = pi1_ref_idx_base + (mvs_in_row * (1 + jump));
i4_mv_pos_in_implicit_array = hme_find_pos_of_implicitly_stored_ref_id(
pi1_ref_idx, i1_ref_idx, i4_result_id, i4_num_results_in_given_dir);
if(-1 != i4_mv_pos_in_implicit_array)
{
COPY_MV_TO_SEARCH_NODE(
ps_search_node,
&ps_mv[i4_mv_pos_in_implicit_array],
&pi1_ref_idx[i4_mv_pos_in_implicit_array],
i1_ref_idx,
shift);
}
else
{
ps_search_node->u1_is_avail = 0;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
}
}
}
/**
********************************************************************************
* @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] i1_ref_idx : Corresponds to ref idx from which to pick up mv
* results, useful if multiple ref idx candts maintained separately.
*
* @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)
{
search_node_t *ps_grid_node;
layer_mv_t *ps_layer_mvbank = ps_curr_layer->ps_layer_mvbank;
S32 i4_offset;
hme_mv_t *ps_mv, *ps_mv_base;
S08 *pi1_ref_idx, *pi1_ref_idx_base;
S32 jump = 0, inc, i, mvs_in_blk, mvs_in_row;
if(ps_layer_mvbank->e_blk_size == BLK_4x4)
{
/* searching 16x16, mvs are for 4x4 */
jump = 1;
blk_x <<= 2;
blk_y <<= 2;
}
else
{
/* Searching 16x16, mvs are for 8x8 */
blk_x <<= 1;
blk_y <<= 1;
}
ASSERT(ps_layer_mvbank->e_blk_size != BLK_16x16);
mvs_in_blk = ps_layer_mvbank->i4_num_mvs_per_blk;
mvs_in_row = ps_layer_mvbank->i4_num_mvs_per_row;
/* Adjust the blk coord to point to top left locn */
blk_x -= 1;
blk_y -= 1;
/* Pick up the mvs from the location */
i4_offset = (blk_x * ps_layer_mvbank->i4_num_mvs_per_blk);
i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * blk_y);
i4_offset += (u1_pred_dir_ctr == 1);
ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;
ps_mv_base = ps_mv;
pi1_ref_idx_base = pi1_ref_idx;
/* the 0, 0 entry of the grid pts to top left for the ctb */
ps_grid_node = &ps_mv_grid->as_node[0];
/* Copy 18 mvs at 4x4 level including top left, 16 top mvs for ctb, 1 tr */
for(i = 0; i < 18; i++)
{
COPY_MV_TO_SEARCH_NODE(ps_grid_node, ps_mv, pi1_ref_idx, u1_default_ref_id, 0);
ps_grid_node++;
inc = 1;
/* If blk size is 8x8, then every 2 grid nodes are updated with same mv */
if(i & 1)
inc = jump;
ps_mv += (mvs_in_blk * inc);
pi1_ref_idx += (mvs_in_blk * inc);
}
ps_mv = ps_mv_base + mvs_in_row;
pi1_ref_idx = pi1_ref_idx_base + mvs_in_row;
/* now copy left 16 left mvs */
ps_grid_node = &ps_mv_grid->as_node[0];
ps_grid_node += (ps_mv_grid->i4_stride);
for(i = 0; i < 16; i++)
{
COPY_MV_TO_SEARCH_NODE(ps_grid_node, ps_mv, pi1_ref_idx, u1_default_ref_id, 0);
ps_grid_node += ps_mv_grid->i4_stride;
inc = 1;
/* If blk size is 8x8, then every 2 grid nodes are updated with same mv */
if(!(i & 1))
inc = jump;
ps_mv += (mvs_in_row * inc);
pi1_ref_idx += (mvs_in_row * inc);
}
/* last one set to invalid as bottom left not yet encoded */
ps_grid_node->u1_is_avail = 0;
}
void hme_reset_wkg_mem(buf_mgr_t *ps_buf_mgr)
{
ps_buf_mgr->i4_used = 0;
}
void hme_init_wkg_mem(buf_mgr_t *ps_buf_mgr, U08 *pu1_mem, S32 size)
{
ps_buf_mgr->pu1_wkg_mem = pu1_mem;
ps_buf_mgr->i4_total = size;
hme_reset_wkg_mem(ps_buf_mgr);
}
void hme_init_mv_grid(mv_grid_t *ps_mv_grid)
{
S32 i, j;
search_node_t *ps_search_node;
/*************************************************************************/
/* We have a 64x64 CTB in the worst case. For this, we have 16x16 4x4 MVs*/
/* Additionally, we have 1 neighbour on each side. This makes it a 18x18 */
/* MV Grid. The boundary of this Grid on all sides are neighbours and the*/
/* left and top edges of this grid is filled run time. The center portion*/
/* represents the actual CTB MVs (16x16) and is also filled run time. */
/* However, the availability is always set as available (init time) */
/*************************************************************************/
ps_mv_grid->i4_stride = NUM_COLUMNS_IN_CTB_GRID;
ps_mv_grid->i4_start_offset = ps_mv_grid->i4_stride + CTB_MV_GRID_PAD;
ps_search_node = &ps_mv_grid->as_node[ps_mv_grid->i4_start_offset];
for(i = 0; i < 16; i++)
{
for(j = 0; j < 16; j++)
{
ps_search_node[j].u1_is_avail = 1;
}
ps_search_node += ps_mv_grid->i4_stride;
}
}
/**
********************************************************************************
* @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)
{
S32 i, j;
U08 u1_val;
for(i = 0; i < pad_ht; i++)
{
u1_val = pu1_dst[0];
for(j = -pad_wd; j < 0; j++)
pu1_dst[j] = u1_val;
pu1_dst += stride;
}
}
/**
********************************************************************************
* @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)
{
S32 i, j;
U08 u1_val;
for(i = 0; i < pad_ht; i++)
{
u1_val = pu1_dst[0];
for(j = 1; j <= pad_wd; j++)
pu1_dst[j] = u1_val;
pu1_dst += stride;
}
}
/**
********************************************************************************
* @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)
{
S32 i;
for(i = 1; i <= pad_ht; i++)
memcpy(pu1_dst - (i * stride), pu1_dst, 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)
{
S32 i;
for(i = 1; i <= pad_ht; i++)
memcpy(pu1_dst + (i * stride), pu1_dst, pad_wd);
}
/**
********************************************************************************
* @fn void hme_get_wt_inp(layer_ctxt_t *ps_curr_layer, S32 pos_x,
* S32 pos_y, S32 size)
*
* @brief Does weighting of the input in case the search needs to happen
* with reference frames weighted
*
* @param[in] ps_curr_layer: layer ctxt
*
* @param[in] pos_x : x coordinate of the input blk in the picture
*
* @param[in] pos_y : y coordinate of hte input blk in the picture
*
* @param[in] size : size of the input block
*
* @param[in] num_ref : Number of reference frames
*
* @return void
********************************************************************************
*/
void hme_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)
{
S32 ref, i, j;
U08 *pu1_src, *pu1_dst, *pu1_src_tmp;
S32 log_wdc = ps_wt_inp_prms->wpred_log_wdc;
S32 x_count, y_count;
/* Fixed source */
pu1_src = ps_curr_layer->pu1_inp;
/* Make sure the start positions of block are inside frame limits */
pos_x = MIN(pos_x, ps_curr_layer->i4_wd - 1);
pos_y = MIN(pos_y, ps_curr_layer->i4_ht - 1);
pu1_src += (pos_x + (pos_y * ps_curr_layer->i4_inp_stride));
/* In case we handle imcomplete CTBs, we copy only as much as reqd */
/* from input buffers to prevent out of bound accesses. In this */
/* case, we do padding in x or y or both dirns */
x_count = MIN(size, (ps_curr_layer->i4_wd - pos_x));
y_count = MIN(size, (ps_curr_layer->i4_ht - pos_y));
for(i = 0; i < num_ref + 1; i++)
{
ps_wt_inp_prms->apu1_wt_inp[i] = ps_wt_inp_prms->apu1_wt_inp_buf_array[num_ref];
}
/* Run thro all ref ids */
for(ref = 0; ref < num_ref + 1; ref++)
{
S32 wt, off;
S32 inv_wt;
pu1_src_tmp = pu1_src;
/* Each ref id may have differnet wt/offset. */
/* So we have unique inp buf for each ref id */
pu1_dst = ps_wt_inp_prms->apu1_wt_inp[ref];
if(ref == num_ref)
{
/* last ref will be non weighted input */
for(i = 0; i < y_count; i++)
{
for(j = 0; j < x_count; j++)
{
pu1_dst[j] = pu1_src_tmp[j];
}
pu1_src_tmp += ps_curr_layer->i4_inp_stride;
pu1_dst += dst_stride;
}
}
else
{
/* Wt and off specific to this ref id */
wt = ps_wt_inp_prms->a_wpred_wt[ref];
inv_wt = ps_wt_inp_prms->a_inv_wpred_wt[ref];
off = ps_wt_inp_prms->a_wpred_off[ref];
/* Generate size*size worth of modified input samples */
for(i = 0; i < y_count; i++)
{
for(j = 0; j < x_count; j++)
{
S32 tmp;
/* Since we scale input, we use inverse transform of wt pred */
//tmp = HME_INV_WT_PRED(pu1_src_tmp[j], wt, off, log_wdc);
tmp = HME_INV_WT_PRED1(pu1_src_tmp[j], inv_wt, off, log_wdc);
pu1_dst[j] = (U08)(HME_CLIP(tmp, 0, 255));
}
pu1_src_tmp += ps_curr_layer->i4_inp_stride;
pu1_dst += dst_stride;
}
}
/* Check and do padding in right direction if need be */
pu1_dst = ps_wt_inp_prms->apu1_wt_inp[ref];
if(x_count != size)
{
hme_pad_right(pu1_dst + x_count - 1, dst_stride, size - x_count, y_count);
}
/* Check and do padding in bottom directino if need be */
if(y_count != size)
{
hme_pad_bot(pu1_dst + (y_count - 1) * dst_stride, dst_stride, size - y_count, size);
}
}
}
/**
****************************************************************************************
* @fn hme_pick_best_pu_cand(pu_result_t *ps_pu_results_dst,
* pu_result_t *ps_pu_results_inp,
* UWORD8 u1_num_results_per_part,
* UWORD8 u1_num_best_cand)
*
* @brief Does the candidate evaluation across all the current candidates and returns
* the best two or one candidates across given lists
*
* @param[in] - ps_pu_results_inp : Pointer to the input candidates
* - u1_num_results_per_part: Number of available candidates
*
* @param[out] - ps_pu_results_dst : Pointer to best PU results
*
****************************************************************************************
*/
void hme_pick_best_pu_cand(
pu_result_t *ps_pu_results_dst,
pu_result_t *ps_pu_results_list0,
pu_result_t *ps_pu_results_list1,
UWORD8 u1_num_results_per_part_l0,
UWORD8 u1_num_results_per_part_l1,
UWORD8 u1_candidate_rank)
{
struct cand_pos_data
{
U08 u1_cand_list_id;
U08 u1_cand_id_in_cand_list;
} as_cand_pos_data[MAX_NUM_RESULTS_PER_PART_LIST << 1];
S32 ai4_costs[MAX_NUM_RESULTS_PER_PART_LIST << 1];
U08 i, j;
for(i = 0; i < u1_num_results_per_part_l0; i++)
{
ai4_costs[i] = ps_pu_results_list0[i].i4_tot_cost;
as_cand_pos_data[i].u1_cand_id_in_cand_list = i;
as_cand_pos_data[i].u1_cand_list_id = 0;
}
for(i = 0, j = u1_num_results_per_part_l0; i < u1_num_results_per_part_l1; i++, j++)
{
ai4_costs[j] = ps_pu_results_list1[i].i4_tot_cost;
as_cand_pos_data[j].u1_cand_id_in_cand_list = i;
as_cand_pos_data[j].u1_cand_list_id = 1;
}
SORT_PRIMARY_INTTYPE_ARRAY_AND_REORDER_GENERIC_COMPANION_ARRAY(
ai4_costs,
as_cand_pos_data,
u1_num_results_per_part_l0 + u1_num_results_per_part_l1,
struct cand_pos_data);
if(as_cand_pos_data[u1_candidate_rank].u1_cand_list_id)
{
ps_pu_results_dst[0] =
ps_pu_results_list1[as_cand_pos_data[u1_candidate_rank].u1_cand_id_in_cand_list];
}
else
{
ps_pu_results_dst[0] =
ps_pu_results_list0[as_cand_pos_data[u1_candidate_rank].u1_cand_id_in_cand_list];
}
}
/* Returns the number of candidates */
static S32 hme_tu_recur_cand_harvester(
part_type_results_t *ps_cand_container,
inter_pu_results_t *ps_pu_data,
inter_ctb_prms_t *ps_inter_ctb_prms,
S32 i4_part_mask)
{
part_type_results_t s_cand_data;
U08 i, j;
PART_ID_T e_part_id;
S32 i4_num_cands = 0;
/* 2Nx2N part_type decision part */
if(i4_part_mask & ENABLE_2Nx2N)
{
U08 u1_num_candt_to_pick;
e_part_id = ge_part_type_to_part_id[PRT_2Nx2N][0];
ASSERT(ps_inter_ctb_prms->u1_max_2nx2n_tu_recur_cands >= 1);
if(!ps_inter_ctb_prms->i4_bidir_enabled || (i4_part_mask == ENABLE_2Nx2N))
{
u1_num_candt_to_pick =
MIN(ps_inter_ctb_prms->u1_max_2nx2n_tu_recur_cands,
ps_pu_data->u1_num_results_per_part_l0[e_part_id] +
ps_pu_data->u1_num_results_per_part_l1[e_part_id]);
}
else
{
u1_num_candt_to_pick =
MIN(1,
ps_pu_data->u1_num_results_per_part_l0[e_part_id] +
ps_pu_data->u1_num_results_per_part_l1[e_part_id]);
}
if(ME_XTREME_SPEED_25 == ps_inter_ctb_prms->i1_quality_preset)
{
u1_num_candt_to_pick = MIN(u1_num_candt_to_pick, MAX_NUM_TU_RECUR_CANDS_IN_XS25);
}
for(i = 0; i < u1_num_candt_to_pick; i++)
{
/* Picks the best two candidates of all the available ones */
hme_pick_best_pu_cand(
ps_cand_container[i4_num_cands].as_pu_results,
ps_pu_data->aps_pu_results[0][e_part_id],
ps_pu_data->aps_pu_results[1][e_part_id],
ps_pu_data->u1_num_results_per_part_l0[e_part_id],
ps_pu_data->u1_num_results_per_part_l1[e_part_id],
i);
/* Update the other params part_type and total_cost in part_type_results */
ps_cand_container[i4_num_cands].u1_part_type = e_part_id;
ps_cand_container[i4_num_cands].i4_tot_cost =
ps_cand_container[i4_num_cands].as_pu_results->i4_tot_cost;
i4_num_cands++;
}
}
/* SMP */
{
S32 i4_total_cost;
S32 num_part_types = PRT_Nx2N - PRT_2NxN + 1;
S32 start_part_type = PRT_2NxN;
S32 best_cost = MAX_32BIT_VAL;
S32 part_type_cnt = 0;
for(j = 0; j < num_part_types; j++)
{
if(!(i4_part_mask & gai4_part_type_to_part_mask[j + start_part_type]))
{
continue;
}
for(i = 0; i < gau1_num_parts_in_part_type[j + start_part_type]; i++)
{
e_part_id = ge_part_type_to_part_id[j + start_part_type][i];
/* Pick the best candidate for the partition acroos lists */
hme_pick_best_pu_cand(
&s_cand_data.as_pu_results[i],
ps_pu_data->aps_pu_results[0][e_part_id],
ps_pu_data->aps_pu_results[1][e_part_id],
ps_pu_data->u1_num_results_per_part_l0[e_part_id],
ps_pu_data->u1_num_results_per_part_l1[e_part_id],
0);
}
i4_total_cost =
s_cand_data.as_pu_results[0].i4_tot_cost + s_cand_data.as_pu_results[1].i4_tot_cost;
if(i4_total_cost < best_cost)
{
/* Stores the index of the best part_type in the sub-catoegory */
best_cost = i4_total_cost;
ps_cand_container[i4_num_cands] = s_cand_data;
ps_cand_container[i4_num_cands].u1_part_type = j + start_part_type;
ps_cand_container[i4_num_cands].i4_tot_cost = i4_total_cost;
}
part_type_cnt++;
}
i4_num_cands = (part_type_cnt) ? (i4_num_cands + 1) : i4_num_cands;
}
/* AMP */
{
S32 i4_total_cost;
S32 num_part_types = PRT_nRx2N - PRT_2NxnU + 1;
S32 start_part_type = PRT_2NxnU;
S32 best_cost = MAX_32BIT_VAL;
S32 part_type_cnt = 0;
for(j = 0; j < num_part_types; j++)
{
if(!(i4_part_mask & gai4_part_type_to_part_mask[j + start_part_type]))
{
continue;
}
for(i = 0; i < gau1_num_parts_in_part_type[j + start_part_type]; i++)
{
e_part_id = ge_part_type_to_part_id[j + start_part_type][i];
/* Pick the best candidate for the partition acroos lists */
hme_pick_best_pu_cand(
&s_cand_data.as_pu_results[i],
ps_pu_data->aps_pu_results[0][e_part_id],
ps_pu_data->aps_pu_results[1][e_part_id],
ps_pu_data->u1_num_results_per_part_l0[e_part_id],
ps_pu_data->u1_num_results_per_part_l1[e_part_id],
0);
}
i4_total_cost =
s_cand_data.as_pu_results[0].i4_tot_cost + s_cand_data.as_pu_results[1].i4_tot_cost;
if(i4_total_cost < best_cost)
{
/* Stores the index of the best part_type in the sub-catoegory */
best_cost = i4_total_cost;
ps_cand_container[i4_num_cands] = s_cand_data;
ps_cand_container[i4_num_cands].u1_part_type = j + start_part_type;
ps_cand_container[i4_num_cands].i4_tot_cost = i4_total_cost;
}
part_type_cnt++;
}
i4_num_cands = (part_type_cnt) ? (i4_num_cands + 1) : i4_num_cands;
}
return i4_num_cands;
}
/**
*****************************************************************************
* @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)
* }
* ||
* ||
* \/
* Bi-Pred evaluation:
* for upto 4 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
)
{
S32 i, j;
S32 i4_part_mask;
ULWORD64 au8_pred_sigmaXSquare[NUM_BEST_ME_OUTPUTS][NUM_INTER_PU_PARTS];
ULWORD64 au8_pred_sigmaX[NUM_BEST_ME_OUTPUTS][NUM_INTER_PU_PARTS];
S32 i4_noise_term;
WORD32 e_part_id;
PF_SAD_FXN_TU_REC apf_err_compute[4];
part_type_results_t as_part_type_results[NUM_BEST_ME_OUTPUTS];
part_type_results_t *ps_part_type_results;
S32 num_best_cand = 0;
const S32 i4_default_src_wt = ((1 << 15) + (WGHT_DEFAULT >> 1)) / WGHT_DEFAULT;
i4_part_mask = ps_cu_results->i4_part_mask;
num_best_cand = hme_tu_recur_cand_harvester(
as_part_type_results, ps_pu_results, ps_inter_ctb_prms, i4_part_mask);
/* Partition ID for the current PU */
e_part_id = (UWORD8)ge_part_type_to_part_id[PRT_2Nx2N][0];
ps_part_type_results = as_part_type_results;
for(i = 0; i < num_best_cand; i++)
{
hme_compute_pred_and_evaluate_bi(
ps_cu_results,
ps_pu_results,
ps_inter_ctb_prms,
&(ps_part_type_results[i]),
au8_pred_sigmaXSquare[i],
au8_pred_sigmaX[i],
ps_cmn_utils_optimised_function_list,
ps_me_optimised_function_list
);
}
/* Perform TU_REC on the best candidates selected */
{
WORD32 i4_sad_grid;
WORD32 ai4_tu_split_flag[4];
WORD32 ai4_tu_early_cbf[4];
WORD32 best_cost[NUM_BEST_ME_OUTPUTS];
WORD32 ai4_final_idx[NUM_BEST_ME_OUTPUTS];
WORD16 i2_wght;
WORD32 i4_satd;
err_prms_t s_err_prms;
err_prms_t *ps_err_prms = &s_err_prms;
/* Default cost and final idx initialization */
for(i = 0; i < num_best_cand; i++)
{
best_cost[i] = MAX_32BIT_VAL;
ai4_final_idx[i] = -1;
}
/* Assign the stad function to the err_compute function pointer :
Implemented only for 32x32 and 64x64, hence 16x16 and 8x8 are kept NULL */
apf_err_compute[CU_64x64] = hme_evalsatd_pt_pu_64x64_tu_rec;
apf_err_compute[CU_32x32] = hme_evalsatd_pt_pu_32x32_tu_rec;
apf_err_compute[CU_16x16] = hme_evalsatd_pt_pu_16x16_tu_rec;
apf_err_compute[CU_8x8] = hme_evalsatd_pt_pu_8x8_tu_rec;
ps_err_prms->pi4_sad_grid = &i4_sad_grid;
ps_err_prms->pi4_tu_split_flags = ai4_tu_split_flag;
ps_err_prms->u1_max_tr_depth = ps_inter_ctb_prms->u1_max_tr_depth;
ps_err_prms->pi4_tu_early_cbf = ai4_tu_early_cbf;
ps_err_prms->i4_grid_mask = 1;
ps_err_prms->pu1_wkg_mem = ps_inter_ctb_prms->pu1_wkg_mem;
ps_err_prms->u1_max_tr_size = 32;
if(ps_inter_ctb_prms->u1_is_cu_noisy)
{
ps_err_prms->u1_max_tr_size = MAX_TU_SIZE_WHEN_NOISY;
}
/* TU_REC for the best candidates, as mentioned in NOTE above (except candidates that
are disabled by Part_mask */
for(i = 0; i < num_best_cand; i++)
{
part_type_results_t *ps_best_results;
pu_result_t *ps_pu_result;
WORD32 part_type_cost;
WORD32 cand_idx;
WORD32 pred_dir;
S32 i4_inp_off;
S32 lambda;
U08 lambda_qshift;
U08 *apu1_inp[MAX_NUM_INTER_PARTS];
S16 ai2_wt[MAX_NUM_INTER_PARTS];
S32 ai4_inv_wt[MAX_NUM_INTER_PARTS];
S32 ai4_inv_wt_shift_val[MAX_NUM_INTER_PARTS];
WORD32 part_type = ps_part_type_results[i].u1_part_type;
WORD32 e_cu_size = ps_cu_results->u1_cu_size;
WORD32 e_blk_size = ge_cu_size_to_blk_size[e_cu_size];
U08 u1_num_parts = gau1_num_parts_in_part_type[part_type];
U08 u1_inp_buf_idx = UCHAR_MAX;
ps_err_prms->i4_part_mask = i4_part_mask;
ps_err_prms->i4_blk_wd = gau1_blk_size_to_wd[e_blk_size];
ps_err_prms->i4_blk_ht = gau1_blk_size_to_ht[e_blk_size];
ps_err_prms->pu1_ref = ps_part_type_results[i].pu1_pred;
ps_err_prms->i4_ref_stride = ps_part_type_results[i].i4_pred_stride;
/* Current offset for the present part type */
i4_inp_off = ps_cu_results->i4_inp_offset;
ps_best_results = &(ps_part_type_results[i]);
part_type_cost = 0;
lambda = ps_inter_ctb_prms->i4_lamda;
lambda_qshift = ps_inter_ctb_prms->u1_lamda_qshift;
for(j = 0; j < u1_num_parts; j++)
{
ps_pu_result = &(ps_best_results->as_pu_results[j]);
pred_dir = ps_pu_result->pu.b2_pred_mode;
if(PRED_L0 == pred_dir)
{
apu1_inp[j] =
ps_inter_ctb_prms->apu1_wt_inp[PRED_L0][ps_pu_result->pu.mv.i1_l0_ref_idx] +
i4_inp_off;
ai2_wt[j] =
ps_inter_ctb_prms->pps_rec_list_l0[ps_pu_result->pu.mv.i1_l0_ref_idx]
->s_weight_offset.i2_luma_weight;
ai4_inv_wt[j] =
ps_inter_ctb_prms->pi4_inv_wt
[ps_inter_ctb_prms->pi1_past_list[ps_pu_result->pu.mv.i1_l0_ref_idx]];
ai4_inv_wt_shift_val[j] =
ps_inter_ctb_prms->pi4_inv_wt_shift_val
[ps_inter_ctb_prms->pi1_past_list[ps_pu_result->pu.mv.i1_l0_ref_idx]];
}
else if(PRED_L1 == pred_dir)
{
apu1_inp[j] =
ps_inter_ctb_prms->apu1_wt_inp[PRED_L1][ps_pu_result->pu.mv.i1_l1_ref_idx] +
i4_inp_off;
ai2_wt[j] =
ps_inter_ctb_prms->pps_rec_list_l1[ps_pu_result->pu.mv.i1_l1_ref_idx]
->s_weight_offset.i2_luma_weight;
ai4_inv_wt[j] =
ps_inter_ctb_prms->pi4_inv_wt
[ps_inter_ctb_prms->pi1_future_list[ps_pu_result->pu.mv.i1_l1_ref_idx]];
ai4_inv_wt_shift_val[j] =
ps_inter_ctb_prms->pi4_inv_wt_shift_val
[ps_inter_ctb_prms->pi1_future_list[ps_pu_result->pu.mv.i1_l1_ref_idx]];
}
else if(PRED_BI == pred_dir)
{
apu1_inp[j] = ps_inter_ctb_prms->pu1_non_wt_inp + i4_inp_off;
ai2_wt[j] = 1 << ps_inter_ctb_prms->wpred_log_wdc;
ai4_inv_wt[j] = i4_default_src_wt;
ai4_inv_wt_shift_val[j] = 0;
}
else
{
ASSERT(0);
}
part_type_cost += ps_pu_result->i4_mv_cost;
}
if((u1_num_parts == 1) || (ai2_wt[0] == ai2_wt[1]))
{
ps_err_prms->pu1_inp = apu1_inp[0];
ps_err_prms->i4_inp_stride = ps_inter_ctb_prms->i4_inp_stride;
i2_wght = ai2_wt[0];
}
else
{
if(1 != ihevce_get_free_pred_buf_indices(
&u1_inp_buf_idx,
&ps_inter_ctb_prms->s_pred_buf_mngr.u4_pred_buf_usage_indicator,
1))
{
ASSERT(0);
}
else
{
U08 *pu1_dst =
ps_inter_ctb_prms->s_pred_buf_mngr.apu1_pred_bufs[u1_inp_buf_idx];
U08 *pu1_src = apu1_inp[0];
U08 u1_pu1_wd = (ps_part_type_results[i].as_pu_results[0].pu.b4_wd + 1) << 2;
U08 u1_pu1_ht = (ps_part_type_results[i].as_pu_results[0].pu.b4_ht + 1) << 2;
U08 u1_pu2_wd = (ps_part_type_results[i].as_pu_results[1].pu.b4_wd + 1) << 2;
U08 u1_pu2_ht = (ps_part_type_results[i].as_pu_results[1].pu.b4_ht + 1) << 2;
ps_cmn_utils_optimised_function_list->pf_copy_2d(
pu1_dst,
MAX_CU_SIZE,
pu1_src,
ps_inter_ctb_prms->i4_inp_stride,
u1_pu1_wd,
u1_pu1_ht);
pu1_dst +=
(gai1_is_part_vertical[ge_part_type_to_part_id[part_type][0]]
? u1_pu1_ht * MAX_CU_SIZE
: u1_pu1_wd);
pu1_src =
apu1_inp[1] + (gai1_is_part_vertical[ge_part_type_to_part_id[part_type][0]]
? u1_pu1_ht * ps_inter_ctb_prms->i4_inp_stride
: u1_pu1_wd);
ps_cmn_utils_optimised_function_list->pf_copy_2d(
pu1_dst,
MAX_CU_SIZE,
pu1_src,
ps_inter_ctb_prms->i4_inp_stride,
u1_pu2_wd,
u1_pu2_ht);
ps_err_prms->pu1_inp =
ps_inter_ctb_prms->s_pred_buf_mngr.apu1_pred_bufs[u1_inp_buf_idx];
ps_err_prms->i4_inp_stride = MAX_CU_SIZE;
i2_wght = ai2_wt[1];
}
}
#if !DISABLE_TU_RECURSION
i4_satd = apf_err_compute[e_cu_size](
ps_err_prms,
lambda,
lambda_qshift,
ps_inter_ctb_prms->i4_qstep_ls8,
ps_ctxt->ps_func_selector);
#else
ps_err_prms->pi4_sad_grid = &i4_satd;
pf_err_compute(ps_err_prms);
if((part_type == PRT_2Nx2N) || (e_cu_size != CU_64x64))
{
ai4_tu_split_flag[0] = 1;
ai4_tu_split_flag[1] = 1;
ai4_tu_split_flag[2] = 1;
ai4_tu_split_flag[3] = 1;
ps_err_prms->i4_tu_split_cost = 0;
}
else
{
ai4_tu_split_flag[0] = 1;
ai4_tu_split_flag[1] = 1;
ai4_tu_split_flag[2] = 1;
ai4_tu_split_flag[3] = 1;
ps_err_prms->i4_tu_split_cost = 0;
}
#endif
#if UNI_SATD_SCALE
i4_satd = (i4_satd * i2_wght) >> ps_inter_ctb_prms->wpred_log_wdc;
#endif
if(ps_inter_ctb_prms->u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)
{
ULWORD64 u8_temp_var, u8_temp_var1, u8_pred_sigmaSquaredX;
ULWORD64 u8_src_variance, u8_pred_variance;
unsigned long u4_shift_val;
S32 i4_bits_req;
S32 i4_q_level = STIM_Q_FORMAT + ALPHA_Q_FORMAT;
if(1 == u1_num_parts)
{
u8_pred_sigmaSquaredX = au8_pred_sigmaX[i][0] * au8_pred_sigmaX[i][0];
u8_pred_variance = au8_pred_sigmaXSquare[i][0] - u8_pred_sigmaSquaredX;
if(e_cu_size == CU_8x8)
{
PART_ID_T e_part_id = (PART_ID_T)(
(PART_ID_NxN_TL) + (ps_cu_results->u1_x_off & 1) +
((ps_cu_results->u1_y_off & 1) << 1));
u4_shift_val = ihevce_calc_stim_injected_variance(
ps_inter_ctb_prms->pu8_part_src_sigmaX,
ps_inter_ctb_prms->pu8_part_src_sigmaXSquared,
&u8_src_variance,
ai4_inv_wt[0],
ai4_inv_wt_shift_val[0],
ps_inter_ctb_prms->wpred_log_wdc,
e_part_id);
}
else
{
u4_shift_val = ihevce_calc_stim_injected_variance(
ps_inter_ctb_prms->pu8_part_src_sigmaX,
ps_inter_ctb_prms->pu8_part_src_sigmaXSquared,
&u8_src_variance,
ai4_inv_wt[0],
ai4_inv_wt_shift_val[0],
ps_inter_ctb_prms->wpred_log_wdc,
e_part_id);
}
u8_pred_variance = u8_pred_variance >> u4_shift_val;
GETRANGE64(i4_bits_req, u8_pred_variance);
if(i4_bits_req > 27)
{
u8_pred_variance = u8_pred_variance >> (i4_bits_req - 27);
u8_src_variance = u8_src_variance >> (i4_bits_req - 27);
}
if(u8_src_variance == u8_pred_variance)
{
u8_temp_var = (1 << STIM_Q_FORMAT);
}
else
{
u8_temp_var = (2 * u8_src_variance * u8_pred_variance);
u8_temp_var = (u8_temp_var * (1 << STIM_Q_FORMAT));
u8_temp_var1 = (u8_src_variance * u8_src_variance) +
(u8_pred_variance * u8_pred_variance);
u8_temp_var = (u8_temp_var + (u8_temp_var1 / 2));
u8_temp_var = (u8_temp_var / u8_temp_var1);
}
i4_noise_term = (UWORD32)u8_temp_var;
ASSERT(i4_noise_term >= 0);
i4_noise_term *= ps_inter_ctb_prms->i4_alpha_stim_multiplier;
u8_temp_var = i4_satd;
u8_temp_var *= ((1 << (i4_q_level)) - (i4_noise_term));
u8_temp_var += (1 << ((i4_q_level)-1));
i4_satd = (UWORD32)(u8_temp_var >> (i4_q_level));
}
else /*if(e_cu_size <= CU_16x16)*/
{
unsigned long temp_shift_val;
PART_ID_T ae_part_id[MAX_NUM_INTER_PARTS] = {
ge_part_type_to_part_id[part_type][0], ge_part_type_to_part_id[part_type][1]
};
u4_shift_val = ihevce_calc_variance_for_diff_weights(
ps_inter_ctb_prms->pu8_part_src_sigmaX,
ps_inter_ctb_prms->pu8_part_src_sigmaXSquared,
&u8_src_variance,
ai4_inv_wt,
ai4_inv_wt_shift_val,
ps_best_results->as_pu_results,
ps_inter_ctb_prms->wpred_log_wdc,
ae_part_id,
gau1_blk_size_to_wd[e_blk_size],
u1_num_parts,
1);
temp_shift_val = u4_shift_val;
u4_shift_val = ihevce_calc_variance_for_diff_weights(
au8_pred_sigmaX[i],
au8_pred_sigmaXSquare[i],
&u8_pred_variance,
ai4_inv_wt,
ai4_inv_wt_shift_val,
ps_best_results->as_pu_results,
0,
ae_part_id,
gau1_blk_size_to_wd[e_blk_size],
u1_num_parts,
0);
u8_pred_variance = u8_pred_variance >> temp_shift_val;
GETRANGE64(i4_bits_req, u8_pred_variance);
if(i4_bits_req > 27)
{
u8_pred_variance = u8_pred_variance >> (i4_bits_req - 27);
u8_src_variance = u8_src_variance >> (i4_bits_req - 27);
}
if(u8_src_variance == u8_pred_variance)
{
u8_temp_var = (1 << STIM_Q_FORMAT);
}
else
{
u8_temp_var = (2 * u8_src_variance * u8_pred_variance);
u8_temp_var = (u8_temp_var * (1 << STIM_Q_FORMAT));
u8_temp_var1 = (u8_src_variance * u8_src_variance) +
(u8_pred_variance * u8_pred_variance);
u8_temp_var = (u8_temp_var + (u8_temp_var1 / 2));
u8_temp_var = (u8_temp_var / u8_temp_var1);
}
i4_noise_term = (UWORD32)u8_temp_var;
ASSERT(i4_noise_term >= 0);
ASSERT(i4_noise_term <= (1 << (STIM_Q_FORMAT + ALPHA_Q_FORMAT)));
i4_noise_term *= ps_inter_ctb_prms->i4_alpha_stim_multiplier;
u8_temp_var = i4_satd;
u8_temp_var *= ((1 << (i4_q_level)) - (i4_noise_term));
u8_temp_var += (1 << ((i4_q_level)-1));
i4_satd = (UWORD32)(u8_temp_var >> (i4_q_level));
ASSERT(i4_satd >= 0);
}
}
if(u1_inp_buf_idx != UCHAR_MAX)
{
ihevce_set_pred_buf_as_free(
&ps_inter_ctb_prms->s_pred_buf_mngr.u4_pred_buf_usage_indicator,
u1_inp_buf_idx);
}
part_type_cost += i4_satd;
/*Update the best results with the new results */
ps_best_results->i4_tot_cost = part_type_cost;
ps_best_results->i4_tu_split_cost = ps_err_prms->i4_tu_split_cost;
ASSERT(ai4_tu_split_flag[0] >= 0);
if(e_cu_size == CU_64x64)
{
ps_best_results->ai4_tu_split_flag[0] = ai4_tu_split_flag[0];
ps_best_results->ai4_tu_split_flag[1] = ai4_tu_split_flag[1];
ps_best_results->ai4_tu_split_flag[2] = ai4_tu_split_flag[2];
ps_best_results->ai4_tu_split_flag[3] = ai4_tu_split_flag[3];
/* Update the TU early cbf flags into the best results structure */
ps_best_results->ai4_tu_early_cbf[0] = ai4_tu_early_cbf[0];
ps_best_results->ai4_tu_early_cbf[1] = ai4_tu_early_cbf[1];
ps_best_results->ai4_tu_early_cbf[2] = ai4_tu_early_cbf[2];
ps_best_results->ai4_tu_early_cbf[3] = ai4_tu_early_cbf[3];
}
else
{
ps_best_results->ai4_tu_split_flag[0] = ai4_tu_split_flag[0];
ps_best_results->ai4_tu_early_cbf[0] = ai4_tu_early_cbf[0];
}
if(part_type_cost < best_cost[num_best_cand - 1])
{
/* Push and sort current part type if it is one of the num_best_cand */
for(cand_idx = 0; cand_idx < i; cand_idx++)
{
if(part_type_cost <= best_cost[cand_idx])
{
memmove(
&ai4_final_idx[cand_idx + 1],
&ai4_final_idx[cand_idx],
sizeof(WORD32) * (i - cand_idx));
memmove(
&best_cost[cand_idx + 1],
&best_cost[cand_idx],
sizeof(WORD32) * (i - cand_idx));
break;
}
}
ai4_final_idx[cand_idx] = i;
best_cost[cand_idx] = part_type_cost;
}
}
ps_cu_results->u1_num_best_results = num_best_cand;
for(i = 0; i < num_best_cand; i++)
{
ASSERT(ai4_final_idx[i] < num_best_cand);
if(ai4_final_idx[i] != -1)
{
memcpy(
&(ps_cu_results->ps_best_results[i]),
&(ps_part_type_results[ai4_final_idx[i]]),
sizeof(part_type_results_t));
}
}
}
for(i = 0; i < (MAX_NUM_PRED_BUFS_USED_FOR_PARTTYPE_DECISIONS)-2; i++)
{
ihevce_set_pred_buf_as_free(
&ps_inter_ctb_prms->s_pred_buf_mngr.u4_pred_buf_usage_indicator, i);
}
}
/**
**************************************************************************************************
* @fn hme_populate_pus(search_results_t *ps_search_results, inter_cu_results_t *ps_cu_results)
*
* @brief Does the population of the inter_cu_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)
{
WORD32 i, j, k;
WORD32 i4_part_mask;
WORD32 i4_ref;
UWORD8 e_part_id;
pu_result_t *ps_curr_pu;
search_node_t *ps_search_node;
part_attr_t *ps_part_attr;
UWORD8 e_cu_size = ps_search_results->e_cu_size;
WORD32 num_results_per_part_l0 = 0;
WORD32 num_results_per_part_l1 = 0;
WORD32 i4_ref_id;
WORD32 i4_total_act_ref;
i4_part_mask = ps_search_results->i4_part_mask;
/* pred_buf_mngr init */
{
hme_get_wkg_mem(&ps_ctxt->s_buf_mgr, MAX_WKG_MEM_SIZE_PER_THREAD);
ps_inter_ctb_prms->s_pred_buf_mngr.u4_pred_buf_usage_indicator = UINT_MAX;
for(i = 0; i < MAX_NUM_PRED_BUFS_USED_FOR_PARTTYPE_DECISIONS - 2; i++)
{
ps_inter_ctb_prms->s_pred_buf_mngr.apu1_pred_bufs[i] =
ps_ctxt->s_buf_mgr.pu1_wkg_mem + i * INTERP_OUT_BUF_SIZE;
ps_inter_ctb_prms->s_pred_buf_mngr.u4_pred_buf_usage_indicator &= ~(1 << i);
}
ps_inter_ctb_prms->pu1_wkg_mem = ps_ctxt->s_buf_mgr.pu1_wkg_mem + i * INTERP_OUT_BUF_SIZE;
}
ps_inter_ctb_prms->i4_alpha_stim_multiplier = ALPHA_FOR_NOISE_TERM_IN_ME;
ps_inter_ctb_prms->u1_is_cu_noisy = ps_subpel_prms->u1_is_cu_noisy;
ps_inter_ctb_prms->i4_lamda = ps_search_results->as_pred_ctxt[0].lambda;
/* Populate the CU level parameters */
ps_cu_results->u1_cu_size = ps_search_results->e_cu_size;
ps_cu_results->u1_num_best_results = ps_search_results->u1_num_best_results;
ps_cu_results->i4_part_mask = ps_search_results->i4_part_mask;
ps_cu_results->u1_x_off = ps_search_results->u1_x_off;
ps_cu_results->u1_y_off = ps_search_results->u1_y_off;
i4_total_act_ref =
ps_ctxt->s_frm_prms.u1_num_active_ref_l0 + ps_ctxt->s_frm_prms.u1_num_active_ref_l1;
/*Populate the partition results
Loop across all the active references that are enabled right now */
for(i = 0; i < MAX_PART_TYPES; i++)
{
if(!(i4_part_mask & gai4_part_type_to_part_mask[i]))
{
continue;
}
for(j = 0; j < gau1_num_parts_in_part_type[i]; j++)
{
/* Partition ID for the current PU */
e_part_id = (UWORD8)ge_part_type_to_part_id[i][j];
ps_part_attr = &gas_part_attr_in_cu[e_part_id];
num_results_per_part_l0 = 0;
num_results_per_part_l1 = 0;
ps_pu_results->aps_pu_results[0][e_part_id] =
ps_pu_result + (e_part_id * MAX_NUM_RESULTS_PER_PART_LIST);
ps_pu_results->aps_pu_results[1][e_part_id] =
ps_pu_result + ((e_part_id + TOT_NUM_PARTS) * MAX_NUM_RESULTS_PER_PART_LIST);
for(i4_ref = 0; i4_ref < i4_num_active_ref; i4_ref++)
{
U08 u1_pred_dir = pu1_pred_dir_searched[i4_ref];
for(k = 0; k < ps_search_results->u1_num_results_per_part; k++)
{
ps_search_node =
&ps_search_results->aps_part_results[u1_pred_dir][e_part_id][k];
/* If subpel is done then the node is a valid candidate else break the loop */
if(ps_search_node->u1_subpel_done)
{
i4_ref_id = ps_search_node->i1_ref_idx;
ASSERT(i4_ref_id >= 0);
/* Check whether current ref_id is past or future and assign the pointers to L0 or L1 list accordingly */
if(!u1_pred_dir)
{
ps_curr_pu = ps_pu_results->aps_pu_results[0][e_part_id] +
num_results_per_part_l0;
ASSERT(
ps_ctxt->a_ref_idx_lc_to_l0[i4_ref_id] <
ps_inter_ctb_prms->u1_num_active_ref_l0);
/* Always populate the ref_idx value in l0_ref_idx */
ps_curr_pu->pu.mv.i1_l0_ref_idx =
ps_ctxt->a_ref_idx_lc_to_l0[i4_ref_id];
ps_curr_pu->pu.mv.s_l0_mv = ps_search_node->s_mv;
ps_curr_pu->pu.mv.i1_l1_ref_idx = -1;
ps_curr_pu->pu.b2_pred_mode = PRED_L0;
ps_inter_ctb_prms->apu1_wt_inp[0][ps_curr_pu->pu.mv.i1_l0_ref_idx] =
ps_wt_prms->apu1_wt_inp[i4_ref_id];
num_results_per_part_l0++;
}
else
{
ps_curr_pu = ps_pu_results->aps_pu_results[1][e_part_id] +
num_results_per_part_l1;
ASSERT(
ps_ctxt->a_ref_idx_lc_to_l1[i4_ref_id] <
ps_inter_ctb_prms->u1_num_active_ref_l1);
/* populate the ref_idx value in l1_ref_idx */
ps_curr_pu->pu.mv.i1_l1_ref_idx =
ps_ctxt->a_ref_idx_lc_to_l1[i4_ref_id];
ps_curr_pu->pu.mv.s_l1_mv = ps_search_node->s_mv;
ps_curr_pu->pu.mv.i1_l0_ref_idx = -1;
ps_curr_pu->pu.b2_pred_mode = PRED_L1;
/* Copy the values from weighted params to common_frm_aprams */
ps_inter_ctb_prms->apu1_wt_inp[1][ps_curr_pu->pu.mv.i1_l1_ref_idx] =
ps_wt_prms->apu1_wt_inp[i4_ref_id];
num_results_per_part_l1++;
}
ps_curr_pu->i4_mv_cost = ps_search_node->i4_mv_cost;
ps_curr_pu->i4_sdi = ps_search_node->i4_sdi;
#if UNI_SATD_SCALE
/*SATD is scaled by weight. Hence rescale the SATD */
ps_curr_pu->i4_tot_cost =
((ps_search_node->i4_sad *
ps_ctxt->s_wt_pred.a_wpred_wt[ps_search_node->i1_ref_idx] +
(1 << (ps_inter_ctb_prms->wpred_log_wdc - 1))) >>
ps_inter_ctb_prms->wpred_log_wdc) +
ps_search_node->i4_mv_cost;
#endif
/* Packed format of the width and height */
ps_curr_pu->pu.b4_wd = ((ps_part_attr->u1_x_count << e_cu_size) >> 2) - 1;
ps_curr_pu->pu.b4_ht = ((ps_part_attr->u1_y_count << e_cu_size) >> 2) - 1;
ps_curr_pu->pu.b4_pos_x =
(((ps_part_attr->u1_x_start << e_cu_size) + ps_cu_results->u1_x_off) >>
2);
ps_curr_pu->pu.b4_pos_y =
(((ps_part_attr->u1_y_start << e_cu_size) + ps_cu_results->u1_y_off) >>
2);
ps_curr_pu->pu.b1_intra_flag = 0;
/* Unweighted input */
ps_inter_ctb_prms->pu1_non_wt_inp =
ps_wt_prms->apu1_wt_inp[i4_total_act_ref];
ps_search_node++;
}
else
{
break;
}
}
}
ps_pu_results->u1_num_results_per_part_l0[e_part_id] = num_results_per_part_l0;
ps_pu_results->u1_num_results_per_part_l1[e_part_id] = num_results_per_part_l1;
}
}
}
/**
*********************************************************************************************************
* @fn hme_populate_pus_8x8_cu(search_results_t *ps_search_results, inter_cu_results_t *ps_cu_results)
*
* @brief Does the population of the inter_cu_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_results : Pointer for the PU's
* ps_pu_result : Pointer to the memory for storing PU's
*
*********************************************************************************************************
*/
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)
{
WORD32 i, k;
WORD32 i4_part_mask;
WORD32 i4_ref;
pu_result_t *ps_curr_pu;
search_node_t *ps_search_node;
WORD32 i4_ref_id;
WORD32 x_off, y_off;
/* Make part mask available as only 2Nx2N
Later support for 4x8 and 8x4 needs to be added */
i4_part_mask = ENABLE_2Nx2N;
x_off = ps_search_results->u1_x_off;
y_off = ps_search_results->u1_y_off;
for(i = 0; i < 4; i++)
{
if(u1_blk_8x8_mask & (1 << i))
{
UWORD8 u1_x_pos, u1_y_pos;
WORD32 num_results_per_part_l0 = 0;
WORD32 num_results_per_part_l1 = 0;
ps_cu_results->u1_cu_size = CU_8x8;
ps_cu_results->u1_num_best_results = ps_search_results->u1_num_best_results;
ps_cu_results->i4_part_mask = i4_part_mask;
ps_cu_results->u1_x_off = x_off + (i & 1) * 8;
ps_cu_results->u1_y_off = y_off + (i >> 1) * 8;
ps_cu_results->i4_inp_offset = ps_cu_results->u1_x_off + (ps_cu_results->u1_y_off * 64);
ps_cu_results->ps_best_results[0].i4_tot_cost = MAX_32BIT_VAL;
ps_cu_results->ps_best_results[0].i4_tu_split_cost = 0;
u1_x_pos = ps_cu_results->u1_x_off >> 2;
u1_y_pos = ps_cu_results->u1_y_off >> 2;
if(!(ps_search_results->i4_part_mask & ENABLE_NxN))
{
ps_curr_pu = &ps_cu_results->ps_best_results[0].as_pu_results[0];
ps_cu_results->i4_part_mask = 0;
ps_cu_results->u1_num_best_results = 0;
ps_curr_pu->i4_tot_cost = MAX_32BIT_VAL;
ps_curr_pu->pu.b4_wd = 1;
ps_curr_pu->pu.b4_ht = 1;
ps_curr_pu->pu.b4_pos_x = u1_x_pos;
ps_curr_pu->pu.b4_pos_y = u1_y_pos;
ps_cu_results->ps_best_results[0].i4_tu_split_cost = 0;
ps_cu_results++;
ps_pu_results++;
continue;
}
ps_pu_results->aps_pu_results[0][0] =
ps_pu_result + (i * MAX_NUM_RESULTS_PER_PART_LIST);
ps_pu_results->aps_pu_results[1][0] =
ps_pu_result + ((i + TOT_NUM_PARTS) * MAX_NUM_RESULTS_PER_PART_LIST);
for(i4_ref = 0; i4_ref < i4_num_active_ref; i4_ref++)
{
U08 u1_pred_dir = pu1_pred_dir_searched[i4_ref];
/* Select the NxN partition node for the current ref_idx in the search results*/
ps_search_node =
ps_search_results->aps_part_results[u1_pred_dir][PART_ID_NxN_TL + i];
for(k = 0; k < ps_search_results->u1_num_results_per_part; k++)
{
/* If subpel is done then the node is a valid candidate else break the loop */
if((ps_search_node->u1_is_avail) || (ps_search_node->u1_subpel_done))
{
i4_ref_id = ps_search_node->i1_ref_idx;
ASSERT(i4_ref_id >= 0);
if(!u1_pred_dir)
{
ps_curr_pu =
ps_pu_results->aps_pu_results[0][0] + num_results_per_part_l0;
ASSERT(
ps_ctxt->a_ref_idx_lc_to_l0[i4_ref_id] <
ps_inter_ctb_prms->u1_num_active_ref_l0);
ps_curr_pu->pu.mv.i1_l0_ref_idx =
ps_ctxt->a_ref_idx_lc_to_l0[i4_ref_id];
ps_curr_pu->pu.mv.s_l0_mv = ps_search_node->s_mv;
ps_curr_pu->pu.mv.i1_l1_ref_idx = -1;
ps_curr_pu->pu.b2_pred_mode = PRED_L0;
num_results_per_part_l0++;
}
else
{
ps_curr_pu =
ps_pu_results->aps_pu_results[1][0] + num_results_per_part_l1;
ASSERT(
ps_ctxt->a_ref_idx_lc_to_l1[i4_ref_id] <
ps_inter_ctb_prms->u1_num_active_ref_l1);
ps_curr_pu->pu.mv.i1_l1_ref_idx =
ps_ctxt->a_ref_idx_lc_to_l1[i4_ref_id];
ps_curr_pu->pu.mv.s_l1_mv = ps_search_node->s_mv;
ps_curr_pu->pu.mv.i1_l0_ref_idx = -1;
ps_curr_pu->pu.b2_pred_mode = PRED_L1;
num_results_per_part_l1++;
}
ps_curr_pu->i4_mv_cost = ps_search_node->i4_mv_cost;
ps_curr_pu->i4_sdi = ps_search_node->i4_sdi;
#if UNI_SATD_SCALE
/*SATD is scaled by weight. Hence rescale the SATD */
ps_curr_pu->i4_tot_cost =
((ps_search_node->i4_sad *
ps_ctxt->s_wt_pred.a_wpred_wt[ps_search_node->i1_ref_idx] +
(1 << (ps_inter_ctb_prms->wpred_log_wdc - 1))) >>
ps_inter_ctb_prms->wpred_log_wdc) +
ps_search_node->i4_mv_cost;
#endif
ps_curr_pu->pu.b4_wd = 1;
ps_curr_pu->pu.b4_ht = 1;
ps_curr_pu->pu.b4_pos_x = u1_x_pos;
ps_curr_pu->pu.b4_pos_y = u1_y_pos;
ps_curr_pu->pu.b1_intra_flag = 0;
ps_search_node++;
}
else
{
/* if NxN was not evaluated at 16x16 level, assign max cost to 8x8 CU
to remove 8x8's as possible candidates during evaluation */
ps_curr_pu = ps_pu_results->aps_pu_results[0][0] + num_results_per_part_l0;
ps_curr_pu->i4_tot_cost = MAX_32BIT_VAL;
ps_curr_pu = ps_pu_results->aps_pu_results[1][0] + num_results_per_part_l1;
ps_curr_pu->i4_tot_cost = MAX_32BIT_VAL;
break;
}
}
}
/* Update the num_results per_part across lists L0 and L1 */
ps_pu_results->u1_num_results_per_part_l0[0] = num_results_per_part_l0;
ps_pu_results->u1_num_results_per_part_l1[0] = num_results_per_part_l1;
}
ps_cu_results++;
ps_pu_results++;
}
}
/**
********************************************************************************
* @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)
{
WORD32 i;
WORD32 num_results;
WORD32 cu_size = ps_cu_results->u1_cu_size;
UWORD8 u1_x_off = ps_cu_results->u1_x_off;
UWORD8 u1_y_off = ps_cu_results->u1_y_off;
/* Id of the 32x32 block, 16x16 block in a CTB */
WORD32 i4_32x32_id = (u1_y_off >> 5) * 2 + (u1_x_off >> 5);
WORD32 i4_16x16_id = ((u1_y_off >> 4) & 0x1) * 2 + ((u1_x_off >> 4) & 0x1);
/* Flags to indicate if intra64/intra32/intra16 cusize are invalid as per IPE decision */
WORD32 disable_intra64 = 0;
WORD32 disable_intra32 = 0;
WORD32 disable_intra16 = 0;
S32 i4_intra_2nx2n_cost;
/* ME final results for this CU (post seeding of best uni/bi pred results) */
part_type_results_t *ps_best_result;
i4_frm_qstep *= !L0ME_IN_OPENLOOP_MODE;
/*If inter candidates are enabled then enter the for loop to update the intra candidate */
if((ps_cu_results->u1_num_best_results == 0) && (CU_8x8 == ps_cu_results->u1_cu_size))
{
ps_cu_results->u1_num_best_results = 1;
}
num_results = ps_cu_results->u1_num_best_results;
ps_best_result = &ps_cu_results->ps_best_results[0];
/* Disable intra16/32/64 flags based on split flags recommended by IPE */
if(ps_cur_ipe_ctb->u1_split_flag)
{
disable_intra64 = 1;
if(ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id].b1_split_flag)
{
disable_intra32 = 1;
if(ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id]
.as_intra16_analyse[i4_16x16_id]
.b1_split_flag)
{
disable_intra16 = 1;
}
}
}
/* Derive the intra cost based on current cu size and offset */
switch(cu_size)
{
case CU_8x8:
{
i4_intra_2nx2n_cost = ps_cur_ipe_ctb->ai4_best8x8_intra_cost[u1_y_off + (u1_x_off >> 3)];
/* Accounting for coding noise in the open loop IPE cost */
i4_intra_2nx2n_cost +=
((i4_frm_qstep * 16) >> 2) /*+ ((i4_frm_qstep*i4_intra_2nx2n_cost)/256) */;
break;
}
case CU_16x16:
{
i4_intra_2nx2n_cost =
ps_cur_ipe_ctb->ai4_best16x16_intra_cost[(u1_y_off >> 4) * 4 + (u1_x_off >> 4)];
/* Accounting for coding noise in the open loop IPE cost */
i4_intra_2nx2n_cost +=
((i4_frm_qstep * 16)); /* + ((i4_frm_qstep*i4_intra_2nx2n_cost)/256) */
if(disable_intra16)
{
/* Disable intra 2Nx2N (intra 16) as IPE suggested best mode as 8x8 */
i4_intra_2nx2n_cost = MAX_32BIT_VAL;
}
break;
}
case CU_32x32:
{
i4_intra_2nx2n_cost =
ps_cur_ipe_ctb->ai4_best32x32_intra_cost[(u1_y_off >> 5) * 2 + (u1_x_off >> 5)];
/* Accounting for coding noise in the open loop IPE cost */
i4_intra_2nx2n_cost +=
(i4_frm_qstep * 16 * 4) /* + ((i4_frm_qstep*i4_intra_2nx2n_cost)/256) */;
if(disable_intra32)
{
/* Disable intra 2Nx2N (intra 32) as IPE suggested best mode as 16x16 or 8x8 */
i4_intra_2nx2n_cost = MAX_32BIT_VAL;
}
break;
}
case CU_64x64:
{
i4_intra_2nx2n_cost = ps_cur_ipe_ctb->i4_best64x64_intra_cost;
/* Accounting for coding noise in the open loop IPE cost */
i4_intra_2nx2n_cost +=
(i4_frm_qstep * 16 * 16) /* + ((i4_frm_qstep*i4_intra_2nx2n_cost)/256) */;
if(disable_intra64)
{
/* Disable intra 2Nx2N (intra 64) as IPE suggested best mode as 32x32 /16x16 / 8x8 */
i4_intra_2nx2n_cost = MAX_32BIT_VAL;
}
break;
}
default:
ASSERT(0);
}
{
/*****************************************************************/
/* Intra / Inter cost comparison for 2Nx2N : cu size 8/16/32/64 */
/* Identify where the current result isto be placed. Basically */
/* find the node which has cost just higher than node under test */
/*****************************************************************/
for(i = 0; i < num_results; i++)
{
/* Subtrqact the tu_spli_flag_cost from total_inter_cost for fair comparision */
WORD32 inter_cost = ps_best_result[i].i4_tot_cost - ps_best_result[i].i4_tu_split_cost;
if(i4_intra_2nx2n_cost < inter_cost)
{
if(i < (num_results - 1))
{
memmove(
ps_best_result + i + 1,
ps_best_result + i,
sizeof(ps_best_result[0]) * (num_results - 1 - i));
}
/* Insert the intra node result */
ps_best_result[i].u1_part_type = PRT_2Nx2N;
ps_best_result[i].i4_tot_cost = i4_intra_2nx2n_cost;
ps_best_result[i].ai4_tu_split_flag[0] = 0;
ps_best_result[i].ai4_tu_split_flag[1] = 0;
ps_best_result[i].ai4_tu_split_flag[2] = 0;
ps_best_result[i].ai4_tu_split_flag[3] = 0;
/* Populate intra flag, cost and default mvs, refidx for intra pu */
ps_best_result[i].as_pu_results[0].i4_tot_cost = i4_intra_2nx2n_cost;
//ps_best_result[i].as_pu_results[0].i4_sad = i4_intra_2nx2n_cost;
ps_best_result[i].as_pu_results[0].i4_mv_cost = 0;
ps_best_result[i].as_pu_results[0].pu.b1_intra_flag = 1;
ps_best_result[i].as_pu_results[0].pu.mv.i1_l0_ref_idx = -1;
ps_best_result[i].as_pu_results[0].pu.mv.i1_l1_ref_idx = -1;
ps_best_result[i].as_pu_results[0].pu.mv.s_l0_mv.i2_mvx = INTRA_MV;
ps_best_result[i].as_pu_results[0].pu.mv.s_l0_mv.i2_mvy = INTRA_MV;
ps_best_result[i].as_pu_results[0].pu.mv.s_l1_mv.i2_mvx = INTRA_MV;
ps_best_result[i].as_pu_results[0].pu.mv.s_l1_mv.i2_mvy = INTRA_MV;
break;
}
}
}
}
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)
{
double lambda;
double lambda_modifier;
WORD32 i4_cu_qp;
frm_lambda_ctxt_t *ps_frm_lambda_ctxt;
//ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb;
WORD32 i4_frame_qp;
rc_quant_t *ps_rc_quant_ctxt;
WORD32 i4_is_bpic;
ps_frm_lambda_ctxt = &ps_ctxt->s_frm_lambda_ctxt;
//ps_cur_ipe_ctb = ps_ctxt->ps_ipe_l0_ctb_frm_base;
i4_frame_qp = ps_ctxt->s_frm_prms.i4_frame_qp;
ps_rc_quant_ctxt = ps_ctxt->ps_rc_quant_ctxt;
i4_is_bpic = ps_ctxt->s_frm_prms.bidir_enabled;
i4_cu_qp = ps_rc_quant_ctxt->pi4_qp_to_qscale[i4_frame_qp + ps_rc_quant_ctxt->i1_qp_offset];
{
if(ps_ctxt->i4_l0me_qp_mod)
{
#if MODULATE_LAMDA_WHEN_SPATIAL_MOD_ON
#if LAMDA_BASED_ON_QUANT
WORD32 i4_activity = ps_cur_ipe_ctb->i4_64x64_act_factor[2][0];
#else
WORD32 i4_activity = ps_cur_ipe_ctb->i4_64x64_act_factor[3][0];
#endif
i4_cu_qp = (((i4_cu_qp)*i4_activity) + (1 << (QP_LEVEL_MOD_ACT_FACTOR - 1))) >>
QP_LEVEL_MOD_ACT_FACTOR;
#endif
}
if(i4_cu_qp > ps_rc_quant_ctxt->i2_max_qscale)
i4_cu_qp = ps_rc_quant_ctxt->i2_max_qscale;
else if(i4_cu_qp < ps_rc_quant_ctxt->i2_min_qscale)
i4_cu_qp = ps_rc_quant_ctxt->i2_min_qscale;
i4_cu_qp = ps_rc_quant_ctxt->pi4_qscale_to_qp[i4_cu_qp];
}
if(i4_cu_qp > ps_rc_quant_ctxt->i2_max_qp)
i4_cu_qp = ps_rc_quant_ctxt->i2_max_qp;
else if(i4_cu_qp < ps_rc_quant_ctxt->i2_min_qp)
i4_cu_qp = ps_rc_quant_ctxt->i2_min_qp;
lambda = pow(2.0, (((double)(i4_cu_qp - 12)) / 3));
lambda_modifier = ps_frm_lambda_ctxt->lambda_modifier;
if(i4_is_bpic)
{
lambda_modifier = lambda_modifier * CLIP3((((double)(i4_cu_qp - 12)) / 6.0), 2.00, 4.00);
}
if(ps_ctxt->i4_use_const_lamda_modifier)
{
if(ps_ctxt->s_frm_prms.is_i_pic)
{
lambda_modifier = ps_ctxt->f_i_pic_lamda_modifier;
}
else
{
lambda_modifier = CONST_LAMDA_MOD_VAL;
}
}
lambda *= lambda_modifier;
return ((WORD32)(sqrt(lambda) * (1 << LAMBDA_Q_SHIFT)));
}
/**
********************************************************************************
* @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)
{
/* If MV is up large, update i2_dyn_max_y */
if(i2_mvy > ps_dyn_range_prms->i2_dyn_max_y)
ps_dyn_range_prms->i2_dyn_max_y = i2_mvy;
/* If MV is down large, update i2_dyn_min_y */
if(i2_mvy < ps_dyn_range_prms->i2_dyn_min_y)
ps_dyn_range_prms->i2_dyn_min_y = i2_mvy;
}
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)
{
U32 i;
if(NULL == pu1_shifts)
{
S32 i4_cur_node_cost = ps_result_node->i4_tot_cost;
for(i = 0; i < u4_num_results_updated; i++)
{
if(i4_cur_node_cost < pps_sorted_array[i]->i4_tot_cost)
{
memmove(
&pps_sorted_array[i + 1],
&pps_sorted_array[i],
(u4_num_results_updated - i) * sizeof(search_node_t *));
break;
}
}
}
else
{
S32 i4_cur_node_cost =
(u1_shift == 0) ? ps_result_node->i4_tot_cost
: (ps_result_node->i4_tot_cost + (1 << (u1_shift - 1))) >> u1_shift;
for(i = 0; i < u4_num_results_updated; i++)
{
S32 i4_prev_node_cost = (pu1_shifts[i] == 0) ? pps_sorted_array[i]->i4_tot_cost
: (pps_sorted_array[i]->i4_tot_cost +
(1 << (pu1_shifts[i] - 1))) >>
pu1_shifts[i];
if(i4_cur_node_cost < i4_prev_node_cost)
{
memmove(
&pps_sorted_array[i + 1],
&pps_sorted_array[i],
(u4_num_results_updated - i) * sizeof(search_node_t *));
memmove(
&pu1_shifts[i + 1], &pu1_shifts[i], (u4_num_results_updated - i) * sizeof(U08));
break;
}
}
pu1_shifts[i] = u1_shift;
}
pps_sorted_array[i] = ps_result_node;
}
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 i;
for(i = 0; i < i4_num_results; i++)
{
if(i1_ref_idx == pi1_ref_idx[i])
{
if(0 == i4_result_id)
{
return i;
}
else
{
i4_result_id--;
}
}
}
return -1;
}
static __inline void hme_search_node_populator(
search_node_t *ps_search_node, hme_mv_t *ps_mv, S08 i1_ref_idx, S08 i1_mv_magnitude_shift)
{
ps_search_node->ps_mv->i2_mvx = SHL_NEG((WORD16)ps_mv->i2_mv_x, i1_mv_magnitude_shift);
ps_search_node->ps_mv->i2_mvy = SHL_NEG((WORD16)ps_mv->i2_mv_y, i1_mv_magnitude_shift);
ps_search_node->i1_ref_idx = i1_ref_idx;
ps_search_node->u1_is_avail = 1;
ps_search_node->u1_subpel_done = 0;
}
S32 hme_populate_search_candidates(fpel_srch_cand_init_data_t *ps_ctxt)
{
hme_mv_t *ps_mv;
S32 wd_c, ht_c, wd_p, ht_p;
S32 blksize_p, blksize_c;
S32 i;
S08 *pi1_ref_idx;
/* Cache for storing offsets */
S32 ai4_cand_offsets[NUM_SEARCH_CAND_LOCATIONS];
layer_ctxt_t *ps_curr_layer = ps_ctxt->ps_curr_layer;
layer_ctxt_t *ps_coarse_layer = ps_ctxt->ps_coarse_layer;
layer_mv_t *ps_coarse_layer_mvbank = ps_coarse_layer->ps_layer_mvbank;
layer_mv_t *ps_curr_layer_mvbank = ps_curr_layer->ps_layer_mvbank;
search_candt_t *ps_search_cands = ps_ctxt->ps_search_cands;
hme_mv_t s_zero_mv = { 0 };
S32 i4_pos_x = ps_ctxt->i4_pos_x;
S32 i4_pos_y = ps_ctxt->i4_pos_y;
S32 i4_num_act_ref_l0 = ps_ctxt->i4_num_act_ref_l0;
S32 i4_num_act_ref_l1 = ps_ctxt->i4_num_act_ref_l1;
U08 u1_pred_dir = ps_ctxt->u1_pred_dir;
U08 u1_pred_dir_ctr = ps_ctxt->u1_pred_dir_ctr;
U08 u1_num_results_in_curr_mvbank = ps_ctxt->u1_num_results_in_mvbank;
U08 u1_num_results_in_coarse_mvbank =
(u1_pred_dir == 0) ? (i4_num_act_ref_l0 * ps_coarse_layer_mvbank->i4_num_mvs_per_ref)
: (i4_num_act_ref_l1 * ps_coarse_layer_mvbank->i4_num_mvs_per_ref);
S32 i4_init_offset_projected =
(u1_pred_dir == 1) ? (i4_num_act_ref_l0 * ps_coarse_layer_mvbank->i4_num_mvs_per_ref) : 0;
S32 i4_init_offset_spatial =
(u1_pred_dir_ctr == 1)
? (ps_curr_layer_mvbank->i4_num_mvs_per_ref * u1_num_results_in_curr_mvbank)
: 0;
U08 u1_search_candidate_list_index = ps_ctxt->u1_search_candidate_list_index;
U08 u1_max_num_search_cands =
gau1_max_num_search_cands_in_l0_me[u1_search_candidate_list_index];
S32 i4_num_srch_cands = MIN(u1_max_num_search_cands, ps_ctxt->i4_max_num_init_cands << 1);
U16 u2_is_offset_available = 0;
U08 u1_search_blk_to_spatial_mvbank_blk_size_factor = 1;
/* Width and ht of current and prev layers */
wd_c = ps_curr_layer->i4_wd;
ht_c = ps_curr_layer->i4_ht;
wd_p = ps_coarse_layer->i4_wd;
ht_p = ps_coarse_layer->i4_ht;
blksize_p = gau1_blk_size_to_wd_shift[ps_coarse_layer_mvbank->e_blk_size];
blksize_c = gau1_blk_size_to_wd_shift[ps_curr_layer_mvbank->e_blk_size];
/* ASSERT for valid sizes */
ASSERT((blksize_p == 3) || (blksize_p == 4) || (blksize_p == 5));
{
S32 x = i4_pos_x >> 4;
S32 y = i4_pos_y >> 4;
if(blksize_c != gau1_blk_size_to_wd_shift[ps_ctxt->e_search_blk_size])
{
x *= 2;
y *= 2;
u1_search_blk_to_spatial_mvbank_blk_size_factor = 2;
}
i4_init_offset_spatial += (x + y * ps_curr_layer_mvbank->i4_num_blks_per_row) *
ps_curr_layer_mvbank->i4_num_mvs_per_blk;
}
for(i = 0; i < i4_num_srch_cands; i++)
{
SEARCH_CANDIDATE_TYPE_T e_search_cand_type =
gae_search_cand_priority_to_search_cand_type_map_in_l0_me[u1_search_candidate_list_index]
[i];
SEARCH_CAND_LOCATIONS_T e_search_cand_loc =
gae_search_cand_type_to_location_map[e_search_cand_type];
S08 i1_result_id = MIN(
gai1_search_cand_type_to_result_id_map[e_search_cand_type],
(e_search_cand_loc < 0 ? 0
: ps_ctxt->pu1_num_fpel_search_cands[e_search_cand_loc] - 1));
U08 u1_is_spatial_cand = (1 == gau1_search_cand_type_to_spatiality_map[e_search_cand_type]);
U08 u1_is_proj_cand = (0 == gau1_search_cand_type_to_spatiality_map[e_search_cand_type]);
U08 u1_is_zeroMV_cand = (ZERO_MV == e_search_cand_type) ||
(ZERO_MV_ALTREF == e_search_cand_type);
/* When spatial candidates are available, use them, else use the projected candidates */
/* This is required since some blocks will never have certain spatial candidates, and in order */
/* to accomodate such instances in 'gae_search_cand_priority_to_search_cand_type_map_in_l0_me' list, */
/* all candidates apart from the 'LEFT' have been marked as projected */
if(((e_search_cand_loc == TOPLEFT) || (e_search_cand_loc == TOP) ||
(e_search_cand_loc == TOPRIGHT)) &&
(i1_result_id < u1_num_results_in_curr_mvbank) && u1_is_proj_cand)
{
if(e_search_cand_loc == TOPLEFT)
{
u1_is_spatial_cand = ps_ctxt->u1_is_topLeft_available ||
!ps_ctxt->u1_is_left_available;
}
else if(e_search_cand_loc == TOPRIGHT)
{
u1_is_spatial_cand = ps_ctxt->u1_is_topRight_available;
}
else
{
u1_is_spatial_cand = ps_ctxt->u1_is_top_available;
}
u1_is_proj_cand = !u1_is_spatial_cand;
}
switch(u1_is_zeroMV_cand + (u1_is_spatial_cand << 1) + (u1_is_proj_cand << 2))
{
case 1:
{
hme_search_node_populator(
ps_search_cands[i].ps_search_node,
&s_zero_mv,
(ZERO_MV == e_search_cand_type) ? ps_ctxt->i1_default_ref_id
: ps_ctxt->i1_alt_default_ref_id,
0);
break;
}
case 2:
{
S08 i1_mv_magnitude_shift = 0;
S32 i4_offset = i4_init_offset_spatial;
i1_result_id = MIN(i1_result_id, u1_num_results_in_curr_mvbank - 1);
i4_offset += i1_result_id;
switch(e_search_cand_loc)
{
case LEFT:
{
if(ps_ctxt->u1_is_left_available)
{
i1_mv_magnitude_shift = -2;
i4_offset -= ps_curr_layer_mvbank->i4_num_mvs_per_blk;
ps_mv = ps_curr_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_curr_layer_mvbank->pi1_ref_idx + i4_offset;
}
else
{
i1_mv_magnitude_shift = 0;
ps_mv = &s_zero_mv;
pi1_ref_idx = &ps_ctxt->i1_default_ref_id;
}
break;
}
case TOPLEFT:
{
if(ps_ctxt->u1_is_topLeft_available)
{
i1_mv_magnitude_shift = -2;
i4_offset -= ps_curr_layer_mvbank->i4_num_mvs_per_blk;
i4_offset -= ps_curr_layer_mvbank->i4_num_mvs_per_row;
ps_mv = ps_curr_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_curr_layer_mvbank->pi1_ref_idx + i4_offset;
}
else
{
i1_mv_magnitude_shift = 0;
ps_mv = &s_zero_mv;
pi1_ref_idx = &ps_ctxt->i1_default_ref_id;
}
break;
}
case TOP:
{
if(ps_ctxt->u1_is_top_available)
{
i1_mv_magnitude_shift = -2;
i4_offset -= ps_curr_layer_mvbank->i4_num_mvs_per_row;
ps_mv = ps_curr_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_curr_layer_mvbank->pi1_ref_idx + i4_offset;
}
else
{
i1_mv_magnitude_shift = 0;
ps_mv = &s_zero_mv;
pi1_ref_idx = &ps_ctxt->i1_default_ref_id;
}
break;
}
case TOPRIGHT:
{
if(ps_ctxt->u1_is_topRight_available)
{
i1_mv_magnitude_shift = -2;
i4_offset += ps_curr_layer_mvbank->i4_num_mvs_per_blk *
u1_search_blk_to_spatial_mvbank_blk_size_factor;
i4_offset -= ps_curr_layer_mvbank->i4_num_mvs_per_row;
ps_mv = ps_curr_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_curr_layer_mvbank->pi1_ref_idx + i4_offset;
}
else
{
i1_mv_magnitude_shift = 0;
ps_mv = &s_zero_mv;
pi1_ref_idx = &ps_ctxt->i1_default_ref_id;
}
break;
}
default:
{
/* AiyAiyYo!! */
ASSERT(0);
}
}
hme_search_node_populator(
ps_search_cands[i].ps_search_node, ps_mv, pi1_ref_idx[0], i1_mv_magnitude_shift);
break;
}
case 4:
{
ASSERT(ILLUSORY_CANDIDATE != e_search_cand_type);
ASSERT(ILLUSORY_LOCATION != e_search_cand_loc);
i1_result_id = MIN(i1_result_id, u1_num_results_in_coarse_mvbank - 1);
if(!(u2_is_offset_available & (1 << e_search_cand_loc)))
{
S32 x, y;
x = i4_pos_x + gai4_search_cand_location_to_x_offset_map[e_search_cand_loc];
y = i4_pos_y + gai4_search_cand_location_to_y_offset_map[e_search_cand_loc];
/* Safety check to avoid uninitialized access across temporal layers */
x = CLIP3(x, 0, (wd_c - blksize_p));
y = CLIP3(y, 0, (ht_c - blksize_p));
/* Project the positions to prev layer */
x = x >> blksize_p;
y = y >> blksize_p;
ai4_cand_offsets[e_search_cand_loc] =
(x * ps_coarse_layer_mvbank->i4_num_mvs_per_blk);
ai4_cand_offsets[e_search_cand_loc] +=
(y * ps_coarse_layer_mvbank->i4_num_mvs_per_row);
ai4_cand_offsets[e_search_cand_loc] += i4_init_offset_projected;
u2_is_offset_available |= (1 << e_search_cand_loc);
}
ps_mv =
ps_coarse_layer_mvbank->ps_mv + ai4_cand_offsets[e_search_cand_loc] + i1_result_id;
pi1_ref_idx = ps_coarse_layer_mvbank->pi1_ref_idx +
ai4_cand_offsets[e_search_cand_loc] + i1_result_id;
hme_search_node_populator(ps_search_cands[i].ps_search_node, ps_mv, pi1_ref_idx[0], 1);
break;
}
default:
{
/* NoNoNoNoNooooooooNO! */
ASSERT(0);
}
}
ASSERT(ps_search_cands[i].ps_search_node->i1_ref_idx >= 0);
ASSERT(
!u1_pred_dir
? (ps_ctxt->pi4_ref_id_lc_to_l0_map[ps_search_cands[i].ps_search_node->i1_ref_idx] <
i4_num_act_ref_l0)
: (ps_ctxt->pi4_ref_id_lc_to_l1_map[ps_search_cands[i].ps_search_node->i1_ref_idx] <
ps_ctxt->i4_num_act_ref_l1));
}
return i4_num_srch_cands;
}
void hme_mv_clipper(
hme_search_prms_t *ps_search_prms_blk,
S32 i4_num_srch_cands,
S08 i1_check_for_mult_refs,
U08 u1_fpel_refine_extent,
U08 u1_hpel_refine_extent,
U08 u1_qpel_refine_extent)
{
S32 candt;
range_prms_t *ps_range_prms;
for(candt = 0; candt < i4_num_srch_cands; candt++)
{
search_node_t *ps_search_node;
ps_search_node = ps_search_prms_blk->ps_search_candts[candt].ps_search_node;
ps_range_prms = ps_search_prms_blk->aps_mv_range[ps_search_node->i1_ref_idx];
/* Clip the motion vectors as well here since after clipping
two candidates can become same and they will be removed during deduplication */
CLIP_MV_WITHIN_RANGE(
ps_search_node->ps_mv->i2_mvx,
ps_search_node->ps_mv->i2_mvy,
ps_range_prms,
u1_fpel_refine_extent,
u1_hpel_refine_extent,
u1_qpel_refine_extent);
}
}
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)
{
U08 u1_pred_buf_array_id;
if(1 != ihevce_get_free_pred_buf_indices(
&u1_pred_buf_array_id, &ps_buf_mngr->u4_pred_buf_usage_indicator, 1))
{
ASSERT(0);
}
else
{
ps_info[0][0].i4_pred_stride = MAX_CU_SIZE;
ps_info[0][0].pu1_pred = ps_buf_mngr->apu1_pred_bufs[u1_pred_buf_array_id];
ps_info[0][0].u1_pred_buf_array_id = u1_pred_buf_array_id;
if(PRT_2Nx2N != e_part_type)
{
ps_info[0][1].i4_pred_stride = MAX_CU_SIZE;
ps_info[0][1].pu1_pred = ps_buf_mngr->apu1_pred_bufs[u1_pred_buf_array_id] +
(gai1_is_part_vertical[ge_part_type_to_part_id[e_part_type][0]]
? u1_pu1_ht * ps_info[0][1].i4_pred_stride
: u1_pu1_wd);
ps_info[0][1].u1_pred_buf_array_id = u1_pred_buf_array_id;
}
}
}
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
)
{
PART_TYPE_T e_part_type = (PART_TYPE_T)ps_part_type_result->u1_part_type;
U32 *pu4_pred_buf_usage_indicator = &ps_pred_buf_mngr->u4_pred_buf_usage_indicator;
U08 u1_is_part_vertical = gai1_is_part_vertical[ge_part_type_to_part_id[e_part_type][0]];
if(0 == ps_part_type_result->u1_part_type)
{
if(ps_part_type_result->as_pu_results->pu.b2_pred_mode == PRED_BI)
{
ASSERT(UCHAR_MAX != ps_pred_buf_info[2][0].u1_pred_buf_array_id);
ps_part_type_result->pu1_pred = ps_pred_buf_info[2][0].pu1_pred;
ps_part_type_result->i4_pred_stride = ps_pred_buf_info[2][0].i4_pred_stride;
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[0]);
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[1]);
}
else
{
ps_part_type_result->pu1_pred = ps_pred_buf_info[0][0].pu1_pred;
ps_part_type_result->i4_pred_stride = ps_pred_buf_info[0][0].i4_pred_stride;
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[2]);
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[1]);
if(UCHAR_MAX == ps_pred_buf_info[0][0].u1_pred_buf_array_id)
{
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[0]);
}
}
}
else
{
U08 *pu1_src_pred;
U08 *pu1_dst_pred;
S32 i4_src_pred_stride;
S32 i4_dst_pred_stride;
U08 u1_pu1_wd = (ps_part_type_result->as_pu_results[0].pu.b4_wd + 1) << 2;
U08 u1_pu1_ht = (ps_part_type_result->as_pu_results[0].pu.b4_ht + 1) << 2;
U08 u1_pu2_wd = (ps_part_type_result->as_pu_results[1].pu.b4_wd + 1) << 2;
U08 u1_pu2_ht = (ps_part_type_result->as_pu_results[1].pu.b4_ht + 1) << 2;
U08 u1_condition_for_switch =
(ps_part_type_result->as_pu_results[0].pu.b2_pred_mode == PRED_BI) |
((ps_part_type_result->as_pu_results[1].pu.b2_pred_mode == PRED_BI) << 1);
switch(u1_condition_for_switch)
{
case 0:
{
ps_part_type_result->pu1_pred =
ps_pred_buf_mngr->apu1_pred_bufs[pu1_allocated_pred_buf_array_indixes[0]];
ps_part_type_result->i4_pred_stride = MAX_CU_SIZE;
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[2]);
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[1]);
if(UCHAR_MAX == ps_pred_buf_info[0][0].u1_pred_buf_array_id)
{
pu1_src_pred = ps_pred_buf_info[0][0].pu1_pred;
pu1_dst_pred = ps_part_type_result->pu1_pred;
i4_src_pred_stride = ps_pred_buf_info[0][0].i4_pred_stride;
i4_dst_pred_stride = ps_part_type_result->i4_pred_stride;
ps_cmn_utils_optimised_function_list->pf_copy_2d(
pu1_dst_pred,
i4_dst_pred_stride,
pu1_src_pred,
i4_src_pred_stride,
u1_pu1_wd,
u1_pu1_ht);
}
if(UCHAR_MAX == ps_pred_buf_info[0][1].u1_pred_buf_array_id)
{
pu1_src_pred = ps_pred_buf_info[0][1].pu1_pred;
pu1_dst_pred = ps_part_type_result->pu1_pred +
(u1_is_part_vertical
? u1_pu1_ht * ps_part_type_result->i4_pred_stride
: u1_pu1_wd);
i4_src_pred_stride = ps_pred_buf_info[0][1].i4_pred_stride;
i4_dst_pred_stride = ps_part_type_result->i4_pred_stride;
ps_cmn_utils_optimised_function_list->pf_copy_2d(
pu1_dst_pred,
i4_dst_pred_stride,
pu1_src_pred,
i4_src_pred_stride,
u1_pu2_wd,
u1_pu2_ht);
}
break;
}
case 1:
{
ASSERT(UCHAR_MAX != ps_pred_buf_info[2][0].u1_pred_buf_array_id);
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[1]);
/* Copy PU1 pred into PU2's pred buf */
if(((u1_pu1_ht < u1_pu2_ht) || (u1_pu1_wd < u1_pu2_wd)) &&
(UCHAR_MAX != ps_pred_buf_info[0][1].u1_pred_buf_array_id))
{
ps_part_type_result->pu1_pred =
ps_pred_buf_info[0][1].pu1_pred -
(u1_is_part_vertical ? u1_pu1_ht * ps_pred_buf_info[0][1].i4_pred_stride
: u1_pu1_wd);
ps_part_type_result->i4_pred_stride = ps_pred_buf_info[0][1].i4_pred_stride;
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[2]);
pu1_src_pred = ps_pred_buf_info[2][0].pu1_pred;
pu1_dst_pred = ps_part_type_result->pu1_pred;
i4_src_pred_stride = ps_pred_buf_info[2][0].i4_pred_stride;
i4_dst_pred_stride = ps_part_type_result->i4_pred_stride;
ps_cmn_utils_optimised_function_list->pf_copy_2d(
pu1_dst_pred,
i4_dst_pred_stride,
pu1_src_pred,
i4_src_pred_stride,
u1_pu1_wd,
u1_pu1_ht);
}
else
{
ps_part_type_result->pu1_pred = ps_pred_buf_info[2][0].pu1_pred;
ps_part_type_result->i4_pred_stride = ps_pred_buf_info[2][0].i4_pred_stride;
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[0]);
pu1_src_pred = ps_pred_buf_info[0][1].pu1_pred;
pu1_dst_pred = ps_part_type_result->pu1_pred;
i4_src_pred_stride = ps_pred_buf_info[0][1].i4_pred_stride;
i4_dst_pred_stride = ps_part_type_result->i4_pred_stride;
ps_cmn_utils_optimised_function_list->pf_copy_2d(
pu1_dst_pred,
i4_dst_pred_stride,
pu1_src_pred,
i4_src_pred_stride,
u1_pu2_wd,
u1_pu2_ht);
}
break;
}
case 2:
{
ASSERT(UCHAR_MAX != ps_pred_buf_info[2][1].u1_pred_buf_array_id);
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[1]);
/* Copy PU2 pred into PU1's pred buf */
if(((u1_pu1_ht > u1_pu2_ht) || (u1_pu1_wd > u1_pu2_wd)) &&
(UCHAR_MAX != ps_pred_buf_info[0][0].u1_pred_buf_array_id))
{
ps_part_type_result->pu1_pred = ps_pred_buf_info[0][0].pu1_pred;
ps_part_type_result->i4_pred_stride = ps_pred_buf_info[0][0].i4_pred_stride;
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[2]);
pu1_src_pred = ps_pred_buf_info[2][1].pu1_pred;
pu1_dst_pred = ps_part_type_result->pu1_pred +
(u1_is_part_vertical
? u1_pu1_ht * ps_part_type_result->i4_pred_stride
: u1_pu1_wd);
i4_src_pred_stride = ps_pred_buf_info[2][1].i4_pred_stride;
i4_dst_pred_stride = ps_part_type_result->i4_pred_stride;
ps_cmn_utils_optimised_function_list->pf_copy_2d(
pu1_dst_pred,
i4_dst_pred_stride,
pu1_src_pred,
i4_src_pred_stride,
u1_pu2_wd,
u1_pu2_ht);
}
else
{
ps_part_type_result->pu1_pred =
ps_pred_buf_info[2][1].pu1_pred -
(u1_is_part_vertical ? u1_pu1_ht * ps_pred_buf_info[2][1].i4_pred_stride
: u1_pu1_wd);
ps_part_type_result->i4_pred_stride = ps_pred_buf_info[2][1].i4_pred_stride;
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[0]);
pu1_src_pred = ps_pred_buf_info[0][0].pu1_pred;
pu1_dst_pred = ps_part_type_result->pu1_pred;
i4_src_pred_stride = ps_pred_buf_info[0][0].i4_pred_stride;
i4_dst_pred_stride = ps_part_type_result->i4_pred_stride;
ps_cmn_utils_optimised_function_list->pf_copy_2d(
pu1_dst_pred,
i4_dst_pred_stride,
pu1_src_pred,
i4_src_pred_stride,
u1_pu1_wd,
u1_pu1_ht);
}
break;
}
case 3:
{
ASSERT(UCHAR_MAX != ps_pred_buf_info[2][0].u1_pred_buf_array_id);
ASSERT(UCHAR_MAX != ps_pred_buf_info[2][1].u1_pred_buf_array_id);
ASSERT(
ps_pred_buf_info[2][1].u1_pred_buf_array_id ==
ps_pred_buf_info[2][0].u1_pred_buf_array_id);
ps_part_type_result->pu1_pred = ps_pred_buf_info[2][0].pu1_pred;
ps_part_type_result->i4_pred_stride = ps_pred_buf_info[2][0].i4_pred_stride;
ihevce_set_pred_buf_as_free(
pu4_pred_buf_usage_indicator, pu1_allocated_pred_buf_array_indixes[0]);
break;
}
}
}
}
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 u1_priority_val =
gau1_search_cand_priority_in_l1_and_l2_me[e_quality_preset >= ME_MEDIUM_SPEED][e_cand_type];
if(UCHAR_MAX == u1_priority_val)
{
ASSERT(0);
}
ASSERT(u1_priority_val <= MAX_INIT_CANDTS);
return u1_priority_val;
}
U08 hme_decide_search_candidate_priority_in_l0_me(SEARCH_CANDIDATE_TYPE_T e_cand_type, U08 u1_index)
{
U08 u1_priority_val = gau1_search_cand_priority_in_l0_me[u1_index][e_cand_type];
if(UCHAR_MAX == u1_priority_val)
{
ASSERT(0);
}
ASSERT(u1_priority_val <= MAX_INIT_CANDTS);
return u1_priority_val;
}
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)
{
S32 i, j;
S32 i4_num_coloc_cands;
U08 u1_search_candidate_list_index;
if(!u1_is_bidir_enabled && !u1_4x4_blk_in_l1me)
{
S32 i;
u1_search_candidate_list_index = (i4_num_act_ref_l0 - 1) * 2;
i4_num_coloc_cands = i4_num_act_ref_l0 * 2;
switch(i4_num_act_ref_l0)
{
case 1:
{
for(i = 0; i < 2; i++)
{
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
(SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
u1_search_candidate_list_index);
}
break;
}
case 2:
{
for(i = 0; i < 4; i++)
{
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
(SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
u1_search_candidate_list_index);
}
break;
}
case 3:
{
for(i = 0; i < 6; i++)
{
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
(SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
u1_search_candidate_list_index);
}
break;
}
case 4:
{
for(i = 0; i < 8; i++)
{
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
(SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
u1_search_candidate_list_index);
}
break;
}
default:
{
ASSERT(0);
}
}
*pi4_num_coloc_cands = i4_num_coloc_cands;
*pu1_search_candidate_list_index = u1_search_candidate_list_index;
}
else if(!u1_is_bidir_enabled && u1_4x4_blk_in_l1me)
{
S32 i;
i4_num_coloc_cands = i4_num_act_ref_l0 * 2;
u1_search_candidate_list_index = (i4_num_act_ref_l0 - 1) * 2 + 1;
switch(i4_num_act_ref_l0)
{
case 1:
{
for(i = 0; i < 2; i++)
{
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
(SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
u1_search_candidate_list_index);
}
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_TR0, u1_search_candidate_list_index);
pi4_id_coloc[i + 1] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BL0, u1_search_candidate_list_index);
pi4_id_coloc[i + 2] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BR0, u1_search_candidate_list_index);
i4_num_coloc_cands += 3;
break;
}
case 2:
{
for(i = 0; i < 4; i++)
{
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
(SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
u1_search_candidate_list_index);
}
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_TR0, u1_search_candidate_list_index);
pi4_id_coloc[i + 1] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BL0, u1_search_candidate_list_index);
pi4_id_coloc[i + 2] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BR0, u1_search_candidate_list_index);
pi4_id_coloc[i + 3] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_TR1, u1_search_candidate_list_index);
pi4_id_coloc[i + 4] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BL1, u1_search_candidate_list_index);
pi4_id_coloc[i + 5] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BR1, u1_search_candidate_list_index);
i4_num_coloc_cands += 6;
break;
}
case 3:
{
for(i = 0; i < 6; i++)
{
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
(SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
u1_search_candidate_list_index);
}
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_TR0, u1_search_candidate_list_index);
pi4_id_coloc[i + 1] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BL0, u1_search_candidate_list_index);
pi4_id_coloc[i + 2] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BR0, u1_search_candidate_list_index);
pi4_id_coloc[i + 3] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_TR1, u1_search_candidate_list_index);
pi4_id_coloc[i + 4] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BL1, u1_search_candidate_list_index);
pi4_id_coloc[i + 5] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BR1, u1_search_candidate_list_index);
i4_num_coloc_cands += 6;
break;
}
case 4:
{
for(i = 0; i < 8; i++)
{
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
(SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
u1_search_candidate_list_index);
}
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_TR0, u1_search_candidate_list_index);
pi4_id_coloc[i + 1] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BL0, u1_search_candidate_list_index);
pi4_id_coloc[i + 2] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BR0, u1_search_candidate_list_index);
pi4_id_coloc[i + 3] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_TR1, u1_search_candidate_list_index);
pi4_id_coloc[i + 4] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BL1, u1_search_candidate_list_index);
pi4_id_coloc[i + 5] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BR1, u1_search_candidate_list_index);
i4_num_coloc_cands += 6;
break;
}
default:
{
ASSERT(0);
}
}
*pi4_num_coloc_cands = i4_num_coloc_cands;
*pu1_search_candidate_list_index = u1_search_candidate_list_index;
}
else
{
/* The variable 'u1_search_candidate_list_index' is hardcoded */
/* to 10 and 11 respectively. But, these values are not returned */
/* by this function since the actual values are dependent on */
/* the number of refs in L0 and L1 respectively */
/* Hence, the actual return values are being recomputed */
/* in the latter part of this block */
if(!u1_4x4_blk_in_l1me)
{
u1_search_candidate_list_index = 10;
i4_num_coloc_cands = 2 + (2 * ((i4_num_act_ref_l0 > 1) || (i4_num_act_ref_l1 > 1)));
for(i = 0; i < i4_num_coloc_cands; i++)
{
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
(SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
u1_search_candidate_list_index);
}
}
else
{
u1_search_candidate_list_index = 11;
i4_num_coloc_cands = 2 + (2 * ((i4_num_act_ref_l0 > 1) || (i4_num_act_ref_l1 > 1)));
for(i = 0; i < i4_num_coloc_cands; i++)
{
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
(SEARCH_CANDIDATE_TYPE_T)(PROJECTED_COLOC0 + i),
u1_search_candidate_list_index);
}
pi4_id_coloc[i] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_TR0, u1_search_candidate_list_index);
pi4_id_coloc[i + 1] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BL0, u1_search_candidate_list_index);
pi4_id_coloc[i + 2] = hme_decide_search_candidate_priority_in_l0_me(
PROJECTED_COLOC_BR0, u1_search_candidate_list_index);
}
for(j = 0; j < 2; j++)
{
if(0 == j)
{
pu1_search_candidate_list_index[j] =
8 + ((i4_num_act_ref_l0 > 1) * 2) + u1_4x4_blk_in_l1me;
pi4_num_coloc_cands[j] =
(u1_4x4_blk_in_l1me * 3) + 2 + ((i4_num_act_ref_l0 > 1) * 2);
}
else
{
pu1_search_candidate_list_index[j] =
8 + ((i4_num_act_ref_l1 > 1) * 2) + u1_4x4_blk_in_l1me;
pi4_num_coloc_cands[j] =
(u1_4x4_blk_in_l1me * 3) + 2 + ((i4_num_act_ref_l1 > 1) * 2);
}
}
}
if(i4_num_act_ref_l0 || i4_num_act_ref_l1)
{
pi4_id_Z[0] = hme_decide_search_candidate_priority_in_l0_me(
(SEARCH_CANDIDATE_TYPE_T)ZERO_MV, pu1_search_candidate_list_index[0]);
}
if((i4_num_act_ref_l0 > 1) && !u1_is_bidir_enabled)
{
pi4_id_Z[1] = hme_decide_search_candidate_priority_in_l0_me(
(SEARCH_CANDIDATE_TYPE_T)ZERO_MV_ALTREF, pu1_search_candidate_list_index[0]);
}
}
static U08
hme_determine_base_block_size(S32 *pi4_valid_part_array, S32 i4_num_valid_parts, U08 u1_cu_size)
{
ASSERT(i4_num_valid_parts > 0);
if(1 == i4_num_valid_parts)
{
ASSERT(pi4_valid_part_array[i4_num_valid_parts - 1] == PART_ID_2Nx2N);
return u1_cu_size;
}
else
{
if(pi4_valid_part_array[i4_num_valid_parts - 1] <= PART_ID_NxN_BR)
{
return u1_cu_size / 2;
}
else if(pi4_valid_part_array[i4_num_valid_parts - 1] <= PART_ID_nRx2N_R)
{
return u1_cu_size / 4;
}
}
return u1_cu_size / 4;
}
static U32 hme_compute_variance_of_pu_from_base_blocks(
ULWORD64 *pu8_SigmaX,
ULWORD64 *pu8_SigmaXSquared,
U08 u1_cu_size,
U08 u1_base_block_size,
S32 i4_part_id)
{
U08 i, j;
ULWORD64 u8_final_variance;
U08 u1_part_dimension_multiplier = (u1_cu_size >> 4);
S32 i4_part_wd = gai1_part_wd_and_ht[i4_part_id][0] * u1_part_dimension_multiplier;
S32 i4_part_ht = gai1_part_wd_and_ht[i4_part_id][1] * u1_part_dimension_multiplier;
U08 u1_num_base_blocks_in_pu_row = i4_part_wd / u1_base_block_size;
U08 u1_num_base_blocks_in_pu_column = i4_part_ht / u1_base_block_size;
U08 u1_num_base_blocks_in_cu_row = u1_cu_size / u1_base_block_size;
U08 u1_num_base_blocks = (u1_num_base_blocks_in_pu_row * u1_num_base_blocks_in_pu_column);
U32 u4_num_pixels_in_base_block = u1_base_block_size * u1_base_block_size;
ULWORD64 u8_final_SigmaXSquared = 0;
ULWORD64 u8_final_SigmaX = 0;
if(ge_part_id_to_part_type[i4_part_id] != PRT_NxN)
{
U08 u1_column_start_index = gau1_part_id_to_part_num[i4_part_id]
? (gai1_is_part_vertical[i4_part_id]
? 0
: (u1_cu_size - i4_part_wd) / u1_base_block_size)
: 0;
U08 u1_row_start_index = gau1_part_id_to_part_num[i4_part_id]
? (gai1_is_part_vertical[i4_part_id]
? (u1_cu_size - i4_part_ht) / u1_base_block_size
: 0)
: 0;
U08 u1_column_end_index = u1_column_start_index + u1_num_base_blocks_in_pu_row;
U08 u1_row_end_index = u1_row_start_index + u1_num_base_blocks_in_pu_column;
for(i = u1_row_start_index; i < u1_row_end_index; i++)
{
for(j = u1_column_start_index; j < u1_column_end_index; j++)
{
u8_final_SigmaXSquared += pu8_SigmaXSquared[j + i * u1_num_base_blocks_in_cu_row];
u8_final_SigmaX += pu8_SigmaX[j + i * u1_num_base_blocks_in_cu_row];
}
}
u8_final_variance =
u1_num_base_blocks * u4_num_pixels_in_base_block * u8_final_SigmaXSquared;
u8_final_variance -= u8_final_SigmaX * u8_final_SigmaX;
u8_final_variance +=
((u1_num_base_blocks * u4_num_pixels_in_base_block) *
(u1_num_base_blocks * u4_num_pixels_in_base_block) / 2);
u8_final_variance /= (u1_num_base_blocks * u4_num_pixels_in_base_block) *
(u1_num_base_blocks * u4_num_pixels_in_base_block);
ASSERT(u8_final_variance <= UINT_MAX);
}
else
{
U08 u1_row_start_index;
U08 u1_column_start_index;
U08 u1_row_end_index;
U08 u1_column_end_index;
switch(gau1_part_id_to_part_num[i4_part_id])
{
case 0:
{
u1_row_start_index = 0;
u1_column_start_index = 0;
break;
}
case 1:
{
u1_row_start_index = 0;
u1_column_start_index = u1_num_base_blocks_in_pu_row;
break;
}
case 2:
{
u1_row_start_index = u1_num_base_blocks_in_pu_column;
u1_column_start_index = 0;
break;
}
case 3:
{
u1_row_start_index = u1_num_base_blocks_in_pu_column;
u1_column_start_index = u1_num_base_blocks_in_pu_row;
break;
}
}
u1_column_end_index = u1_column_start_index + u1_num_base_blocks_in_pu_row;
u1_row_end_index = u1_row_start_index + u1_num_base_blocks_in_pu_column;
for(i = u1_row_start_index; i < u1_row_end_index; i++)
{
for(j = u1_column_start_index; j < u1_column_end_index; j++)
{
u8_final_SigmaXSquared += pu8_SigmaXSquared[j + i * u1_num_base_blocks_in_cu_row];
u8_final_SigmaX += pu8_SigmaX[j + i * u1_num_base_blocks_in_cu_row];
}
}
u8_final_variance =
u1_num_base_blocks * u4_num_pixels_in_base_block * u8_final_SigmaXSquared;
u8_final_variance -= u8_final_SigmaX * u8_final_SigmaX;
u8_final_variance +=
((u1_num_base_blocks * u4_num_pixels_in_base_block) *
(u1_num_base_blocks * u4_num_pixels_in_base_block) / 2);
u8_final_variance /= (u1_num_base_blocks * u4_num_pixels_in_base_block) *
(u1_num_base_blocks * u4_num_pixels_in_base_block);
ASSERT(u8_final_variance <= UINT_MAX);
}
return u8_final_variance;
}
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)
{
ULWORD64 au8_SigmaX[16];
ULWORD64 au8_SigmaXSquared[16];
U08 i, j, k, l;
U08 u1_base_block_size;
U08 u1_num_base_blocks_in_cu_row;
U08 u1_num_base_blocks_in_cu_column;
u1_base_block_size =
hme_determine_base_block_size(pi4_valid_part_array, i4_num_valid_parts, u1_cu_size);
u1_num_base_blocks_in_cu_row = u1_num_base_blocks_in_cu_column =
u1_cu_size / u1_base_block_size;
ASSERT(u1_num_base_blocks_in_cu_row <= 4);
for(i = 0; i < u1_num_base_blocks_in_cu_column; i++)
{
for(j = 0; j < u1_num_base_blocks_in_cu_row; j++)
{
U08 *pu1_buf =
pu1_data + (u1_base_block_size * j) + (u1_base_block_size * i * i4_data_stride);
au8_SigmaX[j + i * u1_num_base_blocks_in_cu_row] = 0;
au8_SigmaXSquared[j + i * u1_num_base_blocks_in_cu_row] = 0;
for(k = 0; k < u1_base_block_size; k++)
{
for(l = 0; l < u1_base_block_size; l++)
{
au8_SigmaX[j + i * u1_num_base_blocks_in_cu_row] +=
pu1_buf[l + k * i4_data_stride];
au8_SigmaXSquared[j + i * u1_num_base_blocks_in_cu_row] +=
pu1_buf[l + k * i4_data_stride] * pu1_buf[l + k * i4_data_stride];
}
}
}
}
for(i = 0; i < i4_num_valid_parts; i++)
{
pu4_variance[pi4_valid_part_array[i]] = hme_compute_variance_of_pu_from_base_blocks(
au8_SigmaX, au8_SigmaXSquared, u1_cu_size, u1_base_block_size, pi4_valid_part_array[i]);
}
}
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)
{
U08 i, j;
//U08 u1_num_base_blocks_in_cu_row;
U08 u1_part_dimension_multiplier = (u1_cu_size >> 4);
S32 i4_part_wd = gai1_part_wd_and_ht[i4_part_id][0] * u1_part_dimension_multiplier;
S32 i4_part_ht = gai1_part_wd_and_ht[i4_part_id][1] * u1_part_dimension_multiplier;
U08 u1_num_base_blocks_in_pu_row = i4_part_wd / u1_base_block_size;
U08 u1_num_base_blocks_in_pu_column = i4_part_ht / u1_base_block_size;
U16 u2_num_base_blocks = (u1_num_base_blocks_in_pu_row * u1_num_base_blocks_in_pu_column);
U32 u4_num_pixels_in_base_block = u1_base_block_size * u1_base_block_size;
U32 u4_N = (u2_num_base_blocks * u4_num_pixels_in_base_block);
/*if (u1_is_for_src)
{
u1_num_base_blocks_in_cu_row = 16;
}
else
{
u1_num_base_blocks_in_cu_row = u1_cu_size / u1_base_block_size;
}*/
pu8_final_sigmaX[i4_part_id] = 0;
pu8_final_sigmaX_Squared[i4_part_id] = 0;
if(ge_part_id_to_part_type[i4_part_id] != PRT_NxN)
{
U08 u1_column_start_index = gau1_part_id_to_part_num[i4_part_id]
? (gai1_is_part_vertical[i4_part_id]
? 0
: (u1_cu_size - i4_part_wd) / u1_base_block_size)
: 0;
U08 u1_row_start_index = gau1_part_id_to_part_num[i4_part_id]
? (gai1_is_part_vertical[i4_part_id]
? (u1_cu_size - i4_part_ht) / u1_base_block_size
: 0)
: 0;
U08 u1_column_end_index = u1_column_start_index + u1_num_base_blocks_in_pu_row;
U08 u1_row_end_index = u1_row_start_index + u1_num_base_blocks_in_pu_column;
for(i = u1_row_start_index; i < u1_row_end_index; i++)
{
for(j = u1_column_start_index; j < u1_column_end_index; j++)
{
pu8_final_sigmaX_Squared[i4_part_id] +=
pu4_SigmaXSquared[j + i * u1_base_blk_array_stride];
pu8_final_sigmaX[i4_part_id] += pu4_SigmaX[j + i * u1_base_blk_array_stride];
}
}
}
else
{
U08 u1_row_start_index;
U08 u1_column_start_index;
U08 u1_row_end_index;
U08 u1_column_end_index;
switch(gau1_part_id_to_part_num[i4_part_id])
{
case 0:
{
u1_row_start_index = 0;
u1_column_start_index = 0;
break;
}
case 1:
{
u1_row_start_index = 0;
u1_column_start_index = u1_num_base_blocks_in_pu_row;
break;
}
case 2:
{
u1_row_start_index = u1_num_base_blocks_in_pu_column;
u1_column_start_index = 0;
break;
}
case 3:
{
u1_row_start_index = u1_num_base_blocks_in_pu_column;
u1_column_start_index = u1_num_base_blocks_in_pu_row;
break;
}
}
u1_column_end_index = u1_column_start_index + u1_num_base_blocks_in_pu_row;
u1_row_end_index = u1_row_start_index + u1_num_base_blocks_in_pu_column;
for(i = u1_row_start_index; i < u1_row_end_index; i++)
{
for(j = u1_column_start_index; j < u1_column_end_index; j++)
{
pu8_final_sigmaX_Squared[i4_part_id] +=
pu4_SigmaXSquared[j + i * u1_base_blk_array_stride];
pu8_final_sigmaX[i4_part_id] += pu4_SigmaX[j + i * u1_base_blk_array_stride];
}
}
}
pu8_final_sigmaX_Squared[i4_part_id] *= u4_N;
}
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)
{
U32 au4_sigmaX[16], au4_sigmaXSquared[16];
ULWORD64 au8_final_ref_sigmaX[17], au8_final_ref_sigmaXSquared[17];
S32 i4_noise_term;
U16 i2_count;
ULWORD64 u8_temp_var, u8_temp_var1, u8_pure_dist;
ULWORD64 u8_ref_X_Square, u8_src_var, u8_ref_var;
U08 u1_base_block_size;
WORD32 i4_q_level = STIM_Q_FORMAT + ALPHA_Q_FORMAT;
u1_base_block_size =
hme_determine_base_block_size(pi4_valid_part_array, i4_num_valid_parts, u1_cu_size);
ASSERT(u1_cu_size >= 16);
hme_compute_sigmaX_and_sigmaXSquared(
pu1_pred,
i4_pred_stride,
au4_sigmaX,
au4_sigmaXSquared,
u1_base_block_size,
u1_base_block_size,
u1_cu_size,
u1_cu_size,
1,
u1_cu_size / u1_base_block_size);
/* Noise Term Computation */
for(i2_count = 0; i2_count < i4_num_valid_parts; i2_count++)
{
unsigned long u4_shift_val;
S32 i4_bits_req;
S32 part_id = pi4_valid_part_array[i2_count];
if(i4_alpha_stim_multiplier)
{
/* Final SigmaX and SigmaX-Squared Calculation */
hme_compute_final_sigma_of_pu_from_base_blocks(
au4_sigmaX,
au4_sigmaXSquared,
au8_final_ref_sigmaX,
au8_final_ref_sigmaXSquared,
u1_cu_size,
u1_base_block_size,
part_id,
(u1_cu_size / u1_base_block_size));
u8_ref_X_Square = (au8_final_ref_sigmaX[part_id] * au8_final_ref_sigmaX[part_id]);
u8_ref_var = (au8_final_ref_sigmaXSquared[part_id] - u8_ref_X_Square);
u4_shift_val = ihevce_calc_stim_injected_variance(
pu8_src_sigmaX,
pu8_src_sigmaXSquared,
&u8_src_var,
i4_inv_wt,
i4_inv_wt_shift_val,
i4_wpred_log_wdc,
part_id);
u8_ref_var = u8_ref_var >> u4_shift_val;
GETRANGE64(i4_bits_req, u8_ref_var);
if(i4_bits_req > 27)
{
u8_ref_var = u8_ref_var >> (i4_bits_req - 27);
u8_src_var = u8_src_var >> (i4_bits_req - 27);
}
if(u8_src_var == u8_ref_var)
{
u8_temp_var = (1 << STIM_Q_FORMAT);
}
else
{
u8_temp_var = (u8_src_var * u8_ref_var * (1 << STIM_Q_FORMAT));
u8_temp_var1 = (u8_src_var * u8_src_var) + (u8_ref_var * u8_ref_var);
u8_temp_var = (u8_temp_var + (u8_temp_var1 / 2));
u8_temp_var = (u8_temp_var / u8_temp_var1);
u8_temp_var = (2 * u8_temp_var);
}
i4_noise_term = (UWORD32)u8_temp_var;
ASSERT(i4_noise_term >= 0);
i4_noise_term *= i4_alpha_stim_multiplier;
}
else
{
i4_noise_term = 0;
}
u8_pure_dist = pi4_sad_array[part_id];
u8_pure_dist *= ((1 << (i4_q_level)) - (i4_noise_term));
u8_pure_dist += (1 << ((i4_q_level)-1));
pi4_sad_array[part_id] = (UWORD32)(u8_pure_dist >> (i4_q_level));
}
}
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)
{
U08 i, j, k, l;
U08 u1_num_base_blks_in_row;
U08 u1_num_base_blks_in_column;
u1_num_base_blks_in_row = u1_blk_wd / u1_base_blk_wd;
u1_num_base_blks_in_column = u1_blk_ht / u1_base_blk_ht;
if(u1_is_sigma_pointer_size_32_bit)
{
U32 *sigmaX, *sigmaXSquared;
sigmaX = (U32 *)pv_sigmaX;
sigmaXSquared = (U32 *)pv_sigmaXSquared;
/* Loop to compute the sigma_X and sigma_X_Squared */
for(i = 0; i < u1_num_base_blks_in_column; i++)
{
for(j = 0; j < u1_num_base_blks_in_row; j++)
{
U32 u4_sigmaX = 0, u4_sigmaXSquared = 0;
U08 *pu1_buf =
pu1_data + (u1_base_blk_wd * j) + (u1_base_blk_ht * i * i4_buf_stride);
for(k = 0; k < u1_base_blk_ht; k++)
{
for(l = 0; l < u1_base_blk_wd; l++)
{
u4_sigmaX += pu1_buf[l + k * i4_buf_stride];
u4_sigmaXSquared +=
(pu1_buf[l + k * i4_buf_stride] * pu1_buf[l + k * i4_buf_stride]);
}
}
sigmaX[j + i * u1_array_stride] = u4_sigmaX;
sigmaXSquared[j + i * u1_array_stride] = u4_sigmaXSquared;
}
}
}
else
{
ULWORD64 *sigmaX, *sigmaXSquared;
sigmaX = (ULWORD64 *)pv_sigmaX;
sigmaXSquared = (ULWORD64 *)pv_sigmaXSquared;
/* Loop to compute the sigma_X and sigma_X_Squared */
for(i = 0; i < u1_num_base_blks_in_column; i++)
{
for(j = 0; j < u1_num_base_blks_in_row; j++)
{
ULWORD64 u8_sigmaX = 0, u8_sigmaXSquared = 0;
U08 *pu1_buf =
pu1_data + (u1_base_blk_wd * j) + (u1_base_blk_ht * i * i4_buf_stride);
for(k = 0; k < u1_base_blk_ht; k++)
{
for(l = 0; l < u1_base_blk_wd; l++)
{
u8_sigmaX += pu1_buf[l + k * i4_buf_stride];
u8_sigmaXSquared +=
(pu1_buf[l + k * i4_buf_stride] * pu1_buf[l + k * i4_buf_stride]);
}
}
u8_sigmaXSquared = u8_sigmaXSquared * u1_blk_wd * u1_blk_ht;
sigmaX[j + i * u1_array_stride] = u8_sigmaX;
sigmaXSquared[j + i * u1_array_stride] = u8_sigmaXSquared;
}
}
}
}
#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_16x16_index)
{
WORD32 i;
WORD32 noise_detected;
UWORD8 *pu1_l0_block;
UWORD8 *pu1_l1_block;
WORD32 mean;
UWORD32 variance_8x8;
/* to store the mean and variance of each 8*8 block and find the variance of any higher block sizes later on. block */
WORD16 pi2_residue_16x16[256];
WORD32 mean_16x16;
UWORD32 variance_16x16[2];
/* throw errors in case of un- supported arguments */
/* assumptions size is 8 or 16 or 32 */
assert(
(had_block_size == 8) || (had_block_size == 16) || (had_block_size == 32)); //ihevc_assert
/* initialize the variables */
noise_detected = 0;
variance_8x8 = 0;
mean = 0;
{
i = 0;
/* get the ref/pred and source using the MV of both directions */
/* pick the best candidates in each direction */
/* Colocated cands */
{
// steps to be done
/* pick the candidates */
/* do motion compoensation using the candidates got from prev step : pick from the offset */
/* get the ref or the pred from the offset*/
/* get the source data */
/* send the pred - source to noise detect */
/* do noise detect on the residue of source and pred */
layer_mv_t *ps_layer_mvbank;
hme_mv_t *ps_mv;
//S32 i;
S32 wd_c, ht_c, wd_p, ht_p;
S32 blksize_p, blk_x, blk_y, i4_offset;
S08 *pi1_ref_idx;
fpel_srch_cand_init_data_t *ps_ctxt_2 = s_proj_srch_cand_init_data;
layer_ctxt_t *ps_curr_layer = ps_ctxt_2->ps_curr_layer;
layer_ctxt_t *ps_coarse_layer = ps_ctxt_2->ps_coarse_layer;
err_prms_t s_err_prms;
S32 i4_blk_wd;
S32 i4_blk_ht;
BLK_SIZE_T e_blk_size;
hme_search_prms_t *ps_search_prms;
S32 i4_part_mask;
S32 *pi4_valid_part_ids;
/* has list of valid partition to search terminated by -1 */
S32 ai4_valid_part_ids[TOT_NUM_PARTS + 1];
/*SEARCH_COMPLEXITY_T e_search_complexity = ps_ctxt->e_search_complexity;*/
S32 i4_pos_x;
S32 i4_pos_y;
U08 u1_pred_dir; // = ps_ctxt_2->u1_pred_dir;
U08 u1_default_ref_id = 0; //ps_ctxt_2->u1_default_ref_id;
S32 i4_inp_off, i4_ref_offset, i4_ref_stride;
/* The reference is actually an array of ptrs since there are several */
/* reference id. So an array gets passed form calling function */
U08 **ppu1_ref;
/* Atributes of input candidates */
search_node_t as_search_node[2];
wgt_pred_ctxt_t *ps_wt_inp_prms;
S32 posx;
S32 posy;
S32 i4_num_results_to_proj;
S32 ai4_sad_grid[9 * TOT_NUM_PARTS];
S32 i4_inp_stride;
/* intialize variables */
/* Width and ht of current and prev layers */
wd_c = ps_curr_layer->i4_wd;
ht_c = ps_curr_layer->i4_ht;
wd_p = ps_coarse_layer->i4_wd;
ht_p = ps_coarse_layer->i4_ht;
ps_search_prms = s_search_prms_blk;
ps_wt_inp_prms = &ps_ctxt->s_wt_pred;
e_blk_size = ps_search_prms->e_blk_size;
i4_part_mask = ps_search_prms->i4_part_mask;
i4_blk_wd = gau1_blk_size_to_wd[e_blk_size];
i4_blk_ht = gau1_blk_size_to_ht[e_blk_size];
ps_layer_mvbank = ps_coarse_layer->ps_layer_mvbank;
blksize_p = gau1_blk_size_to_wd_shift[ps_layer_mvbank->e_blk_size];
/* ASSERT for valid sizes */
ASSERT((blksize_p == 3) || (blksize_p == 4) || (blksize_p == 5));
i4_pos_x = i4_cu_x_off;
i4_pos_y = i4_cu_y_off;
posx = i4_pos_x + 2;
posy = i4_pos_y + 2;
i4_inp_stride = ps_search_prms->i4_inp_stride;
/* Move to the location of the search blk in inp buffer */
//i4_inp_off = i4_cu_x_off;
//i4_inp_off += i4_cu_y_off * i4_inp_stride;
i4_inp_off = (i4_16x16_index % 4) * 16;
i4_inp_off += (i4_16x16_index / 4) * 16 * i4_inp_stride;
/***********pick the candidates**************************************/
for(u1_pred_dir = 0; u1_pred_dir < num_pred_dir; u1_pred_dir++)
{
WORD32 actual_pred_dir = 0;
if(u1_pred_dir == 0 && i4_num_act_ref_l0 == 0)
{
actual_pred_dir = 1;
}
else if(u1_pred_dir == 0 && i4_num_act_ref_l0 != 0)
{
actual_pred_dir = 0;
}
else if(u1_pred_dir == 1)
{
actual_pred_dir = 1;
}
i4_num_results_to_proj = 1; // only the best proj
/* Safety check to avoid uninitialized access across temporal layers */
posx = CLIP3(posx, 0, (wd_c - blksize_p)); /* block position withing frAME */
posy = CLIP3(posy, 0, (ht_c - blksize_p));
/* Project the positions to prev layer */
blk_x = posx >> blksize_p;
blk_y = posy >> blksize_p;
/* Pick up the mvs from the location */
i4_offset = (blk_x * ps_layer_mvbank->i4_num_mvs_per_blk);
i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * blk_y);
ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;
if(actual_pred_dir == 1)
{
ps_mv += (i4_num_act_ref_l0 * ps_layer_mvbank->i4_num_mvs_per_ref);
pi1_ref_idx += (i4_num_act_ref_l0 * ps_layer_mvbank->i4_num_mvs_per_ref);
}
{
as_search_node[actual_pred_dir].s_mv.i2_mvx = ps_mv[0].i2_mv_x << 1;
as_search_node[actual_pred_dir].s_mv.i2_mvy = ps_mv[0].i2_mv_y << 1;
as_search_node[actual_pred_dir].i1_ref_idx = pi1_ref_idx[0];
if((as_search_node[actual_pred_dir].i1_ref_idx < 0) ||
(as_search_node[actual_pred_dir].s_mv.i2_mvx == INTRA_MV))
{
as_search_node[actual_pred_dir].i1_ref_idx = u1_default_ref_id;
as_search_node[actual_pred_dir].s_mv.i2_mvx = 0;
as_search_node[actual_pred_dir].s_mv.i2_mvy = 0;
}
}
/********************************************************************************************/
{
/* declare the variables */
//ps_fullpel_refine_ctxt = ps_search_prms->ps_fullpel_refine_ctxt;
pi4_valid_part_ids = ai4_valid_part_ids;
i4_ref_stride = ps_curr_layer->i4_rec_stride;
s_err_prms.i4_inp_stride = i4_inp_stride;
s_err_prms.i4_ref_stride = i4_ref_stride;
s_err_prms.i4_part_mask = i4_part_mask;
s_err_prms.pi4_sad_grid = &ai4_sad_grid[0];
s_err_prms.i4_blk_wd = i4_blk_wd;
s_err_prms.i4_blk_ht = i4_blk_ht;
s_err_prms.i4_step = 1;
s_err_prms.pi4_valid_part_ids = pi4_valid_part_ids;
//s_err_prms.i4_num_partitions = ps_fullpel_refine_ctxt->i4_num_valid_parts;
/*************************************************************************/
/* Depending on flag i4_use_rec, we use either input of previously */
/* encoded pictures or we use recon of previously encoded pictures. */
i4_ref_stride = ps_curr_layer->i4_rec_stride;
ppu1_ref = ps_curr_layer->ppu1_list_rec_fxfy; // pointer to the pred
i4_ref_offset = (i4_ref_stride * i4_cu_y_off) + i4_cu_x_off; //i4_x_off;
s_err_prms.pu1_ref =
ppu1_ref[as_search_node[actual_pred_dir].i1_ref_idx] + i4_ref_offset;
s_err_prms.pu1_ref += as_search_node[actual_pred_dir].s_mv.i2_mvx;
s_err_prms.pu1_ref +=
as_search_node[actual_pred_dir].s_mv.i2_mvy * i4_ref_stride;
/*get the source */
s_err_prms.pu1_inp =
ps_wt_inp_prms->apu1_wt_inp[as_search_node[actual_pred_dir].i1_ref_idx] +
i4_inp_off; //pu1_src_input + i4_inp_off;//ps_wt_inp_prms->apu1_wt_inp[as_search_node[actual_pred_dir].i1_ref_idx] + i4_inp_off;
/* send the pred - source to noise detect */
// noise_detect_hme(noise_structure, s_err_prms.pu1_inp, s_err_prms.pu1_ref);
}
/* change the l0/l1 blcok pointer names accrodingle */
/* get memory pointers the input and the reference */
pu1_l0_block = s_err_prms.pu1_inp;
pu1_l1_block = s_err_prms.pu1_ref;
{
WORD32 i2, j2;
WORD32 dim = 16;
UWORD8 *buf1;
UWORD8 *buf2;
for(i2 = 0; i2 < dim; i2++)
{
buf1 = pu1_l0_block + i2 * i4_inp_stride;
buf2 = pu1_l1_block + i2 * i4_ref_stride;
for(j2 = 0; j2 < dim; j2++)
{
pi2_residue_16x16[i2 * dim + j2] = (WORD16)(buf1[j2] - buf2[j2]);
}
}
ihevce_calc_variance_signed(
pi2_residue_16x16, 16, &mean_16x16, &variance_16x16[u1_pred_dir], 16, 16);
/* compare the source and residue variance for this block ps_ctb_noise_params->i4_variance_src_16x16 */
if(variance_16x16[u1_pred_dir] >
((TEMPORAL_VARIANCE_FACTOR *
ps_ctb_noise_params->au4_variance_src_16x16[i4_16x16_index]) >>
Q_TEMPORAL_VARIANCE_FACTOR))
{
/* update noisy block count only if all best MV in diff directions indicates noise */
if(u1_pred_dir == num_pred_dir - 1)
{
ps_ctb_noise_params->au1_is_8x8Blk_noisy[index_8x8_block] = 1;
ps_ctb_noise_params->au1_is_8x8Blk_noisy[index_8x8_block + 1] = 1;
ps_ctb_noise_params
->au1_is_8x8Blk_noisy[index_8x8_block + num_8x8_in_ctb_row] = 1;
ps_ctb_noise_params
->au1_is_8x8Blk_noisy[index_8x8_block + num_8x8_in_ctb_row + 1] = 1;
noise_detected = 1;
}
}
else /* if any one of the direction mv says it as non noise then dont check for the other directions MV , move for next block*/
{
noise_detected = 0;
ps_ctb_noise_params->au1_is_8x8Blk_noisy[index_8x8_block] = 0;
ps_ctb_noise_params->au1_is_8x8Blk_noisy[index_8x8_block + 1] = 0;
ps_ctb_noise_params
->au1_is_8x8Blk_noisy[index_8x8_block + num_8x8_in_ctb_row] = 0;
ps_ctb_noise_params
->au1_is_8x8Blk_noisy[index_8x8_block + num_8x8_in_ctb_row + 1] = 0;
break;
}
} // variance analysis and calculation
} // for each direction
} // HME code
} // for each 16x16 block
return (noise_detected);
}
#endif
void hme_qpel_interp_avg_1pt(
interp_prms_t *ps_prms,
S32 i4_mv_x,
S32 i4_mv_y,
S32 i4_buf_id,
U08 **ppu1_final,
S32 *pi4_final_stride)
{
U08 *pu1_src1, *pu1_src2, *pu1_dst;
qpel_input_buf_cfg_t *ps_inp_cfg;
S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;
/*************************************************************************/
/* For a given QPEL pt, we need to determine the 2 source pts that are */
/* needed to do the QPEL averaging. The logic to do this is as follows */
/* i4_mv_x and i4_mv_y are the motion vectors in QPEL units that are */
/* pointing to the pt of interest. Obviously, they are w.r.t. the 0,0 */
/* pt of th reference blk that is colocated to the inp blk. */
/* A j E k B */
/* l m n o p */
/* F q G r H */
/* s t u v w */
/* C x I y D */
/* In above diagram, A. B, C, D are full pts at offsets (0,0),(1,0),(0,1)*/
/* and (1,1) respectively in the fpel buffer (id = 0) */
/* E and I are hxfy pts in offsets (0,0),(0,1) respectively in hxfy buf */
/* F and H are fxhy pts in offsets (0,0),(1,0) respectively in fxhy buf */
/* G is hxhy pt in offset 0,0 in hxhy buf */
/* All above offsets are computed w.r.t. motion displaced pt in */
/* respective bufs. This means that A corresponds to (i4_mv_x >> 2) and */
/* (i4_mv_y >> 2) in fxfy buf. Ditto with E, F and G */
/* fxfy buf is buf id 0, hxfy is buf id 1, fxhy is buf id 2, hxhy is 3 */
/* If we consider pt v to be derived. v has a fractional comp of 3, 3 */
/* v is avg of H and I. So the table look up of v should give following */
/* buf 1 (H) : offset = (1, 0) buf id = 2. */
/* buf 2 (I) : offset = 0 , 1) buf id = 1. */
/* NOTE: For pts that are fxfy/hxfy/fxhy/hxhy, bufid 1 will be -1. */
/*************************************************************************/
i4_mv_x_frac = i4_mv_x & 3;
i4_mv_y_frac = i4_mv_y & 3;
i4_offset = (i4_mv_x >> 2) + (i4_mv_y >> 2) * ps_prms->i4_ref_stride;
/* Derive the descriptor that has all offset and size info */
ps_inp_cfg = &gas_qpel_inp_buf_cfg[i4_mv_y_frac][i4_mv_x_frac];
pu1_src1 = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];
pu1_src1 += ps_inp_cfg->i1_buf_xoff1 + i4_offset;
pu1_src1 += (ps_inp_cfg->i1_buf_yoff1 * ps_prms->i4_ref_stride);
pu1_src2 = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id2];
pu1_src2 += ps_inp_cfg->i1_buf_xoff2 + i4_offset;
pu1_src2 += (ps_inp_cfg->i1_buf_yoff2 * ps_prms->i4_ref_stride);
pu1_dst = ps_prms->apu1_interp_out[i4_buf_id];
hevc_avg_2d(
pu1_src1,
pu1_src2,
ps_prms->i4_ref_stride,
ps_prms->i4_ref_stride,
ps_prms->i4_blk_wd,
ps_prms->i4_blk_ht,
pu1_dst,
ps_prms->i4_out_stride);
ppu1_final[i4_buf_id] = pu1_dst;
pi4_final_stride[i4_buf_id] = ps_prms->i4_out_stride;
}
void hme_qpel_interp_avg_2pt_vert_with_reuse(
interp_prms_t *ps_prms, S32 i4_mv_x, S32 i4_mv_y, U08 **ppu1_final, S32 *pi4_final_stride)
{
hme_qpel_interp_avg_1pt(ps_prms, i4_mv_x, i4_mv_y + 1, 3, ppu1_final, pi4_final_stride);
hme_qpel_interp_avg_1pt(ps_prms, i4_mv_x, i4_mv_y - 1, 1, ppu1_final, pi4_final_stride);
}
void hme_qpel_interp_avg_2pt_horz_with_reuse(
interp_prms_t *ps_prms, S32 i4_mv_x, S32 i4_mv_y, U08 **ppu1_final, S32 *pi4_final_stride)
{
hme_qpel_interp_avg_1pt(ps_prms, i4_mv_x + 1, i4_mv_y, 2, ppu1_final, pi4_final_stride);
hme_qpel_interp_avg_1pt(ps_prms, i4_mv_x - 1, i4_mv_y, 0, ppu1_final, pi4_final_stride);
}
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)
{
WORD32 ref_ctr;
/* Only for B/b pic. */
if(1 == ps_ctxt->s_frm_prms.bidir_enabled)
{
WORD16 i2_mv_y_per_poc, i2_max_mv_y;
WORD32 cur_poc, prev_poc, ref_poc, abs_poc_diff;
WORD32 prev_poc_count = 0;
WORD32 i4_p_idx;
pi2_prev_enc_frm_max_mv_y[0] = 0;
cur_poc = ps_ctxt->i4_curr_poc;
i4_p_idx = 0;
/* Get abs MAX for symmetric search */
i2_mv_y_per_poc = ps_curr_layer->i2_max_mv_y;
/* Assuming P to P distance as 4 */
i2_mv_y_per_poc = (i2_mv_y_per_poc + 2) >> 2;
for(ref_ctr = 0; ref_ctr < u1_num_act_ref_pics; ref_ctr++)
{
/* Get the prev. encoded frame POC */
prev_poc = ps_ctxt->i4_prev_poc;
ref_poc = ps_ctxt->ai4_ref_idx_to_poc_lc[ref_ctr];
abs_poc_diff = ABS((cur_poc - ref_poc));
/* Get the cur. max MV based on POC distance */
i2_max_mv_y = i2_mv_y_per_poc * abs_poc_diff;
i2_max_mv_y = MIN(i2_max_mv_y, ps_curr_layer->i2_max_mv_y);
ps_mv_limit[ref_ctr].i2_min_x = -ps_curr_layer->i2_max_mv_x;
ps_mv_limit[ref_ctr].i2_min_y = -i2_max_mv_y;
ps_mv_limit[ref_ctr].i2_max_x = ps_curr_layer->i2_max_mv_x;
ps_mv_limit[ref_ctr].i2_max_y = i2_max_mv_y;
/* Find the MAX MV for the prev. encoded frame to optimize */
/* the reverse dependency of ME on Enc.Loop */
if(ref_poc == prev_poc)
{
/* TO DO : Same thing for horz. search also */
pi2_prev_enc_frm_max_mv_y[0] = i2_max_mv_y;
prev_poc_count++;
}
}
}
else
{
ASSERT(0 == ps_ctxt->s_frm_prms.u1_num_active_ref_l1);
/* Set the Config. File Params for P pic. */
for(ref_ctr = 0; ref_ctr < ps_ctxt->s_frm_prms.u1_num_active_ref_l0; ref_ctr++)
{
ps_mv_limit[ref_ctr].i2_min_x = -ps_curr_layer->i2_max_mv_x;
ps_mv_limit[ref_ctr].i2_min_y = -ps_curr_layer->i2_max_mv_y;
ps_mv_limit[ref_ctr].i2_max_x = ps_curr_layer->i2_max_mv_x;
ps_mv_limit[ref_ctr].i2_max_y = ps_curr_layer->i2_max_mv_y;
}
/* For P PIC., go with Config. File Params */
pi2_prev_enc_frm_max_mv_y[0] = ps_curr_layer->i2_max_mv_y;
}
}
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)
{
if(15 != u1_blk_8x8_mask)
{
return ENABLE_NxN;
}
else
{
U08 u1_call_inp_segmentation_based_part_mask_populator =
(ME_XTREME_SPEED_25 != e_me_quality_preset) ||
(!u1_is_bPic && !DISABLE_8X8CUS_IN_PPICS_IN_P6) ||
(u1_is_bPic && u1_is_refPic && !DISABLE_8X8CUS_IN_REFBPICS_IN_P6) ||
(u1_is_bPic && !u1_is_refPic && !DISABLE_8X8CUS_IN_NREFBPICS_IN_P6);
if(u1_call_inp_segmentation_based_part_mask_populator)
{
S32 i4_part_mask =
hme_study_input_segmentation(pu1_inp, i4_inp_stride, u1_limit_active_partitions);
if(e_me_quality_preset == ME_XTREME_SPEED)
{
i4_part_mask &= ~ENABLE_AMP;
}
if(e_me_quality_preset == ME_XTREME_SPEED_25)
{
i4_part_mask &= ~ENABLE_AMP;
i4_part_mask &= ~ENABLE_SMP;
}
return i4_part_mask;
}
else
{
return ENABLE_2Nx2N;
}
}
}
Reference in New Issue View Git Blame Copy Permalink