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

4430 lines
179 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 hme_subpel.c
*
* @brief
* Subpel refinement modules for ME algo
*
* @author
* Ittiam
*
*
* List of Functions
* hme_qpel_interp_avg()
* hme_subpel_refine_ctblist_bck()
* hme_subpel_refine_ctblist_fwd()
* hme_refine_bidirect()
* hme_subpel_refinement()
* hme_subpel_refine_ctb_fwd()
* hme_subpel_refine_ctb_bck()
* hme_create_bck_inp()
* hme_subpel_refine_search_node()
******************************************************************************
*/
/*****************************************************************************/
/* 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_bs_compute_ctb.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"
/*****************************************************************************/
/* Function Definitions */
/*****************************************************************************/
void hme_qpel_interp_avg(interp_prms_t *ps_prms, S32 i4_mv_x, S32 i4_mv_y, S32 i4_buf_id)
{
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];
if(ps_inp_cfg->i1_buf_id1 == ps_inp_cfg->i1_buf_id2)
{
/* This is case for fxfy/hxfy/fxhy/hxhy */
ps_prms->pu1_final_out = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];
ps_prms->pu1_final_out += ps_inp_cfg->i1_buf_xoff1 + i4_offset;
ps_prms->pu1_final_out += (ps_inp_cfg->i1_buf_yoff1 * ps_prms->i4_ref_stride);
ps_prms->i4_final_out_stride = ps_prms->i4_ref_stride;
return;
}
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);
ps_prms->pu1_final_out = pu1_dst;
ps_prms->i4_final_out_stride = ps_prms->i4_out_stride;
}
static __inline void hme_qpel_interp_avg_2pt_vert_no_reuse(
interp_prms_t *ps_prms,
S32 i4_mv_x,
S32 i4_mv_y,
U08 **ppu1_final,
S32 *pi4_final_stride,
FT_QPEL_INTERP_AVG_1PT *pf_qpel_interp_avg_1pt)
{
pf_qpel_interp_avg_1pt(ps_prms, i4_mv_x, i4_mv_y + 1, 3, ppu1_final, pi4_final_stride);
pf_qpel_interp_avg_1pt(ps_prms, i4_mv_x, i4_mv_y - 1, 1, ppu1_final, pi4_final_stride);
}
static __inline void hme_qpel_interp_avg_2pt_horz_no_reuse(
interp_prms_t *ps_prms,
S32 i4_mv_x,
S32 i4_mv_y,
U08 **ppu1_final,
S32 *pi4_final_stride,
FT_QPEL_INTERP_AVG_1PT *pf_qpel_interp_avg_1pt)
{
pf_qpel_interp_avg_1pt(ps_prms, i4_mv_x + 1, i4_mv_y, 2, ppu1_final, pi4_final_stride);
pf_qpel_interp_avg_1pt(ps_prms, i4_mv_x - 1, i4_mv_y, 0, ppu1_final, pi4_final_stride);
}
/********************************************************************************
* @fn hme_qpel_interp_comprehensive
*
* @brief Interpolates 2 qpel points by hpel averaging
*
* @param[in,out] ps_prms: Both input buffer ptrs and location of output
*
* @param[in] i4_mv_x : x component of motion vector in QPEL units
*
* @param[in] i4_mv_y : y component of motion vector in QPEL units
*
* @param[in] i4_grid_mask : mask which determines qpels to be computed
*
* @param[out] ppu1_final : storage for final buffer pointers
*
* @param[out] pi4_final_stride : storage for final buffer strides
*
* @return None
********************************************************************************
*/
static __inline void hme_qpel_interp_comprehensive(
interp_prms_t *ps_prms,
U08 **ppu1_final,
S32 *pi4_final_stride,
S32 i4_mv_x,
S32 i4_mv_y,
S32 i4_grid_mask,
ihevce_me_optimised_function_list_t *ps_me_optimised_function_list)
{
S32 pt_select_for_TB, pt_select_for_LR;
S32 dx, dy, dydx;
S32 vert_func_selector, horz_func_selector;
S32 i4_ref_stride = ps_prms->i4_ref_stride;
pt_select_for_TB =
((i4_grid_mask & (1 << PT_B)) >> PT_B) + ((i4_grid_mask & (1 << PT_T)) >> (PT_T - 1));
pt_select_for_LR =
((i4_grid_mask & (1 << PT_R)) >> PT_R) + ((i4_grid_mask & (1 << PT_L)) >> (PT_L - 1));
dx = (i4_mv_x & 3);
dy = (i4_mv_y & 3);
dydx = (dx + (dy << 2));
vert_func_selector = gai4_select_qpel_function_vert[pt_select_for_TB][dydx];
horz_func_selector = gai4_select_qpel_function_horz[pt_select_for_LR][dydx];
/* case descriptions */
/* Let T = (gridmask & T) & B = (gridmask & B) */
/* & hp = pt is an hpel or an fpel */
/* & r = reuse possible */
/* 0 => T || B = 0 */
/* 1 => (!T) && (B) && hp */
/* 2 => (T) && (!B) && hp */
/* 3 => (!T) && (B) && !hp */
/* 4 => (T) && (!B) && !hp */
/* 5 => (T) && (B) && !hp && r */
/* 6 => (T) && (B) && !hp && !r */
/* 7 => (T) && (B) && hp */
switch(vert_func_selector)
{
case 0:
{
break;
}
case 1:
{
S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;
qpel_input_buf_cfg_t *ps_inp_cfg;
S32 i4_mvyp1 = (i4_mv_y + 1);
i4_mv_x_frac = dx;
i4_mv_y_frac = i4_mvyp1 & 3;
i4_offset = (i4_mv_x >> 2) + (i4_mvyp1 >> 2) * 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];
ppu1_final[3] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];
ppu1_final[3] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;
ppu1_final[3] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);
pi4_final_stride[3] = i4_ref_stride;
break;
}
case 2:
{
S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;
qpel_input_buf_cfg_t *ps_inp_cfg;
S32 i4_mvym1 = (i4_mv_y - 1);
i4_mv_x_frac = dx;
i4_mv_y_frac = i4_mvym1 & 3;
i4_offset = (i4_mv_x >> 2) + (i4_mvym1 >> 2) * 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];
ppu1_final[1] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];
ppu1_final[1] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;
ppu1_final[1] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);
pi4_final_stride[1] = i4_ref_stride;
break;
}
case 3:
{
ps_me_optimised_function_list->pf_qpel_interp_avg_1pt(
ps_prms, i4_mv_x, i4_mv_y + 1, 3, ppu1_final, pi4_final_stride);
break;
}
case 4:
{
ps_me_optimised_function_list->pf_qpel_interp_avg_1pt(
ps_prms, i4_mv_x, i4_mv_y - 1, 1, ppu1_final, pi4_final_stride);
break;
}
case 5:
{
ps_me_optimised_function_list->pf_qpel_interp_avg_2pt_vert_with_reuse(
ps_prms, i4_mv_x, i4_mv_y, ppu1_final, pi4_final_stride);
break;
}
case 6:
{
hme_qpel_interp_avg_2pt_vert_no_reuse(
ps_prms,
i4_mv_x,
i4_mv_y,
ppu1_final,
pi4_final_stride,
ps_me_optimised_function_list->pf_qpel_interp_avg_1pt);
break;
}
case 7:
{
S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;
qpel_input_buf_cfg_t *ps_inp_cfg;
S32 i4_mvyp1 = (i4_mv_y + 1);
S32 i4_mvym1 = (i4_mv_y - 1);
i4_mv_x_frac = dx;
i4_mv_y_frac = i4_mvyp1 & 3;
i4_offset = (i4_mv_x >> 2) + (i4_mvyp1 >> 2) * 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];
ppu1_final[3] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];
ppu1_final[3] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;
ppu1_final[3] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);
pi4_final_stride[3] = i4_ref_stride;
i4_mv_y_frac = i4_mvym1 & 3;
i4_offset = (i4_mv_x >> 2) + (i4_mvym1 >> 2) * 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];
ppu1_final[1] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];
ppu1_final[1] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;
ppu1_final[1] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);
pi4_final_stride[1] = i4_ref_stride;
break;
}
}
/* case descriptions */
/* Let L = (gridmask & L) & R = (gridmask & R) */
/* & hp = pt is an hpel or an fpel */
/* & r = reuse possible */
/* 0 => L || R = 0 */
/* 1 => (!L) && (R) && hp */
/* 2 => (L) && (!R) && hp */
/* 3 => (!L) && (R) && !hp */
/* 4 => (L) && (!R) && !hp */
/* 5 => (L) && (R) && !hp && r */
/* 6 => (L) && (R) && !hp && !r */
/* 7 => (L) && (R) && hp */
switch(horz_func_selector)
{
case 0:
{
break;
}
case 1:
{
S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;
qpel_input_buf_cfg_t *ps_inp_cfg;
S32 i4_mvxp1 = (i4_mv_x + 1);
i4_mv_x_frac = i4_mvxp1 & 3;
i4_mv_y_frac = dy;
i4_offset = (i4_mvxp1 >> 2) + (i4_mv_y >> 2) * 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];
ppu1_final[2] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];
ppu1_final[2] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;
ppu1_final[2] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);
pi4_final_stride[2] = i4_ref_stride;
break;
}
case 2:
{
S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;
qpel_input_buf_cfg_t *ps_inp_cfg;
S32 i4_mvxm1 = (i4_mv_x - 1);
i4_mv_x_frac = i4_mvxm1 & 3;
i4_mv_y_frac = dy;
i4_offset = (i4_mvxm1 >> 2) + (i4_mv_y >> 2) * 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];
ppu1_final[0] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];
ppu1_final[0] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;
ppu1_final[0] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);
pi4_final_stride[0] = i4_ref_stride;
break;
}
case 3:
{
ps_me_optimised_function_list->pf_qpel_interp_avg_1pt(
ps_prms, i4_mv_x + 1, i4_mv_y, 2, ppu1_final, pi4_final_stride);
break;
}
case 4:
{
ps_me_optimised_function_list->pf_qpel_interp_avg_1pt(
ps_prms, i4_mv_x - 1, i4_mv_y, 0, ppu1_final, pi4_final_stride);
break;
}
case 5:
{
ps_me_optimised_function_list->pf_qpel_interp_avg_2pt_horz_with_reuse(
ps_prms, i4_mv_x, i4_mv_y, ppu1_final, pi4_final_stride);
break;
}
case 6:
{
hme_qpel_interp_avg_2pt_horz_no_reuse(
ps_prms,
i4_mv_x,
i4_mv_y,
ppu1_final,
pi4_final_stride,
ps_me_optimised_function_list->pf_qpel_interp_avg_1pt);
break;
}
case 7:
{
S32 i4_mv_x_frac, i4_mv_y_frac, i4_offset;
qpel_input_buf_cfg_t *ps_inp_cfg;
S32 i4_mvxp1 = (i4_mv_x + 1);
S32 i4_mvxm1 = (i4_mv_x - 1);
i4_mv_x_frac = i4_mvxp1 & 3;
i4_mv_y_frac = dy;
i4_offset = (i4_mvxp1 >> 2) + (i4_mv_y >> 2) * 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];
ppu1_final[2] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];
ppu1_final[2] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;
ppu1_final[2] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);
pi4_final_stride[2] = i4_ref_stride;
i4_mv_x_frac = i4_mvxm1 & 3;
i4_offset = (i4_mvxm1 >> 2) + (i4_mv_y >> 2) * 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];
ppu1_final[0] = ps_prms->ppu1_ref[ps_inp_cfg->i1_buf_id1];
ppu1_final[0] += ps_inp_cfg->i1_buf_xoff1 + i4_offset;
ppu1_final[0] += (ps_inp_cfg->i1_buf_yoff1 * i4_ref_stride);
pi4_final_stride[0] = i4_ref_stride;
break;
}
}
}
/**
********************************************************************************
* @fn S32 hme_compute_pred_and_evaluate_bi(hme_subpel_prms_t *ps_prms,
* search_results_t *ps_search_results,
* layer_ctxt_t *ps_curr_layer,
* U08 **ppu1_pred)
*
*
* @brief Evaluates the best bipred cost as avg(P0, P1) where P0 and P1 are
* best L0 and L1 bufs respectively for the entire CU
*
* @param[in] ps_prms: subpel prms input to this function
*
* @param[in] ps_curr_layer: points to the current layer ctxt
*
* @return The best BI cost of best uni cost, whichever better
********************************************************************************
*/
void hme_compute_pred_and_evaluate_bi(
inter_cu_results_t *ps_cu_results,
inter_pu_results_t *ps_pu_results,
inter_ctb_prms_t *ps_inter_ctb_prms,
part_type_results_t *ps_part_type_result,
ULWORD64 *pu8_winning_pred_sigmaXSquare,
ULWORD64 *pu8_winning_pred_sigmaX,
ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list,
ihevce_me_optimised_function_list_t *ps_me_optimised_function_list)
{
/* Idx0 - Uni winner */
/* Idx1 - Uni runner-up */
/* Idx2 - Bi winner */
hme_pred_buf_info_t as_pred_buf_data[3][NUM_INTER_PU_PARTS];
err_prms_t s_err_prms;
interp_prms_t s_interp_prms;
PF_SAD_FXN_T pf_err_compute;
S32 i, j;
S32 x_off, y_off, x_pic, y_pic;
S32 i4_sad_grid;
U08 e_cu_size;
S32 i4_part_type;
U08 u1_cu_size;
S32 shift;
S32 x_part, y_part, num_parts;
S32 inp_stride, ref_stride;
U08 au1_pred_buf_array_indixes[3];
S32 cur_iter_best_cost;
S32 uni_cost, bi_cost, best_cost, tot_cost;
/* Idx0 - Uni winner */
/* Idx1 - Bi winner */
ULWORD64 au8_sigmaX[2][NUM_INTER_PU_PARTS];
ULWORD64 au8_sigmaXSquared[2][NUM_INTER_PU_PARTS];
#if USE_NOISE_TERM_DURING_BICAND_SEARCH
S32 i4_noise_term;
#endif
interp_prms_t *ps_interp_prms = &s_interp_prms;
S32 best_cand_in_opp_dir_idx = 0;
S32 is_best_cand_an_intra = 0;
U08 u1_is_cu_noisy = ps_inter_ctb_prms->u1_is_cu_noisy;
#if USE_NOISE_TERM_DURING_BICAND_SEARCH
const S32 i4_default_src_wt = ((1 << 15) + (WGHT_DEFAULT >> 1)) / WGHT_DEFAULT;
#endif
tot_cost = 0;
/* Start of the CU w.r.t. CTB */
x_off = ps_cu_results->u1_x_off;
y_off = ps_cu_results->u1_y_off;
inp_stride = ps_inter_ctb_prms->i4_inp_stride;
ref_stride = ps_inter_ctb_prms->i4_rec_stride;
ps_interp_prms->i4_ref_stride = ref_stride;
/* Start of the CU w.r.t. Pic 0,0 */
x_pic = x_off + ps_inter_ctb_prms->i4_ctb_x_off;
y_pic = y_off + ps_inter_ctb_prms->i4_ctb_y_off;
u1_cu_size = ps_cu_results->u1_cu_size;
e_cu_size = u1_cu_size;
shift = (S32)e_cu_size;
i4_part_type = ps_part_type_result->u1_part_type;
num_parts = gau1_num_parts_in_part_type[i4_part_type];
for(i = 0; i < 3; i++)
{
hme_init_pred_buf_info(
&as_pred_buf_data[i],
&ps_inter_ctb_prms->s_pred_buf_mngr,
(ps_part_type_result->as_pu_results->pu.b4_wd + 1) << 2,
(ps_part_type_result->as_pu_results->pu.b4_ht + 1) << 2,
(PART_TYPE_T)i4_part_type);
au1_pred_buf_array_indixes[i] = as_pred_buf_data[i][0].u1_pred_buf_array_id;
}
for(j = 0; j < num_parts; j++)
{
UWORD8 *apu1_hpel_ref[2][4];
PART_ID_T e_part_id;
BLK_SIZE_T e_blk_size;
WORD8 i1_ref_idx;
UWORD8 pred_dir;
WORD32 ref_offset, inp_offset, wd, ht;
pu_result_t *ps_pu_node1, *ps_pu_node2, *ps_pu_result;
mv_t *aps_mv[2];
UWORD8 num_active_ref_opp;
UWORD8 num_results_per_part;
WORD32 luma_weight_ref1, luma_offset_ref1;
WORD32 luma_weight_ref2, luma_offset_ref2;
WORD32 pu_node2_found = 0;
e_part_id = ge_part_type_to_part_id[i4_part_type][j];
e_blk_size = ge_part_id_to_blk_size[e_cu_size][e_part_id];
x_part = gas_part_attr_in_cu[e_part_id].u1_x_start << shift;
y_part = gas_part_attr_in_cu[e_part_id].u1_y_start << shift;
ref_offset = (x_part + x_pic) + (y_pic + y_part) * ref_stride;
inp_offset = (x_part + y_part * inp_stride) + ps_cu_results->i4_inp_offset;
pred_dir = ps_part_type_result->as_pu_results[j].pu.b2_pred_mode;
ps_pu_node1 = &(ps_part_type_result->as_pu_results[j]);
if(PRED_L0 == pred_dir)
{
i1_ref_idx = ps_pu_node1->pu.mv.i1_l0_ref_idx;
aps_mv[0] = &(ps_pu_node1->pu.mv.s_l0_mv);
num_active_ref_opp =
ps_inter_ctb_prms->u1_num_active_ref_l1 * (ps_inter_ctb_prms->i4_bidir_enabled);
num_results_per_part = ps_pu_results->u1_num_results_per_part_l0[e_part_id];
ps_pu_result = ps_pu_results->aps_pu_results[PRED_L0][e_part_id];
ASSERT(i1_ref_idx >= 0);
apu1_hpel_ref[0][0] =
(UWORD8 *)(ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->s_yuv_buf_desc.pv_y_buf) +
ref_offset;
apu1_hpel_ref[0][1] =
ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->apu1_y_sub_pel_planes[0] +
ref_offset;
apu1_hpel_ref[0][2] =
ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->apu1_y_sub_pel_planes[1] +
ref_offset;
apu1_hpel_ref[0][3] =
ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->apu1_y_sub_pel_planes[2] +
ref_offset;
luma_weight_ref1 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]
->s_weight_offset.i2_luma_weight;
luma_offset_ref1 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]
->s_weight_offset.i2_luma_offset;
}
else
{
i1_ref_idx = ps_pu_node1->pu.mv.i1_l1_ref_idx;
aps_mv[0] = &(ps_pu_node1->pu.mv.s_l1_mv);
ASSERT(i1_ref_idx >= 0);
num_active_ref_opp =
ps_inter_ctb_prms->u1_num_active_ref_l0 * (ps_inter_ctb_prms->i4_bidir_enabled);
num_results_per_part = ps_pu_results->u1_num_results_per_part_l1[e_part_id];
ps_pu_result = ps_pu_results->aps_pu_results[PRED_L1][e_part_id];
apu1_hpel_ref[0][0] =
(UWORD8 *)(ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->s_yuv_buf_desc.pv_y_buf) +
ref_offset;
apu1_hpel_ref[0][1] =
ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->apu1_y_sub_pel_planes[0] +
ref_offset;
apu1_hpel_ref[0][2] =
ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->apu1_y_sub_pel_planes[1] +
ref_offset;
apu1_hpel_ref[0][3] =
ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->apu1_y_sub_pel_planes[2] +
ref_offset;
luma_weight_ref1 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]
->s_weight_offset.i2_luma_weight;
luma_offset_ref1 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]
->s_weight_offset.i2_luma_offset;
}
if(aps_mv[0]->i2_mvx == INTRA_MV)
{
uni_cost = ps_pu_node1->i4_tot_cost;
cur_iter_best_cost = ps_pu_node1->i4_tot_cost;
best_cost = MIN(uni_cost, cur_iter_best_cost);
tot_cost += best_cost;
continue;
}
ps_interp_prms->i4_blk_wd = wd = gau1_blk_size_to_wd[e_blk_size];
ps_interp_prms->i4_blk_ht = ht = gau1_blk_size_to_ht[e_blk_size];
ps_interp_prms->i4_out_stride = MAX_CU_SIZE;
if(num_active_ref_opp)
{
if(PRED_L0 == pred_dir)
{
if(ps_pu_results->u1_num_results_per_part_l1[e_part_id])
{
ps_pu_node2 = ps_pu_results->aps_pu_results[1][e_part_id];
pu_node2_found = 1;
}
}
else
{
if(ps_pu_results->u1_num_results_per_part_l0[e_part_id])
{
ps_pu_node2 = ps_pu_results->aps_pu_results[0][e_part_id];
pu_node2_found = 1;
}
}
}
if(!pu_node2_found)
{
bi_cost = INT_MAX >> 1;
s_interp_prms.apu1_interp_out[0] = as_pred_buf_data[0][j].pu1_pred;
ps_interp_prms->ppu1_ref = &apu1_hpel_ref[0][0];
ps_me_optimised_function_list->pf_qpel_interp_avg_generic(
ps_interp_prms, aps_mv[0]->i2_mvx, aps_mv[0]->i2_mvy, 0);
if(ps_interp_prms->pu1_final_out != s_interp_prms.apu1_interp_out[0])
{
as_pred_buf_data[0][j].u1_pred_buf_array_id = UCHAR_MAX;
as_pred_buf_data[0][j].pu1_pred = ps_interp_prms->pu1_final_out;
as_pred_buf_data[0][j].i4_pred_stride = ps_interp_prms->i4_final_out_stride;
}
if(u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)
{
hme_compute_sigmaX_and_sigmaXSquared(
as_pred_buf_data[0][j].pu1_pred,
as_pred_buf_data[0][j].i4_pred_stride,
&au8_sigmaX[0][j],
&au8_sigmaXSquared[0][j],
ps_interp_prms->i4_blk_wd,
ps_interp_prms->i4_blk_ht,
ps_interp_prms->i4_blk_wd,
ps_interp_prms->i4_blk_ht,
0,
1);
}
}
else
{
i = 0;
bi_cost = MAX_32BIT_VAL;
is_best_cand_an_intra = 0;
best_cand_in_opp_dir_idx = 0;
pred_dir = ps_pu_node2[i].pu.b2_pred_mode;
if(PRED_L0 == pred_dir)
{
i1_ref_idx = ps_pu_node2[i].pu.mv.i1_l0_ref_idx;
aps_mv[1] = &(ps_pu_node2[i].pu.mv.s_l0_mv);
ASSERT(i1_ref_idx >= 0);
apu1_hpel_ref[1][0] =
(UWORD8 *)(ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]
->s_yuv_buf_desc.pv_y_buf) +
ref_offset; //>ppu1_list_rec_fxfy[0][i1_ref_idx] + ref_offset;
apu1_hpel_ref[1][1] =
ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->apu1_y_sub_pel_planes[0] +
ref_offset;
apu1_hpel_ref[1][2] =
ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->apu1_y_sub_pel_planes[1] +
ref_offset;
apu1_hpel_ref[1][3] =
ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]->apu1_y_sub_pel_planes[2] +
ref_offset;
luma_weight_ref2 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]
->s_weight_offset.i2_luma_weight;
luma_offset_ref2 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l0[i1_ref_idx]
->s_weight_offset.i2_luma_offset;
}
else
{
i1_ref_idx = ps_pu_node2[i].pu.mv.i1_l1_ref_idx;
aps_mv[1] = &(ps_pu_node2[i].pu.mv.s_l1_mv);
ASSERT(i1_ref_idx >= 0);
apu1_hpel_ref[1][0] =
(UWORD8 *)(ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]
->s_yuv_buf_desc.pv_y_buf) +
ref_offset; //>ppu1_list_rec_fxfy[0][i1_ref_idx] + ref_offset;
apu1_hpel_ref[1][1] =
ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->apu1_y_sub_pel_planes[0] +
ref_offset;
apu1_hpel_ref[1][2] =
ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->apu1_y_sub_pel_planes[1] +
ref_offset;
apu1_hpel_ref[1][3] =
ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]->apu1_y_sub_pel_planes[2] +
ref_offset;
luma_weight_ref2 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]
->s_weight_offset.i2_luma_weight;
luma_offset_ref2 = (WORD32)ps_inter_ctb_prms->pps_rec_list_l1[i1_ref_idx]
->s_weight_offset.i2_luma_offset;
}
if(aps_mv[1]->i2_mvx == INTRA_MV)
{
uni_cost = ps_pu_node1->i4_tot_cost;
cur_iter_best_cost = ps_pu_node2[i].i4_tot_cost;
if(cur_iter_best_cost < bi_cost)
{
bi_cost = cur_iter_best_cost;
best_cand_in_opp_dir_idx = i;
is_best_cand_an_intra = 1;
}
best_cost = MIN(uni_cost, bi_cost);
tot_cost += best_cost;
continue;
}
s_interp_prms.apu1_interp_out[0] = as_pred_buf_data[0][j].pu1_pred;
ps_interp_prms->ppu1_ref = &apu1_hpel_ref[0][0];
ps_me_optimised_function_list->pf_qpel_interp_avg_generic(
ps_interp_prms, aps_mv[0]->i2_mvx, aps_mv[0]->i2_mvy, 0);
if(ps_interp_prms->pu1_final_out != s_interp_prms.apu1_interp_out[0])
{
as_pred_buf_data[0][j].u1_pred_buf_array_id = UCHAR_MAX;
as_pred_buf_data[0][j].pu1_pred = ps_interp_prms->pu1_final_out;
as_pred_buf_data[0][j].i4_pred_stride = ps_interp_prms->i4_final_out_stride;
}
if(u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)
{
hme_compute_sigmaX_and_sigmaXSquared(
as_pred_buf_data[0][j].pu1_pred,
as_pred_buf_data[0][j].i4_pred_stride,
&au8_sigmaX[0][j],
&au8_sigmaXSquared[0][j],
ps_interp_prms->i4_blk_wd,
ps_interp_prms->i4_blk_ht,
ps_interp_prms->i4_blk_wd,
ps_interp_prms->i4_blk_ht,
0,
1);
}
s_interp_prms.apu1_interp_out[0] = as_pred_buf_data[1][j].pu1_pred;
ps_interp_prms->ppu1_ref = &apu1_hpel_ref[1][0];
ps_me_optimised_function_list->pf_qpel_interp_avg_generic(
ps_interp_prms, aps_mv[1]->i2_mvx, aps_mv[1]->i2_mvy, 0);
if(ps_interp_prms->pu1_final_out != s_interp_prms.apu1_interp_out[0])
{
as_pred_buf_data[1][j].u1_pred_buf_array_id = UCHAR_MAX;
as_pred_buf_data[1][j].pu1_pred = ps_interp_prms->pu1_final_out;
as_pred_buf_data[1][j].i4_pred_stride = ps_interp_prms->i4_final_out_stride;
}
ps_cmn_utils_optimised_function_list->pf_wt_avg_2d(
as_pred_buf_data[0][j].pu1_pred,
as_pred_buf_data[1][j].pu1_pred,
as_pred_buf_data[0][j].i4_pred_stride,
as_pred_buf_data[1][j].i4_pred_stride,
wd,
ht,
as_pred_buf_data[2][j].pu1_pred,
as_pred_buf_data[2][j].i4_pred_stride,
luma_weight_ref1,
luma_weight_ref2,
luma_offset_ref1,
luma_offset_ref2,
ps_inter_ctb_prms->wpred_log_wdc);
if(u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)
{
hme_compute_sigmaX_and_sigmaXSquared(
as_pred_buf_data[2][j].pu1_pred,
as_pred_buf_data[2][j].i4_pred_stride,
&au8_sigmaX[1][j],
&au8_sigmaXSquared[1][j],
ps_interp_prms->i4_blk_wd,
ps_interp_prms->i4_blk_ht,
ps_interp_prms->i4_blk_wd,
ps_interp_prms->i4_blk_ht,
0,
1);
}
s_err_prms.pu1_inp = (U08 *)ps_inter_ctb_prms->pu1_non_wt_inp + inp_offset;
s_err_prms.i4_inp_stride = inp_stride;
s_err_prms.i4_ref_stride = as_pred_buf_data[2][j].i4_pred_stride;
s_err_prms.i4_part_mask = (ENABLE_2Nx2N);
s_err_prms.i4_grid_mask = 1;
s_err_prms.pi4_sad_grid = &i4_sad_grid;
s_err_prms.i4_blk_wd = wd;
s_err_prms.i4_blk_ht = ht;
s_err_prms.pu1_ref = as_pred_buf_data[2][j].pu1_pred;
s_err_prms.ps_cmn_utils_optimised_function_list = ps_cmn_utils_optimised_function_list;
if(ps_inter_ctb_prms->u1_use_satd)
{
pf_err_compute = compute_satd_8bit;
}
else
{
pf_err_compute = ps_me_optimised_function_list->pf_evalsad_pt_npu_mxn_8bit;
}
pf_err_compute(&s_err_prms);
#if USE_NOISE_TERM_DURING_BICAND_SEARCH
if(u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)
{
unsigned long u4_shift_val;
ULWORD64 u8_src_variance, u8_pred_variance, u8_pred_sigmaSquareX;
ULWORD64 u8_temp_var, u8_temp_var1;
S32 i4_bits_req;
S32 i4_q_level = STIM_Q_FORMAT + ALPHA_Q_FORMAT;
u8_pred_sigmaSquareX = (au8_sigmaX[1][j] * au8_sigmaX[1][j]);
u8_pred_variance = au8_sigmaXSquared[1][j] - u8_pred_sigmaSquareX;
if(e_cu_size == CU_8x8)
{
PART_ID_T e_part_id =
(PART_ID_T)((PART_ID_NxN_TL) + (x_off & 1) + ((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,
i4_default_src_wt,
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,
i4_default_src_wt,
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;
i4_noise_term *= ps_inter_ctb_prms->i4_alpha_stim_multiplier;
ASSERT(i4_noise_term >= 0);
u8_temp_var = i4_sad_grid;
u8_temp_var *= ((1 << (i4_q_level)) - (i4_noise_term));
u8_temp_var += (1 << ((i4_q_level)-1));
i4_sad_grid = (UWORD32)(u8_temp_var >> (i4_q_level));
}
#endif
cur_iter_best_cost = i4_sad_grid;
cur_iter_best_cost += ps_pu_node1->i4_mv_cost;
cur_iter_best_cost += ps_pu_node2[i].i4_mv_cost;
if(cur_iter_best_cost < bi_cost)
{
bi_cost = cur_iter_best_cost;
best_cand_in_opp_dir_idx = i;
is_best_cand_an_intra = 0;
}
}
uni_cost = ps_pu_node1->i4_tot_cost;
#if USE_NOISE_TERM_DURING_BICAND_SEARCH
if(u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)
{
unsigned long u4_shift_val;
ULWORD64 u8_src_variance, u8_pred_variance, u8_pred_sigmaSquareX;
ULWORD64 u8_temp_var, u8_temp_var1;
S32 i4_bits_req;
S32 i4_q_level = STIM_Q_FORMAT + ALPHA_Q_FORMAT;
S08 i1_ref_idx =
(PRED_L0 == ps_pu_node1->pu.b2_pred_mode)
? ps_inter_ctb_prms->pi1_past_list[ps_pu_node1->pu.mv.i1_l0_ref_idx]
: ps_inter_ctb_prms->pi1_future_list[ps_pu_node1->pu.mv.i1_l1_ref_idx];
S32 i4_sad = ps_pu_node1->i4_tot_cost - ps_pu_node1->i4_mv_cost;
u8_pred_sigmaSquareX = (au8_sigmaX[0][j] * au8_sigmaX[0][j]);
u8_pred_variance = au8_sigmaXSquared[0][j] - u8_pred_sigmaSquareX;
if(e_cu_size == CU_8x8)
{
PART_ID_T e_part_id =
(PART_ID_T)((PART_ID_NxN_TL) + (x_off & 1) + ((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,
ps_inter_ctb_prms->pi4_inv_wt[i1_ref_idx],
ps_inter_ctb_prms->pi4_inv_wt_shift_val[i1_ref_idx],
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,
ps_inter_ctb_prms->pi4_inv_wt[i1_ref_idx],
ps_inter_ctb_prms->pi4_inv_wt_shift_val[i1_ref_idx],
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;
i4_noise_term *= ps_inter_ctb_prms->i4_alpha_stim_multiplier;
ASSERT(i4_noise_term >= 0);
u8_temp_var = i4_sad;
u8_temp_var *= ((1 << (i4_q_level)) - (i4_noise_term));
u8_temp_var += (1 << ((i4_q_level)-1));
i4_sad = (UWORD32)(u8_temp_var >> (i4_q_level));
uni_cost = i4_sad + ps_pu_node1->i4_mv_cost;
pu8_winning_pred_sigmaX[j] = au8_sigmaX[0][j];
pu8_winning_pred_sigmaXSquare[j] = au8_sigmaXSquared[0][j];
}
#endif
if((bi_cost < uni_cost) && (!is_best_cand_an_intra))
{
if(u1_is_cu_noisy && ps_inter_ctb_prms->i4_alpha_stim_multiplier)
{
pu8_winning_pred_sigmaX[j] = au8_sigmaX[1][j];
pu8_winning_pred_sigmaXSquare[j] = au8_sigmaXSquared[1][j];
}
if(PRED_L0 == ps_pu_node1->pu.b2_pred_mode)
{
ps_pu_node1->pu.b2_pred_mode = PRED_BI;
if(PRED_L0 == ps_pu_node2[best_cand_in_opp_dir_idx].pu.b2_pred_mode)
{
ps_pu_node1->pu.mv.i1_l1_ref_idx =
ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.i1_l0_ref_idx;
ps_pu_node1->pu.mv.s_l1_mv.i2_mvx =
ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l0_mv.i2_mvx;
ps_pu_node1->pu.mv.s_l1_mv.i2_mvy =
ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l0_mv.i2_mvy;
}
else
{
ps_pu_node1->pu.mv.i1_l1_ref_idx =
ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.i1_l1_ref_idx;
ps_pu_node1->pu.mv.s_l1_mv.i2_mvx =
ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l1_mv.i2_mvx;
ps_pu_node1->pu.mv.s_l1_mv.i2_mvy =
ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l1_mv.i2_mvy;
}
}
else
{
ps_pu_node1->pu.b2_pred_mode = PRED_BI;
if(PRED_L0 == ps_pu_node2[best_cand_in_opp_dir_idx].pu.b2_pred_mode)
{
ps_pu_node1->pu.mv.i1_l0_ref_idx =
ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.i1_l0_ref_idx;
ps_pu_node1->pu.mv.s_l0_mv.i2_mvx =
ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l0_mv.i2_mvx;
ps_pu_node1->pu.mv.s_l0_mv.i2_mvy =
ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l0_mv.i2_mvy;
}
else
{
ps_pu_node1->pu.mv.i1_l0_ref_idx =
ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.i1_l1_ref_idx;
ps_pu_node1->pu.mv.s_l0_mv.i2_mvx =
ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l1_mv.i2_mvx;
ps_pu_node1->pu.mv.s_l0_mv.i2_mvy =
ps_pu_node2[best_cand_in_opp_dir_idx].pu.mv.s_l1_mv.i2_mvy;
}
}
ps_part_type_result->as_pu_results[j].i4_tot_cost = bi_cost;
}
best_cost = MIN(uni_cost, bi_cost);
tot_cost += best_cost;
}
hme_debrief_bipred_eval(
ps_part_type_result,
as_pred_buf_data,
&ps_inter_ctb_prms->s_pred_buf_mngr,
au1_pred_buf_array_indixes,
ps_cmn_utils_optimised_function_list);
ps_part_type_result->i4_tot_cost = tot_cost;
}
WORD32 hme_evalsatd_pt_pu_8x8_tu_rec(
err_prms_t *ps_prms,
WORD32 lambda,
WORD32 lambda_q_shift,
WORD32 i4_frm_qstep,
me_func_selector_t *ps_func_selector)
{
S32 ai4_satd_4x4[4]; /* num 4x4s in a 8x8 */
S32 i4_satd_8x8;
S16 *pi2_had_out;
S32 i4_tu_split_flag = 0;
S32 i4_tu_early_cbf = 0;
S32 i4_early_cbf = 1;
// S32 i4_i, i4_k;
S32 i4_total_satd_cost = 0;
S32 best_cost_tu_split;
/* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
S32 *api4_satd_pu[HAD_32x32 + 1];
S32 *api4_tu_split[HAD_32x32 + 1];
S32 *api4_tu_early_cbf[HAD_32x32 + 1];
S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;
S32 *pi4_tu_split = ps_prms->pi4_tu_split_flags;
S32 *pi4_early_cbf = ps_prms->pi4_tu_early_cbf;
U08 *pu1_inp = ps_prms->pu1_inp;
U08 *pu1_ref = ps_prms->pu1_ref;
S32 inp_stride = ps_prms->i4_inp_stride;
S32 ref_stride = ps_prms->i4_ref_stride;
/* Initialize tu_split_cost to "0" */
ps_prms->i4_tu_split_cost = 0;
pi2_had_out = (S16 *)ps_prms->pu1_wkg_mem;
api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
api4_satd_pu[HAD_8x8] = &i4_satd_8x8;
api4_satd_pu[HAD_16x16] = NULL;
api4_satd_pu[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */
api4_tu_split[HAD_4x4] = NULL;
api4_tu_split[HAD_8x8] = &i4_tu_split_flag;
api4_tu_split[HAD_16x16] = NULL;
api4_tu_split[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */
api4_tu_early_cbf[HAD_4x4] = NULL;
api4_tu_early_cbf[HAD_8x8] = &i4_tu_early_cbf;
api4_tu_early_cbf[HAD_16x16] = NULL;
api4_tu_early_cbf[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */
/* Call recursive 16x16 HAD module; updates satds for 4x4, 8x8 and 16x16 */
/* Return value is merge of both best_stad_cost and tu_split_flags */
best_cost_tu_split = ps_func_selector->pf_had_8x8_using_4_4x4_r(
pu1_inp,
inp_stride,
pu1_ref,
ref_stride,
pi2_had_out,
8,
api4_satd_pu,
api4_tu_split,
api4_tu_early_cbf,
0,
2,
0,
0,
i4_frm_qstep,
0,
ps_prms->u1_max_tr_depth,
ps_prms->u1_max_tr_size,
&(ps_prms->i4_tu_split_cost),
NULL);
/* For SATD computation following TU size are assumed for a 8x8 CU */
/* 8 for 2Nx2N, 4 for Nx2N,2NxN */
i4_total_satd_cost = best_cost_tu_split >> 2;
/* Second last bit has the tu pslit flag */
i4_tu_split_flag = (best_cost_tu_split & 0x3) >> 1;
/* Last bit corrsponds to the Early CBF flag */
i4_early_cbf = (best_cost_tu_split & 0x1);
/* Update 8x8 SATDs */
pi4_sad_grid[PART_ID_2Nx2N] = i4_satd_8x8;
pi4_tu_split[PART_ID_2Nx2N] = i4_tu_split_flag;
pi4_early_cbf[PART_ID_2Nx2N] = i4_early_cbf;
return i4_total_satd_cost;
}
//#endif
/**
********************************************************************************
* @fn S32 hme_evalsatd_update_1_best_result_pt_pu_16x16
*
* @brief Evaluates the SATD with partial updates for all the best partitions
* of a 16x16 CU based on recursive Hadamard 16x16, 8x8 and 4x4 satds
*
* @param[inout] ps_prms: error prms containg current and ref ptr, strides,
* pointer to sad grid of each partitions
*
* @return None
********************************************************************************
*/
void hme_evalsatd_update_2_best_results_pt_pu_16x16(
err_prms_t *ps_prms, result_upd_prms_t *ps_result_prms)
{
S32 ai4_satd_4x4[16]; /* num 4x4s in a 16x16 */
S32 ai4_satd_8x8[4]; /* num 8x8s in a 16x16 */
S32 i4_satd_16x16; /* 16x16 satd cost */
S32 i;
S16 ai2_8x8_had[256];
S16 *pi2_y0;
U08 *pu1_src, *pu1_pred;
S32 pos_x_y_4x4_0, pos_x_y_4x4 = 0;
S32 *ppi4_hsad;
/* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
S32 *api4_satd_pu[HAD_32x32 + 1];
S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;
U08 *pu1_inp = ps_prms->pu1_inp;
U08 *pu1_ref = ps_prms->pu1_ref;
S32 inp_stride = ps_prms->i4_inp_stride;
S32 ref_stride = ps_prms->i4_ref_stride;
api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[0];
api4_satd_pu[HAD_16x16] = &i4_satd_16x16;
api4_satd_pu[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */
ppi4_hsad = api4_satd_pu[HAD_16x16];
/* Call recursive 16x16 HAD module; updates satds for 4x4, 8x8 and 16x16 */
for(i = 0; i < 4; i++)
{
pu1_src = pu1_inp + (i & 0x01) * 8 + (i >> 1) * inp_stride * 8;
pu1_pred = pu1_ref + (i & 0x01) * 8 + (i >> 1) * ref_stride * 8;
pi2_y0 = ai2_8x8_had + (i & 0x01) * 8 + (i >> 1) * 16 * 8;
pos_x_y_4x4_0 = pos_x_y_4x4 + (i & 0x01) * 2 + (i >> 1) * (2 << 16);
ihevce_had_8x8_using_4_4x4(
pu1_src, inp_stride, pu1_pred, ref_stride, pi2_y0, 16, api4_satd_pu, pos_x_y_4x4_0, 4);
}
/* For SATD computation following TU size are assumed for a 16x16 CU */
/* 16 for 2Nx2N, 8 for NxN/Nx2N,2NxN and mix of 4 and 8 for AMPs */
/* Update 8x8 SATDs */
/* Modified to cost calculation using only 4x4 SATD */
// ai4_satd_8x8[0] = ai4_satd_4x4[0] + ai4_satd_4x4[1] + ai4_satd_4x4[4] + ai4_satd_4x4[5];
// ai4_satd_8x8[1] = ai4_satd_4x4[2] + ai4_satd_4x4[3] + ai4_satd_4x4[6] + ai4_satd_4x4[7];
// ai4_satd_8x8[2] = ai4_satd_4x4[8] + ai4_satd_4x4[9] + ai4_satd_4x4[12] + ai4_satd_4x4[13];
// ai4_satd_8x8[3] = ai4_satd_4x4[10] + ai4_satd_4x4[11] + ai4_satd_4x4[14] + ai4_satd_4x4[15];
/* Update 16x16 SATDs */
pi4_sad_grid[PART_ID_2Nx2N] =
ai4_satd_8x8[0] + ai4_satd_8x8[1] + ai4_satd_8x8[2] + ai4_satd_8x8[3];
pi4_sad_grid[PART_ID_NxN_TL] = ai4_satd_8x8[0];
pi4_sad_grid[PART_ID_NxN_TR] = ai4_satd_8x8[1];
pi4_sad_grid[PART_ID_NxN_BL] = ai4_satd_8x8[2];
pi4_sad_grid[PART_ID_NxN_BR] = ai4_satd_8x8[3];
/* Update 8x16 / 16x8 SATDs */
pi4_sad_grid[PART_ID_Nx2N_L] = ai4_satd_8x8[0] + ai4_satd_8x8[2];
pi4_sad_grid[PART_ID_Nx2N_R] = ai4_satd_8x8[1] + ai4_satd_8x8[3];
pi4_sad_grid[PART_ID_2NxN_T] = ai4_satd_8x8[0] + ai4_satd_8x8[1];
pi4_sad_grid[PART_ID_2NxN_B] = ai4_satd_8x8[2] + ai4_satd_8x8[3];
/* Update AMP SATDs 16x12,16x4, 12x16,4x16 */
pi4_sad_grid[PART_ID_nLx2N_L] =
ai4_satd_4x4[0] + ai4_satd_4x4[4] + ai4_satd_4x4[8] + ai4_satd_4x4[12];
pi4_sad_grid[PART_ID_nLx2N_R] = ai4_satd_4x4[1] + ai4_satd_4x4[5] + ai4_satd_4x4[9] +
ai4_satd_4x4[13] + pi4_sad_grid[PART_ID_Nx2N_R];
pi4_sad_grid[PART_ID_nRx2N_L] = ai4_satd_4x4[2] + ai4_satd_4x4[6] + ai4_satd_4x4[10] +
ai4_satd_4x4[14] + pi4_sad_grid[PART_ID_Nx2N_L];
pi4_sad_grid[PART_ID_nRx2N_R] =
ai4_satd_4x4[3] + ai4_satd_4x4[7] + ai4_satd_4x4[11] + ai4_satd_4x4[15];
pi4_sad_grid[PART_ID_2NxnU_T] =
ai4_satd_4x4[0] + ai4_satd_4x4[1] + ai4_satd_4x4[2] + ai4_satd_4x4[3];
pi4_sad_grid[PART_ID_2NxnU_B] = ai4_satd_4x4[4] + ai4_satd_4x4[5] + ai4_satd_4x4[6] +
ai4_satd_4x4[7] + pi4_sad_grid[PART_ID_2NxN_B];
pi4_sad_grid[PART_ID_2NxnD_T] = ai4_satd_4x4[8] + ai4_satd_4x4[9] + ai4_satd_4x4[10] +
ai4_satd_4x4[11] + pi4_sad_grid[PART_ID_2NxN_T];
pi4_sad_grid[PART_ID_2NxnD_B] =
ai4_satd_4x4[12] + ai4_satd_4x4[13] + ai4_satd_4x4[14] + ai4_satd_4x4[15];
/* Call the update results function */
{
S32 i4_count = 0, i4_sad, i4_mv_cost, i4_tot_cost;
mv_refine_ctxt_t *ps_subpel_refine_ctxt = ps_result_prms->ps_subpel_refine_ctxt;
S32 *pi4_valid_part_ids = &ps_subpel_refine_ctxt->ai4_part_id[0];
S32 best_node_cost;
S32 second_best_node_cost;
/*For each valid partition, update the refine_prm structure to reflect the best and second
best candidates for that partition*/
for(i4_count = 0; i4_count < ps_subpel_refine_ctxt->i4_num_valid_parts; i4_count++)
{
S32 update_required = 0;
S32 part_id = pi4_valid_part_ids[i4_count];
S32 index = (ps_subpel_refine_ctxt->i4_num_valid_parts > 8) ? part_id : i4_count;
/* Use a pre-computed cost instead of freshly evaluating subpel cost */
i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];
/*Calculate total cost*/
i4_sad = CLIP3(pi4_sad_grid[part_id], 0, 0x7fff);
i4_tot_cost = CLIP_S16(i4_sad + i4_mv_cost);
/*****************************************************************/
/* We do not labor through the results if the total cost worse */
/* than the last of the results. */
/*****************************************************************/
best_node_cost = CLIP_S16(ps_subpel_refine_ctxt->i2_tot_cost[0][index]);
second_best_node_cost = CLIP_S16(ps_subpel_refine_ctxt->i2_tot_cost[1][index]);
if(i4_tot_cost < second_best_node_cost)
{
update_required = 2;
/*************************************************************/
/* Identify where the current result isto be placed.Basically*/
/* find the node which has cost just higher thannodeundertest*/
/*************************************************************/
if(i4_tot_cost < best_node_cost)
{
update_required = 1;
}
else if(i4_tot_cost == ps_subpel_refine_ctxt->i2_tot_cost[0][index])
{
update_required = 0;
}
if(update_required == 2)
{
ps_subpel_refine_ctxt->i2_tot_cost[1][index] = i4_tot_cost;
ps_subpel_refine_ctxt->i2_mv_cost[1][index] = i4_mv_cost;
ps_subpel_refine_ctxt->i2_mv_x[1][index] = ps_result_prms->i2_mv_x;
ps_subpel_refine_ctxt->i2_mv_y[1][index] = ps_result_prms->i2_mv_y;
ps_subpel_refine_ctxt->i2_ref_idx[1][index] = ps_result_prms->i1_ref_idx;
}
else if(update_required == 1)
{
ps_subpel_refine_ctxt->i2_tot_cost[1][index] =
ps_subpel_refine_ctxt->i2_tot_cost[0][index];
ps_subpel_refine_ctxt->i2_mv_cost[1][index] =
ps_subpel_refine_ctxt->i2_mv_cost[0][index];
ps_subpel_refine_ctxt->i2_mv_x[1][index] =
ps_subpel_refine_ctxt->i2_mv_x[0][index];
ps_subpel_refine_ctxt->i2_mv_y[1][index] =
ps_subpel_refine_ctxt->i2_mv_y[0][index];
ps_subpel_refine_ctxt->i2_ref_idx[1][index] =
ps_subpel_refine_ctxt->i2_ref_idx[0][index];
ps_subpel_refine_ctxt->i2_tot_cost[0][index] = i4_tot_cost;
ps_subpel_refine_ctxt->i2_mv_cost[0][index] = i4_mv_cost;
ps_subpel_refine_ctxt->i2_mv_x[0][index] = ps_result_prms->i2_mv_x;
ps_subpel_refine_ctxt->i2_mv_y[0][index] = ps_result_prms->i2_mv_y;
ps_subpel_refine_ctxt->i2_ref_idx[0][index] = ps_result_prms->i1_ref_idx;
}
}
}
}
}
//#if COMPUTE_16x16_R == C
void hme_evalsatd_update_1_best_result_pt_pu_16x16(
err_prms_t *ps_prms, result_upd_prms_t *ps_result_prms)
{
S32 ai4_satd_4x4[16]; /* num 4x4s in a 16x16 */
S32 ai4_satd_8x8[4]; /* num 8x8s in a 16x16 */
S32 i4_satd_16x16; /* 16x16 satd cost */
S32 i;
S16 ai2_8x8_had[256];
S16 *pi2_y0;
U08 *pu1_src, *pu1_pred;
S32 pos_x_y_4x4_0, pos_x_y_4x4 = 0;
S32 *ppi4_hsad;
/* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
S32 *api4_satd_pu[HAD_32x32 + 1];
S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;
U08 *pu1_inp = ps_prms->pu1_inp;
U08 *pu1_ref = ps_prms->pu1_ref;
S32 inp_stride = ps_prms->i4_inp_stride;
S32 ref_stride = ps_prms->i4_ref_stride;
api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[0];
api4_satd_pu[HAD_16x16] = &i4_satd_16x16;
api4_satd_pu[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */
ppi4_hsad = api4_satd_pu[HAD_16x16];
/* Call recursive 16x16 HAD module; updates satds for 4x4, 8x8 and 16x16 */
for(i = 0; i < 4; i++)
{
pu1_src = pu1_inp + (i & 0x01) * 8 + (i >> 1) * inp_stride * 8;
pu1_pred = pu1_ref + (i & 0x01) * 8 + (i >> 1) * ref_stride * 8;
pi2_y0 = ai2_8x8_had + (i & 0x01) * 8 + (i >> 1) * 16 * 8;
pos_x_y_4x4_0 = pos_x_y_4x4 + (i & 0x01) * 2 + (i >> 1) * (2 << 16);
ihevce_had_8x8_using_4_4x4(
pu1_src, inp_stride, pu1_pred, ref_stride, pi2_y0, 16, api4_satd_pu, pos_x_y_4x4_0, 4);
}
/* For SATD computation following TU size are assumed for a 16x16 CU */
/* 16 for 2Nx2N, 8 for NxN/Nx2N,2NxN and mix of 4 and 8 for AMPs */
/* Update 8x8 SATDs */
/* Modified to cost calculation using only 4x4 SATD */
// ai4_satd_8x8[0] = ai4_satd_4x4[0] + ai4_satd_4x4[1] + ai4_satd_4x4[4] + ai4_satd_4x4[5];
// ai4_satd_8x8[1] = ai4_satd_4x4[2] + ai4_satd_4x4[3] + ai4_satd_4x4[6] + ai4_satd_4x4[7];
// ai4_satd_8x8[2] = ai4_satd_4x4[8] + ai4_satd_4x4[9] + ai4_satd_4x4[12] + ai4_satd_4x4[13];
// ai4_satd_8x8[3] = ai4_satd_4x4[10] + ai4_satd_4x4[11] + ai4_satd_4x4[14] + ai4_satd_4x4[15];
/* Update 16x16 SATDs */
pi4_sad_grid[PART_ID_2Nx2N] =
ai4_satd_8x8[0] + ai4_satd_8x8[1] + ai4_satd_8x8[2] + ai4_satd_8x8[3];
pi4_sad_grid[PART_ID_NxN_TL] = ai4_satd_8x8[0];
pi4_sad_grid[PART_ID_NxN_TR] = ai4_satd_8x8[1];
pi4_sad_grid[PART_ID_NxN_BL] = ai4_satd_8x8[2];
pi4_sad_grid[PART_ID_NxN_BR] = ai4_satd_8x8[3];
/* Update 8x16 / 16x8 SATDs */
pi4_sad_grid[PART_ID_Nx2N_L] = ai4_satd_8x8[0] + ai4_satd_8x8[2];
pi4_sad_grid[PART_ID_Nx2N_R] = ai4_satd_8x8[1] + ai4_satd_8x8[3];
pi4_sad_grid[PART_ID_2NxN_T] = ai4_satd_8x8[0] + ai4_satd_8x8[1];
pi4_sad_grid[PART_ID_2NxN_B] = ai4_satd_8x8[2] + ai4_satd_8x8[3];
/* Update AMP SATDs 16x12,16x4, 12x16,4x16 */
pi4_sad_grid[PART_ID_nLx2N_L] =
ai4_satd_4x4[0] + ai4_satd_4x4[2] + ai4_satd_4x4[8] + ai4_satd_4x4[10];
pi4_sad_grid[PART_ID_nRx2N_R] =
ai4_satd_4x4[5] + ai4_satd_4x4[7] + ai4_satd_4x4[13] + ai4_satd_4x4[15];
pi4_sad_grid[PART_ID_2NxnU_T] =
ai4_satd_4x4[0] + ai4_satd_4x4[1] + ai4_satd_4x4[4] + ai4_satd_4x4[5];
pi4_sad_grid[PART_ID_2NxnD_B] =
ai4_satd_4x4[10] + ai4_satd_4x4[11] + ai4_satd_4x4[14] + ai4_satd_4x4[15];
pi4_sad_grid[PART_ID_nLx2N_R] = pi4_sad_grid[PART_ID_2Nx2N] - pi4_sad_grid[PART_ID_nLx2N_L];
pi4_sad_grid[PART_ID_nRx2N_L] = pi4_sad_grid[PART_ID_2Nx2N] - pi4_sad_grid[PART_ID_nRx2N_R];
pi4_sad_grid[PART_ID_2NxnU_B] = pi4_sad_grid[PART_ID_2Nx2N] - pi4_sad_grid[PART_ID_2NxnU_T];
pi4_sad_grid[PART_ID_2NxnD_T] = pi4_sad_grid[PART_ID_2Nx2N] - pi4_sad_grid[PART_ID_2NxnD_B];
/* Call the update results function */
{
S32 i4_count = 0, i4_sad, i4_mv_cost, i4_tot_cost;
mv_refine_ctxt_t *ps_subpel_refine_ctxt = ps_result_prms->ps_subpel_refine_ctxt;
S32 *pi4_valid_part_ids = &ps_subpel_refine_ctxt->ai4_part_id[0];
S32 best_node_cost;
S32 second_best_node_cost;
/*For each valid partition, update the refine_prm structure to reflect the best and second
best candidates for that partition*/
for(i4_count = 0; i4_count < ps_subpel_refine_ctxt->i4_num_valid_parts; i4_count++)
{
S32 update_required = 0;
S32 part_id = pi4_valid_part_ids[i4_count];
S32 index = (ps_subpel_refine_ctxt->i4_num_valid_parts > 8) ? part_id : i4_count;
/* Use a pre-computed cost instead of freshly evaluating subpel cost */
i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];
/*Calculate total cost*/
i4_sad = CLIP3(pi4_sad_grid[part_id], 0, 0x7fff);
i4_tot_cost = CLIP_S16(i4_sad + i4_mv_cost);
/*****************************************************************/
/* We do not labor through the results if the total cost worse */
/* than the last of the results. */
/*****************************************************************/
best_node_cost = CLIP_S16(ps_subpel_refine_ctxt->i2_tot_cost[0][index]);
second_best_node_cost = SHRT_MAX;
if(i4_tot_cost < second_best_node_cost)
{
update_required = 0;
/*************************************************************/
/* Identify where the current result isto be placed.Basically*/
/* find the node which has cost just higher thannodeundertest*/
/*************************************************************/
if(i4_tot_cost < best_node_cost)
{
update_required = 1;
}
else if(i4_tot_cost == ps_subpel_refine_ctxt->i2_tot_cost[0][index])
{
update_required = 0;
}
if(update_required == 2)
{
ps_subpel_refine_ctxt->i2_tot_cost[1][index] = i4_tot_cost;
ps_subpel_refine_ctxt->i2_mv_cost[1][index] = i4_mv_cost;
ps_subpel_refine_ctxt->i2_mv_x[1][index] = ps_result_prms->i2_mv_x;
ps_subpel_refine_ctxt->i2_mv_y[1][index] = ps_result_prms->i2_mv_y;
ps_subpel_refine_ctxt->i2_ref_idx[1][index] = ps_result_prms->i1_ref_idx;
}
else if(update_required == 1)
{
ps_subpel_refine_ctxt->i2_tot_cost[0][index] = i4_tot_cost;
ps_subpel_refine_ctxt->i2_mv_cost[0][index] = i4_mv_cost;
ps_subpel_refine_ctxt->i2_mv_x[0][index] = ps_result_prms->i2_mv_x;
ps_subpel_refine_ctxt->i2_mv_y[0][index] = ps_result_prms->i2_mv_y;
ps_subpel_refine_ctxt->i2_ref_idx[0][index] = ps_result_prms->i1_ref_idx;
}
}
}
}
}
WORD32 hme_evalsatd_pt_pu_16x16_tu_rec(
err_prms_t *ps_prms,
WORD32 lambda,
WORD32 lambda_q_shift,
WORD32 i4_frm_qstep,
me_func_selector_t *ps_func_selector)
{
S32 ai4_satd_4x4[16]; /* num 4x4s in a 16x16 */
S32 ai4_satd_8x8[4]; /* num 8x8s in a 16x16 */
S32 ai4_tu_split_8x8[16];
S32 i4_satd_16x16; /* 16x16 satd cost */
S32 ai4_tu_early_cbf_8x8[16];
//S16 ai2_had_out[256];
S16 *pi2_had_out;
S32 tu_split_flag = 0;
S32 early_cbf_flag = 0;
S32 total_satd_cost = 0;
/* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
S32 *api4_satd_pu[HAD_32x32 + 1];
S32 *api4_tu_split[HAD_32x32 + 1];
S32 *api4_tu_early_cbf[HAD_32x32 + 1];
U08 *pu1_inp = ps_prms->pu1_inp;
U08 *pu1_ref = ps_prms->pu1_ref;
S32 inp_stride = ps_prms->i4_inp_stride;
S32 ref_stride = ps_prms->i4_ref_stride;
/* Initialize tu_split_cost to "0" */
ps_prms->i4_tu_split_cost = 0;
pi2_had_out = (S16 *)ps_prms->pu1_wkg_mem;
api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[0];
api4_satd_pu[HAD_16x16] = &i4_satd_16x16;
api4_satd_pu[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */
api4_tu_split[HAD_4x4] = NULL;
api4_tu_split[HAD_8x8] = &ai4_tu_split_8x8[0];
api4_tu_split[HAD_16x16] = &tu_split_flag;
api4_tu_split[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */
api4_tu_early_cbf[HAD_4x4] = NULL;
api4_tu_early_cbf[HAD_8x8] = &ai4_tu_early_cbf_8x8[0];
api4_tu_early_cbf[HAD_16x16] = &early_cbf_flag;
api4_tu_early_cbf[HAD_32x32] = NULL; /* 32x32 not used for 16x16 subpel refine */
/* Call recursive 16x16 HAD module; updates satds for 4x4, 8x8 and 16x16 */
ps_func_selector->pf_had_16x16_r(
pu1_inp,
inp_stride,
pu1_ref,
ref_stride,
pi2_had_out,
16,
api4_satd_pu,
api4_tu_split,
api4_tu_early_cbf,
0,
4,
lambda,
lambda_q_shift,
i4_frm_qstep,
0,
ps_prms->u1_max_tr_depth,
ps_prms->u1_max_tr_size,
&(ps_prms->i4_tu_split_cost),
NULL);
total_satd_cost = i4_satd_16x16;
ps_prms->pi4_tu_split_flags[0] = tu_split_flag;
ps_prms->pi4_tu_early_cbf[0] = early_cbf_flag;
return total_satd_cost;
}
/**
********************************************************************************
* @fn S32 hme_evalsatd_pt_pu_32x32
*
* @brief Evaluates the SATD with partial updates for all the best partitions
* of a 32x32 CU based on recursive Hadamard 16x16, 8x8 and 4x4 satds
*
* @param[inout] ps_prms: error prms containg current and ref ptr, strides,
* pointer to sad grid of each partitions
*
* @return None
********************************************************************************
*/
void hme_evalsatd_pt_pu_32x32(err_prms_t *ps_prms)
{
//S32 ai4_satd_4x4[64]; /* num 4x4s in a 32x32 */
S32 ai4_satd_8x8[16]; /* num 8x8s in a 32x32 */
S32 ai4_satd_16x16[4]; /* num 16x16 in a 32x32 */
S32 i4_satd_32x32;
// S16 ai2_had_out[32*32];
U08 *pu1_src;
U08 *pu1_pred;
S32 i;
/* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
S32 *api4_satd_pu[HAD_32x32 + 1];
S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;
U08 *pu1_inp = ps_prms->pu1_inp;
U08 *pu1_ref = ps_prms->pu1_ref;
S32 inp_stride = ps_prms->i4_inp_stride;
S32 ref_stride = ps_prms->i4_ref_stride;
//api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[0];
api4_satd_pu[HAD_16x16] = &ai4_satd_16x16[0];
api4_satd_pu[HAD_32x32] = &i4_satd_32x32;
/* 32x32 SATD is calculates as the sum of the 4 8x8's in the block */
for(i = 0; i < 16; i++)
{
pu1_src = pu1_inp + ((i & 0x3) << 3) + ((i >> 2) * inp_stride * 8);
pu1_pred = pu1_ref + ((i & 0x3) << 3) + ((i >> 2) * ref_stride * 8);
ai4_satd_8x8[i] = ps_prms->ps_cmn_utils_optimised_function_list->pf_HAD_8x8_8bit(
pu1_src, inp_stride, pu1_pred, ref_stride, NULL, 1);
}
/* Modified to cost calculation using only 8x8 SATD for 32x32*/
ai4_satd_16x16[0] = ai4_satd_8x8[0] + ai4_satd_8x8[1] + ai4_satd_8x8[4] + ai4_satd_8x8[5];
ai4_satd_16x16[1] = ai4_satd_8x8[2] + ai4_satd_8x8[3] + ai4_satd_8x8[6] + ai4_satd_8x8[7];
ai4_satd_16x16[2] = ai4_satd_8x8[8] + ai4_satd_8x8[9] + ai4_satd_8x8[12] + ai4_satd_8x8[13];
ai4_satd_16x16[3] = ai4_satd_8x8[10] + ai4_satd_8x8[11] + ai4_satd_8x8[14] + ai4_satd_8x8[15];
/* Update 32x32 SATD */
pi4_sad_grid[PART_ID_2Nx2N] =
ai4_satd_16x16[0] + ai4_satd_16x16[1] + ai4_satd_16x16[2] + ai4_satd_16x16[3];
/* Update 16x16 SATDs */
pi4_sad_grid[PART_ID_NxN_TL] = ai4_satd_16x16[0];
pi4_sad_grid[PART_ID_NxN_TR] = ai4_satd_16x16[1];
pi4_sad_grid[PART_ID_NxN_BL] = ai4_satd_16x16[2];
pi4_sad_grid[PART_ID_NxN_BR] = ai4_satd_16x16[3];
/* Update 16x32 / 32x16 SATDs */
pi4_sad_grid[PART_ID_Nx2N_L] = ai4_satd_16x16[0] + ai4_satd_16x16[2];
pi4_sad_grid[PART_ID_Nx2N_R] = ai4_satd_16x16[1] + ai4_satd_16x16[3];
pi4_sad_grid[PART_ID_2NxN_T] = ai4_satd_16x16[0] + ai4_satd_16x16[1];
pi4_sad_grid[PART_ID_2NxN_B] = ai4_satd_16x16[2] + ai4_satd_16x16[3];
/* Update AMP SATDs 32x24,32x8, 24x32,8x32 */
pi4_sad_grid[PART_ID_nLx2N_L] =
ai4_satd_8x8[0] + ai4_satd_8x8[4] + ai4_satd_8x8[8] + ai4_satd_8x8[12];
pi4_sad_grid[PART_ID_nLx2N_R] = ai4_satd_8x8[1] + ai4_satd_8x8[5] + ai4_satd_8x8[9] +
ai4_satd_8x8[13] + pi4_sad_grid[PART_ID_Nx2N_R];
pi4_sad_grid[PART_ID_nRx2N_L] = ai4_satd_8x8[2] + ai4_satd_8x8[6] + ai4_satd_8x8[10] +
ai4_satd_8x8[14] + pi4_sad_grid[PART_ID_Nx2N_L];
pi4_sad_grid[PART_ID_nRx2N_R] =
ai4_satd_8x8[3] + ai4_satd_8x8[7] + ai4_satd_8x8[11] + ai4_satd_8x8[15];
pi4_sad_grid[PART_ID_2NxnU_T] =
ai4_satd_8x8[0] + ai4_satd_8x8[1] + ai4_satd_8x8[2] + ai4_satd_8x8[3];
pi4_sad_grid[PART_ID_2NxnU_B] = ai4_satd_8x8[4] + ai4_satd_8x8[5] + ai4_satd_8x8[6] +
ai4_satd_8x8[7] + pi4_sad_grid[PART_ID_2NxN_B];
pi4_sad_grid[PART_ID_2NxnD_T] = ai4_satd_8x8[8] + ai4_satd_8x8[9] + ai4_satd_8x8[10] +
ai4_satd_8x8[11] + pi4_sad_grid[PART_ID_2NxN_T];
pi4_sad_grid[PART_ID_2NxnD_B] =
ai4_satd_8x8[12] + ai4_satd_8x8[13] + ai4_satd_8x8[14] + ai4_satd_8x8[15];
}
WORD32 hme_evalsatd_pt_pu_32x32_tu_rec(
err_prms_t *ps_prms,
WORD32 lambda,
WORD32 lambda_q_shift,
WORD32 i4_frm_qstep,
me_func_selector_t *ps_func_selector)
{
S32 ai4_satd_4x4[64]; /* num 4x4s in a 32x32 */
S32 ai4_satd_8x8[16]; /* num 8x8s in a 32x32 */
S32 ai4_tu_split_8x8[16];
S32 ai4_satd_16x16[4]; /* num 16x16 in a 32x32 */
S32 ai4_tu_split_16x16[4];
S32 i4_satd_32x32;
S32 ai4_tu_early_cbf_8x8[16];
S32 ai4_tu_early_cbf_16x16[4];
S32 early_cbf_flag;
S16 *pi2_had_out;
/* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
S32 *api4_satd_pu[HAD_32x32 + 1];
S32 *api4_tu_split[HAD_32x32 + 1];
S32 *api4_tu_early_cbf[HAD_32x32 + 1];
S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;
S32 *pi4_tu_split_flag = ps_prms->pi4_tu_split_flags;
S32 *pi4_tu_early_cbf = ps_prms->pi4_tu_early_cbf;
S32 tu_split_flag = 0;
S32 total_satd_cost = 0;
U08 *pu1_inp = ps_prms->pu1_inp;
U08 *pu1_ref = ps_prms->pu1_ref;
S32 inp_stride = ps_prms->i4_inp_stride;
S32 ref_stride = ps_prms->i4_ref_stride;
/* Initialize tu_split_cost to "0" */
ps_prms->i4_tu_split_cost = 0;
pi2_had_out = (S16 *)ps_prms->pu1_wkg_mem;
api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[0];
api4_satd_pu[HAD_16x16] = &ai4_satd_16x16[0];
api4_satd_pu[HAD_32x32] = &i4_satd_32x32;
api4_tu_split[HAD_4x4] = NULL;
api4_tu_split[HAD_8x8] = &ai4_tu_split_8x8[0];
api4_tu_split[HAD_16x16] = &ai4_tu_split_16x16[0];
api4_tu_split[HAD_32x32] = &tu_split_flag;
api4_tu_early_cbf[HAD_4x4] = NULL;
api4_tu_early_cbf[HAD_8x8] = &ai4_tu_early_cbf_8x8[0];
api4_tu_early_cbf[HAD_16x16] = &ai4_tu_early_cbf_16x16[0];
api4_tu_early_cbf[HAD_32x32] = &early_cbf_flag;
/* Call recursive 32x32 HAD module; updates satds for 4x4, 8x8, 16x16 and 32x32 */
ihevce_had_32x32_r(
pu1_inp,
inp_stride,
pu1_ref,
ref_stride,
pi2_had_out,
32,
api4_satd_pu,
api4_tu_split,
api4_tu_early_cbf,
0,
8,
lambda,
lambda_q_shift,
i4_frm_qstep,
0,
ps_prms->u1_max_tr_depth,
ps_prms->u1_max_tr_size,
&(ps_prms->i4_tu_split_cost),
ps_func_selector);
total_satd_cost = i4_satd_32x32;
/*The structure of the TU_SPLIT flag for the current 32x32 is as follows
TL_16x16 - 5bits (4 for child and LSBit for 16x16 split)
TR_16x16 - 5bits (4 for child and LSBit for 16x16 split)
BL_16x16 - 5bits (4 for child and LSBit for 16x16 split)
BR_16x16 - 5bits (4 for child and LSBit for 16x16 split)
32x32_split - 1bit (LSBit)
TU_SPLIT : (TL_16x16)_(TR_16x16)_(BL_16x16)_(BR_16x16)_32x32_split (21bits)*/
pi4_sad_grid[PART_ID_2Nx2N] = total_satd_cost;
pi4_tu_split_flag[PART_ID_2Nx2N] = tu_split_flag;
pi4_tu_early_cbf[PART_ID_2Nx2N] = early_cbf_flag;
return total_satd_cost;
}
/**
********************************************************************************
* @fn S32 hme_evalsatd_pt_pu_64x64
*
* @brief Evaluates the SATD with partial updates for all the best partitions
* of a 64x64 CU based on accumulated Hadamard 32x32 and 16x16 satds
*
* Note : 64x64 SATD does not do hadamard Transform using 32x32 hadamard
* outputs but directly uses four 32x32 SATD and 16 16x16 SATDS as
* TU size of 64 is not supported in HEVC
*
* @param[inout] ps_prms: error prms containg current and ref ptr, strides,
* pointer to sad grid of each partitions
*
* @return None
********************************************************************************
*/
void hme_evalsatd_pt_pu_64x64(err_prms_t *ps_prms)
{
//S32 ai4_satd_4x4[4][64]; /* num 4x4s in a 32x32 * num 32x32 in 64x64 */
S32 ai4_satd_8x8[4][16]; /* num 8x8s in a 32x32 * num 32x32 in 64x64 */
S32 ai4_satd_16x16[4][4]; /* num 16x16 in a 32x32* num 32x32 in 64x64 */
S32 ai4_satd_32x32[4]; /* num 32x32 in 64x64 */
// S16 ai2_had_out[32*32];
S32 i, j;
// S32 ai4_tu_split_8x8[4][16];
// S32 ai4_tu_split_16x16[4][4];
// S32 ai4_tu_split_32x32[4];
/* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
S32 *api4_satd_pu[HAD_32x32 + 1];
// S32 *api4_tu_split[HAD_32x32 + 1];
S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;
U08 *pu1_inp = ps_prms->pu1_inp;
U08 *pu1_ref = ps_prms->pu1_ref;
U08 *pu1_src;
U08 *pu1_pred;
S32 inp_stride = ps_prms->i4_inp_stride;
S32 ref_stride = ps_prms->i4_ref_stride;
for(i = 0; i < 4; i++)
{
S32 blkx = (i & 0x1);
S32 blky = (i >> 1);
U08 *pu1_pi0, *pu1_pi1;
//api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[i][0];
api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[i][0];
api4_satd_pu[HAD_16x16] = &ai4_satd_16x16[i][0];
api4_satd_pu[HAD_32x32] = &ai4_satd_32x32[i];
pu1_pi0 = pu1_inp + (blkx * 32) + (blky * 32 * inp_stride);
pu1_pi1 = pu1_ref + (blkx * 32) + (blky * 32 * ref_stride);
/* 64x64 SATD is calculates as the sum of the 4 16x16's in the block */
for(j = 0; j < 16; j++)
{
pu1_src = pu1_pi0 + ((j & 0x3) << 3) + ((j >> 2) * inp_stride * 8);
pu1_pred = pu1_pi1 + ((j & 0x3) << 3) + ((j >> 2) * ref_stride * 8);
ai4_satd_8x8[i][j] = ps_prms->ps_cmn_utils_optimised_function_list->pf_HAD_8x8_8bit(
pu1_src, inp_stride, pu1_pred, ref_stride, NULL, 1);
}
/* Modified to cost calculation using only 8x8 SATD for 32x32*/
ai4_satd_16x16[i][0] =
ai4_satd_8x8[i][0] + ai4_satd_8x8[i][1] + ai4_satd_8x8[i][4] + ai4_satd_8x8[i][5];
ai4_satd_16x16[i][1] =
ai4_satd_8x8[i][2] + ai4_satd_8x8[i][3] + ai4_satd_8x8[i][6] + ai4_satd_8x8[i][7];
ai4_satd_16x16[i][2] =
ai4_satd_8x8[i][8] + ai4_satd_8x8[i][9] + ai4_satd_8x8[i][12] + ai4_satd_8x8[i][13];
ai4_satd_16x16[i][3] =
ai4_satd_8x8[i][10] + ai4_satd_8x8[i][11] + ai4_satd_8x8[i][14] + ai4_satd_8x8[i][15];
}
/* Modified to cost calculation using only 8x8 SATD for 32x32*/
ai4_satd_32x32[0] =
ai4_satd_16x16[0][0] + ai4_satd_16x16[0][1] + ai4_satd_16x16[0][2] + ai4_satd_16x16[0][3];
ai4_satd_32x32[1] =
ai4_satd_16x16[1][0] + ai4_satd_16x16[1][1] + ai4_satd_16x16[1][2] + ai4_satd_16x16[1][3];
ai4_satd_32x32[2] =
ai4_satd_16x16[2][0] + ai4_satd_16x16[2][1] + ai4_satd_16x16[2][2] + ai4_satd_16x16[2][3];
ai4_satd_32x32[3] =
ai4_satd_16x16[3][0] + ai4_satd_16x16[3][1] + ai4_satd_16x16[3][2] + ai4_satd_16x16[3][3];
/* Update 64x64 SATDs */
pi4_sad_grid[PART_ID_2Nx2N] =
ai4_satd_32x32[0] + ai4_satd_32x32[1] + ai4_satd_32x32[2] + ai4_satd_32x32[3];
/* Update 32x32 SATDs */
pi4_sad_grid[PART_ID_NxN_TL] = ai4_satd_32x32[0];
pi4_sad_grid[PART_ID_NxN_TR] = ai4_satd_32x32[1];
pi4_sad_grid[PART_ID_NxN_BL] = ai4_satd_32x32[2];
pi4_sad_grid[PART_ID_NxN_BR] = ai4_satd_32x32[3];
/* Update 32x64 / 64x32 SATDs */
pi4_sad_grid[PART_ID_Nx2N_L] = ai4_satd_32x32[0] + ai4_satd_32x32[2];
pi4_sad_grid[PART_ID_Nx2N_R] = ai4_satd_32x32[1] + ai4_satd_32x32[3];
pi4_sad_grid[PART_ID_2NxN_T] = ai4_satd_32x32[0] + ai4_satd_32x32[1];
pi4_sad_grid[PART_ID_2NxN_B] = ai4_satd_32x32[2] + ai4_satd_32x32[3];
/* Update AMP SATDs 64x48,64x16, 48x64,16x64 */
pi4_sad_grid[PART_ID_nLx2N_L] =
ai4_satd_16x16[0][0] + ai4_satd_16x16[0][2] + ai4_satd_16x16[2][0] + ai4_satd_16x16[2][2];
pi4_sad_grid[PART_ID_nLx2N_R] = ai4_satd_16x16[0][1] + ai4_satd_16x16[0][3] +
ai4_satd_16x16[2][1] + ai4_satd_16x16[2][3] +
pi4_sad_grid[PART_ID_Nx2N_R];
pi4_sad_grid[PART_ID_nRx2N_L] = ai4_satd_16x16[1][0] + ai4_satd_16x16[1][2] +
ai4_satd_16x16[3][0] + ai4_satd_16x16[3][2] +
pi4_sad_grid[PART_ID_Nx2N_L];
pi4_sad_grid[PART_ID_nRx2N_R] =
ai4_satd_16x16[1][1] + ai4_satd_16x16[1][3] + ai4_satd_16x16[3][1] + ai4_satd_16x16[3][3];
pi4_sad_grid[PART_ID_2NxnU_T] =
ai4_satd_16x16[0][0] + ai4_satd_16x16[0][1] + ai4_satd_16x16[1][0] + ai4_satd_16x16[1][1];
pi4_sad_grid[PART_ID_2NxnU_B] = ai4_satd_16x16[0][2] + ai4_satd_16x16[0][3] +
ai4_satd_16x16[1][2] + ai4_satd_16x16[1][3] +
pi4_sad_grid[PART_ID_2NxN_B];
pi4_sad_grid[PART_ID_2NxnD_T] = ai4_satd_16x16[2][0] + ai4_satd_16x16[2][1] +
ai4_satd_16x16[3][0] + ai4_satd_16x16[3][1] +
pi4_sad_grid[PART_ID_2NxN_T];
pi4_sad_grid[PART_ID_2NxnD_B] =
ai4_satd_16x16[2][2] + ai4_satd_16x16[2][3] + ai4_satd_16x16[3][2] + ai4_satd_16x16[3][3];
}
WORD32 hme_evalsatd_pt_pu_64x64_tu_rec(
err_prms_t *ps_prms,
WORD32 lambda,
WORD32 lambda_q_shift,
WORD32 i4_frm_qstep,
me_func_selector_t *ps_func_selector)
{
S32 ai4_satd_4x4[64]; /* num 4x4s in a 32x32 * num 32x32 in 64x64 */
S32 ai4_satd_8x8[16]; /* num 8x8s in a 32x32 * num 32x32 in 64x64 */
S32 ai4_satd_16x16[4]; /* num 16x16 in a 32x32* num 32x32 in 64x64 */
S32 ai4_satd_32x32[4]; /* num 32x32 in 64x64 */
S32 ai4_tu_split_8x8[16];
S32 ai4_tu_split_16x16[4];
S32 ai4_tu_early_cbf_8x8[16];
S32 ai4_tu_early_cbf_16x16[4];
S16 *pi2_had_out;
S32 i;
/* Initialize array of ptrs to hold partial SATDs at all levels of 16x16 */
S32 *api4_satd_pu[HAD_32x32 + 1];
S32 *api4_tu_split[HAD_32x32 + 1];
S32 *api4_tu_early_cbf[HAD_32x32 + 1];
S32 *pi4_sad_grid = ps_prms->pi4_sad_grid;
S32 tu_split_flag = 0;
S32 total_satd_cost = 0;
U08 *pu1_inp = ps_prms->pu1_inp;
U08 *pu1_ref = ps_prms->pu1_ref;
S32 inp_stride = ps_prms->i4_inp_stride;
S32 ref_stride = ps_prms->i4_ref_stride;
/* Initialize tu_split_cost to "0" */
ps_prms->i4_tu_split_cost = 0;
pi2_had_out = (S16 *)ps_prms->pu1_wkg_mem;
for(i = 0; i < 4; i++)
{
S32 blkx = (i & 0x1);
S32 blky = (i >> 1);
U08 *pu1_pi0, *pu1_pi1;
tu_split_flag = 0;
api4_satd_pu[HAD_4x4] = &ai4_satd_4x4[0];
api4_satd_pu[HAD_8x8] = &ai4_satd_8x8[0];
api4_satd_pu[HAD_16x16] = &ai4_satd_16x16[0];
api4_satd_pu[HAD_32x32] = &ai4_satd_32x32[i];
api4_tu_split[HAD_4x4] = NULL;
api4_tu_split[HAD_8x8] = &ai4_tu_split_8x8[0];
api4_tu_split[HAD_16x16] = &ai4_tu_split_16x16[0];
api4_tu_split[HAD_32x32] = &ps_prms->pi4_tu_split_flags[i];
api4_tu_early_cbf[HAD_4x4] = NULL;
api4_tu_early_cbf[HAD_8x8] = &ai4_tu_early_cbf_8x8[0];
api4_tu_early_cbf[HAD_16x16] = &ai4_tu_early_cbf_16x16[0];
api4_tu_early_cbf[HAD_32x32] = &ps_prms->pi4_tu_early_cbf[i];
pu1_pi0 = pu1_inp + (blkx * 32) + (blky * 32 * inp_stride);
pu1_pi1 = pu1_ref + (blkx * 32) + (blky * 32 * ref_stride);
/* Call recursive 32x32 HAD module; updates satds for 4x4, 8x8, 16x16 and 32x32 */
ihevce_had_32x32_r(
pu1_pi0,
inp_stride,
pu1_pi1,
ref_stride,
pi2_had_out,
32,
api4_satd_pu,
api4_tu_split,
api4_tu_early_cbf,
0,
8,
lambda,
lambda_q_shift,
i4_frm_qstep,
1,
ps_prms->u1_max_tr_depth,
ps_prms->u1_max_tr_size,
&(ps_prms->i4_tu_split_cost),
ps_func_selector);
}
total_satd_cost = ai4_satd_32x32[0] + ai4_satd_32x32[1] + ai4_satd_32x32[2] + ai4_satd_32x32[3];
/* Update 64x64 SATDs */
pi4_sad_grid[PART_ID_2Nx2N] =
ai4_satd_32x32[0] + ai4_satd_32x32[1] + ai4_satd_32x32[2] + ai4_satd_32x32[3];
return total_satd_cost;
}
/**
********************************************************************************
* @fn void hme_subpel_refine_search_node(search_node_t *ps_search_node,
* hme_subpel_prms_t *ps_prms,
* layer_ctxt_t *ps_curr_layer,
* BLK_SIZE_T e_blk_size,
* S32 x_off,
* S32 y_off)
*
* @brief Refines a given partition within a CU
*
* @param[in,out] ps_search_node: supplies starting mv and also ref id.
* updated with the accurate subpel mv
*
* @param[in] ps_prms: subpel prms input to this function
*
* @param[in] ps_curr_layer : layer context
*
* @param[in] e_blk_size : Block size enumeration
*
* @param[in] x_off : x offset of the partition w.r.t. pic start
*
* @param[in] y_off : y offset of the partition w.r.t. pic start
*
* @return None
********************************************************************************
*/
static __inline PF_SAD_RESULT_FXN_T hme_get_calc_sad_and_result_subpel_fxn(
me_func_selector_t *ps_func_selector,
ihevce_me_optimised_function_list_t *ps_me_optimised_function_list,
S32 i4_part_mask,
U08 u1_use_satd,
U08 u1_num_parts,
U08 u1_num_results)
{
PF_SAD_RESULT_FXN_T pf_err_compute;
ASSERT((1 == u1_num_results) || (2 == u1_num_results));
if(1 == u1_num_results)
{
if(u1_use_satd)
{
if(u1_num_parts == 1)
{
pf_err_compute =
ps_func_selector->pf_evalsatd_update_1_best_result_pt_pu_16x16_num_part_eq_1;
}
else if((u1_num_parts > 1) && (u1_num_parts <= 8))
{
pf_err_compute =
ps_func_selector->pf_evalsatd_update_1_best_result_pt_pu_16x16_num_part_lt_9;
}
else
{
pf_err_compute =
ps_func_selector->pf_evalsatd_update_1_best_result_pt_pu_16x16_num_part_lt_17;
}
}
else
{
if(u1_num_parts == 1)
{
pf_err_compute = ps_me_optimised_function_list
->pf_calc_sad_and_1_best_result_subpel_num_part_eq_1;
}
else if(((i4_part_mask & ENABLE_SQUARE_PARTS) != 0) && (u1_num_parts == 5))
{
pf_err_compute =
ps_me_optimised_function_list->pf_calc_sad_and_1_best_result_subpel_square_parts;
}
else if((u1_num_parts > 1) && (u1_num_parts <= 8))
{
pf_err_compute = ps_me_optimised_function_list
->pf_calc_sad_and_1_best_result_subpel_num_part_lt_9;
}
else
{
pf_err_compute = ps_me_optimised_function_list
->pf_calc_sad_and_1_best_result_subpel_num_part_lt_17;
}
}
}
else
{
if(u1_use_satd)
{
if(u1_num_parts == 1)
{
pf_err_compute =
ps_func_selector->pf_evalsatd_update_2_best_results_pt_pu_16x16_num_part_eq_1;
}
else if((u1_num_parts > 1) && (u1_num_parts <= 8))
{
pf_err_compute =
ps_func_selector->pf_evalsatd_update_2_best_results_pt_pu_16x16_num_part_lt_9;
}
else
{
pf_err_compute =
ps_func_selector->pf_evalsatd_update_2_best_results_pt_pu_16x16_num_part_lt_17;
}
}
else
{
if(u1_num_parts == 1)
{
pf_err_compute = ps_me_optimised_function_list
->pf_calc_sad_and_2_best_results_subpel_num_part_eq_1;
}
else if(((i4_part_mask & ENABLE_SQUARE_PARTS) != 0) && (u1_num_parts == 5))
{
pf_err_compute = ps_me_optimised_function_list
->pf_calc_sad_and_2_best_results_subpel_square_parts;
}
else if((u1_num_parts > 1) && (u1_num_parts <= 8))
{
pf_err_compute = ps_me_optimised_function_list
->pf_calc_sad_and_2_best_results_subpel_num_part_lt_9;
}
else
{
pf_err_compute = ps_me_optimised_function_list
->pf_calc_sad_and_2_best_results_subpel_num_part_lt_17;
}
}
}
return pf_err_compute;
}
#if DIAMOND_GRID == 1
S32 hme_subpel_refine_search_node_high_speed(
search_node_t *ps_search_node,
hme_subpel_prms_t *ps_prms,
layer_ctxt_t *ps_curr_layer,
BLK_SIZE_T e_blk_size,
S32 x_off,
S32 y_off,
search_results_t *ps_search_results,
S32 pred_lx,
S32 i4_part_mask,
S32 *pi4_valid_part_ids,
S32 search_idx,
subpel_dedup_enabler_t *ps_dedup_enabler,
me_func_selector_t *ps_func_selector,
ihevce_me_optimised_function_list_t *ps_me_optimised_function_list)
{
S32 i4_num_hpel_refine, i4_num_qpel_refine;
S32 i4_offset, i4_grid_mask;
S08 i1_ref_idx;
S32 i4_blk_wd, i4_blk_ht;
S32 i4_ref_stride, i4_i;
pred_ctxt_t *ps_pred_ctxt = &ps_search_results->as_pred_ctxt[pred_lx];
result_upd_prms_t s_result_prms;
search_node_t s_temp_search_node;
/*************************************************************************/
/* Tracks current MV with the fractional component. */
/*************************************************************************/
S32 i4_mv_x, i4_mv_y;
S32 i4_frac_x, i4_frac_y;
/*************************************************************************/
/* Function pointer for SAD/SATD, array and prms structure to pass to */
/* This function */
/*************************************************************************/
PF_SAD_RESULT_FXN_T pf_err_compute;
S32 ai4_sad_grid[17], i4_tot_cost;
err_prms_t s_err_prms;
/*************************************************************************/
/* Allowed MV RANGE */
/*************************************************************************/
range_prms_t *ps_range_prms;
/*************************************************************************/
/* stores min id in grid with associated min cost. */
/*************************************************************************/
S32 i4_min_cost, i4_min_sad;
GRID_PT_T e_min_id;
PF_INTERP_FXN_T pf_qpel_interp;
/*************************************************************************/
/* For hpel and qpel we move in diamonds and hence each point in the */
/* diamond will belong to a completely different plane. To simplify the */
/* look up of the ref ptr, we declare a 2x2 array of ref ptrs for the */
/* hpel planes which are interpolated during recon. */
/*************************************************************************/
U08 *apu1_hpel_ref[4], *pu1_ref;
interp_prms_t s_interp_prms;
/*************************************************************************/
/* Maintains the minimum id of interpolated buffers, and the pointer that*/
/* points to the corresponding predicted buf with its stride. */
/* Note that the pointer cannot be derived just from the id, since the */
/* pointer may also point to the hpel buffer (in case we request interp */
/* of a hpel pt, which already exists in the recon hpel planes) */
/*************************************************************************/
U08 *pu1_final_out;
S32 i4_final_out_stride;
S32 part_id;
S32 check_for_duplicate = 0;
subpel_refine_ctxt_t *ps_subpel_refine_ctxt = ps_prms->ps_subpel_refine_ctxt;
S32 mvx_qpel;
S32 mvy_qpel;
pf_err_compute = hme_get_calc_sad_and_result_subpel_fxn(
ps_func_selector,
ps_me_optimised_function_list,
i4_part_mask,
ps_prms->i4_use_satd,
ps_subpel_refine_ctxt->i4_num_valid_parts,
ps_search_results->u1_num_results_per_part);
i4_num_hpel_refine = ps_prms->i4_num_steps_hpel_refine;
i4_num_qpel_refine = ps_prms->i4_num_steps_qpel_refine;
/* Prediction contet should now deal with qpel units */
HME_SET_MVPRED_RES(ps_pred_ctxt, MV_RES_QPEL);
/* Buffer allocation for subpel */
/* Current design is that there may be many partitions and different mvs */
/* that attempt subpel refinemnt. While there is possibility of overlap, the */
/* hashing to detect and avoid overlap may be very complex. So, currently, */
/* the only thing done is to store the eventual predicted buffer with every */
/* ctb node that holds the result of hte best subpel search */
/* Compute the base pointer for input, interpolated buffers */
/* The base pointers point as follows: */
/* fx fy : 0, 0 :: fx, hy : 0, 0.5, hx, fy: 0.5, 0, hx, fy: 0.5, 0.5 */
/* To these, we need to add the offset of the current node */
i4_ref_stride = ps_curr_layer->i4_rec_stride;
i4_offset = x_off + (y_off * i4_ref_stride);
i1_ref_idx = ps_search_node->i1_ref_idx;
apu1_hpel_ref[0] = ps_curr_layer->ppu1_list_rec_fxfy[i1_ref_idx] + i4_offset;
apu1_hpel_ref[1] = ps_curr_layer->ppu1_list_rec_hxfy[i1_ref_idx] + i4_offset;
apu1_hpel_ref[2] = ps_curr_layer->ppu1_list_rec_fxhy[i1_ref_idx] + i4_offset;
apu1_hpel_ref[3] = ps_curr_layer->ppu1_list_rec_hxhy[i1_ref_idx] + i4_offset;
/* Initialize result params used for partition update */
s_result_prms.pf_mv_cost_compute = NULL;
s_result_prms.ps_search_results = ps_search_results;
s_result_prms.pi4_valid_part_ids = pi4_valid_part_ids;
s_result_prms.i1_ref_idx = ps_search_node->i1_ref_idx;
s_result_prms.u1_pred_lx = search_idx;
s_result_prms.i4_part_mask = i4_part_mask;
s_result_prms.ps_search_node_base = ps_search_node;
s_result_prms.pi4_sad_grid = &ai4_sad_grid[0];
s_result_prms.i4_grid_mask = 1;
s_result_prms.ps_search_node = &s_temp_search_node;
s_temp_search_node.i1_ref_idx = ps_search_node->i1_ref_idx;
/* convert to hpel units */
i4_mv_x = ps_search_node->s_mv.i2_mvx >> 1;
i4_mv_y = ps_search_node->s_mv.i2_mvy >> 1;
/* for first pt, we compute at all locations in the grid, 4 + 1 centre */
ps_range_prms = ps_prms->aps_mv_range_qpel[i1_ref_idx];
i4_grid_mask = (GRID_DIAMOND_ENABLE_ALL);
i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 2, ps_range_prms);
i4_min_cost = MAX_32BIT_VAL;
i4_min_sad = MAX_32BIT_VAL;
/*************************************************************************/
/* Prepare the input params to SAD/SATD function. Note that input is */
/* passed from the calling funcion since it may be I (normal subpel */
/* refinement) or 2I - P0 in case of bidirect subpel refinement. */
/* Both cases are handled here. */
/*************************************************************************/
s_err_prms.pu1_inp = (U08 *)ps_prms->pv_inp;
s_err_prms.i4_inp_stride = ps_prms->i4_inp_stride;
s_err_prms.i4_ref_stride = i4_ref_stride;
s_err_prms.i4_part_mask = (ENABLE_2Nx2N);
s_err_prms.i4_grid_mask = 1;
s_err_prms.pi4_sad_grid = &ai4_sad_grid[0];
s_err_prms.i4_blk_wd = i4_blk_wd = gau1_blk_size_to_wd[e_blk_size];
s_err_prms.i4_blk_ht = i4_blk_ht = gau1_blk_size_to_ht[e_blk_size];
s_result_prms.ps_subpel_refine_ctxt = ps_subpel_refine_ctxt;
part_id = ps_search_node->u1_part_id;
for(i4_i = 0; i4_i < i4_num_hpel_refine; i4_i++)
{
e_min_id = PT_C;
mvx_qpel = i4_mv_x << 1;
mvy_qpel = i4_mv_y << 1;
/* Central pt */
if(i4_grid_mask & BIT_EN(PT_C))
{
//ps_search_node->i2_mv_x = (S16)i4_mv_x;
//ps_search_node->i2_mv_x = (S16)i4_mv_y;
/* central pt is i4_mv_x, i4_mv_y */
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel, mvy_qpel, check_for_duplicate);
i4_frac_x = i4_mv_x & 1;
i4_frac_y = i4_mv_y & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref = pu1_ref + (i4_mv_x >> 1) + ((i4_mv_y >> 1) * i4_ref_stride);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel;
s_result_prms.i2_mv_y = mvy_qpel;
s_temp_search_node.s_mv.i2_mvx = mvx_qpel;
s_temp_search_node.s_mv.i2_mvy = mvy_qpel;
pf_err_compute(&s_err_prms, &s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_C;
pu1_final_out = s_err_prms.pu1_ref;
}
}
/* left pt */
if(i4_grid_mask & BIT_EN(PT_L))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel - 2, mvy_qpel, check_for_duplicate);
if(!check_for_duplicate)
{
/* search node mv is stored in qpel units */
ps_search_node->s_mv.i2_mvx = (S16)((i4_mv_x - 1) << 1);
ps_search_node->s_mv.i2_mvy = (S16)(i4_mv_y << 1);
/* central pt is i4_mv_x - 1, i4_mv_y */
i4_frac_x = (i4_mv_x - 1) & 1; // same as (x-1)&1
i4_frac_y = i4_mv_y & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref =
pu1_ref + ((i4_mv_x - 1) >> 1) + ((i4_mv_y >> 1) * i4_ref_stride);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel - 2;
s_result_prms.i2_mv_y = mvy_qpel;
s_temp_search_node.s_mv.i2_mvx = mvx_qpel - 2;
s_temp_search_node.s_mv.i2_mvy = mvy_qpel;
pf_err_compute(&s_err_prms, &s_result_prms);
//hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_L;
pu1_final_out = s_err_prms.pu1_ref;
}
}
}
/* top pt */
if(i4_grid_mask & BIT_EN(PT_T))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel, mvy_qpel - 2, check_for_duplicate);
if(!check_for_duplicate)
{
/* search node mv is stored in qpel units */
ps_search_node->s_mv.i2_mvx = (S16)(i4_mv_x << 1);
ps_search_node->s_mv.i2_mvy = (S16)((i4_mv_y - 1) << 1);
/* top pt is i4_mv_x, i4_mv_y - 1 */
i4_frac_x = i4_mv_x & 1;
i4_frac_y = (i4_mv_y - 1) & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref =
pu1_ref + (i4_mv_x >> 1) + (((i4_mv_y - 1) >> 1) * i4_ref_stride);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel;
s_result_prms.i2_mv_y = mvy_qpel - 2;
s_temp_search_node.s_mv.i2_mvx = mvx_qpel;
s_temp_search_node.s_mv.i2_mvy = mvy_qpel - 2;
pf_err_compute(&s_err_prms, &s_result_prms);
//hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_T;
pu1_final_out = s_err_prms.pu1_ref;
}
}
}
/* right pt */
if(i4_grid_mask & BIT_EN(PT_R))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, num_unique_nodes, mvx_qpel + 2, mvy_qpel, check_for_duplicate);
if(!check_for_duplicate)
{
/* search node mv is stored in qpel units */
ps_search_node->s_mv.i2_mvx = (S16)((i4_mv_x + 1) << 1);
ps_search_node->s_mv.i2_mvy = (S16)(i4_mv_y << 1);
/* right pt is i4_mv_x + 1, i4_mv_y */
i4_frac_x = (i4_mv_x + 1) & 1;
i4_frac_y = i4_mv_y & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref =
pu1_ref + ((i4_mv_x + 1) >> 1) + ((i4_mv_y >> 1) * i4_ref_stride);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel + 2;
s_result_prms.i2_mv_y = mvy_qpel;
s_temp_search_node.s_mv.i2_mvx = mvx_qpel + 2;
s_temp_search_node.s_mv.i2_mvy = mvy_qpel;
pf_err_compute(&s_err_prms, &s_result_prms);
//hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_R;
pu1_final_out = s_err_prms.pu1_ref;
}
}
}
/* bottom pt */
if(i4_grid_mask & BIT_EN(PT_B))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, num_unique_nodes, mvx_qpel, mvy_qpel + 2, check_for_duplicate);
if(!check_for_duplicate)
{
/* search node mv is stored in qpel units */
ps_search_node->s_mv.i2_mvx = ((S16)i4_mv_x << 1);
ps_search_node->s_mv.i2_mvy = ((S16)(i4_mv_y + 1) << 1);
i4_frac_x = i4_mv_x & 1;
i4_frac_y = (i4_mv_y + 1) & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref =
pu1_ref + (i4_mv_x >> 1) + (((i4_mv_y + 1) >> 1) * i4_ref_stride);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel;
s_result_prms.i2_mv_y = mvy_qpel + 2;
s_temp_search_node.s_mv.i2_mvx = mvx_qpel;
s_temp_search_node.s_mv.i2_mvy = mvy_qpel + 2;
pf_err_compute(&s_err_prms, &s_result_prms);
//hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_B;
pu1_final_out = s_err_prms.pu1_ref;
}
}
}
/* Early exit in case of central point */
if(e_min_id == PT_C)
break;
/*********************************************************************/
/* Depending on the best result location, we may be able to skip */
/* atleast two pts, centre pt and one more pt. E.g. if right pt is */
/* the best result, the next iteration need not do centre, left pts */
/*********************************************************************/
i4_grid_mask = gai4_opt_grid_mask_diamond[e_min_id];
i4_mv_x += gai1_grid_id_to_x[e_min_id];
i4_mv_y += gai1_grid_id_to_y[e_min_id];
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 2, ps_range_prms);
}
/* Convert to QPEL units */
i4_mv_x <<= 1;
i4_mv_y <<= 1;
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
/* Exact interpolation or averaging chosen here */
pf_qpel_interp = ps_prms->pf_qpel_interp;
/* Next QPEL ME */
/* In this case, we have option of doing exact QPEL interpolation or avg */
/*************************************************************************/
/* x */
/* A b C d */
/* e f g h */
/* I j K l */
/* m n o p */
/* Q r S t */
/* */
/* Approximate QPEL logic */
/* b = avg(A,C) f = avg(I,C), g= avg(C,K) j=avg(I,K) */
/* for any given pt, we can get all the information required about */
/* the surrounding 4 pts. For example, given point C (0.5, 0) */
/* surrounding pts info: */
/* b : qpel offset: 1, 0, generated by averaging. buffer1: fpel buf */
/* buffer 2: hxfy, offsets for both are 0, 0 */
/* similarly for other pts the info can be gotten */
/*************************************************************************/
i4_grid_mask = GRID_DIAMOND_ENABLE_ALL ^ (BIT_EN(PT_C));
i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 1, ps_range_prms);
/*************************************************************************/
/* One time preparation of non changing interpolation params. These */
/* include a set of ping pong result buf ptrs, input buf ptrs and some */
/* working memory (not used though in case of averaging). */
/*************************************************************************/
s_interp_prms.ppu1_ref = &apu1_hpel_ref[0];
s_interp_prms.i4_ref_stride = i4_ref_stride;
s_interp_prms.i4_blk_wd = i4_blk_wd;
s_interp_prms.i4_blk_ht = i4_blk_ht;
i4_final_out_stride = i4_ref_stride;
{
U08 *pu1_mem;
/*********************************************************************/
/* Allocation of working memory for interpolated buffers. We maintain*/
/* an intermediate working buffer, and 2 ping pong interpolated out */
/* buffers, purpose of ping pong explained later below */
/*********************************************************************/
pu1_mem = ps_prms->pu1_wkg_mem;
s_interp_prms.pu1_wkg_mem = pu1_mem;
//pu1_mem += (INTERP_INTERMED_BUF_SIZE);
s_interp_prms.apu1_interp_out[0] = pu1_mem;
pu1_mem += (INTERP_OUT_BUF_SIZE);
s_interp_prms.apu1_interp_out[1] = pu1_mem;
pu1_mem += (INTERP_OUT_BUF_SIZE);
s_interp_prms.apu1_interp_out[2] = pu1_mem;
pu1_mem += (INTERP_OUT_BUF_SIZE);
s_interp_prms.apu1_interp_out[3] = pu1_mem;
pu1_mem += (INTERP_OUT_BUF_SIZE);
s_interp_prms.apu1_interp_out[4] = pu1_mem;
/*********************************************************************/
/* Stride of interpolated output is just a function of blk width of */
/* this partition and hence remains constant for this partition */
/*********************************************************************/
s_interp_prms.i4_out_stride = (i4_blk_wd);
}
{
UWORD8 *apu1_final[4];
WORD32 ai4_ref_stride[4];
/*************************************************************************/
/* Ping pong design for interpolated buffers. We use a min id, which */
/* tracks the id of the ppu1_interp_out that stores the best result. */
/* When new interp to be done, it uses 1 - bes result id to do the interp*/
/* min id is toggled when any new result becomes the best result. */
/*************************************************************************/
for(i4_i = 0; i4_i < i4_num_qpel_refine; i4_i++)
{
e_min_id = PT_C;
mvx_qpel = i4_mv_x;
mvy_qpel = i4_mv_y;
hme_qpel_interp_comprehensive(
&s_interp_prms,
apu1_final,
ai4_ref_stride,
i4_mv_x,
i4_mv_y,
i4_grid_mask,
ps_me_optimised_function_list);
if(i4_grid_mask & BIT_EN(PT_L))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler,
num_unique_nodes,
mvx_qpel - 1,
mvy_qpel - 0,
check_for_duplicate);
if(!check_for_duplicate)
{
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x - 1;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
s_err_prms.pu1_ref = apu1_final[0];
s_err_prms.i4_ref_stride = ai4_ref_stride[0];
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel - 1;
s_result_prms.i2_mv_y = mvy_qpel;
s_temp_search_node.s_mv.i2_mvx = mvx_qpel - 1;
s_temp_search_node.s_mv.i2_mvy = mvy_qpel;
pf_err_compute(&s_err_prms, &s_result_prms);
//hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
e_min_id = PT_L;
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
}
}
}
if(i4_grid_mask & BIT_EN(PT_T))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler,
num_unique_nodes,
mvx_qpel - 0,
mvy_qpel - 1,
check_for_duplicate);
if(!check_for_duplicate)
{
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y - 1;
s_err_prms.pu1_ref = apu1_final[1];
s_err_prms.i4_ref_stride = ai4_ref_stride[1];
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel;
s_result_prms.i2_mv_y = mvy_qpel - 1;
s_temp_search_node.s_mv.i2_mvx = mvx_qpel;
s_temp_search_node.s_mv.i2_mvy = mvy_qpel - 1;
pf_err_compute(&s_err_prms, &s_result_prms);
//hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
e_min_id = PT_T;
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
}
}
}
if(i4_grid_mask & BIT_EN(PT_R))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, num_unique_nodes, mvx_qpel + 1, mvy_qpel, check_for_duplicate);
if(!check_for_duplicate)
{
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x + 1;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
s_err_prms.pu1_ref = apu1_final[2];
s_err_prms.i4_ref_stride = ai4_ref_stride[2];
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel + 1;
s_result_prms.i2_mv_y = mvy_qpel;
s_temp_search_node.s_mv.i2_mvx = mvx_qpel + 1;
s_temp_search_node.s_mv.i2_mvy = mvy_qpel;
pf_err_compute(&s_err_prms, &s_result_prms);
//hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
e_min_id = PT_R;
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
}
}
}
/* i4_mv_x and i4_mv_y will always be the centre pt */
/* for qpel we start with least hpel, and hence compute of center pt never reqd */
if(i4_grid_mask & BIT_EN(PT_B))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, num_unique_nodes, mvx_qpel, mvy_qpel + 1, check_for_duplicate);
if(!check_for_duplicate)
{
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y + 1;
s_err_prms.pu1_ref = apu1_final[3];
s_err_prms.i4_ref_stride = ai4_ref_stride[3];
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel;
s_result_prms.i2_mv_y = mvy_qpel + 1;
s_temp_search_node.s_mv.i2_mvx = mvx_qpel;
s_temp_search_node.s_mv.i2_mvy = mvy_qpel + 1;
pf_err_compute(&s_err_prms, &s_result_prms);
//hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
e_min_id = PT_B;
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
}
}
}
/* New QPEL mv x and y */
if(e_min_id == PT_C)
break;
i4_grid_mask = gai4_opt_grid_mask_diamond[e_min_id];
i4_mv_x += gai1_grid_id_to_x[e_min_id];
i4_mv_y += gai1_grid_id_to_y[e_min_id];
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 1, ps_range_prms);
}
}
/* update modified motion vectors and cost at end of subpel */
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
ps_search_node->i4_tot_cost = i4_min_cost;
ps_search_node->i4_sad = i4_min_sad;
/********************************************************************************/
/* TODO: Restoring back Sad lambda from Hadamard lambda */
/* Need to pass the had/satd lambda in more cleaner way for subpel cost compute */
/********************************************************************************/
//ps_pred_ctxt->lambda >>= 1;
return (i4_min_cost);
}
#elif DIAMOND_GRID == 0
S32 hme_subpel_refine_search_node_high_speed(
search_node_t *ps_search_node,
hme_subpel_prms_t *ps_prms,
layer_ctxt_t *ps_curr_layer,
BLK_SIZE_T e_blk_size,
S32 x_off,
S32 y_off,
search_results_t *ps_search_results,
S32 pred_lx,
S32 i4_part_mask,
S32 *pi4_valid_part_ids,
S32 search_idx,
subpel_dedup_enabler_t *ps_dedup_enabler,
me_func_selector_t *ps_func_selector)
{
S32 i4_num_hpel_refine, i4_num_qpel_refine;
S32 i4_offset, i4_grid_mask;
S08 i1_ref_idx;
S32 i4_blk_wd, i4_blk_ht;
S32 i4_ref_stride, i4_i;
pred_ctxt_t *ps_pred_ctxt = &ps_search_results->as_pred_ctxt[pred_lx];
result_upd_prms_t s_result_prms;
/*************************************************************************/
/* Tracks current MV with the fractional component. */
/*************************************************************************/
S32 i4_mv_x, i4_mv_y;
S32 i4_frac_x, i4_frac_y;
/*************************************************************************/
/* Function pointer for SAD/SATD, array and prms structure to pass to */
/* This function */
/*************************************************************************/
PF_SAD_FXN_T pf_err_compute;
S32 ai4_sad_grid[9][17], i4_tot_cost;
err_prms_t s_err_prms;
/*************************************************************************/
/* Allowed MV RANGE */
/*************************************************************************/
range_prms_t *ps_range_prms;
/*************************************************************************/
/* stores min id in grid with associated min cost. */
/*************************************************************************/
S32 i4_min_cost, i4_min_sad;
GRID_PT_T e_min_id;
PF_INTERP_FXN_T pf_qpel_interp;
/*************************************************************************/
/* For hpel and qpel we move in diamonds and hence each point in the */
/* diamond will belong to a completely different plane. To simplify the */
/* look up of the ref ptr, we declare a 2x2 array of ref ptrs for the */
/* hpel planes which are interpolated during recon. */
/*************************************************************************/
U08 *apu1_hpel_ref[4], *pu1_ref;
interp_prms_t s_interp_prms;
/*************************************************************************/
/* Maintains the minimum id of interpolated buffers, and the pointer that*/
/* points to the corresponding predicted buf with its stride. */
/* Note that the pointer cannot be derived just from the id, since the */
/* pointer may also point to the hpel buffer (in case we request interp */
/* of a hpel pt, which already exists in the recon hpel planes) */
/*************************************************************************/
U08 *pu1_final_out;
S32 i4_final_out_stride;
S32 part_id;
S32 check_for_duplicate = 0;
S32 mvx_qpel;
S32 mvy_qpel;
/*************************************************************************/
/* Appropriate Err compute fxn, depends on SAD/SATD, blk size and remains*/
/* fixed through this subpel refinement for this partition. */
/* Note, we do not enable grid sads since each pt is different buffers. */
/* Hence, part mask is also nearly dont care and we use 2Nx2N enabled. */
/*************************************************************************/
if(ps_prms->i4_use_satd)
{
pf_err_compute = hme_evalsatd_update_1_best_result_pt_pu_16x16;
}
else
{
pf_err_compute = hme_evalsad_grid_pu_16x16; /* hme_evalsad_pt_pu_16x16; */
}
i4_num_hpel_refine = ps_prms->i4_num_steps_hpel_refine;
i4_num_qpel_refine = ps_prms->i4_num_steps_qpel_refine;
/* Prediction contet should now deal with qpel units */
HME_SET_MVPRED_RES(ps_pred_ctxt, MV_RES_QPEL);
/* Buffer allocation for subpel */
/* Current design is that there may be many partitions and different mvs */
/* that attempt subpel refinemnt. While there is possibility of overlap, the */
/* hashing to detect and avoid overlap may be very complex. So, currently, */
/* the only thing done is to store the eventual predicted buffer with every */
/* ctb node that holds the result of hte best subpel search */
/* Compute the base pointer for input, interpolated buffers */
/* The base pointers point as follows:
/* fx fy : 0, 0 :: fx, hy : 0, 0.5, hx, fy: 0.5, 0, hx, fy: 0.5, 0.5 */
/* To these, we need to add the offset of the current node */
i4_ref_stride = ps_curr_layer->i4_rec_stride;
i4_offset = x_off + (y_off * i4_ref_stride);
i1_ref_idx = ps_search_node->i1_ref_idx;
apu1_hpel_ref[0] = ps_curr_layer->ppu1_list_rec_fxfy[i1_ref_idx] + i4_offset;
apu1_hpel_ref[1] = ps_curr_layer->ppu1_list_rec_hxfy[i1_ref_idx] + i4_offset;
apu1_hpel_ref[2] = ps_curr_layer->ppu1_list_rec_fxhy[i1_ref_idx] + i4_offset;
apu1_hpel_ref[3] = ps_curr_layer->ppu1_list_rec_hxhy[i1_ref_idx] + i4_offset;
/* Initialize result params used for partition update */
s_result_prms.pf_mv_cost_compute = NULL;
s_result_prms.ps_search_results = ps_search_results;
s_result_prms.pi4_valid_part_ids = pi4_valid_part_ids;
s_result_prms.i1_ref_idx = search_idx;
s_result_prms.i4_part_mask = i4_part_mask;
s_result_prms.ps_search_node_base = ps_search_node;
s_result_prms.pi4_sad_grid = &ai4_sad_grid[0][0];
s_result_prms.i4_grid_mask = 1;
/* convert to hpel units */
i4_mv_x = ps_search_node->s_mv.i2_mvx >> 1;
i4_mv_y = ps_search_node->s_mv.i2_mvy >> 1;
/* for first pt, we compute at all locations in the grid, 4 + 1 centre */
ps_range_prms = ps_prms->ps_mv_range_qpel;
i4_grid_mask = (GRID_ALL_PTS_VALID);
i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 2, ps_range_prms);
i4_min_cost = MAX_32BIT_VAL;
i4_min_sad = MAX_32BIT_VAL;
/*************************************************************************/
/* Prepare the input params to SAD/SATD function. Note that input is */
/* passed from the calling funcion since it may be I (normal subpel */
/* refinement) or 2I - P0 in case of bidirect subpel refinement. */
/* Both cases are handled here. */
/*************************************************************************/
s_err_prms.pu1_inp = (U08 *)ps_prms->pv_inp;
s_err_prms.i4_inp_stride = ps_prms->i4_inp_stride;
s_err_prms.i4_ref_stride = i4_ref_stride;
s_err_prms.i4_part_mask = (ENABLE_2Nx2N);
s_err_prms.i4_grid_mask = 1;
s_err_prms.pi4_sad_grid = &ai4_sad_grid[0][0];
s_err_prms.i4_blk_wd = i4_blk_wd = gau1_blk_size_to_wd[e_blk_size];
s_err_prms.i4_blk_ht = i4_blk_ht = gau1_blk_size_to_ht[e_blk_size];
/* TODO: Currently doubling lambda for Hadamard Sad instead of 1.9*sadlambda */
//ps_pred_ctxt->lambda <<= 1;
part_id = ps_search_node->u1_part_id;
for(i4_i = 0; i4_i < i4_num_hpel_refine; i4_i++)
{
e_min_id = PT_C;
mvx_qpel = i4_mv_x << 1;
mvy_qpel = i4_mv_y << 1;
/* Central pt */
if(i4_grid_mask & BIT_EN(PT_C))
{
//ps_search_node->i2_mv_x = (S16)i4_mv_x;
//ps_search_node->i2_mv_x = (S16)i4_mv_y;
/* central pt is i4_mv_x, i4_mv_y */
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel, mvy_qpel, check_for_duplicate);
i4_frac_x = i4_mv_x & 1;
i4_frac_y = i4_mv_y & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref = pu1_ref + (i4_mv_x >> 1) + ((i4_mv_y >> 1) * i4_ref_stride);
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel;
s_result_prms.i2_mv_y = mvy_qpel;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_C;
pu1_final_out = s_err_prms.pu1_ref;
}
}
/* left pt */
if(i4_grid_mask & BIT_EN(PT_L))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel - 2, mvy_qpel, check_for_duplicate);
if(!check_for_duplicate)
{
/* search node mv is stored in qpel units */
ps_search_node->s_mv.i2_mvx = (S16)((i4_mv_x - 1) << 1);
ps_search_node->s_mv.i2_mvy = (S16)(i4_mv_y << 1);
/* central pt is i4_mv_x - 1, i4_mv_y */
i4_frac_x = (i4_mv_x - 1) & 1; // same as (x-1)&1
i4_frac_y = i4_mv_y & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref =
pu1_ref + ((i4_mv_x - 1) >> 1) + ((i4_mv_y >> 1) * i4_ref_stride);
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel;
s_result_prms.i2_mv_y = mvy_qpel;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_L;
pu1_final_out = s_err_prms.pu1_ref;
}
}
}
/* top pt */
if(i4_grid_mask & BIT_EN(PT_T))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel, mvy_qpel - 2, check_for_duplicate);
if(!check_for_duplicate)
{
/* search node mv is stored in qpel units */
ps_search_node->s_mv.i2_mvx = (S16)(i4_mv_x << 1);
ps_search_node->s_mv.i2_mvy = (S16)((i4_mv_y - 1) << 1);
/* top pt is i4_mv_x, i4_mv_y - 1 */
i4_frac_x = i4_mv_x & 1;
i4_frac_y = (i4_mv_y - 1) & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref =
pu1_ref + (i4_mv_x >> 1) + (((i4_mv_y - 1) >> 1) * i4_ref_stride);
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel;
s_result_prms.i2_mv_y = mvy_qpel - 2;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_T;
pu1_final_out = s_err_prms.pu1_ref;
}
}
}
/* right pt */
if(i4_grid_mask & BIT_EN(PT_R))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel + 2, mvy_qpel, check_for_duplicate);
if(!check_for_duplicate)
{
/* search node mv is stored in qpel units */
ps_search_node->s_mv.i2_mvx = (S16)((i4_mv_x + 1) << 1);
ps_search_node->s_mv.i2_mvy = (S16)(i4_mv_y << 1);
/* right pt is i4_mv_x + 1, i4_mv_y */
i4_frac_x = (i4_mv_x + 1) & 1;
i4_frac_y = i4_mv_y & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref =
pu1_ref + ((i4_mv_x + 1) >> 1) + ((i4_mv_y >> 1) * i4_ref_stride);
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel + 2;
s_result_prms.i2_mv_y = mvy_qpel;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_R;
pu1_final_out = s_err_prms.pu1_ref;
}
}
}
/* bottom pt */
if(i4_grid_mask & BIT_EN(PT_B))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel, mvy_qpel + 2, check_for_duplicate);
if(!check_for_duplicate)
{
/* search node mv is stored in qpel units */
ps_search_node->s_mv.i2_mvx = ((S16)i4_mv_x << 1);
ps_search_node->s_mv.i2_mvy = ((S16)(i4_mv_y + 1) << 1);
i4_frac_x = i4_mv_x & 1;
i4_frac_y = (i4_mv_y + 1) & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref =
pu1_ref + (i4_mv_x >> 1) + (((i4_mv_y + 1) >> 1) * i4_ref_stride);
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel;
s_result_prms.i2_mv_y = mvy_qpel + 2;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_B;
pu1_final_out = s_err_prms.pu1_ref;
}
}
}
if(e_min_id == PT_C)
{
if(!i4_i)
{
/* TL pt */
if(i4_grid_mask & BIT_EN(PT_TL))
{
S32 mvx_minus_1 = (i4_mv_x - 1);
S32 mvy_minus_1 = (i4_mv_y - 1);
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel - 2, mvy_qpel - 2, check_for_duplicate);
if(!check_for_duplicate)
{
/* search node mv is stored in qpel units */
ps_search_node->s_mv.i2_mvx = ((S16)mvx_minus_1 << 1);
ps_search_node->s_mv.i2_mvy = ((S16)mvy_minus_1 << 1);
i4_frac_x = mvx_minus_1 & 1;
i4_frac_y = mvy_minus_1 & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref =
pu1_ref + (mvx_minus_1 >> 1) + ((mvy_minus_1 >> 1) * i4_ref_stride);
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel - 2;
s_result_prms.i2_mv_y = mvy_qpel - 2;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_TL;
pu1_final_out = s_err_prms.pu1_ref;
}
}
}
/* TR pt */
if(i4_grid_mask & BIT_EN(PT_TR))
{
S32 mvx_plus_1 = (i4_mv_x + 1);
S32 mvy_minus_1 = (i4_mv_y - 1);
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel + 2, mvy_qpel - 2, check_for_duplicate);
if(!check_for_duplicate)
{
/* search node mv is stored in qpel units */
ps_search_node->s_mv.i2_mvx = ((S16)mvx_plus_1 << 1);
ps_search_node->s_mv.i2_mvy = ((S16)mvy_minus_1 << 1);
i4_frac_x = mvx_plus_1 & 1;
i4_frac_y = mvy_minus_1 & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref =
pu1_ref + (mvx_plus_1 >> 1) + ((mvy_minus_1 >> 1) * i4_ref_stride);
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel + 2;
s_result_prms.i2_mv_y = mvy_qpel - 2;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_TR;
pu1_final_out = s_err_prms.pu1_ref;
}
}
}
/* BL pt */
if(i4_grid_mask & BIT_EN(PT_BL))
{
S32 mvx_minus_1 = (i4_mv_x - 1);
S32 mvy_plus_1 = (i4_mv_y + 1);
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel - 2, mvy_qpel + 2, check_for_duplicate);
if(!check_for_duplicate)
{
/* search node mv is stored in qpel units */
ps_search_node->s_mv.i2_mvx = ((S16)mvx_minus_1 << 1);
ps_search_node->s_mv.i2_mvy = ((S16)mvy_plus_1 << 1);
i4_frac_x = mvx_minus_1 & 1;
i4_frac_y = mvy_plus_1 & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref =
pu1_ref + (mvx_minus_1 >> 1) + ((mvy_plus_1 >> 1) * i4_ref_stride);
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel - 2;
s_result_prms.i2_mv_y = mvy_qpel + 2;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_BL;
pu1_final_out = s_err_prms.pu1_ref;
}
}
}
/* BR pt */
if(i4_grid_mask & BIT_EN(PT_BR))
{
S32 mvx_plus_1 = (i4_mv_x + 1);
S32 mvy_plus_1 = (i4_mv_y + 1);
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel + 2, mvy_qpel + 2, check_for_duplicate);
if(!check_for_duplicate)
{
/* search node mv is stored in qpel units */
ps_search_node->s_mv.i2_mvx = ((S16)mvx_plus_1 << 1);
ps_search_node->s_mv.i2_mvy = ((S16)mvy_plus_1 << 1);
i4_frac_x = mvx_plus_1 & 1;
i4_frac_y = mvy_plus_1 & 1;
pu1_ref = apu1_hpel_ref[i4_frac_y * 2 + i4_frac_x];
s_err_prms.pu1_ref =
pu1_ref + (mvx_plus_1 >> 1) + ((mvy_plus_1 >> 1) * i4_ref_stride);
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel + 2;
s_result_prms.i2_mv_y = mvy_qpel + 2;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
e_min_id = PT_BR;
pu1_final_out = s_err_prms.pu1_ref;
}
}
}
if(e_min_id == PT_C)
{
break;
}
}
else
{
break;
}
}
/*********************************************************************/
/* Depending on the best result location, we may be able to skip */
/* atleast two pts, centre pt and one more pt. E.g. if right pt is */
/* the best result, the next iteration need not do centre, left pts */
/*********************************************************************/
if(i4_i)
{
i4_grid_mask = gai4_opt_grid_mask_diamond[e_min_id];
}
else
{
i4_grid_mask = gai4_opt_grid_mask_conventional[e_min_id];
}
i4_mv_x += gai1_grid_id_to_x[e_min_id];
i4_mv_y += gai1_grid_id_to_y[e_min_id];
ps_search_node->s_mv.i2_mvx = (S16)(i4_mv_x << 1);
ps_search_node->s_mv.i2_mvy = (S16)(i4_mv_y << 1);
i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 2, ps_range_prms);
}
/* Convert to QPEL units */
i4_mv_x <<= 1;
i4_mv_y <<= 1;
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
/* Early exit if this partition is visiting same hpel mv again */
/* Assumption : Checkin for early exit in best result of partition */
if((ps_search_results->aps_part_results[search_idx][part_id][0].i2_best_hpel_mv_x ==
ps_search_node->s_mv.i2_mvx) &&
(ps_search_results->aps_part_results[search_idx][part_id][0].i2_best_hpel_mv_y ==
ps_search_node->s_mv.i2_mvy))
{
return (ps_search_results->aps_part_results[search_idx][part_id][0].i4_tot_cost);
}
else
{
/* Store the best hpel mv for future early exit checks */
ps_search_results->aps_part_results[search_idx][part_id][0].i2_best_hpel_mv_x =
(S16)i4_mv_x;
ps_search_results->aps_part_results[search_idx][part_id][0].i2_best_hpel_mv_y =
(S16)i4_mv_y;
}
/* Early exit if this partition is visiting same hpel mv again */
/* Assumption : Checkin for early exit in second best result of partition */
if((ps_search_results->aps_part_results[search_idx][part_id][1].i2_best_hpel_mv_x ==
ps_search_node->s_mv.i2_mvx) &&
(ps_search_results->aps_part_results[search_idx][part_id][1].i2_best_hpel_mv_y ==
ps_search_node->s_mv.i2_mvy))
{
return (ps_search_results->aps_part_results[search_idx][part_id][1].i4_tot_cost);
}
else
{
/* Store the best hpel mv for future early exit checks */
ps_search_results->aps_part_results[search_idx][part_id][1].i2_best_hpel_mv_x =
(S16)i4_mv_x;
ps_search_results->aps_part_results[search_idx][part_id][1].i2_best_hpel_mv_y =
(S16)i4_mv_y;
}
/* Exact interpolation or averaging chosen here */
pf_qpel_interp = ps_prms->pf_qpel_interp;
/* Next QPEL ME */
/* In this case, we have option of doing exact QPEL interpolation or avg */
/*************************************************************************/
/* x */
/* A b C d */
/* e f g h */
/* I j K l */
/* m n o p */
/* Q r S t */
/* */
/* Approximate QPEL logic */
/* b = avg(A,C) f = avg(I,C), g= avg(C,K) j=avg(I,K) */
/* for any given pt, we can get all the information required about */
/* the surrounding 4 pts. For example, given point C (0.5, 0) */
/* surrounding pts info: */
/* b : qpel offset: 1, 0, generated by averaging. buffer1: fpel buf */
/* buffer 2: hxfy, offsets for both are 0, 0 */
/* similarly for other pts the info can be gotten */
/*************************************************************************/
i4_grid_mask = GRID_ALL_PTS_VALID ^ (BIT_EN(PT_C));
i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 1, ps_range_prms);
/*************************************************************************/
/* One time preparation of non changing interpolation params. These */
/* include a set of ping pong result buf ptrs, input buf ptrs and some */
/* working memory (not used though in case of averaging). */
/*************************************************************************/
s_interp_prms.ppu1_ref = &apu1_hpel_ref[0];
s_interp_prms.i4_ref_stride = i4_ref_stride;
s_interp_prms.i4_blk_wd = i4_blk_wd;
s_interp_prms.i4_blk_ht = i4_blk_ht;
i4_final_out_stride = i4_ref_stride;
{
U08 *pu1_mem;
/*********************************************************************/
/* Allocation of working memory for interpolated buffers. We maintain*/
/* an intermediate working buffer, and 2 ping pong interpolated out */
/* buffers, purpose of ping pong explained later below */
/*********************************************************************/
pu1_mem = ps_prms->pu1_wkg_mem;
s_interp_prms.pu1_wkg_mem = pu1_mem;
//pu1_mem += (INTERP_INTERMED_BUF_SIZE);
s_interp_prms.apu1_interp_out[0] = pu1_mem;
pu1_mem += (INTERP_OUT_BUF_SIZE);
s_interp_prms.apu1_interp_out[1] = pu1_mem;
pu1_mem += (INTERP_OUT_BUF_SIZE);
s_interp_prms.apu1_interp_out[2] = pu1_mem;
pu1_mem += (INTERP_OUT_BUF_SIZE);
s_interp_prms.apu1_interp_out[3] = pu1_mem;
pu1_mem += (INTERP_OUT_BUF_SIZE);
s_interp_prms.apu1_interp_out[4] = pu1_mem;
/*********************************************************************/
/* Stride of interpolated output is just a function of blk width of */
/* this partition and hence remains constant for this partition */
/*********************************************************************/
s_interp_prms.i4_out_stride = (i4_blk_wd);
}
{
UWORD8 *apu1_final[4];
WORD32 ai4_ref_stride[4];
/*************************************************************************/
/* Ping pong design for interpolated buffers. We use a min id, which */
/* tracks the id of the ppu1_interp_out that stores the best result. */
/* When new interp to be done, it uses 1 - bes result id to do the interp*/
/* min id is toggled when any new result becomes the best result. */
/*************************************************************************/
for(i4_i = 0; i4_i < i4_num_qpel_refine; i4_i++)
{
e_min_id = PT_C;
hme_qpel_interp_comprehensive(
&s_interp_prms, apu1_final, ai4_ref_stride, i4_mv_x, i4_mv_y, i4_grid_mask);
mvx_qpel = i4_mv_x;
mvy_qpel = i4_mv_y;
if(i4_grid_mask & BIT_EN(PT_L))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel - 1, mvy_qpel - 0, check_for_duplicate);
if(!check_for_duplicate)
{
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x - 1;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
s_err_prms.pu1_ref = apu1_final[0];
s_err_prms.i4_ref_stride = ai4_ref_stride[0];
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel - 1;
s_result_prms.i2_mv_y = mvy_qpel;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
e_min_id = PT_L;
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
}
}
}
if(i4_grid_mask & BIT_EN(PT_T))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel - 0, mvy_qpel - 1, check_for_duplicate);
if(!check_for_duplicate)
{
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y - 1;
s_err_prms.pu1_ref = apu1_final[1];
s_err_prms.i4_ref_stride = ai4_ref_stride[1];
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel;
s_result_prms.i2_mv_y = mvy_qpel - 1;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
e_min_id = PT_T;
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
}
}
}
if(i4_grid_mask & BIT_EN(PT_R))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel + 1, mvy_qpel, check_for_duplicate);
if(!check_for_duplicate)
{
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x + 1;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
s_err_prms.pu1_ref = apu1_final[2];
s_err_prms.i4_ref_stride = ai4_ref_stride[2];
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel + 1;
s_result_prms.i2_mv_y = mvy_qpel;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
e_min_id = PT_R;
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
}
}
}
/* i4_mv_x and i4_mv_y will always be the centre pt */
/* for qpel we start with least hpel, and hence compute of center pt never reqd */
if(i4_grid_mask & BIT_EN(PT_B))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel, mvy_qpel + 1, check_for_duplicate);
if(!check_for_duplicate)
{
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y + 1;
s_err_prms.pu1_ref = apu1_final[3];
s_err_prms.i4_ref_stride = ai4_ref_stride[3];
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel;
s_result_prms.i2_mv_y = mvy_qpel + 1;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
e_min_id = PT_B;
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
}
}
}
if(e_min_id == PT_C)
{
if(!i4_i)
{
S32 i4_interp_buf_id = 0;
if(i4_grid_mask & BIT_EN(PT_TL))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel - 1, mvy_qpel - 1, check_for_duplicate);
if(!check_for_duplicate)
{
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x - 1;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y - 1;
/* Carry out the interpolation */
pf_qpel_interp(
&s_interp_prms, i4_mv_x - 1, i4_mv_y - 1, i4_interp_buf_id);
s_err_prms.pu1_ref = s_interp_prms.pu1_final_out;
s_err_prms.i4_ref_stride = s_interp_prms.i4_final_out_stride;
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel - 1;
s_result_prms.i2_mv_y = mvy_qpel - 1;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
e_min_id = PT_TL;
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
}
}
}
if(i4_grid_mask & BIT_EN(PT_TR))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel + 1, mvy_qpel - 1, check_for_duplicate);
if(!check_for_duplicate)
{
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x + 1;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y - 1;
/* Carry out the interpolation */
pf_qpel_interp(
&s_interp_prms, i4_mv_x + 1, i4_mv_y - 1, i4_interp_buf_id);
s_err_prms.pu1_ref = s_interp_prms.pu1_final_out;
s_err_prms.i4_ref_stride = s_interp_prms.i4_final_out_stride;
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel + 1;
s_result_prms.i2_mv_y = mvy_qpel - 1;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
e_min_id = PT_TR;
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
}
}
}
if(i4_grid_mask & BIT_EN(PT_BL))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel - 1, mvy_qpel + 1, check_for_duplicate);
if(!check_for_duplicate)
{
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x - 1;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y + 1;
/* Carry out the interpolation */
pf_qpel_interp(
&s_interp_prms, i4_mv_x - 1, i4_mv_y + 1, i4_interp_buf_id);
s_err_prms.pu1_ref = s_interp_prms.pu1_final_out;
s_err_prms.i4_ref_stride = s_interp_prms.i4_final_out_stride;
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel - 1;
s_result_prms.i2_mv_y = mvy_qpel + 1;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
e_min_id = PT_BL;
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
}
}
}
/* i4_mv_x and i4_mv_y will always be the centre pt */
/* for qpel we start with least hpel, and hence compute of center pt never reqd */
if(i4_grid_mask & BIT_EN(PT_BR))
{
CHECK_FOR_DUPES_AND_INSERT_UNIQUE_NODES(
ps_dedup_enabler, 1, mvx_qpel + 1, mvy_qpel + 1, check_for_duplicate);
if(!check_for_duplicate)
{
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x + 1;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y + 1;
/* Carry out the interpolation */
pf_qpel_interp(
&s_interp_prms, i4_mv_x + 1, i4_mv_y + 1, i4_interp_buf_id);
s_err_prms.pu1_ref = s_interp_prms.pu1_final_out;
s_err_prms.i4_ref_stride = s_interp_prms.i4_final_out_stride;
pf_err_compute(&s_err_prms);
/* Update the mv's with the current candt motion vectors */
s_result_prms.i2_mv_x = mvx_qpel + 1;
s_result_prms.i2_mv_y = mvy_qpel + 1;
hme_update_results_pt_pu_best1_subpel_hs(&s_result_prms);
i4_tot_cost = s_err_prms.pi4_sad_grid[part_id];
if(i4_tot_cost < i4_min_cost)
{
e_min_id = PT_BR;
i4_min_cost = i4_tot_cost;
i4_min_sad = s_err_prms.pi4_sad_grid[part_id];
}
}
}
if(e_min_id == PT_C)
{
break;
}
}
else
{
break;
}
}
if(i4_i)
{
i4_grid_mask = gai4_opt_grid_mask_diamond[e_min_id];
}
else
{
i4_grid_mask = gai4_opt_grid_mask_conventional[e_min_id];
}
i4_mv_x += gai1_grid_id_to_x[e_min_id];
i4_mv_y += gai1_grid_id_to_y[e_min_id];
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
i4_grid_mask &= hme_clamp_grid_by_mvrange(ps_search_node, 1, ps_range_prms);
}
}
/* update modified motion vectors and cost at end of subpel */
ps_search_node->s_mv.i2_mvx = (S16)i4_mv_x;
ps_search_node->s_mv.i2_mvy = (S16)i4_mv_y;
ps_search_node->i4_tot_cost = i4_min_cost;
ps_search_node->i4_sad = i4_min_sad;
/********************************************************************************/
/* TODO: Restoring back Sad lambda from Hadamard lambda */
/* Need to pass the had/satd lambda in more cleaner way for subpel cost compute */
/********************************************************************************/
//ps_pred_ctxt->lambda >>= 1;
return (i4_min_cost);
}
#endif
static void hme_subpel_refine_struct_to_search_results_struct_converter(
subpel_refine_ctxt_t *ps_subpel_refine_ctxt,
search_results_t *ps_search_results,
U08 u1_pred_dir,
ME_QUALITY_PRESETS_T e_quality_preset)
{
U08 i;
U08 u1_num_results_per_part = ps_search_results->u1_num_results_per_part;
for(i = 0; i < ps_subpel_refine_ctxt->i4_num_valid_parts; i++)
{
S32 index;
S32 i4_sad;
S32 part_id = ps_subpel_refine_ctxt->ai4_part_id[i];
search_node_t *ps_best_node = ps_search_results->aps_part_results[u1_pred_dir][part_id];
if(ps_subpel_refine_ctxt->i4_num_valid_parts > 8)
{
index = part_id;
}
else
{
index = i;
}
if(!ps_best_node->u1_subpel_done)
{
i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[0][index] -
ps_subpel_refine_ctxt->i2_mv_cost[0][index];
ps_best_node[0].i4_sdi = 0;
ASSERT((e_quality_preset == ME_PRISTINE_QUALITY) ? (ps_best_node[0].i4_sdi >= 0) : 1);
ps_best_node[0].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[0][index];
if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] == MAX_SIGNED_16BIT_VAL)
{
i4_sad = MAX_SIGNED_16BIT_VAL;
}
ps_best_node[0].i4_sad = i4_sad;
ps_best_node[0].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];
ps_best_node[0].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
ps_best_node[0].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
ps_best_node[0].i1_ref_idx = (WORD8)ps_subpel_refine_ctxt->i2_ref_idx[0][index];
ps_best_node->u1_subpel_done = 1;
if(2 == u1_num_results_per_part)
{
i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[1][index] -
ps_subpel_refine_ctxt->i2_mv_cost[1][index];
ps_best_node[1].i4_sdi = 0;
ps_best_node[1].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[1][index];
if(ps_subpel_refine_ctxt->i2_tot_cost[1][index] == MAX_SIGNED_16BIT_VAL)
{
i4_sad = MAX_SIGNED_16BIT_VAL;
}
ps_best_node[1].i4_sad = i4_sad;
ps_best_node[1].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[1][index];
ps_best_node[1].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[1][index];
ps_best_node[1].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[1][index];
ps_best_node[1].i1_ref_idx = (WORD8)ps_subpel_refine_ctxt->i2_ref_idx[1][index];
ps_best_node[1].u1_subpel_done = 1;
}
}
else if(
(2 == u1_num_results_per_part) &&
(ps_subpel_refine_ctxt->i2_tot_cost[0][index] < ps_best_node[1].i4_tot_cost))
{
if(ps_subpel_refine_ctxt->i2_tot_cost[1][index] < ps_best_node[0].i4_tot_cost)
{
i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[0][index] -
ps_subpel_refine_ctxt->i2_mv_cost[0][index];
ps_best_node[0].i4_sdi = 0;
ps_best_node[0].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[0][index];
if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] == MAX_SIGNED_16BIT_VAL)
{
i4_sad = MAX_SIGNED_16BIT_VAL;
}
ps_best_node[0].i4_sad = i4_sad;
ps_best_node[0].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];
ps_best_node[0].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
ps_best_node[0].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
ps_best_node[0].i1_ref_idx = (S08)ps_subpel_refine_ctxt->i2_ref_idx[0][index];
i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[1][index] -
ps_subpel_refine_ctxt->i2_mv_cost[1][index];
ps_best_node[1].i4_sdi = 0;
ps_best_node[1].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[1][index];
if(ps_subpel_refine_ctxt->i2_tot_cost[1][index] == MAX_SIGNED_16BIT_VAL)
{
i4_sad = MAX_SIGNED_16BIT_VAL;
}
ps_best_node[1].i4_sad = i4_sad;
ps_best_node[1].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[1][index];
ps_best_node[1].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[1][index];
ps_best_node[1].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[1][index];
ps_best_node[1].i1_ref_idx = (S08)ps_subpel_refine_ctxt->i2_ref_idx[1][index];
}
else if(ps_subpel_refine_ctxt->i2_tot_cost[1][index] > ps_best_node[0].i4_tot_cost)
{
if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] >= ps_best_node[0].i4_tot_cost)
{
i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[0][index] -
ps_subpel_refine_ctxt->i2_mv_cost[0][index];
ps_best_node[1].i4_sdi = 0;
ps_best_node[1].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[0][index];
if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] == MAX_SIGNED_16BIT_VAL)
{
i4_sad = MAX_SIGNED_16BIT_VAL;
}
ps_best_node[1].i4_sad = i4_sad;
ps_best_node[1].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];
ps_best_node[1].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
ps_best_node[1].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
ps_best_node[1].i1_ref_idx = (S08)ps_subpel_refine_ctxt->i2_ref_idx[0][index];
}
else if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] < ps_best_node[0].i4_tot_cost)
{
memmove(&ps_best_node[1], &ps_best_node[0], sizeof(search_node_t));
i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[0][index] -
ps_subpel_refine_ctxt->i2_mv_cost[0][index];
ps_best_node[0].i4_sdi = 0;
ps_best_node[0].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[0][index];
if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] == MAX_SIGNED_16BIT_VAL)
{
i4_sad = MAX_SIGNED_16BIT_VAL;
}
ps_best_node[0].i4_sad = i4_sad;
ps_best_node[0].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];
ps_best_node[0].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
ps_best_node[0].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
ps_best_node[0].i1_ref_idx = (S08)ps_subpel_refine_ctxt->i2_ref_idx[0][index];
}
}
}
else if(
(1 == u1_num_results_per_part) &&
(ps_subpel_refine_ctxt->i2_tot_cost[0][index] < ps_best_node[0].i4_tot_cost))
{
i4_sad = ps_subpel_refine_ctxt->i2_tot_cost[0][index] -
ps_subpel_refine_ctxt->i2_mv_cost[0][index];
ps_best_node[0].i4_sdi = 0;
ps_best_node[0].i4_tot_cost = ps_subpel_refine_ctxt->i2_tot_cost[0][index];
if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] == MAX_SIGNED_16BIT_VAL)
{
i4_sad = MAX_SIGNED_16BIT_VAL;
}
ps_best_node[0].i4_sad = i4_sad;
ps_best_node[0].i4_mv_cost = ps_subpel_refine_ctxt->i2_mv_cost[0][index];
ps_best_node[0].s_mv.i2_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
ps_best_node[0].s_mv.i2_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
ps_best_node[0].i1_ref_idx = (S08)ps_subpel_refine_ctxt->i2_ref_idx[0][index];
}
}
}
/**
********************************************************************************
* @fn S32 hme_subpel_refine_cu_hs
*
* @brief Evaluates the best subpel mvs for active partitions of an MB in L0
* layer for the high speed preset. Recursive hadamard SATD / SAD
* and mv cost is used for 2NxN and NxN partitions with active partition
* update
*
* @param[in] ps_prms: subpel prms input to this function
*
* @param[in] ps_curr_layer: points to the current layer ctxt
*
* @param[out] ps_search_results: points to the search resutls that get updated
* with best results
*
* @param[in] search_idx: ref id of the frame for which results get updated
*
* @param[in] ps_wt_inp_prms: current frame input params
*
* @return None
********************************************************************************
*/
void hme_subpel_refine_cu_hs(
hme_subpel_prms_t *ps_prms,
layer_ctxt_t *ps_curr_layer,
search_results_t *ps_search_results,
S32 search_idx,
wgt_pred_ctxt_t *ps_wt_inp_prms,
WORD32 blk_8x8_mask,
me_func_selector_t *ps_func_selector,
ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list,
ihevce_me_optimised_function_list_t *ps_me_optimised_function_list)
{
/* Unique search node list for 2nx2n and nxn partitions */
search_node_t as_nodes_2nx2n[MAX_RESULTS_PER_PART * 5];
subpel_dedup_enabler_t as_subpel_dedup_enabler[MAX_NUM_REF];
search_node_t *ps_search_node;
S32 i, i4_part_mask, j;
S32 i4_sad_grid;
S32 max_subpel_cand;
WORD32 index;
S32 num_unique_nodes_2nx2n;
S32 part_id;
S32 x_off, y_off;
S32 i4_inp_off;
CU_SIZE_T e_cu_size;
BLK_SIZE_T e_blk_size;
subpel_refine_ctxt_t *ps_subpel_refine_ctxt = ps_prms->ps_subpel_refine_ctxt;
S32 i4_use_satd = ps_prms->i4_use_satd;
S32 i4_num_act_refs = ps_prms->i4_num_act_ref_l0 + ps_prms->i4_num_act_ref_l1;
ASSERT(ps_search_results->u1_num_results_per_part <= MAX_RESULTS_PER_PART);
if(!DISABLE_SUBPEL_REFINEMENT_WHEN_SRC_IS_NOISY || !ps_prms->u1_is_cu_noisy)
{
e_cu_size = ps_search_results->e_cu_size;
i4_part_mask = ps_search_results->i4_part_mask;
ps_prms->i4_inp_type = sizeof(U08);
num_unique_nodes_2nx2n = 0;
for(i = 0; i < i4_num_act_refs; i++)
{
as_subpel_dedup_enabler[i].u1_ref_idx = MAX_NUM_REF;
}
/************************************************************************/
/* */
/* Initialize SATD cost for each valid partition id.one time before */
/* doing full pel time. This is because of the following reasons: */
/* 1. Full pel cost was done in SAD while subpel is in SATD mode */
/* 2. Partitions like AMP, Nx2N and 2NxN are refined on the fly while */
/* doing Diamond search for 2Nx2N and NxN. This partitions are */
/* not explicitly refine in high speed mode */
/* */
/************************************************************************/
for(i = 0; i < ps_subpel_refine_ctxt->i4_num_valid_parts; i++)
{
S32 enable_subpel = 0;
S32 part_type;
/* Derive the x and y offsets of this part id */
part_id = ps_subpel_refine_ctxt->ai4_part_id[i];
if(ps_subpel_refine_ctxt->i4_num_valid_parts > 8)
{
index = part_id;
}
else
{
index = i;
}
part_type = ge_part_id_to_part_type[part_id];
x_off = gas_part_attr_in_cu[part_id].u1_x_start << e_cu_size;
y_off = gas_part_attr_in_cu[part_id].u1_y_start << e_cu_size;
x_off += ps_search_results->u1_x_off;
y_off += ps_search_results->u1_y_off;
i4_inp_off = x_off + y_off * ps_prms->i4_inp_stride;
e_blk_size = ge_part_id_to_blk_size[e_cu_size][part_id];
x_off += ps_prms->i4_ctb_x_off;
y_off += ps_prms->i4_ctb_y_off;
max_subpel_cand = 0;
/* Choose the minimum number of candidates to be used for Sub pel refinement */
if(PART_ID_2Nx2N == part_type)
{
max_subpel_cand =
MIN(ps_prms->u1_max_subpel_candts_2Nx2N,
ps_search_results->u1_num_results_per_part);
}
else if(PRT_NxN == part_type)
{
max_subpel_cand = MIN(
ps_prms->u1_max_subpel_candts_NxN, ps_search_results->u1_num_results_per_part);
}
/* If incomplete CTB, NxN num candidates should be forced to min 1 */
if((0 == max_subpel_cand) && (blk_8x8_mask != 15))
{
max_subpel_cand = 1;
}
if((PART_ID_2Nx2N == part_type) || (PRT_NxN == part_type))
{
enable_subpel = 1;
}
/* Compute full pel SATD for each result per partition before subpel */
/* refinement starts. */
/* Also prepare unique candidate list for 2Nx2N and NxN partitions */
for(j = 0; j < ps_search_results->u1_num_results_per_part; j++)
{
err_prms_t s_err_prms;
S32 i4_satd = 0;
S32 i1_ref_idx;
U08 *pu1_ref_base;
S32 i4_ref_stride = ps_curr_layer->i4_rec_stride;
S32 i4_mv_x, i4_mv_y;
ps_search_node = ps_search_results->aps_part_results[search_idx][part_id] + j;
if(ps_subpel_refine_ctxt->i2_mv_x[j][index] == INTRA_MV)
{
ps_search_node->u1_subpel_done = 1;
continue;
}
i1_ref_idx = ps_subpel_refine_ctxt->i2_ref_idx[j][index];
ps_prms->pv_inp = (void *)(ps_wt_inp_prms->apu1_wt_inp[i1_ref_idx] + i4_inp_off);
pu1_ref_base = ps_curr_layer->ppu1_list_rec_fxfy[i1_ref_idx];
i4_mv_x = ps_subpel_refine_ctxt->i2_mv_x[j][index];
i4_mv_y = ps_subpel_refine_ctxt->i2_mv_y[j][index];
if(i4_use_satd)
{
s_err_prms.pu1_inp = (U08 *)ps_prms->pv_inp;
s_err_prms.i4_inp_stride = ps_prms->i4_inp_stride;
s_err_prms.pu1_ref = pu1_ref_base + x_off + (y_off * i4_ref_stride) + i4_mv_x +
(i4_mv_y * i4_ref_stride);
s_err_prms.i4_ref_stride = i4_ref_stride;
s_err_prms.i4_part_mask = (ENABLE_2Nx2N);
s_err_prms.i4_grid_mask = 1;
s_err_prms.pi4_sad_grid = &i4_sad_grid;
s_err_prms.i4_blk_wd = gau1_blk_size_to_wd[e_blk_size];
s_err_prms.i4_blk_ht = gau1_blk_size_to_ht[e_blk_size];
s_err_prms.ps_cmn_utils_optimised_function_list =
ps_cmn_utils_optimised_function_list;
compute_satd_8bit(&s_err_prms);
i4_satd = s_err_prms.pi4_sad_grid[0];
ps_subpel_refine_ctxt->i2_tot_cost[j][index] =
CLIP_S16(ps_subpel_refine_ctxt->i2_mv_cost[j][index] + i4_satd);
ps_subpel_refine_ctxt->ai2_fullpel_satd[j][index] = i4_satd;
}
/* Sub-pel candidate filtration */
if(j)
{
S16 i2_best_sad;
S32 i4_best_mvx;
S32 i4_best_mvy;
search_node_t *ps_node =
ps_search_results->aps_part_results[search_idx][part_id];
U08 u1_is_subpel_done = ps_node->u1_subpel_done;
S16 i2_curr_sad = ps_subpel_refine_ctxt->ai2_fullpel_satd[j][index];
S32 i4_curr_mvx = i4_mv_x << 2;
S32 i4_curr_mvy = i4_mv_y << 2;
if(u1_is_subpel_done)
{
i2_best_sad = ps_node->i4_sad;
if(ps_node->i1_ref_idx == i1_ref_idx)
{
i4_best_mvx = ps_node->s_mv.i2_mvx;
i4_best_mvy = ps_node->s_mv.i2_mvy;
}
else if(i1_ref_idx == ps_subpel_refine_ctxt->i2_ref_idx[0][index])
{
i4_best_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
i4_best_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
}
else
{
i4_best_mvx = INTRA_MV;
i4_best_mvy = INTRA_MV;
}
}
else
{
i2_best_sad = ps_subpel_refine_ctxt->i2_tot_cost[0][index] -
ps_subpel_refine_ctxt->i2_mv_cost[0][index];
if(i1_ref_idx == ps_subpel_refine_ctxt->i2_ref_idx[0][index])
{
i4_best_mvx = ps_subpel_refine_ctxt->i2_mv_x[0][index];
i4_best_mvy = ps_subpel_refine_ctxt->i2_mv_y[0][index];
}
else
{
i4_best_mvx = INTRA_MV;
i4_best_mvy = INTRA_MV;
}
}
i2_best_sad += (i2_best_sad >> ps_prms->u1_subpel_candt_threshold);
if(((ABS(i4_curr_mvx - i4_best_mvx) < 2) &&
(ABS(i4_curr_mvy - i4_best_mvy) < 2)) ||
(i2_curr_sad > i2_best_sad))
{
enable_subpel = 0;
}
}
ps_search_node->u1_part_id = part_id;
/* Convert mvs in part results from FPEL to QPEL units */
ps_subpel_refine_ctxt->i2_mv_x[j][index] <<= 2;
ps_subpel_refine_ctxt->i2_mv_y[j][index] <<= 2;
/* If the candidate number is more than the number of candts
set initally, do not add those candts for refinement */
if(j >= max_subpel_cand)
{
enable_subpel = 0;
}
if(enable_subpel)
{
if(num_unique_nodes_2nx2n == 0)
{
S32 i4_index = ps_subpel_refine_ctxt->i2_ref_idx[j][index];
as_subpel_dedup_enabler[i4_index].i2_mv_x =
ps_subpel_refine_ctxt->i2_mv_x[j][index];
as_subpel_dedup_enabler[i4_index].i2_mv_y =
ps_subpel_refine_ctxt->i2_mv_y[j][index];
as_subpel_dedup_enabler[i4_index].u1_ref_idx =
(U08)ps_subpel_refine_ctxt->i2_ref_idx[j][index];
memset(
as_subpel_dedup_enabler[i4_index].au4_node_map,
0,
sizeof(U32) * 2 * MAP_X_MAX);
}
INSERT_NEW_NODE_NOMAP_ALTERNATE(
as_nodes_2nx2n, num_unique_nodes_2nx2n, ps_subpel_refine_ctxt, j, i);
}
}
/*********************************************************************************************/
/* If sad_1 < sad_2, then satd_1 need not be lesser than satd_2. Therefore, after conversion */
/* to satd, tot_cost_1 may not be lesser than tot_cost_2. So we need to sort the search nodes*/
/* for each partition again, based on the new costs */
/*********************************************************************************************/
/*********************************************************************************************/
/* Because right now, we store only the two best candidates for each partition, the sort will*/
/* converge to a simple swap. */
/* ASSUMPTION : We store only two best results per partition */
/*********************************************************************************************/
if(ps_search_results->u1_num_results_per_part == 2)
{
if(ps_subpel_refine_ctxt->i2_tot_cost[0][index] >
ps_subpel_refine_ctxt->i2_tot_cost[1][index])
{
SWAP(
ps_subpel_refine_ctxt->i2_tot_cost[0][index],
ps_subpel_refine_ctxt->i2_tot_cost[1][index]);
SWAP(
ps_subpel_refine_ctxt->i2_mv_cost[0][index],
ps_subpel_refine_ctxt->i2_mv_cost[1][index]);
SWAP(
ps_subpel_refine_ctxt->i2_mv_x[0][index],
ps_subpel_refine_ctxt->i2_mv_x[1][index]);
SWAP(
ps_subpel_refine_ctxt->i2_mv_y[0][index],
ps_subpel_refine_ctxt->i2_mv_y[1][index]);
SWAP(
ps_subpel_refine_ctxt->i2_ref_idx[0][index],
ps_subpel_refine_ctxt->i2_ref_idx[1][index]);
SWAP(
ps_subpel_refine_ctxt->ai2_fullpel_satd[0][index],
ps_subpel_refine_ctxt->ai2_fullpel_satd[1][index]);
}
}
}
if(blk_8x8_mask == 0xf)
{
num_unique_nodes_2nx2n =
MIN(num_unique_nodes_2nx2n, ps_prms->u1_max_num_subpel_refine_centers);
}
{
x_off = gas_part_attr_in_cu[0].u1_x_start << e_cu_size;
y_off = gas_part_attr_in_cu[0].u1_y_start << e_cu_size;
x_off += ps_search_results->u1_x_off;
y_off += ps_search_results->u1_y_off;
i4_inp_off = x_off + y_off * ps_prms->i4_inp_stride;
e_blk_size = ge_part_id_to_blk_size[e_cu_size][0];
for(j = 0; j < num_unique_nodes_2nx2n; j++)
{
S32 pred_lx;
ps_search_node = &as_nodes_2nx2n[j];
if(ps_search_node->s_mv.i2_mvx == INTRA_MV)
{
continue;
}
{
S08 i1_ref_idx = ps_search_node->i1_ref_idx;
subpel_dedup_enabler_t *ps_dedup_enabler =
&(as_subpel_dedup_enabler[i1_ref_idx]);
if(ps_dedup_enabler->u1_ref_idx == MAX_NUM_REF)
{
as_subpel_dedup_enabler[i1_ref_idx].i2_mv_x = ps_search_node->s_mv.i2_mvx;
as_subpel_dedup_enabler[i1_ref_idx].i2_mv_y = ps_search_node->s_mv.i2_mvy;
as_subpel_dedup_enabler[i1_ref_idx].u1_ref_idx = i1_ref_idx;
memset(
as_subpel_dedup_enabler[i1_ref_idx].au4_node_map,
0,
sizeof(U32) * 2 * MAP_X_MAX);
}
}
pred_lx = search_idx;
ps_prms->pv_inp =
(void *)(ps_wt_inp_prms->apu1_wt_inp[ps_search_node->i1_ref_idx] + i4_inp_off);
hme_subpel_refine_search_node_high_speed(
ps_search_node,
ps_prms,
ps_curr_layer,
e_blk_size,
x_off + ps_prms->i4_ctb_x_off,
y_off + ps_prms->i4_ctb_y_off,
ps_search_results,
pred_lx,
i4_part_mask,
&ps_subpel_refine_ctxt->ai4_part_id[0],
search_idx,
&(as_subpel_dedup_enabler[ps_search_node->i1_ref_idx]),
ps_func_selector,
ps_me_optimised_function_list);
}
}
}
else
{
for(i = 0; i < ps_subpel_refine_ctxt->i4_num_valid_parts; i++)
{
S32 i4_index;
S32 i4_part_id = ps_subpel_refine_ctxt->ai4_part_id[i];
if(ps_subpel_refine_ctxt->i4_num_valid_parts > 8)
{
i4_index = i4_part_id;
}
else
{
i4_index = i;
}
for(j = 0; j < ps_search_results->u1_num_results_per_part; j++)
{
ps_subpel_refine_ctxt->i2_mv_x[j][i4_index] <<= 2;
ps_subpel_refine_ctxt->i2_mv_y[j][i4_index] <<= 2;
}
}
}
hme_subpel_refine_struct_to_search_results_struct_converter(
ps_subpel_refine_ctxt, ps_search_results, search_idx, ps_prms->e_me_quality_presets);
}
Reference in New Issue View Git Blame Copy Permalink