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

10669 lines
417 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_refine.c
*
* @brief
* Contains the implementation of the refinement layer searches and related
* functionality like CU merge.
*
* @author
* Ittiam
*
*
* List of Functions
*
*
******************************************************************************
*/
/*****************************************************************************/
/* 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"
/*****************************************************************************/
/* Globals */
/*****************************************************************************/
/* brief: mapping buffer to convert raster scan indices into z-scan oder in a ctb */
UWORD8 gau1_raster_scan_to_ctb[4][4] = {
{ 0, 4, 16, 20 }, { 8, 12, 24, 28 }, { 32, 36, 48, 52 }, { 40, 44, 56, 60 }
};
/*****************************************************************************/
/* Extern Fucntion declaration */
/*****************************************************************************/
extern ctb_boundary_attrs_t *
get_ctb_attrs(S32 ctb_start_x, S32 ctb_start_y, S32 pic_wd, S32 pic_ht, me_frm_ctxt_t *ps_ctxt);
typedef void (*PF_HME_PROJECT_COLOC_CANDT_FXN)(
search_node_t *ps_search_node,
layer_ctxt_t *ps_curr_layer,
layer_ctxt_t *ps_coarse_layer,
S32 i4_pos_x,
S32 i4_pos_y,
S08 i1_ref_id,
S32 i4_result_id);
typedef void (*PF_HME_PROJECT_COLOC_CANDT_L0_ME_FXN)(
search_node_t *ps_search_node,
layer_ctxt_t *ps_curr_layer,
layer_ctxt_t *ps_coarse_layer,
S32 i4_pos_x,
S32 i4_pos_y,
S32 i4_num_act_ref_l0,
U08 u1_pred_dir,
U08 u1_default_ref_id,
S32 i4_result_id);
/*****************************************************************************/
/* Function Definitions */
/*****************************************************************************/
void ihevce_no_wt_copy(
coarse_me_ctxt_t *ps_ctxt,
layer_ctxt_t *ps_curr_layer,
pu_t *ps_pu,
UWORD8 *pu1_temp_pred,
WORD32 temp_stride,
WORD32 blk_x,
WORD32 blk_y)
{
UWORD8 *pu1_ref;
WORD32 ref_stride, ref_offset;
WORD32 row, col, i4_tmp;
ASSERT((ps_pu->b2_pred_mode == PRED_L0) || (ps_pu->b2_pred_mode == PRED_L1));
if(ps_pu->b2_pred_mode == PRED_L0)
{
WORD8 i1_ref_idx;
i1_ref_idx = ps_pu->mv.i1_l0_ref_idx;
pu1_ref = ps_curr_layer->ppu1_list_inp[i1_ref_idx];
ref_stride = ps_curr_layer->i4_inp_stride;
ref_offset = ((blk_y << 3) + ps_pu->mv.s_l0_mv.i2_mvy) * ref_stride;
ref_offset += (blk_x << 3) + ps_pu->mv.s_l0_mv.i2_mvx;
pu1_ref += ref_offset;
for(row = 0; row < temp_stride; row++)
{
for(col = 0; col < temp_stride; col++)
{
i4_tmp = pu1_ref[col];
pu1_temp_pred[col] = CLIP_U8(i4_tmp);
}
pu1_ref += ref_stride;
pu1_temp_pred += temp_stride;
}
}
else
{
WORD8 i1_ref_idx;
i1_ref_idx = ps_pu->mv.i1_l1_ref_idx;
pu1_ref = ps_curr_layer->ppu1_list_inp[i1_ref_idx];
ref_stride = ps_curr_layer->i4_inp_stride;
ref_offset = ((blk_y << 3) + ps_pu->mv.s_l1_mv.i2_mvy) * ref_stride;
ref_offset += (blk_x << 3) + ps_pu->mv.s_l1_mv.i2_mvx;
pu1_ref += ref_offset;
for(row = 0; row < temp_stride; row++)
{
for(col = 0; col < temp_stride; col++)
{
i4_tmp = pu1_ref[col];
pu1_temp_pred[col] = CLIP_U8(i4_tmp);
}
pu1_ref += ref_stride;
pu1_temp_pred += temp_stride;
}
}
}
static WORD32 hme_add_clustered_mvs_as_merge_cands(
cluster_data_t *ps_cluster_base,
search_node_t *ps_merge_cand,
range_prms_t **pps_range_prms,
U08 *pu1_refid_to_pred_dir_list,
WORD32 i4_num_clusters,
U08 u1_pred_dir)
{
WORD32 i, j, k;
WORD32 i4_num_cands_added = 0;
WORD32 i4_num_mvs_in_cluster;
for(i = 0; i < i4_num_clusters; i++)
{
cluster_data_t *ps_data = &ps_cluster_base[i];
if(u1_pred_dir == !pu1_refid_to_pred_dir_list[ps_data->ref_id])
{
i4_num_mvs_in_cluster = ps_data->num_mvs;
for(j = 0; j < i4_num_mvs_in_cluster; j++)
{
ps_merge_cand[i4_num_cands_added].s_mv.i2_mvx = ps_data->as_mv[j].mvx;
ps_merge_cand[i4_num_cands_added].s_mv.i2_mvy = ps_data->as_mv[j].mvy;
ps_merge_cand[i4_num_cands_added].i1_ref_idx = ps_data->ref_id;
CLIP_MV_WITHIN_RANGE(
ps_merge_cand[i4_num_cands_added].s_mv.i2_mvx,
ps_merge_cand[i4_num_cands_added].s_mv.i2_mvy,
pps_range_prms[ps_data->ref_id],
0,
0,
0);
for(k = 0; k < i4_num_cands_added; k++)
{
if((ps_merge_cand[k].s_mv.i2_mvx == ps_data->as_mv[j].mvx) &&
(ps_merge_cand[k].s_mv.i2_mvy == ps_data->as_mv[j].mvy) &&
(ps_merge_cand[k].i1_ref_idx == ps_data->ref_id))
{
break;
}
}
if(k == i4_num_cands_added)
{
i4_num_cands_added++;
}
}
}
}
return i4_num_cands_added;
}
static WORD32 hme_add_me_best_as_merge_cands(
search_results_t **pps_child_data_array,
inter_cu_results_t *ps_8x8cu_results,
search_node_t *ps_merge_cand,
range_prms_t **pps_range_prms,
U08 *pu1_refid_to_pred_dir_list,
S08 *pi1_past_list,
S08 *pi1_future_list,
BLK_SIZE_T e_blk_size,
ME_QUALITY_PRESETS_T e_quality_preset,
S32 i4_num_cands_added,
U08 u1_pred_dir)
{
WORD32 i, j, k;
WORD32 i4_max_cands_to_add;
WORD32 i4_result_id = 0;
ASSERT(!pps_child_data_array[0]->u1_split_flag || (BLK_64x64 != e_blk_size));
ASSERT(!pps_child_data_array[1]->u1_split_flag || (BLK_64x64 != e_blk_size));
ASSERT(!pps_child_data_array[2]->u1_split_flag || (BLK_64x64 != e_blk_size));
ASSERT(!pps_child_data_array[3]->u1_split_flag || (BLK_64x64 != e_blk_size));
switch(e_quality_preset)
{
case ME_PRISTINE_QUALITY:
{
i4_max_cands_to_add = MAX_MERGE_CANDTS;
break;
}
case ME_HIGH_QUALITY:
{
/* All 4 children are split and each grandchild contributes an MV */
/* and 2 best results per grandchild */
i4_max_cands_to_add = 4 * 4 * 2;
break;
}
case ME_MEDIUM_SPEED:
{
i4_max_cands_to_add = 4 * 2 * 2;
break;
}
case ME_HIGH_SPEED:
case ME_XTREME_SPEED:
case ME_XTREME_SPEED_25:
{
i4_max_cands_to_add = 4 * 2 * 1;
break;
}
}
while(i4_result_id < 4)
{
for(i = 0; i < 4; i++)
{
inter_cu_results_t *ps_child_data = pps_child_data_array[i]->ps_cu_results;
inter_cu_results_t *ps_grandchild_data = &ps_8x8cu_results[i << 2];
if(!pps_child_data_array[i]->u1_split_flag)
{
part_type_results_t *ps_data = &ps_child_data->ps_best_results[i4_result_id];
if(ps_child_data->u1_num_best_results <= i4_result_id)
{
continue;
}
if(ps_data->as_pu_results->pu.b1_intra_flag)
{
continue;
}
for(j = 0; j <= (ps_data->u1_part_type != PRT_2Nx2N); j++)
{
mv_t *ps_mv;
S08 i1_ref_idx;
pu_t *ps_pu = &ps_data->as_pu_results[j].pu;
if(u1_pred_dir !=
((ps_pu->b2_pred_mode == 2) ? u1_pred_dir : ps_pu->b2_pred_mode))
{
continue;
}
if(u1_pred_dir)
{
ps_mv = &ps_pu->mv.s_l1_mv;
i1_ref_idx = pi1_future_list[ps_pu->mv.i1_l1_ref_idx];
}
else
{
ps_mv = &ps_pu->mv.s_l0_mv;
i1_ref_idx = pi1_past_list[ps_pu->mv.i1_l0_ref_idx];
}
if(-1 == i1_ref_idx)
{
continue;
}
ps_merge_cand[i4_num_cands_added].s_mv.i2_mvx = ps_mv->i2_mvx;
ps_merge_cand[i4_num_cands_added].s_mv.i2_mvy = ps_mv->i2_mvy;
ps_merge_cand[i4_num_cands_added].i1_ref_idx = i1_ref_idx;
CLIP_MV_WITHIN_RANGE(
ps_merge_cand[i4_num_cands_added].s_mv.i2_mvx,
ps_merge_cand[i4_num_cands_added].s_mv.i2_mvy,
pps_range_prms[i1_ref_idx],
0,
0,
0);
for(k = 0; k < i4_num_cands_added; k++)
{
if((ps_merge_cand[k].s_mv.i2_mvx == ps_mv->i2_mvx) &&
(ps_merge_cand[k].s_mv.i2_mvy == ps_mv->i2_mvy) &&
(ps_merge_cand[k].i1_ref_idx == i1_ref_idx))
{
break;
}
}
if(k == i4_num_cands_added)
{
i4_num_cands_added++;
if(i4_max_cands_to_add <= i4_num_cands_added)
{
return i4_num_cands_added;
}
}
}
}
else
{
for(j = 0; j < 4; j++)
{
mv_t *ps_mv;
S08 i1_ref_idx;
part_type_results_t *ps_data = ps_grandchild_data[j].ps_best_results;
pu_t *ps_pu = &ps_data->as_pu_results[0].pu;
ASSERT(ps_data->u1_part_type == PRT_2Nx2N);
if(ps_grandchild_data[j].u1_num_best_results <= i4_result_id)
{
continue;
}
if(ps_data->as_pu_results->pu.b1_intra_flag)
{
continue;
}
if(u1_pred_dir !=
((ps_pu->b2_pred_mode == 2) ? u1_pred_dir : ps_pu->b2_pred_mode))
{
continue;
}
if(u1_pred_dir)
{
ps_mv = &ps_pu->mv.s_l1_mv;
i1_ref_idx = pi1_future_list[ps_pu->mv.i1_l1_ref_idx];
}
else
{
ps_mv = &ps_pu->mv.s_l0_mv;
i1_ref_idx = pi1_past_list[ps_pu->mv.i1_l0_ref_idx];
}
ps_merge_cand[i4_num_cands_added].s_mv.i2_mvx = ps_mv->i2_mvx;
ps_merge_cand[i4_num_cands_added].s_mv.i2_mvy = ps_mv->i2_mvy;
ps_merge_cand[i4_num_cands_added].i1_ref_idx = i1_ref_idx;
CLIP_MV_WITHIN_RANGE(
ps_merge_cand[i4_num_cands_added].s_mv.i2_mvx,
ps_merge_cand[i4_num_cands_added].s_mv.i2_mvy,
pps_range_prms[i1_ref_idx],
0,
0,
0);
for(k = 0; k < i4_num_cands_added; k++)
{
if((ps_merge_cand[k].s_mv.i2_mvx == ps_mv->i2_mvx) &&
(ps_merge_cand[k].s_mv.i2_mvy == ps_mv->i2_mvy) &&
(ps_merge_cand[k].i1_ref_idx == i1_ref_idx))
{
break;
}
}
if(k == i4_num_cands_added)
{
i4_num_cands_added++;
if(i4_max_cands_to_add <= i4_num_cands_added)
{
return i4_num_cands_added;
}
}
}
}
}
i4_result_id++;
}
return i4_num_cands_added;
}
WORD32 hme_add_cands_for_merge_eval(
ctb_cluster_info_t *ps_cluster_info,
search_results_t **pps_child_data_array,
inter_cu_results_t *ps_8x8cu_results,
range_prms_t **pps_range_prms,
search_node_t *ps_merge_cand,
U08 *pu1_refid_to_pred_dir_list,
S08 *pi1_past_list,
S08 *pi1_future_list,
ME_QUALITY_PRESETS_T e_quality_preset,
BLK_SIZE_T e_blk_size,
U08 u1_pred_dir,
U08 u1_blk_id)
{
WORD32 i4_num_cands_added = 0;
if(ME_PRISTINE_QUALITY == e_quality_preset)
{
cluster_data_t *ps_cluster_primo;
WORD32 i4_num_clusters;
if(BLK_32x32 == e_blk_size)
{
ps_cluster_primo = ps_cluster_info->ps_32x32_blk[u1_blk_id].as_cluster_data;
i4_num_clusters = ps_cluster_info->ps_32x32_blk[u1_blk_id].num_clusters;
}
else
{
ps_cluster_primo = ps_cluster_info->ps_64x64_blk->as_cluster_data;
i4_num_clusters = ps_cluster_info->ps_64x64_blk->num_clusters;
}
i4_num_cands_added = hme_add_clustered_mvs_as_merge_cands(
ps_cluster_primo,
ps_merge_cand,
pps_range_prms,
pu1_refid_to_pred_dir_list,
i4_num_clusters,
u1_pred_dir);
}
i4_num_cands_added = hme_add_me_best_as_merge_cands(
pps_child_data_array,
ps_8x8cu_results,
ps_merge_cand,
pps_range_prms,
pu1_refid_to_pred_dir_list,
pi1_past_list,
pi1_future_list,
e_blk_size,
e_quality_preset,
i4_num_cands_added,
u1_pred_dir);
return i4_num_cands_added;
}
/**
********************************************************************************
* @fn void hme_pick_refine_merge_candts(hme_merge_prms_t *ps_merge_prms,
* S08 i1_ref_idx,
* S32 i4_best_part_type,
* S32 i4_is_vert)
*
* @brief Given a target partition orientation in the merged CU, and the
* partition type of most likely partition this fxn picks up
* candidates from the 4 constituent CUs and does refinement search
* to identify best results for the merge CU across active partitions
*
* @param[in,out] ps_merge_prms : Parameters sent from higher layers. Out of
* these params, the search result structure is also derived and
* updated during the search
*
* @param[in] i1_ref_idx : ID of the buffer within the search results to update.
* Will be 0 if all refidx collapsed to one buf, else it'll be 0/1
*
* @param[in] i4_best_part_type : partition type of potential partition in the
* merged CU, -1 if the merge process has not yet been able to
* determine this.
*
* @param[in] i4_is_vert : Whether target partition of merged CU is vertical
* orientation or horizontal orientation.
*
* @return Number of merge candidates
********************************************************************************
*/
WORD32 hme_pick_eval_merge_candts(
hme_merge_prms_t *ps_merge_prms,
hme_subpel_prms_t *ps_subpel_prms,
S32 i4_search_idx,
S32 i4_best_part_type,
S32 i4_is_vert,
wgt_pred_ctxt_t *ps_wt_inp_prms,
S32 i4_frm_qstep,
ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list,
ihevce_me_optimised_function_list_t *ps_me_optimised_function_list)
{
S32 x_off, y_off;
search_node_t *ps_search_node;
S32 ai4_valid_part_ids[TOT_NUM_PARTS + 1];
S32 i4_num_valid_parts;
pred_ctxt_t *ps_pred_ctxt;
search_node_t as_merge_unique_node[MAX_MERGE_CANDTS];
S32 num_unique_nodes_cu_merge = 0;
search_results_t *ps_search_results = ps_merge_prms->ps_results_merge;
CU_SIZE_T e_cu_size = ps_search_results->e_cu_size;
S32 i4_part_mask = ps_search_results->i4_part_mask;
search_results_t *aps_child_results[4];
layer_ctxt_t *ps_curr_layer = ps_merge_prms->ps_layer_ctxt;
S32 i4_ref_stride, i, j;
result_upd_prms_t s_result_prms;
BLK_SIZE_T e_blk_size = ge_cu_size_to_blk_size[e_cu_size];
S32 i4_offset;
/*************************************************************************/
/* 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];
err_prms_t s_err_prms;
/*************************************************************************/
/* Allowed MV RANGE */
/*************************************************************************/
range_prms_t **pps_range_prms = ps_merge_prms->aps_mv_range;
PF_INTERP_FXN_T pf_qpel_interp;
PF_MV_COST_FXN pf_mv_cost_compute;
WORD32 pred_lx;
U08 *apu1_hpel_ref[4];
interp_prms_t s_interp_prms;
S32 i4_interp_buf_id;
S32 i4_ctb_x_off = ps_merge_prms->i4_ctb_x_off;
S32 i4_ctb_y_off = ps_merge_prms->i4_ctb_y_off;
/* Sanity checks */
ASSERT((e_blk_size == BLK_64x64) || (e_blk_size == BLK_32x32));
s_err_prms.ps_cmn_utils_optimised_function_list = ps_cmn_utils_optimised_function_list;
/* Initialize all the ptrs to child CUs for merge decision */
aps_child_results[0] = ps_merge_prms->ps_results_tl;
aps_child_results[1] = ps_merge_prms->ps_results_tr;
aps_child_results[2] = ps_merge_prms->ps_results_bl;
aps_child_results[3] = ps_merge_prms->ps_results_br;
num_unique_nodes_cu_merge = 0;
pf_mv_cost_compute = compute_mv_cost_implicit_high_speed;
if(ME_PRISTINE_QUALITY == ps_merge_prms->e_quality_preset)
{
num_unique_nodes_cu_merge = hme_add_cands_for_merge_eval(
ps_merge_prms->ps_cluster_info,
aps_child_results,
ps_merge_prms->ps_8x8_cu_results,
pps_range_prms,
as_merge_unique_node,
ps_search_results->pu1_is_past,
ps_merge_prms->pi1_past_list,
ps_merge_prms->pi1_future_list,
ps_merge_prms->e_quality_preset,
e_blk_size,
i4_search_idx,
(ps_merge_prms->ps_results_merge->u1_x_off >> 5) +
(ps_merge_prms->ps_results_merge->u1_y_off >> 4));
}
else
{
/*************************************************************************/
/* Populate the list of unique search nodes in the child CUs for merge */
/* evaluation */
/*************************************************************************/
for(i = 0; i < 4; i++)
{
search_node_t s_search_node;
PART_TYPE_T e_part_type;
PART_ID_T e_part_id;
WORD32 part_num;
search_results_t *ps_child = aps_child_results[i];
if(ps_child->ps_cu_results->u1_num_best_results)
{
if(!((ps_child->ps_cu_results->ps_best_results->as_pu_results->pu.b1_intra_flag) &&
(1 == ps_child->ps_cu_results->u1_num_best_results)))
{
e_part_type =
(PART_TYPE_T)ps_child->ps_cu_results->ps_best_results[0].u1_part_type;
ASSERT(num_unique_nodes_cu_merge < MAX_MERGE_CANDTS);
/* Insert mvs of NxN partitions. */
for(part_num = 0; part_num < gau1_num_parts_in_part_type[((S32)e_part_type)];
part_num++)
{
e_part_id = ge_part_type_to_part_id[e_part_type][part_num];
if(ps_child->aps_part_results[i4_search_idx][e_part_id]->i1_ref_idx != -1)
{
s_search_node = *ps_child->aps_part_results[i4_search_idx][e_part_id];
if(s_search_node.s_mv.i2_mvx != INTRA_MV)
{
CLIP_MV_WITHIN_RANGE(
s_search_node.s_mv.i2_mvx,
s_search_node.s_mv.i2_mvy,
pps_range_prms[s_search_node.i1_ref_idx],
0,
0,
0);
INSERT_NEW_NODE_NOMAP(
as_merge_unique_node,
num_unique_nodes_cu_merge,
s_search_node,
1);
}
}
}
}
}
else if(!((ps_merge_prms->ps_results_grandchild[(i << 2)]
.ps_cu_results->ps_best_results->as_pu_results->pu.b1_intra_flag) &&
(1 == ps_merge_prms->ps_results_grandchild[(i << 2)]
.ps_cu_results->u1_num_best_results)))
{
search_results_t *ps_results_root = &ps_merge_prms->ps_results_grandchild[(i << 2)];
for(j = 0; j < 4; j++)
{
e_part_type = (PART_TYPE_T)ps_results_root[j]
.ps_cu_results->ps_best_results[0]
.u1_part_type;
ASSERT(num_unique_nodes_cu_merge < MAX_MERGE_CANDTS);
/* Insert mvs of NxN partitions. */
for(part_num = 0; part_num < gau1_num_parts_in_part_type[((S32)e_part_type)];
part_num++)
{
e_part_id = ge_part_type_to_part_id[e_part_type][part_num];
if((ps_results_root[j]
.aps_part_results[i4_search_idx][e_part_id]
->i1_ref_idx != -1) &&
(!ps_child->ps_cu_results->ps_best_results->as_pu_results->pu
.b1_intra_flag))
{
s_search_node =
*ps_results_root[j].aps_part_results[i4_search_idx][e_part_id];
if(s_search_node.s_mv.i2_mvx != INTRA_MV)
{
CLIP_MV_WITHIN_RANGE(
s_search_node.s_mv.i2_mvx,
s_search_node.s_mv.i2_mvy,
pps_range_prms[s_search_node.i1_ref_idx],
0,
0,
0);
INSERT_NEW_NODE_NOMAP(
as_merge_unique_node,
num_unique_nodes_cu_merge,
s_search_node,
1);
}
}
}
}
}
}
}
if(0 == num_unique_nodes_cu_merge)
{
return 0;
}
/*************************************************************************/
/* 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 one pt is evaluated per node */
/* Hence, part mask is also nearly dont care and we use 2Nx2N enabled. */
/*************************************************************************/
i4_part_mask = ps_search_results->i4_part_mask;
/* Need to add the corresponding SAD functions for EXTREME SPEED : Lokesh */
if(ps_subpel_prms->i4_use_satd)
{
if(BLK_32x32 == e_blk_size)
{
pf_err_compute = hme_evalsatd_pt_pu_32x32;
}
else
{
pf_err_compute = hme_evalsatd_pt_pu_64x64;
}
}
else
{
pf_err_compute = (PF_SAD_FXN_T)hme_evalsad_grid_pu_MxM;
}
i4_ref_stride = ps_curr_layer->i4_rec_stride;
x_off = ps_merge_prms->ps_results_tl->u1_x_off;
y_off = ps_merge_prms->ps_results_tl->u1_y_off;
i4_offset = x_off + i4_ctb_x_off + ((y_off + i4_ctb_y_off) * i4_ref_stride);
/*************************************************************************/
/* This array stores the ids of the partitions whose */
/* SADs are updated. Since the partitions whose SADs are updated may not */
/* be in contiguous order, we supply another level of indirection. */
/*************************************************************************/
i4_num_valid_parts = hme_create_valid_part_ids(i4_part_mask, ai4_valid_part_ids);
/* 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 = ai4_valid_part_ids;
s_result_prms.i1_ref_idx = i4_search_idx;
s_result_prms.i4_part_mask = i4_part_mask;
s_result_prms.pi4_sad_grid = &ai4_sad_grid[0][0];
s_result_prms.i4_grid_mask = 1;
/* One time Initialization of error params used for SAD/SATD compute */
s_err_prms.i4_inp_stride = ps_subpel_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 = 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.i4_step = 1;
/*************************************************************************/
/* One time preparation of non changing interpolation params. */
/*************************************************************************/
s_interp_prms.i4_ref_stride = i4_ref_stride;
s_interp_prms.i4_blk_wd = gau1_blk_size_to_wd[e_blk_size];
s_interp_prms.i4_blk_ht = gau1_blk_size_to_ht[e_blk_size];
s_interp_prms.apu1_interp_out[0] = ps_subpel_prms->pu1_wkg_mem;
s_interp_prms.i4_out_stride = gau1_blk_size_to_wd[e_blk_size];
i4_interp_buf_id = 0;
pf_qpel_interp = ps_subpel_prms->pf_qpel_interp;
/***************************************************************************/
/* Compute SATD/SAD for all unique nodes of children CUs to get best merge */
/* results */
/***************************************************************************/
for(i = 0; i < num_unique_nodes_cu_merge; i++)
{
WORD8 i1_ref_idx;
ps_search_node = &as_merge_unique_node[i];
/*********************************************************************/
/* 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 */
/*********************************************************************/
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;
s_interp_prms.ppu1_ref = &apu1_hpel_ref[0];
pf_qpel_interp(
&s_interp_prms,
ps_search_node->s_mv.i2_mvx,
ps_search_node->s_mv.i2_mvy,
i4_interp_buf_id);
pred_lx = i4_search_idx;
ps_pred_ctxt = &ps_search_results->as_pred_ctxt[pred_lx];
s_result_prms.u1_pred_lx = pred_lx;
s_result_prms.ps_search_node_base = ps_search_node;
s_err_prms.pu1_inp =
ps_wt_inp_prms->apu1_wt_inp[i1_ref_idx] + x_off + y_off * ps_subpel_prms->i4_inp_stride;
s_err_prms.pu1_ref = s_interp_prms.pu1_final_out;
s_err_prms.i4_ref_stride = s_interp_prms.i4_final_out_stride;
/* Carry out the SAD/SATD. This call also does the TU RECURSION.
Here the tu recursion logic is restricted with the size of the PU*/
pf_err_compute(&s_err_prms);
if(ps_subpel_prms->u1_is_cu_noisy &&
ps_merge_prms->ps_inter_ctb_prms->i4_alpha_stim_multiplier)
{
ps_me_optimised_function_list->pf_compute_stim_injected_distortion_for_all_parts(
s_err_prms.pu1_ref,
s_err_prms.i4_ref_stride,
ai4_valid_part_ids,
ps_merge_prms->ps_inter_ctb_prms->pu8_part_src_sigmaX,
ps_merge_prms->ps_inter_ctb_prms->pu8_part_src_sigmaXSquared,
s_err_prms.pi4_sad_grid,
ps_merge_prms->ps_inter_ctb_prms->i4_alpha_stim_multiplier,
ps_wt_inp_prms->a_inv_wpred_wt[i1_ref_idx],
ps_wt_inp_prms->ai4_shift_val[i1_ref_idx],
i4_num_valid_parts,
ps_wt_inp_prms->wpred_log_wdc,
(BLK_32x32 == e_blk_size) ? 32 : 64);
}
/* Update the mv's */
s_result_prms.i2_mv_x = ps_search_node->s_mv.i2_mvx;
s_result_prms.i2_mv_y = ps_search_node->s_mv.i2_mvy;
/* Update best results */
hme_update_results_pt_pu_best1_subpel_hs(&s_err_prms, &s_result_prms);
}
/************************************************************************/
/* Update mv cost and total cost for each valid partition in the CU */
/************************************************************************/
for(i = 0; i < TOT_NUM_PARTS; i++)
{
if(i4_part_mask & (1 << i))
{
WORD32 j;
WORD32 i4_mv_cost;
ps_search_node = ps_search_results->aps_part_results[i4_search_idx][i];
for(j = 0;
j < MIN(ps_search_results->u1_num_results_per_part, num_unique_nodes_cu_merge);
j++)
{
if(ps_search_node->i1_ref_idx != -1)
{
pred_lx = i4_search_idx;
ps_pred_ctxt = &ps_search_results->as_pred_ctxt[pred_lx];
/* Prediction context should now deal with qpel units */
HME_SET_MVPRED_RES(ps_pred_ctxt, MV_RES_QPEL);
ps_search_node->u1_subpel_done = 1;
ps_search_node->u1_is_avail = 1;
i4_mv_cost =
pf_mv_cost_compute(ps_search_node, ps_pred_ctxt, (PART_ID_T)i, MV_RES_QPEL);
ps_search_node->i4_tot_cost = i4_mv_cost + ps_search_node->i4_sad;
ps_search_node->i4_mv_cost = i4_mv_cost;
ps_search_node++;
}
}
}
}
return num_unique_nodes_cu_merge;
}
#define CU_MERGE_MAX_INTRA_PARTS 4
/**
********************************************************************************
* @fn hme_try_merge_high_speed
*
* @brief Attempts to merge 4 NxN candts to a 2Nx2N candt, either as a single
entity or with partititons for high speed preset
*
* @param[in,out] hme_merge_prms_t: Params for CU merge
*
* @return MERGE_RESULT_T type result of merge (CU_MERGED/CU_SPLIT)
********************************************************************************
*/
CU_MERGE_RESULT_T hme_try_merge_high_speed(
me_ctxt_t *ps_thrd_ctxt,
me_frm_ctxt_t *ps_ctxt,
ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb,
hme_subpel_prms_t *ps_subpel_prms,
hme_merge_prms_t *ps_merge_prms,
inter_pu_results_t *ps_pu_results,
pu_result_t *ps_pu_result)
{
search_results_t *ps_results_tl, *ps_results_tr;
search_results_t *ps_results_bl, *ps_results_br;
S32 i;
S32 i4_search_idx;
S32 i4_cost_parent;
S32 intra_cu_size;
ULWORD64 au8_final_src_sigmaX[17], au8_final_src_sigmaXSquared[17];
search_results_t *ps_results_merge = ps_merge_prms->ps_results_merge;
wgt_pred_ctxt_t *ps_wt_inp_prms = &ps_ctxt->s_wt_pred;
S32 i4_part_mask = ENABLE_ALL_PARTS - ENABLE_NxN;
S32 is_vert = 0, i4_best_part_type = -1;
S32 i4_intra_parts = 0; /* Keeps track of intra percentage before merge */
S32 i4_cost_children = 0;
S32 i4_frm_qstep = ps_ctxt->frm_qstep;
S32 i4_num_merge_cands_evaluated = 0;
U08 u1_x_off = ps_results_merge->u1_x_off;
U08 u1_y_off = ps_results_merge->u1_y_off;
S32 i4_32x32_id = (u1_y_off >> 4) + (u1_x_off >> 5);
ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list =
ps_thrd_ctxt->ps_cmn_utils_optimised_function_list;
ihevce_me_optimised_function_list_t *ps_me_optimised_function_list =
((ihevce_me_optimised_function_list_t *)ps_thrd_ctxt->pv_me_optimised_function_list);
ps_results_tl = ps_merge_prms->ps_results_tl;
ps_results_tr = ps_merge_prms->ps_results_tr;
ps_results_bl = ps_merge_prms->ps_results_bl;
ps_results_br = ps_merge_prms->ps_results_br;
if(ps_merge_prms->e_quality_preset == ME_XTREME_SPEED)
{
i4_part_mask &= ~ENABLE_AMP;
}
if(ps_merge_prms->e_quality_preset == ME_XTREME_SPEED_25)
{
i4_part_mask &= ~ENABLE_AMP;
i4_part_mask &= ~ENABLE_SMP;
}
ps_merge_prms->i4_num_pred_dir_actual = 0;
/*************************************************************************/
/* The logic for High speed CU merge goes as follows: */
/* */
/* 1. Early exit with CU_SPLIT if sum of best partitions of children CUs */
/* exceed 7 */
/* 2. Early exit with CU_MERGE if mvs of best partitions of children CUs */
/* are identical */
/* 3. Find the all unique mvs of best partitions of children CUs and */
/* evaluate partial SATDs (all 17 partitions) for each unique mv. If */
/* best parent cost is lower than sum of the best children costs */
/* return CU_MERGE after seeding the best results else return CU_SPLIT*/
/* */
/*************************************************************************/
/* Count the number of best partitions in child CUs, early exit if > 7 */
if((ps_merge_prms->e_quality_preset != ME_PRISTINE_QUALITY) ||
(CU_32x32 == ps_results_merge->e_cu_size))
{
S32 num_parts_in_32x32 = 0;
WORD32 i4_part_type;
if(ps_results_tl->u1_split_flag)
{
num_parts_in_32x32 += 4;
#define COST_INTERCHANGE 0
i4_cost_children = ps_merge_prms->ps_8x8_cu_results[0].ps_best_results->i4_tot_cost +
ps_merge_prms->ps_8x8_cu_results[1].ps_best_results->i4_tot_cost +
ps_merge_prms->ps_8x8_cu_results[2].ps_best_results->i4_tot_cost +
ps_merge_prms->ps_8x8_cu_results[3].ps_best_results->i4_tot_cost;
}
else
{
i4_part_type = ps_results_tl->ps_cu_results->ps_best_results[0].u1_part_type;
num_parts_in_32x32 += gau1_num_parts_in_part_type[i4_part_type];
i4_cost_children = ps_results_tl->ps_cu_results->ps_best_results[0].i4_tot_cost;
}
if(ps_results_tr->u1_split_flag)
{
num_parts_in_32x32 += 4;
i4_cost_children += ps_merge_prms->ps_8x8_cu_results[4].ps_best_results->i4_tot_cost +
ps_merge_prms->ps_8x8_cu_results[5].ps_best_results->i4_tot_cost +
ps_merge_prms->ps_8x8_cu_results[6].ps_best_results->i4_tot_cost +
ps_merge_prms->ps_8x8_cu_results[7].ps_best_results->i4_tot_cost;
}
else
{
i4_part_type = ps_results_tr->ps_cu_results->ps_best_results[0].u1_part_type;
num_parts_in_32x32 += gau1_num_parts_in_part_type[i4_part_type];
i4_cost_children += ps_results_tr->ps_cu_results->ps_best_results[0].i4_tot_cost;
}
if(ps_results_bl->u1_split_flag)
{
num_parts_in_32x32 += 4;
i4_cost_children += ps_merge_prms->ps_8x8_cu_results[8].ps_best_results->i4_tot_cost +
ps_merge_prms->ps_8x8_cu_results[9].ps_best_results->i4_tot_cost +
ps_merge_prms->ps_8x8_cu_results[10].ps_best_results->i4_tot_cost +
ps_merge_prms->ps_8x8_cu_results[11].ps_best_results->i4_tot_cost;
}
else
{
i4_part_type = ps_results_bl->ps_cu_results->ps_best_results[0].u1_part_type;
num_parts_in_32x32 += gau1_num_parts_in_part_type[i4_part_type];
i4_cost_children += ps_results_bl->ps_cu_results->ps_best_results[0].i4_tot_cost;
}
if(ps_results_br->u1_split_flag)
{
num_parts_in_32x32 += 4;
i4_cost_children += ps_merge_prms->ps_8x8_cu_results[12].ps_best_results->i4_tot_cost +
ps_merge_prms->ps_8x8_cu_results[13].ps_best_results->i4_tot_cost +
ps_merge_prms->ps_8x8_cu_results[14].ps_best_results->i4_tot_cost +
ps_merge_prms->ps_8x8_cu_results[15].ps_best_results->i4_tot_cost;
}
else
{
i4_part_type = ps_results_br->ps_cu_results->ps_best_results[0].u1_part_type;
num_parts_in_32x32 += gau1_num_parts_in_part_type[i4_part_type];
i4_cost_children += ps_results_br->ps_cu_results->ps_best_results[0].i4_tot_cost;
}
if((num_parts_in_32x32 > 7) && (ps_merge_prms->e_quality_preset != ME_PRISTINE_QUALITY))
{
return CU_SPLIT;
}
if((num_parts_in_32x32 > MAX_NUM_CONSTITUENT_MVS_TO_ENABLE_32MERGE_IN_XS25) &&
(ps_merge_prms->e_quality_preset == ME_XTREME_SPEED_25))
{
return CU_SPLIT;
}
}
/* Accumulate intra percentage before merge for early CU_SPLIT decision */
/* Note : Each intra part represent a NxN unit of the children CUs */
/* This is essentially 1/16th of the CUsize under consideration for merge */
if(ME_PRISTINE_QUALITY == ps_merge_prms->e_quality_preset)
{
if(CU_64x64 == ps_results_merge->e_cu_size)
{
i4_intra_parts =
(!ps_merge_prms->ps_cluster_info->ps_cu_tree_root->u1_inter_eval_enable)
? 16
: ps_merge_prms->ps_cluster_info->ps_cu_tree_root->u1_intra_eval_enable;
}
else
{
switch((ps_results_merge->u1_x_off >> 5) + ((ps_results_merge->u1_y_off >> 4)))
{
case 0:
{
i4_intra_parts = (!ps_merge_prms->ps_cluster_info->ps_cu_tree_root->ps_child_node_tl
->u1_inter_eval_enable)
? 16
: (ps_merge_prms->ps_cluster_info->ps_cu_tree_root
->ps_child_node_tl->u1_intra_eval_enable);
break;
}
case 1:
{
i4_intra_parts = (!ps_merge_prms->ps_cluster_info->ps_cu_tree_root->ps_child_node_tr
->u1_inter_eval_enable)
? 16
: (ps_merge_prms->ps_cluster_info->ps_cu_tree_root
->ps_child_node_tr->u1_intra_eval_enable);
break;
}
case 2:
{
i4_intra_parts = (!ps_merge_prms->ps_cluster_info->ps_cu_tree_root->ps_child_node_bl
->u1_inter_eval_enable)
? 16
: (ps_merge_prms->ps_cluster_info->ps_cu_tree_root
->ps_child_node_bl->u1_intra_eval_enable);
break;
}
case 3:
{
i4_intra_parts = (!ps_merge_prms->ps_cluster_info->ps_cu_tree_root->ps_child_node_br
->u1_inter_eval_enable)
? 16
: (ps_merge_prms->ps_cluster_info->ps_cu_tree_root
->ps_child_node_br->u1_intra_eval_enable);
break;
}
}
}
}
else
{
for(i = 0; i < 4; i++)
{
search_results_t *ps_results =
(i == 0) ? ps_results_tl
: ((i == 1) ? ps_results_tr : ((i == 2) ? ps_results_bl : ps_results_br));
part_type_results_t *ps_best_res = &ps_results->ps_cu_results->ps_best_results[0];
if(ps_results->u1_split_flag)
{
U08 u1_x_off = ps_results->u1_x_off;
U08 u1_y_off = ps_results->u1_y_off;
U08 u1_8x8_zscan_id = gau1_ctb_raster_to_zscan[(u1_x_off >> 2) + (u1_y_off << 2)] >>
2;
/* Special case to handle 8x8 CUs when 16x16 is split */
ASSERT(ps_results->e_cu_size == CU_16x16);
ps_best_res = &ps_ctxt->as_cu8x8_results[u1_8x8_zscan_id].ps_best_results[0];
if(ps_best_res->as_pu_results[0].pu.b1_intra_flag)
i4_intra_parts += 1;
ps_best_res = &ps_ctxt->as_cu8x8_results[u1_8x8_zscan_id + 1].ps_best_results[0];
if(ps_best_res->as_pu_results[0].pu.b1_intra_flag)
i4_intra_parts += 1;
ps_best_res = &ps_ctxt->as_cu8x8_results[u1_8x8_zscan_id + 2].ps_best_results[0];
if(ps_best_res->as_pu_results[0].pu.b1_intra_flag)
i4_intra_parts += 1;
ps_best_res = &ps_ctxt->as_cu8x8_results[u1_8x8_zscan_id + 3].ps_best_results[0];
if(ps_best_res->as_pu_results[0].pu.b1_intra_flag)
i4_intra_parts += 1;
}
else if(ps_best_res[0].as_pu_results[0].pu.b1_intra_flag)
{
i4_intra_parts += 4;
}
}
}
/* Determine the max intra CU size indicated by IPE */
intra_cu_size = CU_64x64;
if(ps_cur_ipe_ctb->u1_split_flag)
{
intra_cu_size = CU_32x32;
if(ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id].b1_split_flag)
{
intra_cu_size = CU_16x16;
}
}
if(((i4_intra_parts > CU_MERGE_MAX_INTRA_PARTS) &&
(intra_cu_size < ps_results_merge->e_cu_size) &&
(ME_PRISTINE_QUALITY != ps_merge_prms->e_quality_preset)) ||
(i4_intra_parts == 16))
{
S32 i4_merge_outcome;
i4_merge_outcome = (CU_32x32 == ps_results_merge->e_cu_size)
? (!ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id].b1_split_flag &&
ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id].b1_valid_cu)
: (!ps_cur_ipe_ctb->u1_split_flag);
i4_merge_outcome = i4_merge_outcome ||
(ME_PRISTINE_QUALITY == ps_merge_prms->e_quality_preset);
i4_merge_outcome = i4_merge_outcome &&
!(ps_subpel_prms->u1_is_cu_noisy && DISABLE_INTRA_WHEN_NOISY);
if(i4_merge_outcome)
{
inter_cu_results_t *ps_cu_results = ps_results_merge->ps_cu_results;
part_type_results_t *ps_best_result = ps_cu_results->ps_best_results;
pu_t *ps_pu = &ps_best_result->as_pu_results->pu;
ps_cu_results->u1_num_best_results = 1;
ps_cu_results->u1_cu_size = ps_results_merge->e_cu_size;
ps_cu_results->u1_x_off = u1_x_off;
ps_cu_results->u1_y_off = u1_y_off;
ps_best_result->u1_part_type = PRT_2Nx2N;
ps_best_result->ai4_tu_split_flag[0] = 0;
ps_best_result->ai4_tu_split_flag[1] = 0;
ps_best_result->ai4_tu_split_flag[2] = 0;
ps_best_result->ai4_tu_split_flag[3] = 0;
ps_best_result->i4_tot_cost =
(CU_64x64 == ps_results_merge->e_cu_size)
? ps_cur_ipe_ctb->i4_best64x64_intra_cost
: ps_cur_ipe_ctb->ai4_best32x32_intra_cost[i4_32x32_id];
ps_pu->b1_intra_flag = 1;
ps_pu->b4_pos_x = u1_x_off >> 2;
ps_pu->b4_pos_y = u1_y_off >> 2;
ps_pu->b4_wd = (1 << (ps_results_merge->e_cu_size + 1)) - 1;
ps_pu->b4_ht = ps_pu->b4_wd;
ps_pu->mv.i1_l0_ref_idx = -1;
ps_pu->mv.i1_l1_ref_idx = -1;
ps_pu->mv.s_l0_mv.i2_mvx = INTRA_MV;
ps_pu->mv.s_l0_mv.i2_mvy = INTRA_MV;
ps_pu->mv.s_l1_mv.i2_mvx = INTRA_MV;
ps_pu->mv.s_l1_mv.i2_mvy = INTRA_MV;
return CU_MERGED;
}
else
{
return CU_SPLIT;
}
}
if(i4_intra_parts)
{
i4_part_mask = ENABLE_2Nx2N;
}
ps_results_merge->u1_num_active_ref = (ps_ctxt->s_frm_prms.bidir_enabled) ? 2 : 1;
hme_reset_search_results(ps_results_merge, i4_part_mask, MV_RES_QPEL);
ps_results_merge->u1_num_active_ref = ps_merge_prms->i4_num_ref;
ps_merge_prms->i4_num_pred_dir_actual = 0;
if(ps_subpel_prms->u1_is_cu_noisy && ps_merge_prms->ps_inter_ctb_prms->i4_alpha_stim_multiplier)
{
S32 ai4_valid_part_ids[TOT_NUM_PARTS + 1];
S32 i4_num_valid_parts;
S32 i4_sigma_array_offset;
i4_num_valid_parts = hme_create_valid_part_ids(i4_part_mask, ai4_valid_part_ids);
/*********************************************************************************************************************************************/
/* i4_sigma_array_offset : takes care of pointing to the appropriate 4x4 block's sigmaX and sigmaX-squared value in a CTB out of 256 values */
/* Logic is x/4 + ((y/4) x 16) : every 4 pixel increase in x equals one 4x4 block increment, every 4 pixel increase in y equals 16 4x4 block */
/* increment as there will be 256 4x4 blocks in a CTB */
/*********************************************************************************************************************************************/
i4_sigma_array_offset = (ps_merge_prms->ps_results_merge->u1_x_off / 4) +
(ps_merge_prms->ps_results_merge->u1_y_off * 4);
for(i = 0; i < i4_num_valid_parts; i++)
{
S32 i4_part_id = ai4_valid_part_ids[i];
hme_compute_final_sigma_of_pu_from_base_blocks(
ps_ctxt->au4_4x4_src_sigmaX + i4_sigma_array_offset,
ps_ctxt->au4_4x4_src_sigmaXSquared + i4_sigma_array_offset,
au8_final_src_sigmaX,
au8_final_src_sigmaXSquared,
(CU_32x32 == ps_results_merge->e_cu_size) ? 32 : 64,
4,
i4_part_id,
16);
}
ps_merge_prms->ps_inter_ctb_prms->pu8_part_src_sigmaX = au8_final_src_sigmaX;
ps_merge_prms->ps_inter_ctb_prms->pu8_part_src_sigmaXSquared = au8_final_src_sigmaXSquared;
}
/*************************************************************************/
/* Loop through all ref idx and pick the merge candts and refine based */
/* on the active partitions. At this stage num ref will be 1 or 2 */
/*************************************************************************/
for(i4_search_idx = 0; i4_search_idx < ps_merge_prms->i4_num_ref; i4_search_idx++)
{
S32 i4_cands;
U08 u1_pred_dir = 0;
if((2 == ps_merge_prms->i4_num_ref) || (!ps_ctxt->s_frm_prms.bidir_enabled))
{
u1_pred_dir = i4_search_idx;
}
else if(ps_ctxt->s_frm_prms.u1_num_active_ref_l0 == 0)
{
u1_pred_dir = 1;
}
else if(ps_ctxt->s_frm_prms.u1_num_active_ref_l1 == 0)
{
u1_pred_dir = 0;
}
else
{
ASSERT(0);
}
/* call the function to pick and evaluate the merge candts, given */
/* a ref id and a part mask. */
i4_cands = hme_pick_eval_merge_candts(
ps_merge_prms,
ps_subpel_prms,
u1_pred_dir,
i4_best_part_type,
is_vert,
ps_wt_inp_prms,
i4_frm_qstep,
ps_cmn_utils_optimised_function_list,
ps_me_optimised_function_list);
if(i4_cands)
{
ps_merge_prms->au1_pred_dir_searched[ps_merge_prms->i4_num_pred_dir_actual] =
u1_pred_dir;
ps_merge_prms->i4_num_pred_dir_actual++;
}
i4_num_merge_cands_evaluated += i4_cands;
}
/* Call the decide_part_types function here */
/* Populate the new PU struct with the results post subpel refinement*/
if(i4_num_merge_cands_evaluated)
{
inter_cu_results_t *ps_cu_results = ps_results_merge->ps_cu_results;
hme_reset_wkg_mem(&ps_ctxt->s_buf_mgr);
ps_merge_prms->ps_inter_ctb_prms->i4_ctb_x_off = ps_merge_prms->i4_ctb_x_off;
ps_merge_prms->ps_inter_ctb_prms->i4_ctb_y_off = ps_merge_prms->i4_ctb_y_off;
hme_populate_pus(
ps_thrd_ctxt,
ps_ctxt,
ps_subpel_prms,
ps_results_merge,
ps_cu_results,
ps_pu_results,
ps_pu_result,
ps_merge_prms->ps_inter_ctb_prms,
&ps_ctxt->s_wt_pred,
ps_merge_prms->ps_layer_ctxt,
ps_merge_prms->au1_pred_dir_searched,
ps_merge_prms->i4_num_pred_dir_actual);
ps_cu_results->i4_inp_offset = (ps_cu_results->u1_x_off) + (ps_cu_results->u1_y_off * 64);
hme_decide_part_types(
ps_cu_results,
ps_pu_results,
ps_merge_prms->ps_inter_ctb_prms,
ps_ctxt,
ps_cmn_utils_optimised_function_list,
ps_me_optimised_function_list
);
/*****************************************************************/
/* INSERT INTRA RESULTS AT 32x32/64x64 LEVEL. */
/*****************************************************************/
#if DISABLE_INTRA_IN_BPICS
if(1 != ((ME_XTREME_SPEED_25 == ps_merge_prms->e_quality_preset) &&
(ps_ctxt->s_frm_prms.i4_temporal_layer_id > TEMPORAL_LAYER_DISABLE)))
#endif
{
if(!(DISABLE_INTRA_WHEN_NOISY && ps_merge_prms->ps_inter_ctb_prms->u1_is_cu_noisy))
{
hme_insert_intra_nodes_post_bipred(
ps_cu_results, ps_cur_ipe_ctb, ps_ctxt->frm_qstep);
}
}
}
else
{
return CU_SPLIT;
}
/* We check the best result of ref idx 0 and compare for parent vs child */
if((ps_merge_prms->e_quality_preset != ME_PRISTINE_QUALITY) ||
(CU_32x32 == ps_results_merge->e_cu_size))
{
i4_cost_parent = ps_results_merge->ps_cu_results->ps_best_results[0].i4_tot_cost;
/*********************************************************************/
/* Add the cost of signaling the CU tree bits. */
/* Assuming parent is not split, then we signal 1 bit for this parent*/
/* CU. If split, then 1 bit for parent CU + 4 bits for each child CU */
/* So, 4*lambda is extra for children cost. :Lokesh */
/*********************************************************************/
{
pred_ctxt_t *ps_pred_ctxt = &ps_results_merge->as_pred_ctxt[0];
i4_cost_children += ((4 * ps_pred_ctxt->lambda) >> (ps_pred_ctxt->lambda_q_shift));
}
if(i4_cost_parent < i4_cost_children)
{
return CU_MERGED;
}
return CU_SPLIT;
}
else
{
return CU_MERGED;
}
}
#define COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, ps_search_node, shift) \
{ \
(ps_mv)->i2_mv_x = (ps_search_node)->s_mv.i2_mvx >> (shift); \
(ps_mv)->i2_mv_y = (ps_search_node)->s_mv.i2_mvy >> (shift); \
*(pi1_ref_idx) = (ps_search_node)->i1_ref_idx; \
}
/**
********************************************************************************
* @fn hme_update_mv_bank_noencode(search_results_t *ps_search_results,
* layer_mv_t *ps_layer_mv,
* S32 i4_search_blk_x,
* S32 i4_search_blk_y,
* mvbank_update_prms_t *ps_prms)
*
* @brief Updates the mv bank in case there is no further encodign to be done
*
* @param[in] ps_search_results: contains results for the block just searched
*
* @param[in,out] ps_layer_mv : Has pointer to mv bank amongst other things
*
* @param[in] i4_search_blk_x : col num of blk being searched
*
* @param[in] i4_search_blk_y : row num of blk being searched
*
* @param[in] ps_prms : contains certain parameters which govern how updatedone
*
* @return None
********************************************************************************
*/
void hme_update_mv_bank_noencode(
search_results_t *ps_search_results,
layer_mv_t *ps_layer_mv,
S32 i4_search_blk_x,
S32 i4_search_blk_y,
mvbank_update_prms_t *ps_prms)
{
hme_mv_t *ps_mv;
hme_mv_t *ps_mv1, *ps_mv2, *ps_mv3, *ps_mv4;
S08 *pi1_ref_idx, *pi1_ref_idx1, *pi1_ref_idx2, *pi1_ref_idx3, *pi1_ref_idx4;
S32 i4_blk_x, i4_blk_y, i4_offset;
S32 i4_j, i4_ref_id;
search_node_t *ps_search_node;
search_node_t *ps_search_node_8x8, *ps_search_node_4x4_1;
search_node_t *ps_search_node_4x4_2, *ps_search_node_4x4_3;
search_node_t *ps_search_node_4x4_4;
i4_blk_x = i4_search_blk_x << ps_prms->i4_shift;
i4_blk_y = i4_search_blk_y << ps_prms->i4_shift;
i4_offset = i4_blk_x + i4_blk_y * ps_layer_mv->i4_num_blks_per_row;
i4_offset *= ps_layer_mv->i4_num_mvs_per_blk;
/* Identify the correct offset in the mvbank and the reference id buf */
ps_mv = ps_layer_mv->ps_mv + i4_offset;
pi1_ref_idx = ps_layer_mv->pi1_ref_idx + i4_offset;
/*************************************************************************/
/* Supposing we store the mvs in the same blk size as we searched (e.g. */
/* we searched 8x8 blks and store results for 8x8 blks), then we can */
/* do a straightforward single update of results. This will have a 1-1 */
/* correspondence. */
/*************************************************************************/
if(ps_layer_mv->e_blk_size == ps_prms->e_search_blk_size)
{
for(i4_ref_id = 0; i4_ref_id < (S32)ps_prms->i4_num_ref; i4_ref_id++)
{
ps_search_node = ps_search_results->aps_part_results[i4_ref_id][PART_ID_2Nx2N];
for(i4_j = 0; i4_j < ps_layer_mv->i4_num_mvs_per_ref; i4_j++)
{
COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, ps_search_node, 0);
ps_mv++;
pi1_ref_idx++;
ps_search_node++;
}
}
return;
}
/*************************************************************************/
/* Case where search blk size is 8x8, but we update 4x4 results. In this */
/* case, we need to have NxN partitions enabled in search. */
/* Further, we update on a 1-1 basis the 4x4 blk mvs from the respective */
/* NxN partition. We also update the 8x8 result into each of the 4x4 bank*/
/*************************************************************************/
ASSERT(ps_layer_mv->e_blk_size == BLK_4x4);
ASSERT(ps_prms->e_search_blk_size == BLK_8x8);
ASSERT((ps_search_results->i4_part_mask & (ENABLE_NxN)) == (ENABLE_NxN));
/*************************************************************************/
/* For every 4x4 blk we store corresponding 4x4 results and 1 8x8 result */
/* hence the below check. */
/*************************************************************************/
ASSERT(ps_layer_mv->i4_num_mvs_per_ref <= ps_search_results->u1_num_results_per_part + 1);
ps_mv1 = ps_mv;
ps_mv2 = ps_mv1 + ps_layer_mv->i4_num_mvs_per_blk;
ps_mv3 = ps_mv1 + (ps_layer_mv->i4_num_mvs_per_row);
ps_mv4 = ps_mv3 + (ps_layer_mv->i4_num_mvs_per_blk);
pi1_ref_idx1 = pi1_ref_idx;
pi1_ref_idx2 = pi1_ref_idx1 + ps_layer_mv->i4_num_mvs_per_blk;
pi1_ref_idx3 = pi1_ref_idx1 + (ps_layer_mv->i4_num_mvs_per_row);
pi1_ref_idx4 = pi1_ref_idx3 + (ps_layer_mv->i4_num_mvs_per_blk);
for(i4_ref_id = 0; i4_ref_id < (S32)ps_search_results->u1_num_active_ref; i4_ref_id++)
{
ps_search_node_8x8 = ps_search_results->aps_part_results[i4_ref_id][PART_ID_2Nx2N];
ps_search_node_4x4_1 = ps_search_results->aps_part_results[i4_ref_id][PART_ID_NxN_TL];
ps_search_node_4x4_2 = ps_search_results->aps_part_results[i4_ref_id][PART_ID_NxN_TR];
ps_search_node_4x4_3 = ps_search_results->aps_part_results[i4_ref_id][PART_ID_NxN_BL];
ps_search_node_4x4_4 = ps_search_results->aps_part_results[i4_ref_id][PART_ID_NxN_BR];
COPY_SEARCH_RESULT(ps_mv1, pi1_ref_idx1, ps_search_node_4x4_1, 0);
ps_mv1++;
pi1_ref_idx1++;
ps_search_node_4x4_1++;
COPY_SEARCH_RESULT(ps_mv2, pi1_ref_idx2, ps_search_node_4x4_2, 0);
ps_mv2++;
pi1_ref_idx2++;
ps_search_node_4x4_2++;
COPY_SEARCH_RESULT(ps_mv3, pi1_ref_idx3, ps_search_node_4x4_3, 0);
ps_mv3++;
pi1_ref_idx3++;
ps_search_node_4x4_3++;
COPY_SEARCH_RESULT(ps_mv4, pi1_ref_idx4, ps_search_node_4x4_4, 0);
ps_mv4++;
pi1_ref_idx4++;
ps_search_node_4x4_4++;
if(ps_layer_mv->i4_num_mvs_per_ref > 1)
{
COPY_SEARCH_RESULT(ps_mv1, pi1_ref_idx1, ps_search_node_8x8, 0);
ps_mv1++;
pi1_ref_idx1++;
COPY_SEARCH_RESULT(ps_mv2, pi1_ref_idx2, ps_search_node_8x8, 0);
ps_mv2++;
pi1_ref_idx2++;
COPY_SEARCH_RESULT(ps_mv3, pi1_ref_idx3, ps_search_node_8x8, 0);
ps_mv3++;
pi1_ref_idx3++;
COPY_SEARCH_RESULT(ps_mv4, pi1_ref_idx4, ps_search_node_8x8, 0);
ps_mv4++;
pi1_ref_idx4++;
}
for(i4_j = 2; i4_j < ps_layer_mv->i4_num_mvs_per_ref; i4_j++)
{
COPY_SEARCH_RESULT(ps_mv1, pi1_ref_idx1, ps_search_node_4x4_1, 0);
ps_mv1++;
pi1_ref_idx1++;
ps_search_node_4x4_1++;
COPY_SEARCH_RESULT(ps_mv2, pi1_ref_idx2, ps_search_node_4x4_2, 0);
ps_mv2++;
pi1_ref_idx2++;
ps_search_node_4x4_2++;
COPY_SEARCH_RESULT(ps_mv3, pi1_ref_idx3, ps_search_node_4x4_3, 0);
ps_mv3++;
pi1_ref_idx3++;
ps_search_node_4x4_3++;
COPY_SEARCH_RESULT(ps_mv4, pi1_ref_idx4, ps_search_node_4x4_4, 0);
ps_mv4++;
pi1_ref_idx4++;
ps_search_node_4x4_4++;
}
}
}
void hme_update_mv_bank_encode(
search_results_t *ps_search_results,
layer_mv_t *ps_layer_mv,
S32 i4_search_blk_x,
S32 i4_search_blk_y,
mvbank_update_prms_t *ps_prms,
U08 *pu1_pred_dir_searched,
S32 i4_num_act_ref_l0)
{
hme_mv_t *ps_mv;
hme_mv_t *ps_mv1, *ps_mv2, *ps_mv3, *ps_mv4;
S08 *pi1_ref_idx, *pi1_ref_idx1, *pi1_ref_idx2, *pi1_ref_idx3, *pi1_ref_idx4;
S32 i4_blk_x, i4_blk_y, i4_offset;
S32 j, i, num_parts;
search_node_t *ps_search_node_tl, *ps_search_node_tr;
search_node_t *ps_search_node_bl, *ps_search_node_br;
search_node_t s_zero_mv;
WORD32 i4_part_type = ps_search_results->ps_cu_results->ps_best_results[0].u1_part_type;
i4_blk_x = i4_search_blk_x << ps_prms->i4_shift;
i4_blk_y = i4_search_blk_y << ps_prms->i4_shift;
i4_offset = i4_blk_x + i4_blk_y * ps_layer_mv->i4_num_blks_per_row;
i4_offset *= ps_layer_mv->i4_num_mvs_per_blk;
/* Identify the correct offset in the mvbank and the reference id buf */
ps_mv = ps_layer_mv->ps_mv + i4_offset;
pi1_ref_idx = ps_layer_mv->pi1_ref_idx + i4_offset;
ASSERT(ps_layer_mv->e_blk_size == BLK_8x8);
ASSERT(ps_prms->e_search_blk_size == BLK_16x16);
/*************************************************************************/
/* For every 4x4 blk we store corresponding 4x4 results and 1 8x8 result */
/* hence the below check. */
/*************************************************************************/
ASSERT(ps_layer_mv->i4_num_mvs_per_ref <= ps_search_results->u1_num_best_results);
ps_mv1 = ps_mv;
ps_mv2 = ps_mv1 + ps_layer_mv->i4_num_mvs_per_blk;
ps_mv3 = ps_mv1 + (ps_layer_mv->i4_num_mvs_per_row);
ps_mv4 = ps_mv3 + (ps_layer_mv->i4_num_mvs_per_blk);
pi1_ref_idx1 = pi1_ref_idx;
pi1_ref_idx2 = pi1_ref_idx1 + ps_layer_mv->i4_num_mvs_per_blk;
pi1_ref_idx3 = pi1_ref_idx1 + (ps_layer_mv->i4_num_mvs_per_row);
pi1_ref_idx4 = pi1_ref_idx3 + (ps_layer_mv->i4_num_mvs_per_blk);
/* Initialize zero mv: default mv used for intra mvs */
s_zero_mv.s_mv.i2_mvx = 0;
s_zero_mv.s_mv.i2_mvy = 0;
s_zero_mv.i1_ref_idx = 0;
if((ps_search_results->e_cu_size == CU_16x16) && (ps_search_results->u1_split_flag) &&
(ps_search_results->i4_part_mask & ENABLE_NxN))
{
i4_part_type = PRT_NxN;
}
for(i = 0; i < ps_prms->i4_num_ref; i++)
{
for(j = 0; j < ps_layer_mv->i4_num_mvs_per_ref; j++)
{
WORD32 i4_part_id = ge_part_type_to_part_id[i4_part_type][0];
num_parts = gau1_num_parts_in_part_type[i4_part_type];
ps_search_node_tl =
ps_search_results->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id];
if(num_parts == 1)
{
ps_search_node_tr = ps_search_node_tl;
ps_search_node_bl = ps_search_node_tl;
ps_search_node_br = ps_search_node_tl;
}
else if(num_parts == 2)
{
/* For vertically oriented partitions, tl, bl pt to same result */
/* For horizontally oriented partition, tl, tr pt to same result */
/* This means for AMP, 2 of the 8x8 blks in mv bank have ambiguous */
/* result, e.g. for 4x16L. Here left 2 8x8 have the 4x16L partition */
/* and right 2 8x8 have 12x16R partition */
if(gau1_is_vert_part[i4_part_type])
{
ps_search_node_tr =
ps_search_results
->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id + 1];
ps_search_node_bl = ps_search_node_tl;
}
else
{
ps_search_node_tr = ps_search_node_tl;
ps_search_node_bl =
ps_search_results
->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id + 1];
}
ps_search_node_br =
ps_search_results->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id + 1];
}
else
{
/* 4 unique results */
ps_search_node_tr =
ps_search_results->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id + 1];
ps_search_node_bl =
ps_search_results->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id + 2];
ps_search_node_br =
ps_search_results->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id + 3];
}
if(ps_search_node_tl->s_mv.i2_mvx == INTRA_MV)
ps_search_node_tl++;
if(ps_search_node_tr->s_mv.i2_mvx == INTRA_MV)
ps_search_node_tr++;
if(ps_search_node_bl->s_mv.i2_mvx == INTRA_MV)
ps_search_node_bl++;
if(ps_search_node_br->s_mv.i2_mvx == INTRA_MV)
ps_search_node_br++;
COPY_SEARCH_RESULT(ps_mv1, pi1_ref_idx1, ps_search_node_tl, 0);
ps_mv1++;
pi1_ref_idx1++;
COPY_SEARCH_RESULT(ps_mv2, pi1_ref_idx2, ps_search_node_tr, 0);
ps_mv2++;
pi1_ref_idx2++;
COPY_SEARCH_RESULT(ps_mv3, pi1_ref_idx3, ps_search_node_bl, 0);
ps_mv3++;
pi1_ref_idx3++;
COPY_SEARCH_RESULT(ps_mv4, pi1_ref_idx4, ps_search_node_br, 0);
ps_mv4++;
pi1_ref_idx4++;
if(ps_prms->i4_num_results_to_store > 1)
{
ps_search_node_tl =
&ps_search_results->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id][1];
if(num_parts == 1)
{
ps_search_node_tr = ps_search_node_tl;
ps_search_node_bl = ps_search_node_tl;
ps_search_node_br = ps_search_node_tl;
}
else if(num_parts == 2)
{
/* For vertically oriented partitions, tl, bl pt to same result */
/* For horizontally oriented partition, tl, tr pt to same result */
/* This means for AMP, 2 of the 8x8 blks in mv bank have ambiguous */
/* result, e.g. for 4x16L. Here left 2 8x8 have the 4x16L partition */
/* and right 2 8x8 have 12x16R partition */
if(gau1_is_vert_part[i4_part_type])
{
ps_search_node_tr =
&ps_search_results
->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id + 1][1];
ps_search_node_bl = ps_search_node_tl;
}
else
{
ps_search_node_tr = ps_search_node_tl;
ps_search_node_bl =
&ps_search_results
->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id + 1][1];
}
ps_search_node_br =
&ps_search_results
->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id + 1][1];
}
else
{
/* 4 unique results */
ps_search_node_tr =
&ps_search_results
->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id + 1][1];
ps_search_node_bl =
&ps_search_results
->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id + 2][1];
ps_search_node_br =
&ps_search_results
->aps_part_results[pu1_pred_dir_searched[i]][i4_part_id + 3][1];
}
if(ps_search_node_tl->s_mv.i2_mvx == INTRA_MV)
ps_search_node_tl++;
if(ps_search_node_tr->s_mv.i2_mvx == INTRA_MV)
ps_search_node_tr++;
if(ps_search_node_bl->s_mv.i2_mvx == INTRA_MV)
ps_search_node_bl++;
if(ps_search_node_br->s_mv.i2_mvx == INTRA_MV)
ps_search_node_br++;
COPY_SEARCH_RESULT(ps_mv1, pi1_ref_idx1, ps_search_node_tl, 0);
ps_mv1++;
pi1_ref_idx1++;
COPY_SEARCH_RESULT(ps_mv2, pi1_ref_idx2, ps_search_node_tr, 0);
ps_mv2++;
pi1_ref_idx2++;
COPY_SEARCH_RESULT(ps_mv3, pi1_ref_idx3, ps_search_node_bl, 0);
ps_mv3++;
pi1_ref_idx3++;
COPY_SEARCH_RESULT(ps_mv4, pi1_ref_idx4, ps_search_node_br, 0);
ps_mv4++;
pi1_ref_idx4++;
}
}
}
}
/**
********************************************************************************
* @fn hme_update_mv_bank_noencode(search_results_t *ps_search_results,
* layer_mv_t *ps_layer_mv,
* S32 i4_search_blk_x,
* S32 i4_search_blk_y,
* mvbank_update_prms_t *ps_prms)
*
* @brief Updates the mv bank in case there is no further encodign to be done
*
* @param[in] ps_search_results: contains results for the block just searched
*
* @param[in,out] ps_layer_mv : Has pointer to mv bank amongst other things
*
* @param[in] i4_search_blk_x : col num of blk being searched
*
* @param[in] i4_search_blk_y : row num of blk being searched
*
* @param[in] ps_prms : contains certain parameters which govern how updatedone
*
* @return None
********************************************************************************
*/
void hme_update_mv_bank_in_l1_me(
search_results_t *ps_search_results,
layer_mv_t *ps_layer_mv,
S32 i4_search_blk_x,
S32 i4_search_blk_y,
mvbank_update_prms_t *ps_prms)
{
hme_mv_t *ps_mv;
hme_mv_t *ps_mv1, *ps_mv2, *ps_mv3, *ps_mv4;
S08 *pi1_ref_idx, *pi1_ref_idx1, *pi1_ref_idx2, *pi1_ref_idx3, *pi1_ref_idx4;
S32 i4_blk_x, i4_blk_y, i4_offset;
S32 i4_j, i4_ref_id;
search_node_t *ps_search_node;
search_node_t *ps_search_node_8x8, *ps_search_node_4x4;
i4_blk_x = i4_search_blk_x << ps_prms->i4_shift;
i4_blk_y = i4_search_blk_y << ps_prms->i4_shift;
i4_offset = i4_blk_x + i4_blk_y * ps_layer_mv->i4_num_blks_per_row;
i4_offset *= ps_layer_mv->i4_num_mvs_per_blk;
/* Identify the correct offset in the mvbank and the reference id buf */
ps_mv = ps_layer_mv->ps_mv + i4_offset;
pi1_ref_idx = ps_layer_mv->pi1_ref_idx + i4_offset;
/*************************************************************************/
/* Supposing we store the mvs in the same blk size as we searched (e.g. */
/* we searched 8x8 blks and store results for 8x8 blks), then we can */
/* do a straightforward single update of results. This will have a 1-1 */
/* correspondence. */
/*************************************************************************/
if(ps_layer_mv->e_blk_size == ps_prms->e_search_blk_size)
{
search_node_t *aps_result_nodes_sorted[2][MAX_NUM_REF * 2];
hme_mv_t *ps_mv_l0_root = ps_mv;
hme_mv_t *ps_mv_l1_root =
ps_mv + (ps_prms->i4_num_active_ref_l0 * ps_layer_mv->i4_num_mvs_per_ref);
U32 u4_num_l0_results_updated = 0;
U32 u4_num_l1_results_updated = 0;
S08 *pi1_ref_idx_l0_root = pi1_ref_idx;
S08 *pi1_ref_idx_l1_root =
pi1_ref_idx_l0_root + (ps_prms->i4_num_active_ref_l0 * ps_layer_mv->i4_num_mvs_per_ref);
for(i4_ref_id = 0; i4_ref_id < (S32)ps_prms->i4_num_ref; i4_ref_id++)
{
U32 *pu4_num_results_updated;
search_node_t **pps_result_nodes;
U08 u1_pred_dir_of_cur_ref = !ps_search_results->pu1_is_past[i4_ref_id];
if(u1_pred_dir_of_cur_ref)
{
pu4_num_results_updated = &u4_num_l1_results_updated;
pps_result_nodes = &aps_result_nodes_sorted[1][0];
}
else
{
pu4_num_results_updated = &u4_num_l0_results_updated;
pps_result_nodes = &aps_result_nodes_sorted[0][0];
}
ps_search_node = ps_search_results->aps_part_results[i4_ref_id][PART_ID_2Nx2N];
for(i4_j = 0; i4_j < ps_layer_mv->i4_num_mvs_per_ref; i4_j++)
{
hme_add_new_node_to_a_sorted_array(
&ps_search_node[i4_j], pps_result_nodes, NULL, *pu4_num_results_updated, 0);
ASSERT(ps_search_node[i4_j].i1_ref_idx == i4_ref_id);
(*pu4_num_results_updated)++;
}
}
for(i4_j = 0; i4_j < (S32)u4_num_l0_results_updated; i4_j++)
{
COPY_SEARCH_RESULT(
&ps_mv_l0_root[i4_j],
&pi1_ref_idx_l0_root[i4_j],
aps_result_nodes_sorted[0][i4_j],
0);
}
for(i4_j = 0; i4_j < (S32)u4_num_l1_results_updated; i4_j++)
{
COPY_SEARCH_RESULT(
&ps_mv_l1_root[i4_j],
&pi1_ref_idx_l1_root[i4_j],
aps_result_nodes_sorted[1][i4_j],
0);
}
return;
}
/*************************************************************************/
/* Case where search blk size is 8x8, but we update 4x4 results. In this */
/* case, we need to have NxN partitions enabled in search. */
/* Further, we update on a 1-1 basis the 4x4 blk mvs from the respective */
/* NxN partition. We also update the 8x8 result into each of the 4x4 bank*/
/*************************************************************************/
ASSERT(ps_layer_mv->e_blk_size == BLK_4x4);
ASSERT(ps_prms->e_search_blk_size == BLK_8x8);
ASSERT((ps_search_results->i4_part_mask & (ENABLE_NxN)) == (ENABLE_NxN));
/*************************************************************************/
/* For every 4x4 blk we store corresponding 4x4 results and 1 8x8 result */
/* hence the below check. */
/*************************************************************************/
ASSERT(ps_layer_mv->i4_num_mvs_per_ref <= ps_search_results->u1_num_results_per_part + 1);
ps_mv1 = ps_mv;
ps_mv2 = ps_mv1 + ps_layer_mv->i4_num_mvs_per_blk;
ps_mv3 = ps_mv1 + (ps_layer_mv->i4_num_mvs_per_row);
ps_mv4 = ps_mv3 + (ps_layer_mv->i4_num_mvs_per_blk);
pi1_ref_idx1 = pi1_ref_idx;
pi1_ref_idx2 = pi1_ref_idx1 + ps_layer_mv->i4_num_mvs_per_blk;
pi1_ref_idx3 = pi1_ref_idx1 + (ps_layer_mv->i4_num_mvs_per_row);
pi1_ref_idx4 = pi1_ref_idx3 + (ps_layer_mv->i4_num_mvs_per_blk);
{
/* max ref frames * max results per partition * number of partitions (4x4, 8x8) */
search_node_t *aps_result_nodes_sorted[2][MAX_NUM_REF * MAX_RESULTS_PER_PART * 2];
U08 au1_cost_shifts_for_sorted_node[2][MAX_NUM_REF * MAX_RESULTS_PER_PART * 2];
S32 i;
hme_mv_t *ps_mv1_l0_root = ps_mv1;
hme_mv_t *ps_mv1_l1_root =
ps_mv1 + (ps_prms->i4_num_active_ref_l0 * ps_layer_mv->i4_num_mvs_per_ref);
hme_mv_t *ps_mv2_l0_root = ps_mv2;
hme_mv_t *ps_mv2_l1_root =
ps_mv2 + (ps_prms->i4_num_active_ref_l0 * ps_layer_mv->i4_num_mvs_per_ref);
hme_mv_t *ps_mv3_l0_root = ps_mv3;
hme_mv_t *ps_mv3_l1_root =
ps_mv3 + (ps_prms->i4_num_active_ref_l0 * ps_layer_mv->i4_num_mvs_per_ref);
hme_mv_t *ps_mv4_l0_root = ps_mv4;
hme_mv_t *ps_mv4_l1_root =
ps_mv4 + (ps_prms->i4_num_active_ref_l0 * ps_layer_mv->i4_num_mvs_per_ref);
U32 u4_num_l0_results_updated = 0;
U32 u4_num_l1_results_updated = 0;
S08 *pi1_ref_idx1_l0_root = pi1_ref_idx1;
S08 *pi1_ref_idx1_l1_root = pi1_ref_idx1_l0_root + (ps_prms->i4_num_active_ref_l0 *
ps_layer_mv->i4_num_mvs_per_ref);
S08 *pi1_ref_idx2_l0_root = pi1_ref_idx2;
S08 *pi1_ref_idx2_l1_root = pi1_ref_idx2_l0_root + (ps_prms->i4_num_active_ref_l0 *
ps_layer_mv->i4_num_mvs_per_ref);
S08 *pi1_ref_idx3_l0_root = pi1_ref_idx3;
S08 *pi1_ref_idx3_l1_root = pi1_ref_idx3_l0_root + (ps_prms->i4_num_active_ref_l0 *
ps_layer_mv->i4_num_mvs_per_ref);
S08 *pi1_ref_idx4_l0_root = pi1_ref_idx4;
S08 *pi1_ref_idx4_l1_root = pi1_ref_idx4_l0_root + (ps_prms->i4_num_active_ref_l0 *
ps_layer_mv->i4_num_mvs_per_ref);
for(i = 0; i < 4; i++)
{
hme_mv_t *ps_mv_l0_root;
hme_mv_t *ps_mv_l1_root;
S08 *pi1_ref_idx_l0_root;
S08 *pi1_ref_idx_l1_root;
for(i4_ref_id = 0; i4_ref_id < ps_search_results->u1_num_active_ref; i4_ref_id++)
{
U32 *pu4_num_results_updated;
search_node_t **pps_result_nodes;
U08 *pu1_cost_shifts_for_sorted_node;
U08 u1_pred_dir_of_cur_ref = !ps_search_results->pu1_is_past[i4_ref_id];
if(u1_pred_dir_of_cur_ref)
{
pu4_num_results_updated = &u4_num_l1_results_updated;
pps_result_nodes = &aps_result_nodes_sorted[1][0];
pu1_cost_shifts_for_sorted_node = &au1_cost_shifts_for_sorted_node[1][0];
}
else
{
pu4_num_results_updated = &u4_num_l0_results_updated;
pps_result_nodes = &aps_result_nodes_sorted[0][0];
pu1_cost_shifts_for_sorted_node = &au1_cost_shifts_for_sorted_node[1][0];
}
ps_search_node_8x8 = ps_search_results->aps_part_results[i4_ref_id][PART_ID_2Nx2N];
ps_search_node_4x4 =
ps_search_results->aps_part_results[i4_ref_id][PART_ID_NxN_TL + i];
for(i4_j = 0; i4_j < ps_layer_mv->i4_num_mvs_per_ref; i4_j++)
{
hme_add_new_node_to_a_sorted_array(
&ps_search_node_4x4[i4_j],
pps_result_nodes,
pu1_cost_shifts_for_sorted_node,
*pu4_num_results_updated,
0);
(*pu4_num_results_updated)++;
hme_add_new_node_to_a_sorted_array(
&ps_search_node_8x8[i4_j],
pps_result_nodes,
pu1_cost_shifts_for_sorted_node,
*pu4_num_results_updated,
2);
(*pu4_num_results_updated)++;
}
}
switch(i)
{
case 0:
{
ps_mv_l0_root = ps_mv1_l0_root;
ps_mv_l1_root = ps_mv1_l1_root;
pi1_ref_idx_l0_root = pi1_ref_idx1_l0_root;
pi1_ref_idx_l1_root = pi1_ref_idx1_l1_root;
break;
}
case 1:
{
ps_mv_l0_root = ps_mv2_l0_root;
ps_mv_l1_root = ps_mv2_l1_root;
pi1_ref_idx_l0_root = pi1_ref_idx2_l0_root;
pi1_ref_idx_l1_root = pi1_ref_idx2_l1_root;
break;
}
case 2:
{
ps_mv_l0_root = ps_mv3_l0_root;
ps_mv_l1_root = ps_mv3_l1_root;
pi1_ref_idx_l0_root = pi1_ref_idx3_l0_root;
pi1_ref_idx_l1_root = pi1_ref_idx3_l1_root;
break;
}
case 3:
{
ps_mv_l0_root = ps_mv4_l0_root;
ps_mv_l1_root = ps_mv4_l1_root;
pi1_ref_idx_l0_root = pi1_ref_idx4_l0_root;
pi1_ref_idx_l1_root = pi1_ref_idx4_l1_root;
break;
}
}
u4_num_l0_results_updated =
MIN((S32)u4_num_l0_results_updated,
ps_prms->i4_num_active_ref_l0 * ps_layer_mv->i4_num_mvs_per_ref);
u4_num_l1_results_updated =
MIN((S32)u4_num_l1_results_updated,
ps_prms->i4_num_active_ref_l1 * ps_layer_mv->i4_num_mvs_per_ref);
for(i4_j = 0; i4_j < (S32)u4_num_l0_results_updated; i4_j++)
{
COPY_SEARCH_RESULT(
&ps_mv_l0_root[i4_j],
&pi1_ref_idx_l0_root[i4_j],
aps_result_nodes_sorted[0][i4_j],
0);
}
for(i4_j = 0; i4_j < (S32)u4_num_l1_results_updated; i4_j++)
{
COPY_SEARCH_RESULT(
&ps_mv_l1_root[i4_j],
&pi1_ref_idx_l1_root[i4_j],
aps_result_nodes_sorted[1][i4_j],
0);
}
}
}
}
/**
******************************************************************************
* @brief Scales motion vector component projecte from a diff layer in same
* picture (so no ref id related delta poc scaling required)
******************************************************************************
*/
#define SCALE_MV_COMP_RES(mvcomp_p, dim_c, dim_p) \
((((mvcomp_p) * (dim_c)) + ((SIGN((mvcomp_p)) * (dim_p)) >> 1)) / (dim_p))
/**
********************************************************************************
* @fn hme_project_coloc_candt(search_node_t *ps_search_node,
* layer_ctxt_t *ps_curr_layer,
* layer_ctxt_t *ps_coarse_layer,
* S32 i4_pos_x,
* S32 i4_pos_y,
* S08 i1_ref_id,
* S08 i1_result_id)
*
* @brief From a coarser layer, projects a candidated situated at "colocated"
* position in the picture (e.g. given x, y it will be x/2, y/2 dyadic
*
* @param[out] ps_search_node : contains the projected result
*
* @param[in] ps_curr_layer : current layer context
*
* @param[in] ps_coarse_layer : coarser layer context
*
* @param[in] i4_pos_x : x Position where mv is required (w.r.t. curr layer)
*
* @param[in] i4_pos_y : y Position where mv is required (w.r.t. curr layer)
*
* @param[in] i1_ref_id : reference id for which the candidate required
*
* @param[in] i4_result_id : result id for which the candidate required
* (0 : best result, 1 : next best)
*
* @return None
********************************************************************************
*/
void hme_project_coloc_candt(
search_node_t *ps_search_node,
layer_ctxt_t *ps_curr_layer,
layer_ctxt_t *ps_coarse_layer,
S32 i4_pos_x,
S32 i4_pos_y,
S08 i1_ref_id,
S32 i4_result_id)
{
S32 wd_c, ht_c, wd_p, ht_p;
S32 blksize_p, blk_x, blk_y, i4_offset;
layer_mv_t *ps_layer_mvbank;
hme_mv_t *ps_mv;
S08 *pi1_ref_idx;
/* Width and ht of current and prev layers */
wd_c = ps_curr_layer->i4_wd;
ht_c = ps_curr_layer->i4_ht;
wd_p = ps_coarse_layer->i4_wd;
ht_p = ps_coarse_layer->i4_ht;
ps_layer_mvbank = ps_coarse_layer->ps_layer_mvbank;
blksize_p = (S32)gau1_blk_size_to_wd[ps_layer_mvbank->e_blk_size];
/* Safety check to avoid uninitialized access across temporal layers */
i4_pos_x = CLIP3(i4_pos_x, 0, (wd_c - blksize_p));
i4_pos_y = CLIP3(i4_pos_y, 0, (ht_c - blksize_p));
/* Project the positions to prev layer */
/* TODO: convert these to scale factors at pic level */
blk_x = (i4_pos_x * wd_p) / (wd_c * blksize_p);
blk_y = (i4_pos_y * ht_p) / (ht_c * blksize_p);
/* Pick up the mvs from the location */
i4_offset = (blk_x * ps_layer_mvbank->i4_num_mvs_per_blk);
i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * blk_y);
ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;
ps_mv += (i1_ref_id * ps_layer_mvbank->i4_num_mvs_per_ref);
pi1_ref_idx += (i1_ref_id * ps_layer_mvbank->i4_num_mvs_per_ref);
ps_search_node->s_mv.i2_mvx = SCALE_MV_COMP_RES(ps_mv[i4_result_id].i2_mv_x, wd_c, wd_p);
ps_search_node->s_mv.i2_mvy = SCALE_MV_COMP_RES(ps_mv[i4_result_id].i2_mv_y, ht_c, ht_p);
ps_search_node->i1_ref_idx = pi1_ref_idx[i4_result_id];
ps_search_node->u1_subpel_done = 0;
if((ps_search_node->i1_ref_idx < 0) || (ps_search_node->s_mv.i2_mvx == INTRA_MV))
{
ps_search_node->i1_ref_idx = i1_ref_id;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
}
}
/**
********************************************************************************
* @fn hme_project_coloc_candt_dyadic(search_node_t *ps_search_node,
* layer_ctxt_t *ps_curr_layer,
* layer_ctxt_t *ps_coarse_layer,
* S32 i4_pos_x,
* S32 i4_pos_y,
* S08 i1_ref_id,
* S08 i1_result_id)
*
* @brief From a coarser layer, projects a candidated situated at "colocated"
* position in the picture when the ratios are dyadic
*
* @param[out] ps_search_node : contains the projected result
*
* @param[in] ps_curr_layer : current layer context
*
* @param[in] ps_coarse_layer : coarser layer context
*
* @param[in] i4_pos_x : x Position where mv is required (w.r.t. curr layer)
*
* @param[in] i4_pos_y : y Position where mv is required (w.r.t. curr layer)
*
* @param[in] i1_ref_id : reference id for which the candidate required
*
* @param[in] i4_result_id : result id for which the candidate required
* (0 : best result, 1 : next best)
*
* @return None
********************************************************************************
*/
void hme_project_coloc_candt_dyadic(
search_node_t *ps_search_node,
layer_ctxt_t *ps_curr_layer,
layer_ctxt_t *ps_coarse_layer,
S32 i4_pos_x,
S32 i4_pos_y,
S08 i1_ref_id,
S32 i4_result_id)
{
S32 wd_c, ht_c, wd_p, ht_p;
S32 blksize_p, blk_x, blk_y, i4_offset;
layer_mv_t *ps_layer_mvbank;
hme_mv_t *ps_mv;
S08 *pi1_ref_idx;
/* Width and ht of current and prev layers */
wd_c = ps_curr_layer->i4_wd;
ht_c = ps_curr_layer->i4_ht;
wd_p = ps_coarse_layer->i4_wd;
ht_p = ps_coarse_layer->i4_ht;
ps_layer_mvbank = ps_coarse_layer->ps_layer_mvbank;
/* blksize_p = log2(wd) + 1 */
blksize_p = (S32)gau1_blk_size_to_wd_shift[ps_layer_mvbank->e_blk_size];
/* ASSERT for valid sizes */
ASSERT((blksize_p == 3) || (blksize_p == 4) || (blksize_p == 5));
/* Safety check to avoid uninitialized access across temporal layers */
i4_pos_x = CLIP3(i4_pos_x, 0, (wd_c - blksize_p));
i4_pos_y = CLIP3(i4_pos_y, 0, (ht_c - blksize_p));
/* Project the positions to prev layer */
/* TODO: convert these to scale factors at pic level */
blk_x = i4_pos_x >> blksize_p; // (2 * blksize_p);
blk_y = i4_pos_y >> blksize_p; // (2 * blksize_p);
/* Pick up the mvs from the location */
i4_offset = (blk_x * ps_layer_mvbank->i4_num_mvs_per_blk);
i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * blk_y);
ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;
ps_mv += (i1_ref_id * ps_layer_mvbank->i4_num_mvs_per_ref);
pi1_ref_idx += (i1_ref_id * ps_layer_mvbank->i4_num_mvs_per_ref);
ps_search_node->s_mv.i2_mvx = ps_mv[i4_result_id].i2_mv_x << 1;
ps_search_node->s_mv.i2_mvy = ps_mv[i4_result_id].i2_mv_y << 1;
ps_search_node->i1_ref_idx = pi1_ref_idx[i4_result_id];
if((ps_search_node->i1_ref_idx < 0) || (ps_search_node->s_mv.i2_mvx == INTRA_MV))
{
ps_search_node->i1_ref_idx = i1_ref_id;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
}
}
void hme_project_coloc_candt_dyadic_implicit(
search_node_t *ps_search_node,
layer_ctxt_t *ps_curr_layer,
layer_ctxt_t *ps_coarse_layer,
S32 i4_pos_x,
S32 i4_pos_y,
S32 i4_num_act_ref_l0,
U08 u1_pred_dir,
U08 u1_default_ref_id,
S32 i4_result_id)
{
S32 wd_c, ht_c, wd_p, ht_p;
S32 blksize_p, blk_x, blk_y, i4_offset;
layer_mv_t *ps_layer_mvbank;
hme_mv_t *ps_mv;
S08 *pi1_ref_idx;
/* Width and ht of current and prev layers */
wd_c = ps_curr_layer->i4_wd;
ht_c = ps_curr_layer->i4_ht;
wd_p = ps_coarse_layer->i4_wd;
ht_p = ps_coarse_layer->i4_ht;
ps_layer_mvbank = ps_coarse_layer->ps_layer_mvbank;
blksize_p = (S32)gau1_blk_size_to_wd_shift[ps_layer_mvbank->e_blk_size];
/* ASSERT for valid sizes */
ASSERT((blksize_p == 3) || (blksize_p == 4) || (blksize_p == 5));
/* Safety check to avoid uninitialized access across temporal layers */
i4_pos_x = CLIP3(i4_pos_x, 0, (wd_c - blksize_p));
i4_pos_y = CLIP3(i4_pos_y, 0, (ht_c - blksize_p));
/* Project the positions to prev layer */
/* TODO: convert these to scale factors at pic level */
blk_x = i4_pos_x >> blksize_p; // (2 * blksize_p);
blk_y = i4_pos_y >> blksize_p; // (2 * blksize_p);
/* Pick up the mvs from the location */
i4_offset = (blk_x * ps_layer_mvbank->i4_num_mvs_per_blk);
i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * blk_y);
ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;
if(u1_pred_dir == 1)
{
ps_mv += (i4_num_act_ref_l0 * ps_layer_mvbank->i4_num_mvs_per_ref);
pi1_ref_idx += (i4_num_act_ref_l0 * ps_layer_mvbank->i4_num_mvs_per_ref);
}
ps_search_node->s_mv.i2_mvx = ps_mv[i4_result_id].i2_mv_x << 1;
ps_search_node->s_mv.i2_mvy = ps_mv[i4_result_id].i2_mv_y << 1;
ps_search_node->i1_ref_idx = pi1_ref_idx[i4_result_id];
if((ps_search_node->i1_ref_idx < 0) || (ps_search_node->s_mv.i2_mvx == INTRA_MV))
{
ps_search_node->i1_ref_idx = u1_default_ref_id;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
}
}
#define SCALE_RANGE_PRMS(prm1, prm2, shift) \
{ \
prm1.i2_min_x = prm2.i2_min_x << shift; \
prm1.i2_max_x = prm2.i2_max_x << shift; \
prm1.i2_min_y = prm2.i2_min_y << shift; \
prm1.i2_max_y = prm2.i2_max_y << shift; \
}
#define SCALE_RANGE_PRMS_POINTERS(prm1, prm2, shift) \
{ \
prm1->i2_min_x = prm2->i2_min_x << shift; \
prm1->i2_max_x = prm2->i2_max_x << shift; \
prm1->i2_min_y = prm2->i2_min_y << shift; \
prm1->i2_max_y = prm2->i2_max_y << shift; \
}
/**
********************************************************************************
* @fn void hme_refine_frm_init(me_ctxt_t *ps_ctxt,
* refine_layer_prms_t *ps_refine_prms)
*
* @brief Frame init of refinemnet layers in ME
*
* @param[in,out] ps_ctxt: ME Handle
*
* @param[in] ps_refine_prms : refinement layer prms
*
* @return None
********************************************************************************
*/
void hme_refine_frm_init(
layer_ctxt_t *ps_curr_layer, refine_prms_t *ps_refine_prms, layer_ctxt_t *ps_coarse_layer)
{
/* local variables */
BLK_SIZE_T e_result_blk_size = BLK_8x8;
S32 i4_num_ref_fpel, i4_num_ref_prev_layer;
i4_num_ref_prev_layer = ps_coarse_layer->ps_layer_mvbank->i4_num_ref;
if(ps_refine_prms->explicit_ref)
{
i4_num_ref_fpel = i4_num_ref_prev_layer;
}
else
{
i4_num_ref_fpel = 2;
}
if(ps_refine_prms->i4_enable_4x4_part)
{
e_result_blk_size = BLK_4x4;
}
i4_num_ref_fpel = MIN(i4_num_ref_fpel, i4_num_ref_prev_layer);
hme_init_mv_bank(
ps_curr_layer,
e_result_blk_size,
i4_num_ref_fpel,
ps_refine_prms->i4_num_mvbank_results,
ps_refine_prms->i4_layer_id > 0 ? 0 : 1);
}
#if 1 //ENABLE_CU_RECURSION || TEST_AND_EVALUATE_CU_RECURSION
/**
********************************************************************************
* @fn void hme_init_clusters_16x16
* (
* cluster_16x16_blk_t *ps_cluster_blk_16x16
* )
*
* @brief Intialisations for the structs used in clustering algorithm
*
* @param[in/out] ps_cluster_blk_16x16: pointer to structure containing clusters
* of 16x16 block
*
* @return None
********************************************************************************
*/
static __inline void
hme_init_clusters_16x16(cluster_16x16_blk_t *ps_cluster_blk_16x16, S32 bidir_enabled)
{
S32 i;
ps_cluster_blk_16x16->num_clusters = 0;
ps_cluster_blk_16x16->intra_mv_area = 0;
ps_cluster_blk_16x16->best_inter_cost = 0;
for(i = 0; i < MAX_NUM_CLUSTERS_16x16; i++)
{
ps_cluster_blk_16x16->as_cluster_data[i].max_dist_from_centroid =
bidir_enabled ? MAX_DISTANCE_FROM_CENTROID_16x16_B : MAX_DISTANCE_FROM_CENTROID_16x16;
ps_cluster_blk_16x16->as_cluster_data[i].is_valid_cluster = 0;
ps_cluster_blk_16x16->as_cluster_data[i].bi_mv_pixel_area = 0;
ps_cluster_blk_16x16->as_cluster_data[i].uni_mv_pixel_area = 0;
}
for(i = 0; i < MAX_NUM_REF; i++)
{
ps_cluster_blk_16x16->au1_num_clusters[i] = 0;
}
}
/**
********************************************************************************
* @fn void hme_init_clusters_32x32
* (
* cluster_32x32_blk_t *ps_cluster_blk_32x32
* )
*
* @brief Intialisations for the structs used in clustering algorithm
*
* @param[in/out] ps_cluster_blk_32x32: pointer to structure containing clusters
* of 32x32 block
*
* @return None
********************************************************************************
*/
static __inline void
hme_init_clusters_32x32(cluster_32x32_blk_t *ps_cluster_blk_32x32, S32 bidir_enabled)
{
S32 i;
ps_cluster_blk_32x32->num_clusters = 0;
ps_cluster_blk_32x32->intra_mv_area = 0;
ps_cluster_blk_32x32->best_alt_ref = -1;
ps_cluster_blk_32x32->best_uni_ref = -1;
ps_cluster_blk_32x32->best_inter_cost = 0;
ps_cluster_blk_32x32->num_clusters_with_weak_sdi_density = 0;
for(i = 0; i < MAX_NUM_CLUSTERS_32x32; i++)
{
ps_cluster_blk_32x32->as_cluster_data[i].max_dist_from_centroid =
bidir_enabled ? MAX_DISTANCE_FROM_CENTROID_32x32_B : MAX_DISTANCE_FROM_CENTROID_32x32;
ps_cluster_blk_32x32->as_cluster_data[i].is_valid_cluster = 0;
ps_cluster_blk_32x32->as_cluster_data[i].bi_mv_pixel_area = 0;
ps_cluster_blk_32x32->as_cluster_data[i].uni_mv_pixel_area = 0;
}
for(i = 0; i < MAX_NUM_REF; i++)
{
ps_cluster_blk_32x32->au1_num_clusters[i] = 0;
}
}
/**
********************************************************************************
* @fn void hme_init_clusters_64x64
* (
* cluster_64x64_blk_t *ps_cluster_blk_64x64
* )
*
* @brief Intialisations for the structs used in clustering algorithm
*
* @param[in/out] ps_cluster_blk_64x64: pointer to structure containing clusters
* of 64x64 block
*
* @return None
********************************************************************************
*/
static __inline void
hme_init_clusters_64x64(cluster_64x64_blk_t *ps_cluster_blk_64x64, S32 bidir_enabled)
{
S32 i;
ps_cluster_blk_64x64->num_clusters = 0;
ps_cluster_blk_64x64->intra_mv_area = 0;
ps_cluster_blk_64x64->best_alt_ref = -1;
ps_cluster_blk_64x64->best_uni_ref = -1;
ps_cluster_blk_64x64->best_inter_cost = 0;
for(i = 0; i < MAX_NUM_CLUSTERS_64x64; i++)
{
ps_cluster_blk_64x64->as_cluster_data[i].max_dist_from_centroid =
bidir_enabled ? MAX_DISTANCE_FROM_CENTROID_64x64_B : MAX_DISTANCE_FROM_CENTROID_64x64;
ps_cluster_blk_64x64->as_cluster_data[i].is_valid_cluster = 0;
ps_cluster_blk_64x64->as_cluster_data[i].bi_mv_pixel_area = 0;
ps_cluster_blk_64x64->as_cluster_data[i].uni_mv_pixel_area = 0;
}
for(i = 0; i < MAX_NUM_REF; i++)
{
ps_cluster_blk_64x64->au1_num_clusters[i] = 0;
}
}
/**
********************************************************************************
* @fn void hme_sort_and_assign_top_ref_ids_areawise
* (
* ctb_cluster_info_t *ps_ctb_cluster_info
* )
*
* @brief Finds best_uni_ref and best_alt_ref
*
* @param[in/out] ps_ctb_cluster_info: structure that points to ctb data
*
* @param[in] bidir_enabled: flag that indicates whether or not bi-pred is
* enabled
*
* @param[in] block_width: width of the block in pels
*
* @param[in] e_cu_pos: position of the block within the CTB
*
* @return None
********************************************************************************
*/
void hme_sort_and_assign_top_ref_ids_areawise(
ctb_cluster_info_t *ps_ctb_cluster_info, S32 bidir_enabled, S32 block_width, CU_POS_T e_cu_pos)
{
cluster_32x32_blk_t *ps_32x32 = NULL;
cluster_64x64_blk_t *ps_64x64 = NULL;
cluster_data_t *ps_data;
S32 j, k;
S32 ai4_uni_area[MAX_NUM_REF];
S32 ai4_bi_area[MAX_NUM_REF];
S32 ai4_ref_id_found[MAX_NUM_REF];
S32 ai4_ref_id[MAX_NUM_REF];
S32 best_uni_ref = -1, best_alt_ref = -1;
S32 num_clusters;
S32 num_ref = 0;
S32 num_clusters_evaluated = 0;
S32 is_cur_blk_valid;
if(32 == block_width)
{
is_cur_blk_valid = (ps_ctb_cluster_info->blk_32x32_mask & (1 << e_cu_pos)) || 0;
ps_32x32 = &ps_ctb_cluster_info->ps_32x32_blk[e_cu_pos];
num_clusters = ps_32x32->num_clusters;
ps_data = &ps_32x32->as_cluster_data[0];
}
else
{
is_cur_blk_valid = (ps_ctb_cluster_info->blk_32x32_mask == 0xf);
ps_64x64 = ps_ctb_cluster_info->ps_64x64_blk;
num_clusters = ps_64x64->num_clusters;
ps_data = &ps_64x64->as_cluster_data[0];
}
#if !ENABLE_4CTB_EVALUATION
if((num_clusters > MAX_NUM_CLUSTERS_IN_VALID_32x32_BLK))
{
return;
}
#endif
if(num_clusters == 0)
{
return;
}
else if(!is_cur_blk_valid)
{
return;
}
memset(ai4_uni_area, 0, sizeof(S32) * MAX_NUM_REF);
memset(ai4_bi_area, 0, sizeof(S32) * MAX_NUM_REF);
memset(ai4_ref_id_found, 0, sizeof(S32) * MAX_NUM_REF);
memset(ai4_ref_id, -1, sizeof(S32) * MAX_NUM_REF);
for(j = 0; num_clusters_evaluated < num_clusters; j++, ps_data++)
{
S32 ref_id;
if(!ps_data->is_valid_cluster)
{
continue;
}
ref_id = ps_data->ref_id;
num_clusters_evaluated++;
ai4_uni_area[ref_id] += ps_data->uni_mv_pixel_area;
ai4_bi_area[ref_id] += ps_data->bi_mv_pixel_area;
if(!ai4_ref_id_found[ref_id])
{
ai4_ref_id[ref_id] = ref_id;
ai4_ref_id_found[ref_id] = 1;
num_ref++;
}
}
{
S32 ai4_ref_id_temp[MAX_NUM_REF];
memcpy(ai4_ref_id_temp, ai4_ref_id, sizeof(S32) * MAX_NUM_REF);
for(k = 1; k < MAX_NUM_REF; k++)
{
if(ai4_uni_area[k] > ai4_uni_area[0])
{
SWAP_HME(ai4_uni_area[k], ai4_uni_area[0], S32);
SWAP_HME(ai4_ref_id_temp[k], ai4_ref_id_temp[0], S32);
}
}
best_uni_ref = ai4_ref_id_temp[0];
}
if(bidir_enabled)
{
for(k = 1; k < MAX_NUM_REF; k++)
{
if(ai4_bi_area[k] > ai4_bi_area[0])
{
SWAP_HME(ai4_bi_area[k], ai4_bi_area[0], S32);
SWAP_HME(ai4_ref_id[k], ai4_ref_id[0], S32);
}
}
if(!ai4_bi_area[0])
{
best_alt_ref = -1;
if(32 == block_width)
{
SET_VALUES_FOR_TOP_REF_IDS(ps_32x32, best_uni_ref, best_alt_ref, num_ref);
}
else
{
SET_VALUES_FOR_TOP_REF_IDS(ps_64x64, best_uni_ref, best_alt_ref, num_ref);
}
return;
}
if(best_uni_ref == ai4_ref_id[0])
{
for(k = 2; k < MAX_NUM_REF; k++)
{
if(ai4_bi_area[k] > ai4_bi_area[1])
{
SWAP_HME(ai4_bi_area[k], ai4_bi_area[1], S32);
SWAP_HME(ai4_ref_id[k], ai4_ref_id[1], S32);
}
}
best_alt_ref = ai4_ref_id[1];
}
else
{
best_alt_ref = ai4_ref_id[0];
}
}
if(32 == block_width)
{
SET_VALUES_FOR_TOP_REF_IDS(ps_32x32, best_uni_ref, best_alt_ref, num_ref);
}
else
{
SET_VALUES_FOR_TOP_REF_IDS(ps_64x64, best_uni_ref, best_alt_ref, num_ref);
}
}
/**
********************************************************************************
* @fn void hme_find_top_ref_ids
* (
* ctb_cluster_info_t *ps_ctb_cluster_info
* )
*
* @brief Finds best_uni_ref and best_alt_ref
*
* @param[in/out] ps_ctb_cluster_info: structure that points to ctb data
*
* @return None
********************************************************************************
*/
void hme_find_top_ref_ids(
ctb_cluster_info_t *ps_ctb_cluster_info, S32 bidir_enabled, S32 block_width)
{
S32 i;
if(32 == block_width)
{
for(i = 0; i < 4; i++)
{
hme_sort_and_assign_top_ref_ids_areawise(
ps_ctb_cluster_info, bidir_enabled, block_width, (CU_POS_T)i);
}
}
else if(64 == block_width)
{
hme_sort_and_assign_top_ref_ids_areawise(
ps_ctb_cluster_info, bidir_enabled, block_width, POS_NA);
}
}
/**
********************************************************************************
* @fn void hme_boot_out_outlier
* (
* ctb_cluster_info_t *ps_ctb_cluster_info
* )
*
* @brief Removes outlier clusters before CU tree population
*
* @param[in/out] ps_ctb_cluster_info: structure that points to ctb data
*
* @return None
********************************************************************************
*/
void hme_boot_out_outlier(ctb_cluster_info_t *ps_ctb_cluster_info, S32 blk_width)
{
cluster_32x32_blk_t *ps_32x32;
S32 i;
cluster_64x64_blk_t *ps_64x64 = &ps_ctb_cluster_info->ps_64x64_blk[0];
S32 sdi_threshold = ps_ctb_cluster_info->sdi_threshold;
if(32 == blk_width)
{
/* 32x32 clusters */
for(i = 0; i < 4; i++)
{
ps_32x32 = &ps_ctb_cluster_info->ps_32x32_blk[i];
if(ps_32x32->num_clusters > MAX_NUM_CLUSTERS_IN_ONE_REF_IDX)
{
BUMP_OUTLIER_CLUSTERS(ps_32x32, sdi_threshold);
}
}
}
else if(64 == blk_width)
{
/* 64x64 clusters */
if(ps_64x64->num_clusters > MAX_NUM_CLUSTERS_IN_ONE_REF_IDX)
{
BUMP_OUTLIER_CLUSTERS(ps_64x64, sdi_threshold);
}
}
}
/**
********************************************************************************
* @fn void hme_update_cluster_attributes
* (
* cluster_data_t *ps_cluster_data,
* S32 mvx,
* S32 mvy,
* PART_ID_T e_part_id
* )
*
* @brief Implementation fo the clustering algorithm
*
* @param[in/out] ps_cluster_data: pointer to cluster_data_t struct
*
* @param[in] mvx : x co-ordinate of the motion vector
*
* @param[in] mvy : y co-ordinate of the motion vector
*
* @param[in] ref_idx : ref_id of the motion vector
*
* @param[in] e_part_id : partition id of the motion vector
*
* @return None
********************************************************************************
*/
static __inline void hme_update_cluster_attributes(
cluster_data_t *ps_cluster_data,
S32 mvx,
S32 mvy,
S32 mvdx,
S32 mvdy,
S32 ref_id,
S32 sdi,
U08 is_part_of_bi,
PART_ID_T e_part_id)
{
LWORD64 i8_mvx_sum_q8;
LWORD64 i8_mvy_sum_q8;
S32 centroid_posx_q8 = ps_cluster_data->s_centroid.i4_pos_x_q8;
S32 centroid_posy_q8 = ps_cluster_data->s_centroid.i4_pos_y_q8;
if((mvdx > 0) && (ps_cluster_data->min_x > mvx))
{
ps_cluster_data->min_x = mvx;
}
else if((mvdx < 0) && (ps_cluster_data->max_x < mvx))
{
ps_cluster_data->max_x = mvx;
}
if((mvdy > 0) && (ps_cluster_data->min_y > mvy))
{
ps_cluster_data->min_y = mvy;
}
else if((mvdy < 0) && (ps_cluster_data->max_y < mvy))
{
ps_cluster_data->max_y = mvy;
}
{
S32 num_mvs = ps_cluster_data->num_mvs;
ps_cluster_data->as_mv[num_mvs].pixel_count = gai4_partition_area[e_part_id];
ps_cluster_data->as_mv[num_mvs].mvx = mvx;
ps_cluster_data->as_mv[num_mvs].mvy = mvy;
/***************************/
ps_cluster_data->as_mv[num_mvs].is_uni = !is_part_of_bi;
ps_cluster_data->as_mv[num_mvs].sdi = sdi;
/**************************/
}
/* Updation of centroid */
{
i8_mvx_sum_q8 = (LWORD64)centroid_posx_q8 * ps_cluster_data->num_mvs + (mvx << 8);
i8_mvy_sum_q8 = (LWORD64)centroid_posy_q8 * ps_cluster_data->num_mvs + (mvy << 8);
ps_cluster_data->num_mvs++;
ps_cluster_data->s_centroid.i4_pos_x_q8 =
(WORD32)((i8_mvx_sum_q8) / ps_cluster_data->num_mvs);
ps_cluster_data->s_centroid.i4_pos_y_q8 =
(WORD32)((i8_mvy_sum_q8) / ps_cluster_data->num_mvs);
}
ps_cluster_data->area_in_pixels += gai4_partition_area[e_part_id];
if(is_part_of_bi)
{
ps_cluster_data->bi_mv_pixel_area += gai4_partition_area[e_part_id];
}
else
{
ps_cluster_data->uni_mv_pixel_area += gai4_partition_area[e_part_id];
}
}
/**
********************************************************************************
* @fn void hme_try_cluster_merge
* (
* cluster_data_t *ps_cluster_data,
* S32 *pi4_num_clusters,
* S32 idx_of_updated_cluster
* )
*
* @brief Implementation fo the clustering algorithm
*
* @param[in/out] ps_cluster_data: pointer to cluster_data_t struct
*
* @param[in/out] pi4_num_clusters : pointer to number of clusters
*
* @param[in] idx_of_updated_cluster : index of the cluster most recently
* updated
*
* @return Nothing
********************************************************************************
*/
void hme_try_cluster_merge(
cluster_data_t *ps_cluster_data, U08 *pu1_num_clusters, S32 idx_of_updated_cluster)
{
centroid_t *ps_centroid;
S32 cur_pos_x_q8;
S32 cur_pos_y_q8;
S32 i;
S32 max_dist_from_centroid;
S32 mvd;
S32 mvdx_q8;
S32 mvdx;
S32 mvdy_q8;
S32 mvdy;
S32 num_clusters, num_clusters_evaluated;
S32 other_pos_x_q8;
S32 other_pos_y_q8;
cluster_data_t *ps_root = ps_cluster_data;
cluster_data_t *ps_cur_cluster = &ps_cluster_data[idx_of_updated_cluster];
centroid_t *ps_cur_centroid = &ps_cur_cluster->s_centroid;
/* Merge is superfluous if num_clusters is 1 */
if(*pu1_num_clusters == 1)
{
return;
}
cur_pos_x_q8 = ps_cur_centroid->i4_pos_x_q8;
cur_pos_y_q8 = ps_cur_centroid->i4_pos_y_q8;
max_dist_from_centroid = ps_cur_cluster->max_dist_from_centroid;
num_clusters = *pu1_num_clusters;
num_clusters_evaluated = 0;
for(i = 0; num_clusters_evaluated < num_clusters; i++, ps_cluster_data++)
{
if(!ps_cluster_data->is_valid_cluster)
{
continue;
}
if((ps_cluster_data->ref_id != ps_cur_cluster->ref_id) || (i == idx_of_updated_cluster))
{
num_clusters_evaluated++;
continue;
}
ps_centroid = &ps_cluster_data->s_centroid;
other_pos_x_q8 = ps_centroid->i4_pos_x_q8;
other_pos_y_q8 = ps_centroid->i4_pos_y_q8;
mvdx_q8 = (cur_pos_x_q8 - other_pos_x_q8);
mvdy_q8 = (cur_pos_y_q8 - other_pos_y_q8);
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvd = ABS(mvdx) + ABS(mvdy);
if(mvd <= (max_dist_from_centroid >> 1))
{
/* 0 => no updates */
/* 1 => min updated */
/* 2 => max updated */
S32 minmax_x_update_id;
S32 minmax_y_update_id;
LWORD64 i8_mv_x_sum_self = (LWORD64)cur_pos_x_q8 * ps_cur_cluster->num_mvs;
LWORD64 i8_mv_y_sum_self = (LWORD64)cur_pos_y_q8 * ps_cur_cluster->num_mvs;
LWORD64 i8_mv_x_sum_cousin = (LWORD64)other_pos_x_q8 * ps_cluster_data->num_mvs;
LWORD64 i8_mv_y_sum_cousin = (LWORD64)other_pos_y_q8 * ps_cluster_data->num_mvs;
(*pu1_num_clusters)--;
ps_cluster_data->is_valid_cluster = 0;
memcpy(
&ps_cur_cluster->as_mv[ps_cur_cluster->num_mvs],
ps_cluster_data->as_mv,
sizeof(mv_data_t) * ps_cluster_data->num_mvs);
ps_cur_cluster->num_mvs += ps_cluster_data->num_mvs;
ps_cur_cluster->area_in_pixels += ps_cluster_data->area_in_pixels;
ps_cur_cluster->bi_mv_pixel_area += ps_cluster_data->bi_mv_pixel_area;
ps_cur_cluster->uni_mv_pixel_area += ps_cluster_data->uni_mv_pixel_area;
i8_mv_x_sum_self += i8_mv_x_sum_cousin;
i8_mv_y_sum_self += i8_mv_y_sum_cousin;
ps_cur_centroid->i4_pos_x_q8 = (WORD32)(i8_mv_x_sum_self / ps_cur_cluster->num_mvs);
ps_cur_centroid->i4_pos_y_q8 = (WORD32)(i8_mv_y_sum_self / ps_cur_cluster->num_mvs);
minmax_x_update_id = (ps_cur_cluster->min_x < ps_cluster_data->min_x)
? ((ps_cur_cluster->max_x > ps_cluster_data->max_x) ? 0 : 2)
: 1;
minmax_y_update_id = (ps_cur_cluster->min_y < ps_cluster_data->min_y)
? ((ps_cur_cluster->max_y > ps_cluster_data->max_y) ? 0 : 2)
: 1;
/* Updation of centroid spread */
switch(minmax_x_update_id + (minmax_y_update_id << 2))
{
case 1:
{
S32 mvd, mvd_q8;
ps_cur_cluster->min_x = ps_cluster_data->min_x;
mvd_q8 = ps_centroid->i4_pos_x_q8 - (ps_cur_cluster->min_x << 8);
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (max_dist_from_centroid))
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 2:
{
S32 mvd, mvd_q8;
ps_cur_cluster->max_x = ps_cluster_data->max_x;
mvd_q8 = (ps_cur_cluster->max_x << 8) - ps_centroid->i4_pos_x_q8;
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (max_dist_from_centroid))
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 4:
{
S32 mvd, mvd_q8;
ps_cur_cluster->min_y = ps_cluster_data->min_y;
mvd_q8 = ps_centroid->i4_pos_y_q8 - (ps_cur_cluster->min_y << 8);
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (max_dist_from_centroid))
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 5:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdy_q8 = ps_centroid->i4_pos_y_q8 - (ps_cur_cluster->min_y << 8);
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvdx_q8 = ps_centroid->i4_pos_x_q8 - (ps_cur_cluster->min_x << 8);
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
ps_cur_cluster->min_x = ps_cluster_data->min_x;
ps_cur_cluster->min_y = ps_cluster_data->min_y;
if(mvd > max_dist_from_centroid)
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 6:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdy_q8 = ps_centroid->i4_pos_y_q8 - (ps_cur_cluster->min_y << 8);
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvdx_q8 = (ps_cur_cluster->max_x << 8) - ps_centroid->i4_pos_x_q8;
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
ps_cur_cluster->max_x = ps_cluster_data->max_x;
ps_cur_cluster->min_y = ps_cluster_data->min_y;
if(mvd > max_dist_from_centroid)
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 8:
{
S32 mvd, mvd_q8;
ps_cur_cluster->max_y = ps_cluster_data->max_y;
mvd_q8 = (ps_cur_cluster->max_y << 8) - ps_centroid->i4_pos_y_q8;
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (max_dist_from_centroid))
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 9:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdx_q8 = ps_centroid->i4_pos_x_q8 - (ps_cur_cluster->min_x << 8);
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvdy_q8 = (ps_cur_cluster->max_y << 8) - ps_centroid->i4_pos_y_q8;
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
ps_cur_cluster->min_x = ps_cluster_data->min_x;
ps_cur_cluster->max_y = ps_cluster_data->max_y;
if(mvd > max_dist_from_centroid)
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 10:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdx_q8 = (ps_cur_cluster->max_x << 8) - ps_centroid->i4_pos_x_q8;
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvdy_q8 = (ps_cur_cluster->max_y << 8) - ps_centroid->i4_pos_y_q8;
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
ps_cur_cluster->max_x = ps_cluster_data->max_x;
ps_cur_cluster->max_y = ps_cluster_data->max_y;
if(mvd > ps_cluster_data->max_dist_from_centroid)
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
default:
{
break;
}
}
hme_try_cluster_merge(ps_root, pu1_num_clusters, idx_of_updated_cluster);
return;
}
num_clusters_evaluated++;
}
}
/**
********************************************************************************
* @fn void hme_find_and_update_clusters
* (
* cluster_data_t *ps_cluster_data,
* S32 *pi4_num_clusters,
* S32 mvx,
* S32 mvy,
* S32 ref_idx,
* PART_ID_T e_part_id
* )
*
* @brief Implementation fo the clustering algorithm
*
* @param[in/out] ps_cluster_data: pointer to cluster_data_t struct
*
* @param[in/out] pi4_num_clusters : pointer to number of clusters
*
* @param[in] mvx : x co-ordinate of the motion vector
*
* @param[in] mvy : y co-ordinate of the motion vector
*
* @param[in] ref_idx : ref_id of the motion vector
*
* @param[in] e_part_id : partition id of the motion vector
*
* @return None
********************************************************************************
*/
void hme_find_and_update_clusters(
cluster_data_t *ps_cluster_data,
U08 *pu1_num_clusters,
S16 i2_mv_x,
S16 i2_mv_y,
U08 i1_ref_idx,
S32 i4_sdi,
PART_ID_T e_part_id,
U08 is_part_of_bi)
{
S32 i;
S32 min_mvd_cluster_id = -1;
S32 mvd, mvd_limit, mvdx, mvdy;
S32 min_mvdx, min_mvdy;
S32 min_mvd = MAX_32BIT_VAL;
S32 num_clusters = *pu1_num_clusters;
S32 mvx = i2_mv_x;
S32 mvy = i2_mv_y;
S32 ref_idx = i1_ref_idx;
S32 sdi = i4_sdi;
S32 new_cluster_idx = MAX_NUM_CLUSTERS_16x16;
if(num_clusters == 0)
{
cluster_data_t *ps_data = &ps_cluster_data[num_clusters];
ps_data->num_mvs = 1;
ps_data->s_centroid.i4_pos_x_q8 = mvx << 8;
ps_data->s_centroid.i4_pos_y_q8 = mvy << 8;
ps_data->ref_id = ref_idx;
ps_data->area_in_pixels = gai4_partition_area[e_part_id];
ps_data->as_mv[0].pixel_count = gai4_partition_area[e_part_id];
ps_data->as_mv[0].mvx = mvx;
ps_data->as_mv[0].mvy = mvy;
/***************************/
ps_data->as_mv[0].is_uni = !is_part_of_bi;
ps_data->as_mv[0].sdi = sdi;
if(is_part_of_bi)
{
ps_data->bi_mv_pixel_area += ps_data->area_in_pixels;
}
else
{
ps_data->uni_mv_pixel_area += ps_data->area_in_pixels;
}
/**************************/
ps_data->max_x = mvx;
ps_data->min_x = mvx;
ps_data->max_y = mvy;
ps_data->min_y = mvy;
ps_data->is_valid_cluster = 1;
*pu1_num_clusters = 1;
}
else
{
S32 num_clusters_evaluated = 0;
for(i = 0; num_clusters_evaluated < num_clusters; i++)
{
cluster_data_t *ps_data = &ps_cluster_data[i];
centroid_t *ps_centroid;
S32 mvx_q8;
S32 mvy_q8;
S32 posx_q8;
S32 posy_q8;
S32 mvdx_q8;
S32 mvdy_q8;
/* In anticipation of a possible merging of clusters */
if(ps_data->is_valid_cluster == 0)
{
new_cluster_idx = i;
continue;
}
if(ref_idx != ps_data->ref_id)
{
num_clusters_evaluated++;
continue;
}
ps_centroid = &ps_data->s_centroid;
posx_q8 = ps_centroid->i4_pos_x_q8;
posy_q8 = ps_centroid->i4_pos_y_q8;
mvx_q8 = mvx << 8;
mvy_q8 = mvy << 8;
mvdx_q8 = posx_q8 - mvx_q8;
mvdy_q8 = posy_q8 - mvy_q8;
mvdx = (((mvdx_q8 + (1 << 7)) >> 8));
mvdy = (((mvdy_q8 + (1 << 7)) >> 8));
mvd = ABS(mvdx) + ABS(mvdy);
if(mvd < min_mvd)
{
min_mvd = mvd;
min_mvdx = mvdx;
min_mvdy = mvdy;
min_mvd_cluster_id = i;
}
num_clusters_evaluated++;
}
mvd_limit = (min_mvd_cluster_id == -1)
? ps_cluster_data[0].max_dist_from_centroid
: ps_cluster_data[min_mvd_cluster_id].max_dist_from_centroid;
/* This condition implies that min_mvd has been updated */
if(min_mvd <= mvd_limit)
{
hme_update_cluster_attributes(
&ps_cluster_data[min_mvd_cluster_id],
mvx,
mvy,
min_mvdx,
min_mvdy,
ref_idx,
sdi,
is_part_of_bi,
e_part_id);
if(PRT_NxN == ge_part_id_to_part_type[e_part_id])
{
hme_try_cluster_merge(ps_cluster_data, pu1_num_clusters, min_mvd_cluster_id);
}
}
else
{
cluster_data_t *ps_data = (new_cluster_idx == MAX_NUM_CLUSTERS_16x16)
? &ps_cluster_data[num_clusters]
: &ps_cluster_data[new_cluster_idx];
ps_data->num_mvs = 1;
ps_data->s_centroid.i4_pos_x_q8 = mvx << 8;
ps_data->s_centroid.i4_pos_y_q8 = mvy << 8;
ps_data->ref_id = ref_idx;
ps_data->area_in_pixels = gai4_partition_area[e_part_id];
ps_data->as_mv[0].pixel_count = gai4_partition_area[e_part_id];
ps_data->as_mv[0].mvx = mvx;
ps_data->as_mv[0].mvy = mvy;
/***************************/
ps_data->as_mv[0].is_uni = !is_part_of_bi;
ps_data->as_mv[0].sdi = sdi;
if(is_part_of_bi)
{
ps_data->bi_mv_pixel_area += ps_data->area_in_pixels;
}
else
{
ps_data->uni_mv_pixel_area += ps_data->area_in_pixels;
}
/**************************/
ps_data->max_x = mvx;
ps_data->min_x = mvx;
ps_data->max_y = mvy;
ps_data->min_y = mvy;
ps_data->is_valid_cluster = 1;
num_clusters++;
*pu1_num_clusters = num_clusters;
}
}
}
/**
********************************************************************************
* @fn void hme_update_32x32_cluster_attributes
* (
* cluster_32x32_blk_t *ps_blk_32x32,
* cluster_data_t *ps_cluster_data
* )
*
* @brief Updates attributes for 32x32 clusters based on the attributes of
* the constituent 16x16 clusters
*
* @param[out] ps_blk_32x32: structure containing 32x32 block results
*
* @param[in] ps_cluster_data : structure containing 16x16 block results
*
* @return None
********************************************************************************
*/
void hme_update_32x32_cluster_attributes(
cluster_32x32_blk_t *ps_blk_32x32, cluster_data_t *ps_cluster_data)
{
cluster_data_t *ps_cur_cluster_32;
S32 i;
S32 mvd_limit;
S32 num_clusters = ps_blk_32x32->num_clusters;
if(0 == num_clusters)
{
ps_cur_cluster_32 = &ps_blk_32x32->as_cluster_data[0];
ps_blk_32x32->num_clusters++;
ps_blk_32x32->au1_num_clusters[ps_cluster_data->ref_id]++;
ps_cur_cluster_32->is_valid_cluster = 1;
ps_cur_cluster_32->area_in_pixels = ps_cluster_data->area_in_pixels;
ps_cur_cluster_32->bi_mv_pixel_area += ps_cluster_data->bi_mv_pixel_area;
ps_cur_cluster_32->uni_mv_pixel_area += ps_cluster_data->uni_mv_pixel_area;
memcpy(
ps_cur_cluster_32->as_mv,
ps_cluster_data->as_mv,
sizeof(mv_data_t) * ps_cluster_data->num_mvs);
ps_cur_cluster_32->num_mvs = ps_cluster_data->num_mvs;
ps_cur_cluster_32->ref_id = ps_cluster_data->ref_id;
ps_cur_cluster_32->max_x = ps_cluster_data->max_x;
ps_cur_cluster_32->max_y = ps_cluster_data->max_y;
ps_cur_cluster_32->min_x = ps_cluster_data->min_x;
ps_cur_cluster_32->min_y = ps_cluster_data->min_y;
ps_cur_cluster_32->s_centroid = ps_cluster_data->s_centroid;
}
else
{
centroid_t *ps_centroid;
S32 cur_posx_q8, cur_posy_q8;
S32 min_mvd_cluster_id = -1;
S32 mvd;
S32 mvdx;
S32 mvdy;
S32 mvdx_min;
S32 mvdy_min;
S32 mvdx_q8;
S32 mvdy_q8;
S32 num_clusters_evaluated = 0;
S32 mvd_min = MAX_32BIT_VAL;
S32 mvx_inp_q8 = ps_cluster_data->s_centroid.i4_pos_x_q8;
S32 mvy_inp_q8 = ps_cluster_data->s_centroid.i4_pos_y_q8;
for(i = 0; num_clusters_evaluated < num_clusters; i++)
{
ps_cur_cluster_32 = &ps_blk_32x32->as_cluster_data[i];
if(ps_cur_cluster_32->ref_id != ps_cluster_data->ref_id)
{
num_clusters_evaluated++;
continue;
}
if(!ps_cluster_data->is_valid_cluster)
{
continue;
}
num_clusters_evaluated++;
ps_centroid = &ps_cur_cluster_32->s_centroid;
cur_posx_q8 = ps_centroid->i4_pos_x_q8;
cur_posy_q8 = ps_centroid->i4_pos_y_q8;
mvdx_q8 = cur_posx_q8 - mvx_inp_q8;
mvdy_q8 = cur_posy_q8 - mvy_inp_q8;
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvd = ABS(mvdx) + ABS(mvdy);
if(mvd < mvd_min)
{
mvd_min = mvd;
mvdx_min = mvdx;
mvdy_min = mvdy;
min_mvd_cluster_id = i;
}
}
ps_cur_cluster_32 = &ps_blk_32x32->as_cluster_data[0];
mvd_limit = (min_mvd_cluster_id == -1)
? ps_cur_cluster_32[0].max_dist_from_centroid
: ps_cur_cluster_32[min_mvd_cluster_id].max_dist_from_centroid;
if(mvd_min <= mvd_limit)
{
LWORD64 i8_updated_posx;
LWORD64 i8_updated_posy;
WORD32 minmax_updated_x = 0;
WORD32 minmax_updated_y = 0;
ps_cur_cluster_32 = &ps_blk_32x32->as_cluster_data[min_mvd_cluster_id];
ps_centroid = &ps_cur_cluster_32->s_centroid;
ps_cur_cluster_32->is_valid_cluster = 1;
ps_cur_cluster_32->area_in_pixels += ps_cluster_data->area_in_pixels;
ps_cur_cluster_32->bi_mv_pixel_area += ps_cluster_data->bi_mv_pixel_area;
ps_cur_cluster_32->uni_mv_pixel_area += ps_cluster_data->uni_mv_pixel_area;
memcpy(
&ps_cur_cluster_32->as_mv[ps_cur_cluster_32->num_mvs],
ps_cluster_data->as_mv,
sizeof(mv_data_t) * ps_cluster_data->num_mvs);
if((mvdx_min > 0) && ((ps_cur_cluster_32->min_x << 8) > mvx_inp_q8))
{
ps_cur_cluster_32->min_x = (mvx_inp_q8 + ((1 << 7))) >> 8;
minmax_updated_x = 1;
}
else if((mvdx_min < 0) && ((ps_cur_cluster_32->max_x << 8) < mvx_inp_q8))
{
ps_cur_cluster_32->max_x = (mvx_inp_q8 + (1 << 7)) >> 8;
minmax_updated_x = 2;
}
if((mvdy_min > 0) && ((ps_cur_cluster_32->min_y << 8) > mvy_inp_q8))
{
ps_cur_cluster_32->min_y = (mvy_inp_q8 + (1 << 7)) >> 8;
minmax_updated_y = 1;
}
else if((mvdy_min < 0) && ((ps_cur_cluster_32->max_y << 8) < mvy_inp_q8))
{
ps_cur_cluster_32->max_y = (mvy_inp_q8 + (1 << 7)) >> 8;
minmax_updated_y = 2;
}
switch((minmax_updated_y << 2) + minmax_updated_x)
{
case 1:
{
S32 mvd, mvd_q8;
mvd_q8 = ps_centroid->i4_pos_x_q8 - (ps_cur_cluster_32->min_x << 8);
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (mvd_limit))
{
ps_cur_cluster_32->max_dist_from_centroid = mvd;
}
break;
}
case 2:
{
S32 mvd, mvd_q8;
mvd_q8 = (ps_cur_cluster_32->max_x << 8) - ps_centroid->i4_pos_x_q8;
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (mvd_limit))
{
ps_cur_cluster_32->max_dist_from_centroid = mvd;
}
break;
}
case 4:
{
S32 mvd, mvd_q8;
mvd_q8 = ps_centroid->i4_pos_y_q8 - (ps_cur_cluster_32->min_y << 8);
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (mvd_limit))
{
ps_cur_cluster_32->max_dist_from_centroid = mvd;
}
break;
}
case 5:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdy_q8 = ps_centroid->i4_pos_y_q8 - (ps_cur_cluster_32->min_y << 8);
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvdx_q8 = ps_centroid->i4_pos_x_q8 - (ps_cur_cluster_32->min_x << 8);
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
if(mvd > mvd_limit)
{
ps_cur_cluster_32->max_dist_from_centroid = mvd;
}
break;
}
case 6:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdy_q8 = ps_centroid->i4_pos_y_q8 - (ps_cur_cluster_32->min_y << 8);
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvdx_q8 = (ps_cur_cluster_32->max_x << 8) - ps_centroid->i4_pos_x_q8;
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
if(mvd > mvd_limit)
{
ps_cur_cluster_32->max_dist_from_centroid = mvd;
}
break;
}
case 8:
{
S32 mvd, mvd_q8;
mvd_q8 = (ps_cur_cluster_32->max_y << 8) - ps_centroid->i4_pos_y_q8;
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (mvd_limit))
{
ps_cur_cluster_32->max_dist_from_centroid = mvd;
}
break;
}
case 9:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdx_q8 = ps_centroid->i4_pos_x_q8 - (ps_cur_cluster_32->min_x << 8);
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvdy_q8 = (ps_cur_cluster_32->max_y << 8) - ps_centroid->i4_pos_y_q8;
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
if(mvd > mvd_limit)
{
ps_cur_cluster_32->max_dist_from_centroid = mvd;
}
break;
}
case 10:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdx_q8 = (ps_cur_cluster_32->max_x << 8) - ps_centroid->i4_pos_x_q8;
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvdy_q8 = (ps_cur_cluster_32->max_y << 8) - ps_centroid->i4_pos_y_q8;
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
if(mvd > ps_cur_cluster_32->max_dist_from_centroid)
{
ps_cur_cluster_32->max_dist_from_centroid = mvd;
}
break;
}
default:
{
break;
}
}
i8_updated_posx = ((LWORD64)ps_centroid->i4_pos_x_q8 * ps_cur_cluster_32->num_mvs) +
((LWORD64)mvx_inp_q8 * ps_cluster_data->num_mvs);
i8_updated_posy = ((LWORD64)ps_centroid->i4_pos_y_q8 * ps_cur_cluster_32->num_mvs) +
((LWORD64)mvy_inp_q8 * ps_cluster_data->num_mvs);
ps_cur_cluster_32->num_mvs += ps_cluster_data->num_mvs;
ps_centroid->i4_pos_x_q8 = (WORD32)(i8_updated_posx / ps_cur_cluster_32->num_mvs);
ps_centroid->i4_pos_y_q8 = (WORD32)(i8_updated_posy / ps_cur_cluster_32->num_mvs);
}
else if(num_clusters < MAX_NUM_CLUSTERS_32x32)
{
ps_cur_cluster_32 = &ps_blk_32x32->as_cluster_data[num_clusters];
ps_blk_32x32->num_clusters++;
ps_blk_32x32->au1_num_clusters[ps_cluster_data->ref_id]++;
ps_cur_cluster_32->is_valid_cluster = 1;
ps_cur_cluster_32->area_in_pixels = ps_cluster_data->area_in_pixels;
ps_cur_cluster_32->bi_mv_pixel_area += ps_cluster_data->bi_mv_pixel_area;
ps_cur_cluster_32->uni_mv_pixel_area += ps_cluster_data->uni_mv_pixel_area;
memcpy(
ps_cur_cluster_32->as_mv,
ps_cluster_data->as_mv,
sizeof(mv_data_t) * ps_cluster_data->num_mvs);
ps_cur_cluster_32->num_mvs = ps_cluster_data->num_mvs;
ps_cur_cluster_32->ref_id = ps_cluster_data->ref_id;
ps_cur_cluster_32->max_x = ps_cluster_data->max_x;
ps_cur_cluster_32->max_y = ps_cluster_data->max_y;
ps_cur_cluster_32->min_x = ps_cluster_data->min_x;
ps_cur_cluster_32->min_y = ps_cluster_data->min_y;
ps_cur_cluster_32->s_centroid = ps_cluster_data->s_centroid;
}
}
}
/**
********************************************************************************
* @fn void hme_update_64x64_cluster_attributes
* (
* cluster_64x64_blk_t *ps_blk_32x32,
* cluster_data_t *ps_cluster_data
* )
*
* @brief Updates attributes for 64x64 clusters based on the attributes of
* the constituent 16x16 clusters
*
* @param[out] ps_blk_64x64: structure containing 64x64 block results
*
* @param[in] ps_cluster_data : structure containing 32x32 block results
*
* @return None
********************************************************************************
*/
void hme_update_64x64_cluster_attributes(
cluster_64x64_blk_t *ps_blk_64x64, cluster_data_t *ps_cluster_data)
{
cluster_data_t *ps_cur_cluster_64;
S32 i;
S32 mvd_limit;
S32 num_clusters = ps_blk_64x64->num_clusters;
if(0 == num_clusters)
{
ps_cur_cluster_64 = &ps_blk_64x64->as_cluster_data[0];
ps_blk_64x64->num_clusters++;
ps_blk_64x64->au1_num_clusters[ps_cluster_data->ref_id]++;
ps_cur_cluster_64->is_valid_cluster = 1;
ps_cur_cluster_64->area_in_pixels = ps_cluster_data->area_in_pixels;
ps_cur_cluster_64->bi_mv_pixel_area += ps_cluster_data->bi_mv_pixel_area;
ps_cur_cluster_64->uni_mv_pixel_area += ps_cluster_data->uni_mv_pixel_area;
memcpy(
ps_cur_cluster_64->as_mv,
ps_cluster_data->as_mv,
sizeof(mv_data_t) * ps_cluster_data->num_mvs);
ps_cur_cluster_64->num_mvs = ps_cluster_data->num_mvs;
ps_cur_cluster_64->ref_id = ps_cluster_data->ref_id;
ps_cur_cluster_64->max_x = ps_cluster_data->max_x;
ps_cur_cluster_64->max_y = ps_cluster_data->max_y;
ps_cur_cluster_64->min_x = ps_cluster_data->min_x;
ps_cur_cluster_64->min_y = ps_cluster_data->min_y;
ps_cur_cluster_64->s_centroid = ps_cluster_data->s_centroid;
}
else
{
centroid_t *ps_centroid;
S32 cur_posx_q8, cur_posy_q8;
S32 min_mvd_cluster_id = -1;
S32 mvd;
S32 mvdx;
S32 mvdy;
S32 mvdx_min;
S32 mvdy_min;
S32 mvdx_q8;
S32 mvdy_q8;
S32 num_clusters_evaluated = 0;
S32 mvd_min = MAX_32BIT_VAL;
S32 mvx_inp_q8 = ps_cluster_data->s_centroid.i4_pos_x_q8;
S32 mvy_inp_q8 = ps_cluster_data->s_centroid.i4_pos_y_q8;
for(i = 0; num_clusters_evaluated < num_clusters; i++)
{
ps_cur_cluster_64 = &ps_blk_64x64->as_cluster_data[i];
if(ps_cur_cluster_64->ref_id != ps_cluster_data->ref_id)
{
num_clusters_evaluated++;
continue;
}
if(!ps_cur_cluster_64->is_valid_cluster)
{
continue;
}
num_clusters_evaluated++;
ps_centroid = &ps_cur_cluster_64->s_centroid;
cur_posx_q8 = ps_centroid->i4_pos_x_q8;
cur_posy_q8 = ps_centroid->i4_pos_y_q8;
mvdx_q8 = cur_posx_q8 - mvx_inp_q8;
mvdy_q8 = cur_posy_q8 - mvy_inp_q8;
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvd = ABS(mvdx) + ABS(mvdy);
if(mvd < mvd_min)
{
mvd_min = mvd;
mvdx_min = mvdx;
mvdy_min = mvdy;
min_mvd_cluster_id = i;
}
}
ps_cur_cluster_64 = ps_blk_64x64->as_cluster_data;
mvd_limit = (min_mvd_cluster_id == -1)
? ps_cur_cluster_64[0].max_dist_from_centroid
: ps_cur_cluster_64[min_mvd_cluster_id].max_dist_from_centroid;
if(mvd_min <= mvd_limit)
{
LWORD64 i8_updated_posx;
LWORD64 i8_updated_posy;
WORD32 minmax_updated_x = 0;
WORD32 minmax_updated_y = 0;
ps_cur_cluster_64 = &ps_blk_64x64->as_cluster_data[min_mvd_cluster_id];
ps_centroid = &ps_cur_cluster_64->s_centroid;
ps_cur_cluster_64->is_valid_cluster = 1;
ps_cur_cluster_64->area_in_pixels += ps_cluster_data->area_in_pixels;
ps_cur_cluster_64->bi_mv_pixel_area += ps_cluster_data->bi_mv_pixel_area;
ps_cur_cluster_64->uni_mv_pixel_area += ps_cluster_data->uni_mv_pixel_area;
memcpy(
&ps_cur_cluster_64->as_mv[ps_cur_cluster_64->num_mvs],
ps_cluster_data->as_mv,
sizeof(mv_data_t) * ps_cluster_data->num_mvs);
if((mvdx_min > 0) && ((ps_cur_cluster_64->min_x << 8) > mvx_inp_q8))
{
ps_cur_cluster_64->min_x = (mvx_inp_q8 + (1 << 7)) >> 8;
minmax_updated_x = 1;
}
else if((mvdx_min < 0) && ((ps_cur_cluster_64->max_x << 8) < mvx_inp_q8))
{
ps_cur_cluster_64->max_x = (mvx_inp_q8 + (1 << 7)) >> 8;
minmax_updated_x = 2;
}
if((mvdy_min > 0) && ((ps_cur_cluster_64->min_y << 8) > mvy_inp_q8))
{
ps_cur_cluster_64->min_y = (mvy_inp_q8 + (1 << 7)) >> 8;
minmax_updated_y = 1;
}
else if((mvdy_min < 0) && ((ps_cur_cluster_64->max_y << 8) < mvy_inp_q8))
{
ps_cur_cluster_64->max_y = (mvy_inp_q8 + (1 << 7)) >> 8;
minmax_updated_y = 2;
}
switch((minmax_updated_y << 2) + minmax_updated_x)
{
case 1:
{
S32 mvd, mvd_q8;
mvd_q8 = ps_centroid->i4_pos_x_q8 - (ps_cur_cluster_64->min_x << 8);
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (mvd_limit))
{
ps_cur_cluster_64->max_dist_from_centroid = mvd;
}
break;
}
case 2:
{
S32 mvd, mvd_q8;
mvd_q8 = (ps_cur_cluster_64->max_x << 8) - ps_centroid->i4_pos_x_q8;
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (mvd_limit))
{
ps_cur_cluster_64->max_dist_from_centroid = mvd;
}
break;
}
case 4:
{
S32 mvd, mvd_q8;
mvd_q8 = ps_centroid->i4_pos_y_q8 - (ps_cur_cluster_64->min_y << 8);
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (mvd_limit))
{
ps_cur_cluster_64->max_dist_from_centroid = mvd;
}
break;
}
case 5:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdy_q8 = ps_centroid->i4_pos_y_q8 - (ps_cur_cluster_64->min_y << 8);
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvdx_q8 = ps_centroid->i4_pos_x_q8 - (ps_cur_cluster_64->min_x << 8);
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
if(mvd > mvd_limit)
{
ps_cur_cluster_64->max_dist_from_centroid = mvd;
}
break;
}
case 6:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdy_q8 = ps_centroid->i4_pos_y_q8 - (ps_cur_cluster_64->min_y << 8);
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvdx_q8 = (ps_cur_cluster_64->max_x << 8) - ps_centroid->i4_pos_x_q8;
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
if(mvd > mvd_limit)
{
ps_cur_cluster_64->max_dist_from_centroid = mvd;
}
break;
}
case 8:
{
S32 mvd, mvd_q8;
mvd_q8 = (ps_cur_cluster_64->max_y << 8) - ps_centroid->i4_pos_y_q8;
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (mvd_limit))
{
ps_cur_cluster_64->max_dist_from_centroid = mvd;
}
break;
}
case 9:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdx_q8 = ps_centroid->i4_pos_x_q8 - (ps_cur_cluster_64->min_x << 8);
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvdy_q8 = (ps_cur_cluster_64->max_y << 8) - ps_centroid->i4_pos_y_q8;
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
if(mvd > mvd_limit)
{
ps_cur_cluster_64->max_dist_from_centroid = mvd;
}
break;
}
case 10:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdx_q8 = (ps_cur_cluster_64->max_x << 8) - ps_centroid->i4_pos_x_q8;
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvdy_q8 = (ps_cur_cluster_64->max_y << 8) - ps_centroid->i4_pos_y_q8;
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
if(mvd > ps_cur_cluster_64->max_dist_from_centroid)
{
ps_cur_cluster_64->max_dist_from_centroid = mvd;
}
break;
}
default:
{
break;
}
}
i8_updated_posx = ((LWORD64)ps_centroid->i4_pos_x_q8 * ps_cur_cluster_64->num_mvs) +
((LWORD64)mvx_inp_q8 * ps_cluster_data->num_mvs);
i8_updated_posy = ((LWORD64)ps_centroid->i4_pos_y_q8 * ps_cur_cluster_64->num_mvs) +
((LWORD64)mvy_inp_q8 * ps_cluster_data->num_mvs);
ps_cur_cluster_64->num_mvs += ps_cluster_data->num_mvs;
ps_centroid->i4_pos_x_q8 = (WORD32)(i8_updated_posx / ps_cur_cluster_64->num_mvs);
ps_centroid->i4_pos_y_q8 = (WORD32)(i8_updated_posy / ps_cur_cluster_64->num_mvs);
}
else if(num_clusters < MAX_NUM_CLUSTERS_64x64)
{
ps_cur_cluster_64 = &ps_blk_64x64->as_cluster_data[num_clusters];
ps_blk_64x64->num_clusters++;
ps_blk_64x64->au1_num_clusters[ps_cluster_data->ref_id]++;
ps_cur_cluster_64->is_valid_cluster = 1;
ps_cur_cluster_64->area_in_pixels = ps_cluster_data->area_in_pixels;
ps_cur_cluster_64->bi_mv_pixel_area += ps_cluster_data->bi_mv_pixel_area;
ps_cur_cluster_64->uni_mv_pixel_area += ps_cluster_data->uni_mv_pixel_area;
memcpy(
&ps_cur_cluster_64->as_mv[0],
ps_cluster_data->as_mv,
sizeof(mv_data_t) * ps_cluster_data->num_mvs);
ps_cur_cluster_64->num_mvs = ps_cluster_data->num_mvs;
ps_cur_cluster_64->ref_id = ps_cluster_data->ref_id;
ps_cur_cluster_64->max_x = ps_cluster_data->max_x;
ps_cur_cluster_64->max_y = ps_cluster_data->max_y;
ps_cur_cluster_64->min_x = ps_cluster_data->min_x;
ps_cur_cluster_64->min_y = ps_cluster_data->min_y;
ps_cur_cluster_64->s_centroid = ps_cluster_data->s_centroid;
}
}
}
/**
********************************************************************************
* @fn void hme_update_32x32_clusters
* (
* cluster_32x32_blk_t *ps_blk_32x32,
* cluster_16x16_blk_t *ps_blk_16x16
* )
*
* @brief Updates attributes for 32x32 clusters based on the attributes of
* the constituent 16x16 clusters
*
* @param[out] ps_blk_32x32: structure containing 32x32 block results
*
* @param[in] ps_blk_16x16 : structure containing 16x16 block results
*
* @return None
********************************************************************************
*/
static __inline void
hme_update_32x32_clusters(cluster_32x32_blk_t *ps_blk_32x32, cluster_16x16_blk_t *ps_blk_16x16)
{
cluster_16x16_blk_t *ps_blk_16x16_cur;
cluster_data_t *ps_cur_cluster;
S32 i, j;
S32 num_clusters_cur_16x16_blk;
for(i = 0; i < 4; i++)
{
S32 num_clusters_evaluated = 0;
ps_blk_16x16_cur = &ps_blk_16x16[i];
num_clusters_cur_16x16_blk = ps_blk_16x16_cur->num_clusters;
ps_blk_32x32->intra_mv_area += ps_blk_16x16_cur->intra_mv_area;
ps_blk_32x32->best_inter_cost += ps_blk_16x16_cur->best_inter_cost;
for(j = 0; num_clusters_evaluated < num_clusters_cur_16x16_blk; j++)
{
ps_cur_cluster = &ps_blk_16x16_cur->as_cluster_data[j];
if(!ps_cur_cluster->is_valid_cluster)
{
continue;
}
hme_update_32x32_cluster_attributes(ps_blk_32x32, ps_cur_cluster);
num_clusters_evaluated++;
}
}
}
/**
********************************************************************************
* @fn void hme_update_64x64_clusters
* (
* cluster_64x64_blk_t *ps_blk_64x64,
* cluster_32x32_blk_t *ps_blk_32x32
* )
*
* @brief Updates attributes for 64x64 clusters based on the attributes of
* the constituent 16x16 clusters
*
* @param[out] ps_blk_64x64: structure containing 32x32 block results
*
* @param[in] ps_blk_32x32 : structure containing 16x16 block results
*
* @return None
********************************************************************************
*/
static __inline void
hme_update_64x64_clusters(cluster_64x64_blk_t *ps_blk_64x64, cluster_32x32_blk_t *ps_blk_32x32)
{
cluster_32x32_blk_t *ps_blk_32x32_cur;
cluster_data_t *ps_cur_cluster;
S32 i, j;
S32 num_clusters_cur_32x32_blk;
for(i = 0; i < 4; i++)
{
S32 num_clusters_evaluated = 0;
ps_blk_32x32_cur = &ps_blk_32x32[i];
num_clusters_cur_32x32_blk = ps_blk_32x32_cur->num_clusters;
ps_blk_64x64->intra_mv_area += ps_blk_32x32_cur->intra_mv_area;
ps_blk_64x64->best_inter_cost += ps_blk_32x32_cur->best_inter_cost;
for(j = 0; num_clusters_evaluated < num_clusters_cur_32x32_blk; j++)
{
ps_cur_cluster = &ps_blk_32x32_cur->as_cluster_data[j];
if(!ps_cur_cluster->is_valid_cluster)
{
continue;
}
hme_update_64x64_cluster_attributes(ps_blk_64x64, ps_cur_cluster);
num_clusters_evaluated++;
}
}
}
/**
********************************************************************************
* @fn void hme_try_merge_clusters_blksize_gt_16
* (
* cluster_data_t *ps_cluster_data,
* S32 num_clusters
* )
*
* @brief Merging clusters from blocks of size 32x32 and greater
*
* @param[in/out] ps_cluster_data: structure containing cluster data
*
* @param[in/out] pi4_num_clusters : pointer to number of clusters
*
* @return Success or failure
********************************************************************************
*/
S32 hme_try_merge_clusters_blksize_gt_16(cluster_data_t *ps_cluster_data, S32 num_clusters)
{
centroid_t *ps_cur_centroid;
cluster_data_t *ps_cur_cluster;
S32 i, mvd;
S32 mvdx, mvdy, mvdx_q8, mvdy_q8;
centroid_t *ps_centroid = &ps_cluster_data->s_centroid;
S32 mvd_limit = ps_cluster_data->max_dist_from_centroid;
S32 ref_id = ps_cluster_data->ref_id;
S32 node0_posx_q8 = ps_centroid->i4_pos_x_q8;
S32 node0_posy_q8 = ps_centroid->i4_pos_y_q8;
S32 num_clusters_evaluated = 1;
S32 ret_value = 0;
if(1 >= num_clusters)
{
return ret_value;
}
for(i = 1; num_clusters_evaluated < num_clusters; i++)
{
S32 cur_posx_q8;
S32 cur_posy_q8;
ps_cur_cluster = &ps_cluster_data[i];
if((ref_id != ps_cur_cluster->ref_id))
{
num_clusters_evaluated++;
continue;
}
if((!ps_cur_cluster->is_valid_cluster))
{
continue;
}
num_clusters_evaluated++;
ps_cur_centroid = &ps_cur_cluster->s_centroid;
cur_posx_q8 = ps_cur_centroid->i4_pos_x_q8;
cur_posy_q8 = ps_cur_centroid->i4_pos_y_q8;
mvdx_q8 = cur_posx_q8 - node0_posx_q8;
mvdy_q8 = cur_posy_q8 - node0_posy_q8;
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvd = ABS(mvdx) + ABS(mvdy);
if(mvd <= (mvd_limit >> 1))
{
LWORD64 i8_updated_posx;
LWORD64 i8_updated_posy;
WORD32 minmax_updated_x = 0;
WORD32 minmax_updated_y = 0;
ps_cur_cluster->is_valid_cluster = 0;
ps_cluster_data->area_in_pixels += ps_cur_cluster->area_in_pixels;
ps_cluster_data->bi_mv_pixel_area += ps_cur_cluster->bi_mv_pixel_area;
ps_cluster_data->uni_mv_pixel_area += ps_cur_cluster->uni_mv_pixel_area;
memcpy(
&ps_cluster_data->as_mv[ps_cluster_data->num_mvs],
ps_cur_cluster->as_mv,
sizeof(mv_data_t) * ps_cur_cluster->num_mvs);
if(mvdx > 0)
{
ps_cluster_data->min_x = (cur_posx_q8 + (1 << 7)) >> 8;
minmax_updated_x = 1;
}
else
{
ps_cluster_data->max_x = (cur_posx_q8 + (1 << 7)) >> 8;
minmax_updated_x = 2;
}
if(mvdy > 0)
{
ps_cluster_data->min_y = (cur_posy_q8 + (1 << 7)) >> 8;
minmax_updated_y = 1;
}
else
{
ps_cluster_data->max_y = (cur_posy_q8 + (1 << 7)) >> 8;
minmax_updated_y = 2;
}
switch((minmax_updated_y << 2) + minmax_updated_x)
{
case 1:
{
S32 mvd, mvd_q8;
mvd_q8 = ps_cur_centroid->i4_pos_x_q8 - (ps_cluster_data->min_x << 8);
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (mvd_limit))
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 2:
{
S32 mvd, mvd_q8;
mvd_q8 = (ps_cluster_data->max_x << 8) - ps_cur_centroid->i4_pos_x_q8;
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (mvd_limit))
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 4:
{
S32 mvd, mvd_q8;
mvd_q8 = ps_cur_centroid->i4_pos_y_q8 - (ps_cluster_data->min_y << 8);
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (mvd_limit))
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 5:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdy_q8 = ps_cur_centroid->i4_pos_y_q8 - (ps_cluster_data->min_y << 8);
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvdx_q8 = ps_cur_centroid->i4_pos_x_q8 - (ps_cluster_data->min_x << 8);
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
if(mvd > mvd_limit)
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 6:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdy_q8 = ps_cur_centroid->i4_pos_y_q8 - (ps_cluster_data->min_y << 8);
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvdx_q8 = (ps_cluster_data->max_x << 8) - ps_cur_centroid->i4_pos_x_q8;
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
if(mvd > mvd_limit)
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 8:
{
S32 mvd, mvd_q8;
mvd_q8 = (ps_cluster_data->max_y << 8) - ps_cur_centroid->i4_pos_y_q8;
mvd = (mvd_q8 + (1 << 7)) >> 8;
if(mvd > (mvd_limit))
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 9:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdx_q8 = ps_cur_centroid->i4_pos_x_q8 - (ps_cluster_data->min_x << 8);
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvdy_q8 = (ps_cluster_data->max_y << 8) - ps_cur_centroid->i4_pos_y_q8;
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
if(mvd > mvd_limit)
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
case 10:
{
S32 mvd;
S32 mvdx, mvdx_q8;
S32 mvdy, mvdy_q8;
mvdx_q8 = (ps_cluster_data->max_x << 8) - ps_cur_centroid->i4_pos_x_q8;
mvdx = (mvdx_q8 + (1 << 7)) >> 8;
mvdy_q8 = (ps_cluster_data->max_y << 8) - ps_cur_centroid->i4_pos_y_q8;
mvdy = (mvdy_q8 + (1 << 7)) >> 8;
mvd = (mvdx > mvdy) ? mvdx : mvdy;
if(mvd > ps_cluster_data->max_dist_from_centroid)
{
ps_cluster_data->max_dist_from_centroid = mvd;
}
break;
}
default:
{
break;
}
}
i8_updated_posx = ((LWORD64)ps_centroid->i4_pos_x_q8 * ps_cluster_data->num_mvs) +
((LWORD64)cur_posx_q8 * ps_cur_cluster->num_mvs);
i8_updated_posy = ((LWORD64)ps_centroid->i4_pos_y_q8 * ps_cluster_data->num_mvs) +
((LWORD64)cur_posy_q8 * ps_cur_cluster->num_mvs);
ps_cluster_data->num_mvs += ps_cur_cluster->num_mvs;
ps_centroid->i4_pos_x_q8 = (WORD32)(i8_updated_posx / ps_cluster_data->num_mvs);
ps_centroid->i4_pos_y_q8 = (WORD32)(i8_updated_posy / ps_cluster_data->num_mvs);
if(MAX_NUM_CLUSTERS_IN_VALID_64x64_BLK >= num_clusters)
{
num_clusters--;
num_clusters_evaluated = 1;
i = 0;
ret_value++;
}
else
{
ret_value++;
return ret_value;
}
}
}
if(ret_value)
{
for(i = 1; i < (num_clusters + ret_value); i++)
{
if(ps_cluster_data[i].is_valid_cluster)
{
break;
}
}
if(i == (num_clusters + ret_value))
{
return ret_value;
}
}
else
{
i = 1;
}
return (hme_try_merge_clusters_blksize_gt_16(&ps_cluster_data[i], num_clusters - 1)) +
ret_value;
}
/**
********************************************************************************
* @fn S32 hme_determine_validity_32x32
* (
* ctb_cluster_info_t *ps_ctb_cluster_info
* )
*
* @brief Determines whther current 32x32 block needs to be evaluated in enc_loop
* while recursing through the CU tree or not
*
* @param[in] ps_cluster_data: structure containing cluster data
*
* @return Success or failure
********************************************************************************
*/
__inline S32 hme_determine_validity_32x32(
ctb_cluster_info_t *ps_ctb_cluster_info,
S32 *pi4_children_nodes_required,
S32 blk_validity_wrt_pic_bndry,
S32 parent_blk_validity_wrt_pic_bndry)
{
cluster_data_t *ps_data;
cluster_32x32_blk_t *ps_32x32_blk = ps_ctb_cluster_info->ps_32x32_blk;
cluster_64x64_blk_t *ps_64x64_blk = ps_ctb_cluster_info->ps_64x64_blk;
S32 num_clusters = ps_32x32_blk->num_clusters;
S32 num_clusters_parent = ps_64x64_blk->num_clusters;
if(!blk_validity_wrt_pic_bndry)
{
*pi4_children_nodes_required = 1;
return 0;
}
if(!parent_blk_validity_wrt_pic_bndry)
{
*pi4_children_nodes_required = 1;
return 1;
}
if(num_clusters > MAX_NUM_CLUSTERS_IN_VALID_32x32_BLK)
{
*pi4_children_nodes_required = 1;
return 0;
}
if(num_clusters_parent > MAX_NUM_CLUSTERS_IN_VALID_64x64_BLK)
{
*pi4_children_nodes_required = 1;
return 1;
}
else if(num_clusters_parent < MAX_NUM_CLUSTERS_IN_VALID_64x64_BLK)
{
*pi4_children_nodes_required = 0;
return 1;
}
else
{
if(num_clusters < MAX_NUM_CLUSTERS_IN_VALID_32x32_BLK)
{
*pi4_children_nodes_required = 0;
return 1;
}
else
{
S32 i;
S32 area_of_parent = gai4_partition_area[PART_ID_2Nx2N] << 4;
S32 min_area = MAX_32BIT_VAL;
S32 num_clusters_evaluated = 0;
for(i = 0; num_clusters_evaluated < num_clusters; i++)
{
ps_data = &ps_32x32_blk->as_cluster_data[i];
if(!ps_data->is_valid_cluster)
{
continue;
}
num_clusters_evaluated++;
if(ps_data->area_in_pixels < min_area)
{
min_area = ps_data->area_in_pixels;
}
}
if((min_area << 4) < area_of_parent)
{
*pi4_children_nodes_required = 1;
return 0;
}
else
{
*pi4_children_nodes_required = 0;
return 1;
}
}
}
}
/**
********************************************************************************
* @fn S32 hme_determine_validity_16x16
* (
* ctb_cluster_info_t *ps_ctb_cluster_info
* )
*
* @brief Determines whther current 16x16 block needs to be evaluated in enc_loop
* while recursing through the CU tree or not
*
* @param[in] ps_cluster_data: structure containing cluster data
*
* @return Success or failure
********************************************************************************
*/
__inline S32 hme_determine_validity_16x16(
ctb_cluster_info_t *ps_ctb_cluster_info,
S32 *pi4_children_nodes_required,
S32 blk_validity_wrt_pic_bndry,
S32 parent_blk_validity_wrt_pic_bndry)
{
cluster_data_t *ps_data;
cluster_16x16_blk_t *ps_16x16_blk = ps_ctb_cluster_info->ps_16x16_blk;
cluster_32x32_blk_t *ps_32x32_blk = ps_ctb_cluster_info->ps_32x32_blk;
cluster_64x64_blk_t *ps_64x64_blk = ps_ctb_cluster_info->ps_64x64_blk;
S32 num_clusters = ps_16x16_blk->num_clusters;
S32 num_clusters_parent = ps_32x32_blk->num_clusters;
S32 num_clusters_grandparent = ps_64x64_blk->num_clusters;
if(!blk_validity_wrt_pic_bndry)
{
*pi4_children_nodes_required = 1;
return 0;
}
if(!parent_blk_validity_wrt_pic_bndry)
{
*pi4_children_nodes_required = 1;
return 1;
}
if((num_clusters_parent > MAX_NUM_CLUSTERS_IN_VALID_32x32_BLK) &&
(num_clusters_grandparent > MAX_NUM_CLUSTERS_IN_VALID_64x64_BLK))
{
*pi4_children_nodes_required = 1;
return 1;
}
/* Implies nc_64 <= 3 when num_clusters_parent > 3 & */
/* implies nc_64 > 3 when num_clusters_parent < 3 & */
if(num_clusters_parent != MAX_NUM_CLUSTERS_IN_VALID_32x32_BLK)
{
if(num_clusters <= MAX_NUM_CLUSTERS_IN_VALID_16x16_BLK)
{
*pi4_children_nodes_required = 0;
return 1;
}
else
{
*pi4_children_nodes_required = 1;
return 0;
}
}
/* Implies nc_64 >= 3 */
else
{
if(num_clusters < MAX_NUM_CLUSTERS_IN_VALID_16x16_BLK)
{
*pi4_children_nodes_required = 0;
return 1;
}
else if(num_clusters > MAX_NUM_CLUSTERS_IN_VALID_16x16_BLK)
{
*pi4_children_nodes_required = 1;
return 0;
}
else
{
S32 i;
S32 area_of_parent = gai4_partition_area[PART_ID_2Nx2N] << 2;
S32 min_area = MAX_32BIT_VAL;
S32 num_clusters_evaluated = 0;
for(i = 0; num_clusters_evaluated < num_clusters; i++)
{
ps_data = &ps_16x16_blk->as_cluster_data[i];
if(!ps_data->is_valid_cluster)
{
continue;
}
num_clusters_evaluated++;
if(ps_data->area_in_pixels < min_area)
{
min_area = ps_data->area_in_pixels;
}
}
if((min_area << 4) < area_of_parent)
{
*pi4_children_nodes_required = 1;
return 0;
}
else
{
*pi4_children_nodes_required = 0;
return 1;
}
}
}
}
/**
********************************************************************************
* @fn void hme_build_cu_tree
* (
* ctb_cluster_info_t *ps_ctb_cluster_info,
* cur_ctb_cu_tree_t *ps_cu_tree,
* S32 tree_depth,
* CU_POS_T e_grand_parent_blk_pos,
* CU_POS_T e_parent_blk_pos,
* CU_POS_T e_cur_blk_pos
* )
*
* @brief Recursive function for CU tree initialisation
*
* @param[in] ps_ctb_cluster_info: structure containing pointers to clusters
* corresponding to all block sizes from 64x64
* to 16x16
*
* @param[in] e_parent_blk_pos: position of parent block wrt its parent, if
* applicable
*
* @param[in] e_cur_blk_pos: position of current block wrt parent
*
* @param[out] ps_cu_tree : represents CU tree used in CU recursion
*
* @param[in] tree_depth : specifies depth of the CU tree
*
* @return Nothing
********************************************************************************
*/
void hme_build_cu_tree(
ctb_cluster_info_t *ps_ctb_cluster_info,
cur_ctb_cu_tree_t *ps_cu_tree,
S32 tree_depth,
CU_POS_T e_grandparent_blk_pos,
CU_POS_T e_parent_blk_pos,
CU_POS_T e_cur_blk_pos)
{
ihevce_cu_tree_init(
ps_cu_tree,
ps_ctb_cluster_info->ps_cu_tree_root,
&ps_ctb_cluster_info->nodes_created_in_cu_tree,
tree_depth,
e_grandparent_blk_pos,
e_parent_blk_pos,
e_cur_blk_pos);
}
/**
********************************************************************************
* @fn S32 hme_sdi_based_cluster_spread_eligibility
* (
* cluster_32x32_blk_t *ps_blk_32x32
* )
*
* @brief Determines whether the spread of high SDI MV's around each cluster
* center is below a pre-determined threshold
*
* @param[in] ps_blk_32x32: structure containing pointers to clusters
* corresponding to all block sizes from 64x64
* to 16x16
*
* @return 1 if the spread is constrained, else 0
********************************************************************************
*/
__inline S32
hme_sdi_based_cluster_spread_eligibility(cluster_32x32_blk_t *ps_blk_32x32, S32 sdi_threshold)
{
S32 cumulative_mv_distance;
S32 i, j;
S32 num_high_sdi_mvs;
S32 num_clusters = ps_blk_32x32->num_clusters;
for(i = 0; i < num_clusters; i++)
{
cluster_data_t *ps_data = &ps_blk_32x32->as_cluster_data[i];
num_high_sdi_mvs = 0;
cumulative_mv_distance = 0;
for(j = 0; j < ps_data->num_mvs; j++)
{
mv_data_t *ps_mv = &ps_data->as_mv[j];
if(ps_mv->sdi >= sdi_threshold)
{
num_high_sdi_mvs++;
COMPUTE_MVD(ps_mv, ps_data, cumulative_mv_distance);
}
}
if(cumulative_mv_distance > ((ps_data->max_dist_from_centroid >> 1) * num_high_sdi_mvs))
{
return 0;
}
}
return 1;
}
/**
********************************************************************************
* @fn S32 hme_populate_cu_tree
* (
* ctb_cluster_info_t *ps_ctb_cluster_info,
* ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb,
* cur_ctb_cu_tree_t *ps_cu_tree,
* S32 tree_depth,
* CU_POS_T e_parent_blk_pos,
* CU_POS_T e_cur_blk_pos
* )
*
* @brief Recursive function for CU tree population based on output of
* clustering algorithm
*
* @param[in] ps_ctb_cluster_info: structure containing pointers to clusters
* corresponding to all block sizes from 64x64
* to 16x16
*
* @param[in] e_parent_blk_pos: position of parent block wrt its parent, if
applicable
*
* @param[in] e_cur_blk_pos: position of current block wrt parent
*
* @param[in] ps_cur_ipe_ctb : output container for ipe analyses
*
* @param[out] ps_cu_tree : represents CU tree used in CU recursion
*
* @param[in] tree_depth : specifies depth of the CU tree
*
* @param[in] ipe_decision_precedence : specifies whether precedence should
* be given to decisions made either by IPE(1) or clustering algos.
*
* @return 1 if re-evaluation of parent node's validity is not required,
else 0
********************************************************************************
*/
void hme_populate_cu_tree(
ctb_cluster_info_t *ps_ctb_cluster_info,
cur_ctb_cu_tree_t *ps_cu_tree,
S32 tree_depth,
ME_QUALITY_PRESETS_T e_quality_preset,
CU_POS_T e_grandparent_blk_pos,
CU_POS_T e_parent_blk_pos,
CU_POS_T e_cur_blk_pos)
{
S32 area_of_cur_blk;
S32 area_limit_for_me_decision_precedence;
S32 children_nodes_required;
S32 intra_mv_area;
S32 intra_eval_enable;
S32 inter_eval_enable;
S32 ipe_decision_precedence;
S32 node_validity;
S32 num_clusters;
ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb = ps_ctb_cluster_info->ps_cur_ipe_ctb;
if(NULL == ps_cu_tree)
{
return;
}
switch(tree_depth)
{
case 0:
{
/* 64x64 block */
S32 blk_32x32_mask = ps_ctb_cluster_info->blk_32x32_mask;
cluster_64x64_blk_t *ps_blk_64x64 = ps_ctb_cluster_info->ps_64x64_blk;
area_of_cur_blk = gai4_partition_area[PART_ID_2Nx2N] << 4;
area_limit_for_me_decision_precedence = (area_of_cur_blk * MAX_INTRA_PERCENTAGE) / 100;
children_nodes_required = 0;
intra_mv_area = ps_blk_64x64->intra_mv_area;
ipe_decision_precedence = (intra_mv_area >= area_limit_for_me_decision_precedence);
intra_eval_enable = ipe_decision_precedence;
inter_eval_enable = !!ps_blk_64x64->num_clusters;
#if 1 //!PROCESS_GT_1CTB_VIA_CU_RECUR_IN_FAST_PRESETS
if(e_quality_preset >= ME_HIGH_QUALITY)
{
inter_eval_enable = 1;
node_validity = (blk_32x32_mask == 0xf);
#if !USE_CLUSTER_DATA_AS_BLK_MERGE_CANDTS
ps_cu_tree->u1_inter_eval_enable = !(intra_mv_area == area_of_cur_blk);
#endif
break;
}
#endif
#if ENABLE_4CTB_EVALUATION
node_validity = (blk_32x32_mask == 0xf);
break;
#else
{
S32 i;
num_clusters = ps_blk_64x64->num_clusters;
node_validity = (ipe_decision_precedence)
? (!ps_cur_ipe_ctb->u1_split_flag)
: (num_clusters <= MAX_NUM_CLUSTERS_IN_VALID_64x64_BLK);
for(i = 0; i < MAX_NUM_REF; i++)
{
node_validity = node_validity && (ps_blk_64x64->au1_num_clusters[i] <=
MAX_NUM_CLUSTERS_IN_ONE_REF_IDX);
}
node_validity = node_validity && (blk_32x32_mask == 0xf);
}
break;
#endif
}
case 1:
{
/* 32x32 block */
S32 is_percent_intra_area_gt_threshold;
cluster_32x32_blk_t *ps_blk_32x32 = &ps_ctb_cluster_info->ps_32x32_blk[e_cur_blk_pos];
S32 blk_32x32_mask = ps_ctb_cluster_info->blk_32x32_mask;
#if !ENABLE_4CTB_EVALUATION
S32 best_inter_cost = ps_blk_32x32->best_inter_cost;
S32 best_intra_cost =
((ps_ctb_cluster_info->ps_cur_ipe_ctb->ai4_best32x32_intra_cost[e_cur_blk_pos] +
ps_ctb_cluster_info->i4_frame_qstep * ps_ctb_cluster_info->i4_frame_qstep_multiplier *
4) < 0)
? MAX_32BIT_VAL
: (ps_ctb_cluster_info->ps_cur_ipe_ctb->ai4_best32x32_intra_cost[e_cur_blk_pos] +
ps_ctb_cluster_info->i4_frame_qstep *
ps_ctb_cluster_info->i4_frame_qstep_multiplier * 4);
S32 best_cost = (best_inter_cost > best_intra_cost) ? best_intra_cost : best_inter_cost;
S32 cost_differential = (best_inter_cost - best_cost);
#endif
area_of_cur_blk = gai4_partition_area[PART_ID_2Nx2N] << 2;
area_limit_for_me_decision_precedence = (area_of_cur_blk * MAX_INTRA_PERCENTAGE) / 100;
intra_mv_area = ps_blk_32x32->intra_mv_area;
is_percent_intra_area_gt_threshold =
(intra_mv_area > area_limit_for_me_decision_precedence);
ipe_decision_precedence = (intra_mv_area >= area_limit_for_me_decision_precedence);
intra_eval_enable = ipe_decision_precedence;
inter_eval_enable = !!ps_blk_32x32->num_clusters;
children_nodes_required = 1;
#if 1 //!PROCESS_GT_1CTB_VIA_CU_RECUR_IN_FAST_PRESETS
if(e_quality_preset >= ME_HIGH_QUALITY)
{
inter_eval_enable = 1;
node_validity = (((blk_32x32_mask) & (1 << e_cur_blk_pos)) || 0);
#if !USE_CLUSTER_DATA_AS_BLK_MERGE_CANDTS
ps_cu_tree->u1_inter_eval_enable = !(intra_mv_area == area_of_cur_blk);
#endif
break;
}
#endif
#if ENABLE_4CTB_EVALUATION
node_validity = (((blk_32x32_mask) & (1 << e_cur_blk_pos)) || 0);
break;
#else
{
S32 i;
num_clusters = ps_blk_32x32->num_clusters;
if(ipe_decision_precedence)
{
node_validity = (ps_cur_ipe_ctb->as_intra32_analyse[e_cur_blk_pos].b1_merge_flag);
node_validity = node_validity && (((blk_32x32_mask) & (1 << e_cur_blk_pos)) || 0);
}
else
{
node_validity =
((ALL_INTER_COST_DIFF_THR * best_cost) >= (100 * cost_differential)) &&
(num_clusters <= MAX_NUM_CLUSTERS_IN_VALID_32x32_BLK) &&
(((blk_32x32_mask) & (1 << e_cur_blk_pos)) || 0);
for(i = 0; (i < MAX_NUM_REF) && (node_validity); i++)
{
node_validity = node_validity && (ps_blk_32x32->au1_num_clusters[i] <=
MAX_NUM_CLUSTERS_IN_ONE_REF_IDX);
}
if(node_validity)
{
node_validity = node_validity &&
hme_sdi_based_cluster_spread_eligibility(
ps_blk_32x32, ps_ctb_cluster_info->sdi_threshold);
}
}
}
break;
#endif
}
case 2:
{
cluster_16x16_blk_t *ps_blk_16x16 =
&ps_ctb_cluster_info->ps_16x16_blk[e_cur_blk_pos + (e_parent_blk_pos << 2)];
S32 blk_8x8_mask =
ps_ctb_cluster_info->pi4_blk_8x8_mask[(S32)(e_parent_blk_pos << 2) + e_cur_blk_pos];
area_of_cur_blk = gai4_partition_area[PART_ID_2Nx2N];
area_limit_for_me_decision_precedence = (area_of_cur_blk * MAX_INTRA_PERCENTAGE) / 100;
children_nodes_required = 1;
intra_mv_area = ps_blk_16x16->intra_mv_area;
ipe_decision_precedence = (intra_mv_area >= area_limit_for_me_decision_precedence);
num_clusters = ps_blk_16x16->num_clusters;
intra_eval_enable = ipe_decision_precedence;
inter_eval_enable = 1;
#if 1 //!PROCESS_GT_1CTB_VIA_CU_RECUR_IN_FAST_PRESETS
if(e_quality_preset >= ME_HIGH_QUALITY)
{
node_validity =
!ps_ctb_cluster_info
->au1_is_16x16_blk_split[(S32)(e_parent_blk_pos << 2) + e_cur_blk_pos];
children_nodes_required = !node_validity;
break;
}
#endif
#if ENABLE_4CTB_EVALUATION
node_validity = (blk_8x8_mask == 0xf);
#if ENABLE_CU_TREE_CULLING
{
cur_ctb_cu_tree_t *ps_32x32_root;
switch(e_parent_blk_pos)
{
case POS_TL:
{
ps_32x32_root = ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_tl;
break;
}
case POS_TR:
{
ps_32x32_root = ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_tr;
break;
}
case POS_BL:
{
ps_32x32_root = ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_bl;
break;
}
case POS_BR:
{
ps_32x32_root = ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_br;
break;
}
}
if(ps_32x32_root->is_node_valid)
{
node_validity =
node_validity &&
!ps_ctb_cluster_info
->au1_is_16x16_blk_split[(S32)(e_parent_blk_pos << 2) + e_cur_blk_pos];
children_nodes_required = !node_validity;
}
}
#endif
break;
#else
if(ipe_decision_precedence)
{
S32 merge_flag_16 = (ps_cur_ipe_ctb->as_intra32_analyse[e_parent_blk_pos]
.as_intra16_analyse[e_cur_blk_pos]
.b1_merge_flag);
S32 valid_flag = (blk_8x8_mask == 0xf);
node_validity = merge_flag_16 && valid_flag;
}
else
{
node_validity = (blk_8x8_mask == 0xf);
}
break;
#endif
}
case 3:
{
S32 blk_8x8_mask =
ps_ctb_cluster_info
->pi4_blk_8x8_mask[(S32)(e_grandparent_blk_pos << 2) + e_parent_blk_pos];
S32 merge_flag_16 = (ps_cur_ipe_ctb->as_intra32_analyse[e_grandparent_blk_pos]
.as_intra16_analyse[e_parent_blk_pos]
.b1_merge_flag);
S32 merge_flag_32 =
(ps_cur_ipe_ctb->as_intra32_analyse[e_grandparent_blk_pos].b1_merge_flag);
intra_eval_enable = !merge_flag_16 || !merge_flag_32;
inter_eval_enable = 1;
children_nodes_required = 0;
#if 1 //!PROCESS_GT_1CTB_VIA_CU_RECUR_IN_FAST_PRESETS
if(e_quality_preset >= ME_HIGH_QUALITY)
{
node_validity = ((blk_8x8_mask & (1 << e_cur_blk_pos)) || 0);
break;
}
#endif
#if ENABLE_4CTB_EVALUATION
node_validity = ((blk_8x8_mask & (1 << e_cur_blk_pos)) || 0);
break;
#else
{
cur_ctb_cu_tree_t *ps_32x32_root;
cur_ctb_cu_tree_t *ps_16x16_root;
cluster_32x32_blk_t *ps_32x32_blk;
switch(e_grandparent_blk_pos)
{
case POS_TL:
{
ps_32x32_root = ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_tl;
break;
}
case POS_TR:
{
ps_32x32_root = ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_tr;
break;
}
case POS_BL:
{
ps_32x32_root = ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_bl;
break;
}
case POS_BR:
{
ps_32x32_root = ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_br;
break;
}
}
switch(e_parent_blk_pos)
{
case POS_TL:
{
ps_16x16_root = ps_32x32_root->ps_child_node_tl;
break;
}
case POS_TR:
{
ps_16x16_root = ps_32x32_root->ps_child_node_tr;
break;
}
case POS_BL:
{
ps_16x16_root = ps_32x32_root->ps_child_node_bl;
break;
}
case POS_BR:
{
ps_16x16_root = ps_32x32_root->ps_child_node_br;
break;
}
}
ps_32x32_blk = &ps_ctb_cluster_info->ps_32x32_blk[e_grandparent_blk_pos];
node_validity = ((blk_8x8_mask & (1 << e_cur_blk_pos)) || 0) &&
((!ps_32x32_root->is_node_valid) ||
(ps_32x32_blk->num_clusters_with_weak_sdi_density > 0) ||
(!ps_16x16_root->is_node_valid));
break;
}
#endif
}
}
/* Fill the current cu_tree node */
ps_cu_tree->is_node_valid = node_validity;
ps_cu_tree->u1_intra_eval_enable = intra_eval_enable;
ps_cu_tree->u1_inter_eval_enable = inter_eval_enable;
if(children_nodes_required)
{
tree_depth++;
hme_populate_cu_tree(
ps_ctb_cluster_info,
ps_cu_tree->ps_child_node_tl,
tree_depth,
e_quality_preset,
e_parent_blk_pos,
e_cur_blk_pos,
POS_TL);
hme_populate_cu_tree(
ps_ctb_cluster_info,
ps_cu_tree->ps_child_node_tr,
tree_depth,
e_quality_preset,
e_parent_blk_pos,
e_cur_blk_pos,
POS_TR);
hme_populate_cu_tree(
ps_ctb_cluster_info,
ps_cu_tree->ps_child_node_bl,
tree_depth,
e_quality_preset,
e_parent_blk_pos,
e_cur_blk_pos,
POS_BL);
hme_populate_cu_tree(
ps_ctb_cluster_info,
ps_cu_tree->ps_child_node_br,
tree_depth,
e_quality_preset,
e_parent_blk_pos,
e_cur_blk_pos,
POS_BR);
}
}
/**
********************************************************************************
* @fn void hme_analyse_mv_clustering
* (
* search_results_t *ps_search_results,
* ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb,
* cur_ctb_cu_tree_t *ps_cu_tree
* )
*
* @brief Implementation for the clustering algorithm
*
* @param[in] ps_search_results: structure containing 16x16 block results
*
* @param[in] ps_cur_ipe_ctb : output container for ipe analyses
*
* @param[out] ps_cu_tree : represents CU tree used in CU recursion
*
* @return None
********************************************************************************
*/
void hme_analyse_mv_clustering(
search_results_t *ps_search_results,
inter_cu_results_t *ps_16x16_cu_results,
inter_cu_results_t *ps_8x8_cu_results,
ctb_cluster_info_t *ps_ctb_cluster_info,
S08 *pi1_future_list,
S08 *pi1_past_list,
S32 bidir_enabled,
ME_QUALITY_PRESETS_T e_quality_preset)
{
cluster_16x16_blk_t *ps_blk_16x16;
cluster_32x32_blk_t *ps_blk_32x32;
cluster_64x64_blk_t *ps_blk_64x64;
part_type_results_t *ps_best_result;
pu_result_t *aps_part_result[MAX_NUM_PARTS];
pu_result_t *aps_inferior_parts[MAX_NUM_PARTS];
PART_ID_T e_part_id;
PART_TYPE_T e_part_type;
S32 enable_64x64_merge;
S32 i, j, k;
S32 mvx, mvy;
S32 num_parts;
S32 ref_idx;
S32 ai4_pred_mode[MAX_NUM_PARTS];
S32 num_32x32_merges = 0;
/*****************************************/
/*****************************************/
/********* Enter ye who is HQ ************/
/*****************************************/
/*****************************************/
ps_blk_64x64 = ps_ctb_cluster_info->ps_64x64_blk;
/* Initialise data in each of the clusters */
for(i = 0; i < 16; i++)
{
ps_blk_16x16 = &ps_ctb_cluster_info->ps_16x16_blk[i];
#if !USE_CLUSTER_DATA_AS_BLK_MERGE_CANDTS
if(e_quality_preset < ME_HIGH_QUALITY)
{
hme_init_clusters_16x16(ps_blk_16x16, bidir_enabled);
}
else
{
ps_blk_16x16->best_inter_cost = 0;
ps_blk_16x16->intra_mv_area = 0;
}
#else
hme_init_clusters_16x16(ps_blk_16x16, bidir_enabled);
#endif
}
for(i = 0; i < 4; i++)
{
ps_blk_32x32 = &ps_ctb_cluster_info->ps_32x32_blk[i];
#if !USE_CLUSTER_DATA_AS_BLK_MERGE_CANDTS
if(e_quality_preset < ME_HIGH_QUALITY)
{
hme_init_clusters_32x32(ps_blk_32x32, bidir_enabled);
}
else
{
ps_blk_32x32->best_inter_cost = 0;
ps_blk_32x32->intra_mv_area = 0;
}
#else
hme_init_clusters_32x32(ps_blk_32x32, bidir_enabled);
#endif
}
#if !USE_CLUSTER_DATA_AS_BLK_MERGE_CANDTS
if(e_quality_preset < ME_HIGH_QUALITY)
{
hme_init_clusters_64x64(ps_blk_64x64, bidir_enabled);
}
else
{
ps_blk_64x64->best_inter_cost = 0;
ps_blk_64x64->intra_mv_area = 0;
}
#else
hme_init_clusters_64x64(ps_blk_64x64, bidir_enabled);
#endif
/* Initialise data for all nodes in the CU tree */
hme_build_cu_tree(
ps_ctb_cluster_info, ps_ctb_cluster_info->ps_cu_tree_root, 0, POS_NA, POS_NA, POS_NA);
if(e_quality_preset >= ME_HIGH_QUALITY)
{
memset(ps_ctb_cluster_info->au1_is_16x16_blk_split, 1, 16 * sizeof(U08));
}
#if ENABLE_UNIFORM_CU_SIZE_16x16 || ENABLE_UNIFORM_CU_SIZE_8x8
return;
#endif
for(i = 0; i < 16; i++)
{
S32 blk_8x8_mask;
S32 is_16x16_blk_valid;
S32 num_clusters_updated;
S32 num_clusters;
blk_8x8_mask = ps_ctb_cluster_info->pi4_blk_8x8_mask[i];
ps_blk_16x16 = &ps_ctb_cluster_info->ps_16x16_blk[i];
is_16x16_blk_valid = (blk_8x8_mask == 0xf);
if(is_16x16_blk_valid)
{
/* Use 8x8 data when 16x16 CU is split */
if(ps_search_results[i].u1_split_flag)
{
S32 blk_8x8_idx = i << 2;
num_parts = 4;
e_part_type = PRT_NxN;
for(j = 0; j < num_parts; j++, blk_8x8_idx++)
{
/* Only 2Nx2N partition supported for 8x8 block */
ASSERT(
ps_8x8_cu_results[blk_8x8_idx].ps_best_results[0].u1_part_type ==
((PART_TYPE_T)PRT_2Nx2N));
aps_part_result[j] =
&ps_8x8_cu_results[blk_8x8_idx].ps_best_results[0].as_pu_results[0];
aps_inferior_parts[j] =
&ps_8x8_cu_results[blk_8x8_idx].ps_best_results[1].as_pu_results[0];
ai4_pred_mode[j] = (aps_part_result[j]->pu.b2_pred_mode);
}
}
else
{
ps_best_result = &ps_16x16_cu_results[i].ps_best_results[0];
e_part_type = (PART_TYPE_T)ps_best_result->u1_part_type;
num_parts = gau1_num_parts_in_part_type[e_part_type];
for(j = 0; j < num_parts; j++)
{
aps_part_result[j] = &ps_best_result->as_pu_results[j];
aps_inferior_parts[j] = &ps_best_result[1].as_pu_results[j];
ai4_pred_mode[j] = (aps_part_result[j]->pu.b2_pred_mode);
}
ps_ctb_cluster_info->au1_is_16x16_blk_split[i] = 0;
}
for(j = 0; j < num_parts; j++)
{
pu_result_t *ps_part_result = aps_part_result[j];
S32 num_mvs = ((ai4_pred_mode[j] > 1) + 1);
e_part_id = ge_part_type_to_part_id[e_part_type][j];
/* Skip clustering if best mode is intra */
if((ps_part_result->pu.b1_intra_flag))
{
ps_blk_16x16->intra_mv_area += gai4_partition_area[e_part_id];
ps_blk_16x16->best_inter_cost += aps_inferior_parts[j]->i4_tot_cost;
continue;
}
else
{
ps_blk_16x16->best_inter_cost += ps_part_result->i4_tot_cost;
}
#if !USE_CLUSTER_DATA_AS_BLK_MERGE_CANDTS
if(e_quality_preset >= ME_HIGH_QUALITY)
{
continue;
}
#endif
for(k = 0; k < num_mvs; k++)
{
mv_t *ps_mv;
pu_mv_t *ps_pu_mv = &ps_part_result->pu.mv;
S32 is_l0_mv = ((ai4_pred_mode[j] == 2) && !k) || (ai4_pred_mode[j] == 0);
ps_mv = (is_l0_mv) ? (&ps_pu_mv->s_l0_mv) : (&ps_pu_mv->s_l1_mv);
mvx = ps_mv->i2_mvx;
mvy = ps_mv->i2_mvy;
ref_idx = (is_l0_mv) ? pi1_past_list[ps_pu_mv->i1_l0_ref_idx]
: pi1_future_list[ps_pu_mv->i1_l1_ref_idx];
num_clusters = ps_blk_16x16->num_clusters;
hme_find_and_update_clusters(
ps_blk_16x16->as_cluster_data,
&(ps_blk_16x16->num_clusters),
mvx,
mvy,
ref_idx,
ps_part_result->i4_sdi,
e_part_id,
(ai4_pred_mode[j] == 2));
num_clusters_updated = (ps_blk_16x16->num_clusters);
ps_blk_16x16->au1_num_clusters[ref_idx] +=
(num_clusters_updated - num_clusters);
}
}
}
}
/* Search for 32x32 clusters */
for(i = 0; i < 4; i++)
{
S32 num_clusters_merged;
S32 is_32x32_blk_valid = (ps_ctb_cluster_info->blk_32x32_mask & (1 << i)) || 0;
if(is_32x32_blk_valid)
{
ps_blk_32x32 = &ps_ctb_cluster_info->ps_32x32_blk[i];
ps_blk_16x16 = &ps_ctb_cluster_info->ps_16x16_blk[i << 2];
#if !USE_CLUSTER_DATA_AS_BLK_MERGE_CANDTS
if(e_quality_preset >= ME_HIGH_QUALITY)
{
for(j = 0; j < 4; j++, ps_blk_16x16++)
{
ps_blk_32x32->intra_mv_area += ps_blk_16x16->intra_mv_area;
ps_blk_32x32->best_inter_cost += ps_blk_16x16->best_inter_cost;
}
continue;
}
#endif
hme_update_32x32_clusters(ps_blk_32x32, ps_blk_16x16);
if((ps_blk_32x32->num_clusters >= MAX_NUM_CLUSTERS_IN_VALID_32x32_BLK))
{
num_clusters_merged = hme_try_merge_clusters_blksize_gt_16(
ps_blk_32x32->as_cluster_data, (ps_blk_32x32->num_clusters));
if(num_clusters_merged)
{
ps_blk_32x32->num_clusters -= num_clusters_merged;
UPDATE_CLUSTER_METADATA_POST_MERGE(ps_blk_32x32);
}
}
}
}
#if !USE_CLUSTER_DATA_AS_BLK_MERGE_CANDTS
/* Eliminate outlier 32x32 clusters */
if(e_quality_preset < ME_HIGH_QUALITY)
#endif
{
hme_boot_out_outlier(ps_ctb_cluster_info, 32);
/* Find best_uni_ref and best_alt_ref */
hme_find_top_ref_ids(ps_ctb_cluster_info, bidir_enabled, 32);
}
/* Populate the CU tree for depths 1 and higher */
{
cur_ctb_cu_tree_t *ps_tree_root = ps_ctb_cluster_info->ps_cu_tree_root;
cur_ctb_cu_tree_t *ps_tl = ps_tree_root->ps_child_node_tl;
cur_ctb_cu_tree_t *ps_tr = ps_tree_root->ps_child_node_tr;
cur_ctb_cu_tree_t *ps_bl = ps_tree_root->ps_child_node_bl;
cur_ctb_cu_tree_t *ps_br = ps_tree_root->ps_child_node_br;
hme_populate_cu_tree(
ps_ctb_cluster_info, ps_tl, 1, e_quality_preset, POS_NA, POS_NA, POS_TL);
num_32x32_merges += (ps_tl->is_node_valid == 1);
hme_populate_cu_tree(
ps_ctb_cluster_info, ps_tr, 1, e_quality_preset, POS_NA, POS_NA, POS_TR);
num_32x32_merges += (ps_tr->is_node_valid == 1);
hme_populate_cu_tree(
ps_ctb_cluster_info, ps_bl, 1, e_quality_preset, POS_NA, POS_NA, POS_BL);
num_32x32_merges += (ps_bl->is_node_valid == 1);
hme_populate_cu_tree(
ps_ctb_cluster_info, ps_br, 1, e_quality_preset, POS_NA, POS_NA, POS_BR);
num_32x32_merges += (ps_br->is_node_valid == 1);
}
#if !ENABLE_4CTB_EVALUATION
if(e_quality_preset < ME_HIGH_QUALITY)
{
enable_64x64_merge = (num_32x32_merges >= 3);
}
#else
if(e_quality_preset < ME_HIGH_QUALITY)
{
enable_64x64_merge = 1;
}
#endif
#if 1 //!PROCESS_GT_1CTB_VIA_CU_RECUR_IN_FAST_PRESETS
if(e_quality_preset >= ME_HIGH_QUALITY)
{
enable_64x64_merge = 1;
}
#else
if(e_quality_preset >= ME_HIGH_QUALITY)
{
enable_64x64_merge = (num_32x32_merges >= 3);
}
#endif
if(enable_64x64_merge)
{
S32 num_clusters_merged;
ps_blk_32x32 = &ps_ctb_cluster_info->ps_32x32_blk[0];
#if !USE_CLUSTER_DATA_AS_BLK_MERGE_CANDTS
if(e_quality_preset >= ME_HIGH_QUALITY)
{
for(j = 0; j < 4; j++, ps_blk_32x32++)
{
ps_blk_64x64->intra_mv_area += ps_blk_32x32->intra_mv_area;
ps_blk_64x64->best_inter_cost += ps_blk_32x32->best_inter_cost;
}
}
else
#endif
{
hme_update_64x64_clusters(ps_blk_64x64, ps_blk_32x32);
if((ps_blk_64x64->num_clusters >= MAX_NUM_CLUSTERS_IN_VALID_64x64_BLK))
{
num_clusters_merged = hme_try_merge_clusters_blksize_gt_16(
ps_blk_64x64->as_cluster_data, (ps_blk_64x64->num_clusters));
if(num_clusters_merged)
{
ps_blk_64x64->num_clusters -= num_clusters_merged;
UPDATE_CLUSTER_METADATA_POST_MERGE(ps_blk_64x64);
}
}
}
#if !ENABLE_4CTB_EVALUATION
if(e_quality_preset < ME_HIGH_QUALITY)
{
S32 best_inter_cost = ps_blk_64x64->best_inter_cost;
S32 best_intra_cost =
((ps_ctb_cluster_info->ps_cur_ipe_ctb->i4_best64x64_intra_cost +
ps_ctb_cluster_info->i4_frame_qstep *
ps_ctb_cluster_info->i4_frame_qstep_multiplier * 16) < 0)
? MAX_32BIT_VAL
: (ps_ctb_cluster_info->ps_cur_ipe_ctb->i4_best64x64_intra_cost +
ps_ctb_cluster_info->i4_frame_qstep *
ps_ctb_cluster_info->i4_frame_qstep_multiplier * 16);
S32 best_cost = (best_inter_cost > best_intra_cost) ? best_intra_cost : best_inter_cost;
S32 cost_differential = (best_inter_cost - best_cost);
enable_64x64_merge =
((ALL_INTER_COST_DIFF_THR * best_cost) >= (100 * cost_differential));
}
#endif
}
if(enable_64x64_merge)
{
#if !USE_CLUSTER_DATA_AS_BLK_MERGE_CANDTS
if(e_quality_preset < ME_HIGH_QUALITY)
#endif
{
hme_boot_out_outlier(ps_ctb_cluster_info, 64);
hme_find_top_ref_ids(ps_ctb_cluster_info, bidir_enabled, 64);
}
hme_populate_cu_tree(
ps_ctb_cluster_info,
ps_ctb_cluster_info->ps_cu_tree_root,
0,
e_quality_preset,
POS_NA,
POS_NA,
POS_NA);
}
}
#endif
static __inline void hme_merge_prms_init(
hme_merge_prms_t *ps_prms,
layer_ctxt_t *ps_curr_layer,
refine_prms_t *ps_refine_prms,
me_frm_ctxt_t *ps_me_ctxt,
range_prms_t *ps_range_prms_rec,
range_prms_t *ps_range_prms_inp,
mv_grid_t **pps_mv_grid,
inter_ctb_prms_t *ps_inter_ctb_prms,
S32 i4_num_pred_dir,
S32 i4_32x32_id,
BLK_SIZE_T e_blk_size,
ME_QUALITY_PRESETS_T e_me_quality_presets)
{
S32 i4_use_rec = ps_refine_prms->i4_use_rec_in_fpel;
S32 i4_cu_16x16 = (BLK_32x32 == e_blk_size) ? (i4_32x32_id << 2) : 0;
/* Currently not enabling segmentation info from prev layers */
ps_prms->i4_seg_info_avail = 0;
ps_prms->i4_part_mask = 0;
/* Number of reference pics in which to do merge */
ps_prms->i4_num_ref = i4_num_pred_dir;
/* Layer ctxt info */
ps_prms->ps_layer_ctxt = ps_curr_layer;
ps_prms->ps_inter_ctb_prms = ps_inter_ctb_prms;
/* Top left, top right, bottom left and bottom right 16x16 units */
if(BLK_32x32 == e_blk_size)
{
ps_prms->ps_results_tl = &ps_me_ctxt->as_search_results_16x16[i4_cu_16x16];
ps_prms->ps_results_tr = &ps_me_ctxt->as_search_results_16x16[i4_cu_16x16 + 1];
ps_prms->ps_results_bl = &ps_me_ctxt->as_search_results_16x16[i4_cu_16x16 + 2];
ps_prms->ps_results_br = &ps_me_ctxt->as_search_results_16x16[i4_cu_16x16 + 3];
/* Merge results stored here */
ps_prms->ps_results_merge = &ps_me_ctxt->as_search_results_32x32[i4_32x32_id];
/* This could be lesser than the number of 16x16results generated*/
/* For now, keeping it to be same */
ps_prms->i4_num_inp_results = ps_refine_prms->i4_num_fpel_results;
ps_prms->ps_8x8_cu_results = &ps_me_ctxt->as_cu8x8_results[i4_32x32_id << 4];
ps_prms->ps_results_grandchild = NULL;
}
else
{
ps_prms->ps_results_tl = &ps_me_ctxt->as_search_results_32x32[0];
ps_prms->ps_results_tr = &ps_me_ctxt->as_search_results_32x32[1];
ps_prms->ps_results_bl = &ps_me_ctxt->as_search_results_32x32[2];
ps_prms->ps_results_br = &ps_me_ctxt->as_search_results_32x32[3];
/* Merge results stored here */
ps_prms->ps_results_merge = &ps_me_ctxt->s_search_results_64x64;
ps_prms->i4_num_inp_results = ps_refine_prms->i4_num_32x32_merge_results;
ps_prms->ps_8x8_cu_results = &ps_me_ctxt->as_cu8x8_results[0];
ps_prms->ps_results_grandchild = ps_me_ctxt->as_search_results_16x16;
}
if(i4_use_rec)
{
WORD32 ref_ctr;
for(ref_ctr = 0; ref_ctr < MAX_NUM_REF; ref_ctr++)
{
ps_prms->aps_mv_range[ref_ctr] = &ps_range_prms_rec[ref_ctr];
}
}
else
{
WORD32 ref_ctr;
for(ref_ctr = 0; ref_ctr < MAX_NUM_REF; ref_ctr++)
{
ps_prms->aps_mv_range[ref_ctr] = &ps_range_prms_inp[ref_ctr];
}
}
ps_prms->i4_use_rec = i4_use_rec;
ps_prms->pf_mv_cost_compute = compute_mv_cost_implicit_high_speed;
ps_prms->pps_mv_grid = pps_mv_grid;
ps_prms->log_ctb_size = ps_me_ctxt->log_ctb_size;
ps_prms->e_quality_preset = e_me_quality_presets;
ps_prms->pi1_future_list = ps_me_ctxt->ai1_future_list;
ps_prms->pi1_past_list = ps_me_ctxt->ai1_past_list;
ps_prms->ps_cluster_info = ps_me_ctxt->ps_ctb_cluster_info;
}
/**
********************************************************************************
* @fn void hme_refine(me_ctxt_t *ps_ctxt,
* refine_layer_prms_t *ps_refine_prms)
*
* @brief Top level entry point for refinement ME
*
* @param[in,out] ps_ctxt: ME Handle
*
* @param[in] ps_refine_prms : refinement layer prms
*
* @return None
********************************************************************************
*/
void hme_refine(
me_ctxt_t *ps_thrd_ctxt,
refine_prms_t *ps_refine_prms,
PF_EXT_UPDATE_FXN_T pf_ext_update_fxn,
layer_ctxt_t *ps_coarse_layer,
multi_thrd_ctxt_t *ps_multi_thrd_ctxt,
S32 lyr_job_type,
S32 thrd_id,
S32 me_frm_id,
pre_enc_L0_ipe_encloop_ctxt_t *ps_l0_ipe_input)
{
inter_ctb_prms_t s_common_frm_prms;
BLK_SIZE_T e_search_blk_size, e_result_blk_size;
WORD32 i4_me_frm_id = me_frm_id % MAX_NUM_ME_PARALLEL;
me_frm_ctxt_t *ps_ctxt = ps_thrd_ctxt->aps_me_frm_prms[i4_me_frm_id];
ME_QUALITY_PRESETS_T e_me_quality_presets =
ps_thrd_ctxt->s_init_prms.s_me_coding_tools.e_me_quality_presets;
WORD32 num_rows_proc = 0;
WORD32 num_act_ref_pics;
WORD16 i2_prev_enc_frm_max_mv_y;
WORD32 i4_idx_dvsr_p = ps_multi_thrd_ctxt->i4_idx_dvsr_p;
/*************************************************************************/
/* Complexity of search: Low to High */
/*************************************************************************/
SEARCH_COMPLEXITY_T e_search_complexity;
/*************************************************************************/
/* to store the PU results which are passed to the decide_part_types */
/* as input prms. Multiplied by 4 as the max number of Ref in a List is 4*/
/*************************************************************************/
pu_result_t as_pu_results[2][TOT_NUM_PARTS][MAX_NUM_RESULTS_PER_PART_LIST];
inter_pu_results_t as_inter_pu_results[4];
inter_pu_results_t *ps_pu_results = as_inter_pu_results;
/*************************************************************************/
/* Config parameter structures for varius ME submodules */
/*************************************************************************/
hme_merge_prms_t s_merge_prms_32x32_tl, s_merge_prms_32x32_tr;
hme_merge_prms_t s_merge_prms_32x32_bl, s_merge_prms_32x32_br;
hme_merge_prms_t s_merge_prms_64x64;
hme_search_prms_t s_search_prms_blk;
mvbank_update_prms_t s_mv_update_prms;
hme_ctb_prms_t s_ctb_prms;
hme_subpel_prms_t s_subpel_prms;
fullpel_refine_ctxt_t *ps_fullpel_refine_ctxt = ps_ctxt->ps_fullpel_refine_ctxt;
ctb_cluster_info_t *ps_ctb_cluster_info;
fpel_srch_cand_init_data_t s_srch_cand_init_data;
/* 4 bits (LSBs) of this variable control merge of 4 32x32 CUs in CTB */
S32 en_merge_32x32;
/* 5 lsb's specify whether or not merge algorithm is required */
/* to be executed or not. Relevant only in PQ. Ought to be */
/* used in conjunction with en_merge_32x32 and */
/* ps_ctb_bound_attrs->u1_merge_to_64x64_flag. This is */
/* required when all children are deemed to be intras */
S32 en_merge_execution;
/*************************************************************************/
/* All types of search candidates for predictor based search. */
/*************************************************************************/
S32 num_init_candts = 0;
S32 i4_num_act_ref_l0 = ps_ctxt->s_frm_prms.u1_num_active_ref_l0;
S32 i4_num_act_ref_l1 = ps_ctxt->s_frm_prms.u1_num_active_ref_l1;
search_candt_t *ps_search_candts, as_search_candts[MAX_INIT_CANDTS];
search_node_t as_top_neighbours[4], as_left_neighbours[3];
pf_get_wt_inp fp_get_wt_inp;
search_node_t as_unique_search_nodes[MAX_INIT_CANDTS * 9];
U32 au4_unique_node_map[MAP_X_MAX * 2];
/* Controls the boundary attributes of CTB, whether it has 64x64 or not */
ctb_boundary_attrs_t *ps_ctb_bound_attrs;
/*************************************************************************/
/* points ot the search results for the blk level search (8x8/16x16) */
/*************************************************************************/
search_results_t *ps_search_results;
/*************************************************************************/
/* Coordinates */
/*************************************************************************/
S32 blk_x, blk_y, i4_ctb_x, i4_ctb_y, tile_col_idx, blk_id_in_ctb;
S32 pos_x, pos_y;
S32 blk_id_in_full_ctb;
/*************************************************************************/
/* Related to dimensions of block being searched and pic dimensions */
/*************************************************************************/
S32 blk_4x4_to_16x16;
S32 blk_wd, blk_ht, blk_size_shift;
S32 i4_pic_wd, i4_pic_ht, num_blks_in_this_ctb;
S32 num_results_prev_layer;
/*************************************************************************/
/* Size of a basic unit for this layer. For non encode layers, we search */
/* in block sizes of 8x8. For encode layers, though we search 16x16s the */
/* basic unit size is the ctb size. */
/*************************************************************************/
S32 unit_size;
/*************************************************************************/
/* Local variable storing results of any 4 CU merge to bigger CU */
/*************************************************************************/
CU_MERGE_RESULT_T e_merge_result;
/*************************************************************************/
/* This mv grid stores results during and after fpel search, during */
/* merge, subpel and bidirect refinements stages. 2 instances of this are*/
/* meant for the 2 directions of search (l0 and l1). */
/*************************************************************************/
mv_grid_t *aps_mv_grid[2];
/*************************************************************************/
/* Pointers to context in current and coarser layers */
/*************************************************************************/
layer_ctxt_t *ps_curr_layer, *ps_prev_layer;
/*************************************************************************/
/* to store mv range per blk, and picture limit, allowed search range */
/* range prms in hpel and qpel units as well */
/*************************************************************************/
range_prms_t as_range_prms_inp[MAX_NUM_REF], as_range_prms_rec[MAX_NUM_REF];
range_prms_t s_pic_limit_inp, s_pic_limit_rec, as_mv_limit[MAX_NUM_REF];
range_prms_t as_range_prms_hpel[MAX_NUM_REF], as_range_prms_qpel[MAX_NUM_REF];
/*************************************************************************/
/* These variables are used to track number of references at different */
/* stages of ME. */
/*************************************************************************/
S32 i4_num_pred_dir;
S32 i4_num_ref_each_dir, i, i4_num_ref_prev_layer;
S32 lambda_recon = ps_refine_prms->lambda_recon;
/* Counts successful merge to 32x32 every CTB (0-4) */
S32 merge_count_32x32;
S32 ai4_id_coloc[14], ai4_id_Z[2];
U08 au1_search_candidate_list_index[2];
S32 ai4_num_coloc_cands[2];
U08 u1_pred_dir, u1_pred_dir_ctr;
/*************************************************************************/
/* Input pointer and stride */
/*************************************************************************/
U08 *pu1_inp;
S32 i4_inp_stride;
S32 end_of_frame;
S32 num_sync_units_in_row, num_sync_units_in_tile;
/*************************************************************************/
/* Indicates whether the all 4 8x8 blks are valid in the 16x16 blk in the*/
/* encode layer. If not 15, then 1 or more 8x8 blks not valid. Means that*/
/* we need to stop merges and force 8x8 CUs for that 16x16 blk */
/*************************************************************************/
S32 blk_8x8_mask;
S32 ai4_blk_8x8_mask[16];
U08 au1_is_64x64Blk_noisy[1];
U08 au1_is_32x32Blk_noisy[4];
U08 au1_is_16x16Blk_noisy[16];
ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list =
ps_thrd_ctxt->ps_cmn_utils_optimised_function_list;
ihevce_me_optimised_function_list_t *ps_me_optimised_function_list =
((ihevce_me_optimised_function_list_t *)ps_thrd_ctxt->pv_me_optimised_function_list);
ASSERT(ps_refine_prms->i4_layer_id < ps_ctxt->num_layers - 1);
/*************************************************************************/
/* Pointers to current and coarse layer are needed for projection */
/* Pointer to prev layer are needed for other candts like coloc */
/*************************************************************************/
ps_curr_layer = ps_ctxt->ps_curr_descr->aps_layers[ps_refine_prms->i4_layer_id];
ps_prev_layer = hme_get_past_layer_ctxt(
ps_thrd_ctxt, ps_ctxt, ps_refine_prms->i4_layer_id, ps_multi_thrd_ctxt->i4_num_me_frm_pllel);
num_results_prev_layer = ps_coarse_layer->ps_layer_mvbank->i4_num_mvs_per_ref;
/* Function pointer is selected based on the C vc X86 macro */
fp_get_wt_inp = ps_me_optimised_function_list->pf_get_wt_inp_ctb;
i4_inp_stride = ps_curr_layer->i4_inp_stride;
i4_pic_wd = ps_curr_layer->i4_wd;
i4_pic_ht = ps_curr_layer->i4_ht;
e_search_complexity = ps_refine_prms->e_search_complexity;
end_of_frame = 0;
/* This points to all the initial candts */
ps_search_candts = &as_search_candts[0];
/* mv grid being huge strucutre is part of context */
aps_mv_grid[0] = &ps_ctxt->as_mv_grid[0];
aps_mv_grid[1] = &ps_ctxt->as_mv_grid[1];
/*************************************************************************/
/* If the current layer is encoded (since it may be multicast or final */
/* layer (finest)), then we use 16x16 blk size with some selected parts */
/* If the current layer is not encoded, then we use 8x8 blk size, with */
/* enable or disable of 4x4 partitions depending on the input prms */
/*************************************************************************/
e_search_blk_size = BLK_16x16;
blk_wd = blk_ht = 16;
blk_size_shift = 4;
e_result_blk_size = BLK_8x8;
s_mv_update_prms.i4_shift = 1;
if(ps_coarse_layer->ps_layer_mvbank->e_blk_size == BLK_4x4)
{
blk_4x4_to_16x16 = 1;
}
else
{
blk_4x4_to_16x16 = 0;
}
unit_size = 1 << ps_ctxt->log_ctb_size;
s_search_prms_blk.i4_inp_stride = unit_size;
/* This is required to properly update the layer mv bank */
s_mv_update_prms.e_search_blk_size = e_search_blk_size;
s_search_prms_blk.e_blk_size = e_search_blk_size;
/*************************************************************************/
/* If current layer is explicit, then the number of ref frames are to */
/* be same as previous layer. Else it will be 2 */
/*************************************************************************/
i4_num_ref_prev_layer = ps_coarse_layer->ps_layer_mvbank->i4_num_ref;
i4_num_pred_dir =
(ps_ctxt->s_frm_prms.bidir_enabled && (i4_num_act_ref_l0 > 0) && (i4_num_act_ref_l1 > 0)) +
1;
#if USE_MODIFIED == 1
s_search_prms_blk.pf_mv_cost_compute = compute_mv_cost_implicit_high_speed_modified;
#else
s_search_prms_blk.pf_mv_cost_compute = compute_mv_cost_implicit_high_speed;
#endif
i4_num_pred_dir = MIN(i4_num_pred_dir, i4_num_ref_prev_layer);
if(i4_num_ref_prev_layer <= 2)
{
i4_num_ref_each_dir = 1;
}
else
{
i4_num_ref_each_dir = i4_num_ref_prev_layer >> 1;
}
s_mv_update_prms.i4_num_ref = i4_num_pred_dir;
s_mv_update_prms.i4_num_results_to_store =
MIN((ps_ctxt->s_frm_prms.bidir_enabled) ? ps_curr_layer->ps_layer_mvbank->i4_num_mvs_per_ref
: (i4_num_act_ref_l0 > 1) + 1,
ps_refine_prms->i4_num_results_per_part);
/*************************************************************************/
/* Initialization of merge params for 16x16 to 32x32 merge. */
/* There are 4 32x32 units in a CTB, so 4 param structures initialized */
/*************************************************************************/
{
hme_merge_prms_t *aps_merge_prms[4];
aps_merge_prms[0] = &s_merge_prms_32x32_tl;
aps_merge_prms[1] = &s_merge_prms_32x32_tr;
aps_merge_prms[2] = &s_merge_prms_32x32_bl;
aps_merge_prms[3] = &s_merge_prms_32x32_br;
for(i = 0; i < 4; i++)
{
hme_merge_prms_init(
aps_merge_prms[i],
ps_curr_layer,
ps_refine_prms,
ps_ctxt,
as_range_prms_rec,
as_range_prms_inp,
&aps_mv_grid[0],
&s_common_frm_prms,
i4_num_pred_dir,
i,
BLK_32x32,
e_me_quality_presets);
}
}
/*************************************************************************/
/* Initialization of merge params for 32x32 to 64x64 merge. */
/* There are 4 32x32 units in a CTB, so only 1 64x64 CU can be in CTB */
/*************************************************************************/
{
hme_merge_prms_init(
&s_merge_prms_64x64,
ps_curr_layer,
ps_refine_prms,
ps_ctxt,
as_range_prms_rec,
as_range_prms_inp,
&aps_mv_grid[0],
&s_common_frm_prms,
i4_num_pred_dir,
0,
BLK_64x64,
e_me_quality_presets);
}
/* Pointers to cu_results are initialised here */
{
WORD32 i;
ps_ctxt->s_search_results_64x64.ps_cu_results = &ps_ctxt->s_cu64x64_results;
for(i = 0; i < 4; i++)
{
ps_ctxt->as_search_results_32x32[i].ps_cu_results = &ps_ctxt->as_cu32x32_results[i];
}
for(i = 0; i < 16; i++)
{
ps_ctxt->as_search_results_16x16[i].ps_cu_results = &ps_ctxt->as_cu16x16_results[i];
}
}
/*************************************************************************/
/* SUBPEL Params initialized here */
/*************************************************************************/
{
s_subpel_prms.ps_search_results_16x16 = &ps_ctxt->as_search_results_16x16[0];
s_subpel_prms.ps_search_results_32x32 = &ps_ctxt->as_search_results_32x32[0];
s_subpel_prms.ps_search_results_64x64 = &ps_ctxt->s_search_results_64x64;
s_subpel_prms.i4_num_16x16_candts = ps_refine_prms->i4_num_fpel_results;
s_subpel_prms.i4_num_32x32_candts = ps_refine_prms->i4_num_32x32_merge_results;
s_subpel_prms.i4_num_64x64_candts = ps_refine_prms->i4_num_64x64_merge_results;
s_subpel_prms.i4_num_steps_hpel_refine = ps_refine_prms->i4_num_steps_hpel_refine;
s_subpel_prms.i4_num_steps_qpel_refine = ps_refine_prms->i4_num_steps_qpel_refine;
s_subpel_prms.i4_use_satd = ps_refine_prms->i4_use_satd_subpel;
s_subpel_prms.i4_inp_stride = unit_size;
s_subpel_prms.u1_max_subpel_candts_2Nx2N = ps_refine_prms->u1_max_subpel_candts_2Nx2N;
s_subpel_prms.u1_max_subpel_candts_NxN = ps_refine_prms->u1_max_subpel_candts_NxN;
s_subpel_prms.u1_subpel_candt_threshold = ps_refine_prms->u1_subpel_candt_threshold;
s_subpel_prms.pf_qpel_interp = ps_me_optimised_function_list->pf_qpel_interp_avg_generic;
{
WORD32 ref_ctr;
for(ref_ctr = 0; ref_ctr < MAX_NUM_REF; ref_ctr++)
{
s_subpel_prms.aps_mv_range_hpel[ref_ctr] = &as_range_prms_hpel[ref_ctr];
s_subpel_prms.aps_mv_range_qpel[ref_ctr] = &as_range_prms_qpel[ref_ctr];
}
}
s_subpel_prms.pi2_inp_bck = ps_ctxt->pi2_inp_bck;
#if USE_MODIFIED == 0
s_subpel_prms.pf_mv_cost_compute = compute_mv_cost_implicit_high_speed;
#else
s_subpel_prms.pf_mv_cost_compute = compute_mv_cost_implicit_high_speed_modified;
#endif
s_subpel_prms.e_me_quality_presets = e_me_quality_presets;
/* BI Refinement done only if this field is 1 */
s_subpel_prms.bidir_enabled = ps_refine_prms->bidir_enabled;
s_subpel_prms.u1_num_ref = ps_ctxt->num_ref_future + ps_ctxt->num_ref_past;
s_subpel_prms.i4_num_act_ref_l0 = ps_ctxt->s_frm_prms.u1_num_active_ref_l0;
s_subpel_prms.i4_num_act_ref_l1 = ps_ctxt->s_frm_prms.u1_num_active_ref_l1;
s_subpel_prms.u1_max_num_subpel_refine_centers =
ps_refine_prms->u1_max_num_subpel_refine_centers;
}
/* inter_ctb_prms_t struct initialisation */
{
inter_ctb_prms_t *ps_inter_ctb_prms = &s_common_frm_prms;
hme_subpel_prms_t *ps_subpel_prms = &s_subpel_prms;
ps_inter_ctb_prms->pps_rec_list_l0 = ps_ctxt->ps_hme_ref_map->pps_rec_list_l0;
ps_inter_ctb_prms->pps_rec_list_l1 = ps_ctxt->ps_hme_ref_map->pps_rec_list_l1;
ps_inter_ctb_prms->wpred_log_wdc = ps_ctxt->s_wt_pred.wpred_log_wdc;
ps_inter_ctb_prms->u1_max_tr_depth = ps_thrd_ctxt->s_init_prms.u1_max_tr_depth;
ps_inter_ctb_prms->i1_quality_preset = e_me_quality_presets;
ps_inter_ctb_prms->i4_bidir_enabled = ps_subpel_prms->bidir_enabled;
ps_inter_ctb_prms->i4_inp_stride = ps_subpel_prms->i4_inp_stride;
ps_inter_ctb_prms->u1_num_ref = ps_subpel_prms->u1_num_ref;
ps_inter_ctb_prms->u1_use_satd = ps_subpel_prms->i4_use_satd;
ps_inter_ctb_prms->i4_rec_stride = ps_curr_layer->i4_rec_stride;
ps_inter_ctb_prms->u1_num_active_ref_l0 = ps_ctxt->s_frm_prms.u1_num_active_ref_l0;
ps_inter_ctb_prms->u1_num_active_ref_l1 = ps_ctxt->s_frm_prms.u1_num_active_ref_l1;
ps_inter_ctb_prms->i4_lamda = lambda_recon;
ps_inter_ctb_prms->u1_lamda_qshift = ps_refine_prms->lambda_q_shift;
ps_inter_ctb_prms->i4_qstep_ls8 = ps_ctxt->ps_hme_frm_prms->qstep_ls8;
ps_inter_ctb_prms->pi4_inv_wt = ps_ctxt->s_wt_pred.a_inv_wpred_wt;
ps_inter_ctb_prms->pi1_past_list = ps_ctxt->ai1_past_list;
ps_inter_ctb_prms->pi1_future_list = ps_ctxt->ai1_future_list;
ps_inter_ctb_prms->pu4_src_variance = s_search_prms_blk.au4_src_variance;
ps_inter_ctb_prms->u1_max_2nx2n_tu_recur_cands =
ps_refine_prms->u1_max_2nx2n_tu_recur_cands;
}
for(i = 0; i < MAX_INIT_CANDTS; i++)
{
ps_search_candts[i].ps_search_node = &ps_ctxt->s_init_search_node[i];
ps_search_candts[i].ps_search_node->ps_mv = &ps_ctxt->as_search_cand_mv[i];
INIT_SEARCH_NODE(ps_search_candts[i].ps_search_node, 0);
}
num_act_ref_pics =
ps_ctxt->s_frm_prms.u1_num_active_ref_l0 + ps_ctxt->s_frm_prms.u1_num_active_ref_l1;
if(num_act_ref_pics)
{
hme_search_cand_data_init(
ai4_id_Z,
ai4_id_coloc,
ai4_num_coloc_cands,
au1_search_candidate_list_index,
i4_num_act_ref_l0,
i4_num_act_ref_l1,
ps_ctxt->s_frm_prms.bidir_enabled,
blk_4x4_to_16x16);
}
if(!ps_ctxt->s_frm_prms.bidir_enabled && (i4_num_act_ref_l0 > 1))
{
ps_search_candts[ai4_id_Z[0]].ps_search_node->i1_ref_idx = ps_ctxt->ai1_past_list[0];
ps_search_candts[ai4_id_Z[1]].ps_search_node->i1_ref_idx = ps_ctxt->ai1_past_list[1];
}
else if(!ps_ctxt->s_frm_prms.bidir_enabled && (i4_num_act_ref_l0 == 1))
{
ps_search_candts[ai4_id_Z[0]].ps_search_node->i1_ref_idx = ps_ctxt->ai1_past_list[0];
}
for(i = 0; i < 3; i++)
{
search_node_t *ps_search_node;
ps_search_node = &as_left_neighbours[i];
INIT_SEARCH_NODE(ps_search_node, 0);
ps_search_node = &as_top_neighbours[i];
INIT_SEARCH_NODE(ps_search_node, 0);
}
INIT_SEARCH_NODE(&as_top_neighbours[3], 0);
as_left_neighbours[2].u1_is_avail = 0;
/*************************************************************************/
/* Initialize all the search results structure here. We update all the */
/* search results to default values, and configure things like blk sizes */
/*************************************************************************/
if(num_act_ref_pics)
{
S32 i4_x, i4_y;
/* 16x16 results */
for(i = 0; i < 16; i++)
{
search_results_t *ps_search_results;
S32 pred_lx;
ps_search_results = &ps_ctxt->as_search_results_16x16[i];
i4_x = (S32)gau1_encode_to_raster_x[i];
i4_y = (S32)gau1_encode_to_raster_y[i];
i4_x <<= 4;
i4_y <<= 4;
hme_init_search_results(
ps_search_results,
i4_num_pred_dir,
ps_refine_prms->i4_num_fpel_results,
ps_refine_prms->i4_num_results_per_part,
e_search_blk_size,
i4_x,
i4_y,
&ps_ctxt->au1_is_past[0]);
for(pred_lx = 0; pred_lx < 2; pred_lx++)
{
pred_ctxt_t *ps_pred_ctxt;
ps_pred_ctxt = &ps_search_results->as_pred_ctxt[pred_lx];
hme_init_pred_ctxt_encode(
ps_pred_ctxt,
ps_search_results,
ps_search_candts[ai4_id_coloc[0]].ps_search_node,
ps_search_candts[ai4_id_Z[0]].ps_search_node,
aps_mv_grid[pred_lx],
pred_lx,
lambda_recon,
ps_refine_prms->lambda_q_shift,
&ps_ctxt->apu1_ref_bits_tlu_lc[0],
&ps_ctxt->ai2_ref_scf[0]);
}
}
for(i = 0; i < 4; i++)
{
search_results_t *ps_search_results;
S32 pred_lx;
ps_search_results = &ps_ctxt->as_search_results_32x32[i];
i4_x = (S32)gau1_encode_to_raster_x[i];
i4_y = (S32)gau1_encode_to_raster_y[i];
i4_x <<= 5;
i4_y <<= 5;
hme_init_search_results(
ps_search_results,
i4_num_pred_dir,
ps_refine_prms->i4_num_32x32_merge_results,
ps_refine_prms->i4_num_results_per_part,
BLK_32x32,
i4_x,
i4_y,
&ps_ctxt->au1_is_past[0]);
for(pred_lx = 0; pred_lx < 2; pred_lx++)
{
pred_ctxt_t *ps_pred_ctxt;
ps_pred_ctxt = &ps_search_results->as_pred_ctxt[pred_lx];
hme_init_pred_ctxt_encode(
ps_pred_ctxt,
ps_search_results,
ps_search_candts[ai4_id_coloc[0]].ps_search_node,
ps_search_candts[ai4_id_Z[0]].ps_search_node,
aps_mv_grid[pred_lx],
pred_lx,
lambda_recon,
ps_refine_prms->lambda_q_shift,
&ps_ctxt->apu1_ref_bits_tlu_lc[0],
&ps_ctxt->ai2_ref_scf[0]);
}
}
{
search_results_t *ps_search_results;
S32 pred_lx;
ps_search_results = &ps_ctxt->s_search_results_64x64;
hme_init_search_results(
ps_search_results,
i4_num_pred_dir,
ps_refine_prms->i4_num_64x64_merge_results,
ps_refine_prms->i4_num_results_per_part,
BLK_64x64,
0,
0,
&ps_ctxt->au1_is_past[0]);
for(pred_lx = 0; pred_lx < 2; pred_lx++)
{
pred_ctxt_t *ps_pred_ctxt;
ps_pred_ctxt = &ps_search_results->as_pred_ctxt[pred_lx];
hme_init_pred_ctxt_encode(
ps_pred_ctxt,
ps_search_results,
ps_search_candts[ai4_id_coloc[0]].ps_search_node,
ps_search_candts[ai4_id_Z[0]].ps_search_node,
aps_mv_grid[pred_lx],
pred_lx,
lambda_recon,
ps_refine_prms->lambda_q_shift,
&ps_ctxt->apu1_ref_bits_tlu_lc[0],
&ps_ctxt->ai2_ref_scf[0]);
}
}
}
/* Initialise the structure used in clustering */
if(ME_PRISTINE_QUALITY == e_me_quality_presets)
{
ps_ctb_cluster_info = ps_ctxt->ps_ctb_cluster_info;
ps_ctb_cluster_info->ps_16x16_blk = ps_ctxt->ps_blk_16x16;
ps_ctb_cluster_info->ps_32x32_blk = ps_ctxt->ps_blk_32x32;
ps_ctb_cluster_info->ps_64x64_blk = ps_ctxt->ps_blk_64x64;
ps_ctb_cluster_info->pi4_blk_8x8_mask = ai4_blk_8x8_mask;
ps_ctb_cluster_info->sdi_threshold = ps_refine_prms->sdi_threshold;
ps_ctb_cluster_info->i4_frame_qstep = ps_ctxt->frm_qstep;
ps_ctb_cluster_info->i4_frame_qstep_multiplier = 16;
}
/*********************************************************************/
/* Initialize the dyn. search range params. for each reference index */
/* in current layer ctxt */
/*********************************************************************/
/* Only for P pic. For P, both are 0, I&B has them mut. exclusive */
if(ps_ctxt->s_frm_prms.is_i_pic == ps_ctxt->s_frm_prms.bidir_enabled)
{
WORD32 ref_ctr;
/* set no. of act ref in L0 for further use at frame level */
ps_ctxt->as_l0_dyn_range_prms[i4_idx_dvsr_p].i4_num_act_ref_in_l0 =
ps_ctxt->s_frm_prms.u1_num_active_ref_l0;
for(ref_ctr = 0; ref_ctr < ps_ctxt->s_frm_prms.u1_num_active_ref_l0; ref_ctr++)
{
INIT_DYN_SEARCH_PRMS(
&ps_ctxt->as_l0_dyn_range_prms[i4_idx_dvsr_p].as_dyn_range_prms[ref_ctr],
ps_ctxt->ai4_ref_idx_to_poc_lc[ref_ctr]);
}
}
/*************************************************************************/
/* Now that the candidates have been ordered, to choose the right number */
/* of initial candidates. */
/*************************************************************************/
if(blk_4x4_to_16x16)
{
if(i4_num_ref_prev_layer > 2)
{
if(e_search_complexity == SEARCH_CX_LOW)
num_init_candts = 7 * (!ps_ctxt->s_frm_prms.bidir_enabled + 1);
else if(e_search_complexity == SEARCH_CX_MED)
num_init_candts = 14 * (!ps_ctxt->s_frm_prms.bidir_enabled + 1);
else if(e_search_complexity == SEARCH_CX_HIGH)
num_init_candts = 21 * (!ps_ctxt->s_frm_prms.bidir_enabled + 1);
else
ASSERT(0);
}
else if(i4_num_ref_prev_layer == 2)
{
if(e_search_complexity == SEARCH_CX_LOW)
num_init_candts = 5 * (!ps_ctxt->s_frm_prms.bidir_enabled + 1);
else if(e_search_complexity == SEARCH_CX_MED)
num_init_candts = 12 * (!ps_ctxt->s_frm_prms.bidir_enabled + 1);
else if(e_search_complexity == SEARCH_CX_HIGH)
num_init_candts = 19 * (!ps_ctxt->s_frm_prms.bidir_enabled + 1);
else
ASSERT(0);
}
else
{
if(e_search_complexity == SEARCH_CX_LOW)
num_init_candts = 5;
else if(e_search_complexity == SEARCH_CX_MED)
num_init_candts = 12;
else if(e_search_complexity == SEARCH_CX_HIGH)
num_init_candts = 19;
else
ASSERT(0);
}
}
else
{
if(i4_num_ref_prev_layer > 2)
{
if(e_search_complexity == SEARCH_CX_LOW)
num_init_candts = 7 * (!ps_ctxt->s_frm_prms.bidir_enabled + 1);
else if(e_search_complexity == SEARCH_CX_MED)
num_init_candts = 13 * (!ps_ctxt->s_frm_prms.bidir_enabled + 1);
else if(e_search_complexity == SEARCH_CX_HIGH)
num_init_candts = 18 * (!ps_ctxt->s_frm_prms.bidir_enabled + 1);
else
ASSERT(0);
}
else if(i4_num_ref_prev_layer == 2)
{
if(e_search_complexity == SEARCH_CX_LOW)
num_init_candts = 5 * (!ps_ctxt->s_frm_prms.bidir_enabled + 1);
else if(e_search_complexity == SEARCH_CX_MED)
num_init_candts = 11 * (!ps_ctxt->s_frm_prms.bidir_enabled + 1);
else if(e_search_complexity == SEARCH_CX_HIGH)
num_init_candts = 16 * (!ps_ctxt->s_frm_prms.bidir_enabled + 1);
else
ASSERT(0);
}
else
{
if(e_search_complexity == SEARCH_CX_LOW)
num_init_candts = 5;
else if(e_search_complexity == SEARCH_CX_MED)
num_init_candts = 11;
else if(e_search_complexity == SEARCH_CX_HIGH)
num_init_candts = 16;
else
ASSERT(0);
}
}
/*************************************************************************/
/* The following search parameters are fixed throughout the search across*/
/* all blks. So these are configured outside processing loop */
/*************************************************************************/
s_search_prms_blk.i4_num_init_candts = num_init_candts;
s_search_prms_blk.i4_start_step = 1;
s_search_prms_blk.i4_use_satd = 0;
s_search_prms_blk.i4_num_steps_post_refine = ps_refine_prms->i4_num_steps_post_refine_fpel;
/* we use recon only for encoded layers, otherwise it is not available */
s_search_prms_blk.i4_use_rec = ps_refine_prms->i4_encode & ps_refine_prms->i4_use_rec_in_fpel;
s_search_prms_blk.ps_search_candts = ps_search_candts;
if(s_search_prms_blk.i4_use_rec)
{
WORD32 ref_ctr;
for(ref_ctr = 0; ref_ctr < MAX_NUM_REF; ref_ctr++)
s_search_prms_blk.aps_mv_range[ref_ctr] = &as_range_prms_rec[ref_ctr];
}
else
{
WORD32 ref_ctr;
for(ref_ctr = 0; ref_ctr < MAX_NUM_REF; ref_ctr++)
s_search_prms_blk.aps_mv_range[ref_ctr] = &as_range_prms_inp[ref_ctr];
}
/*************************************************************************/
/* Initialize coordinates. Meaning as follows */
/* blk_x : x coordinate of the 16x16 blk, in terms of number of blks */
/* blk_y : same as above, y coord. */
/* num_blks_in_this_ctb : number of blks in this given ctb that starts */
/* at i4_ctb_x, i4_ctb_y. This may not be 16 at picture boundaries. */
/* i4_ctb_x, i4_ctb_y: pixel coordinate of the ctb realtive to top left */
/* corner of the picture. Always multiple of 64. */
/* blk_id_in_ctb : encode order id of the blk in the ctb. */
/*************************************************************************/
blk_y = 0;
blk_id_in_ctb = 0;
i4_ctb_y = 0;
/*************************************************************************/
/* Picture limit on all 4 sides. This will be used to set mv limits for */
/* every block given its coordinate. Note thsi assumes that the min amt */
/* of padding to right of pic is equal to the blk size. If we go all the */
/* way upto 64x64, then the min padding on right size of picture should */
/* be 64, and also on bottom side of picture. */
/*************************************************************************/
SET_PIC_LIMIT(
s_pic_limit_inp,
ps_curr_layer->i4_pad_x_rec,
ps_curr_layer->i4_pad_y_rec,
ps_curr_layer->i4_wd,
ps_curr_layer->i4_ht,
s_search_prms_blk.i4_num_steps_post_refine);
SET_PIC_LIMIT(
s_pic_limit_rec,
ps_curr_layer->i4_pad_x_rec,
ps_curr_layer->i4_pad_y_rec,
ps_curr_layer->i4_wd,
ps_curr_layer->i4_ht,
s_search_prms_blk.i4_num_steps_post_refine);
/*************************************************************************/
/* set the MV limit per ref. pic. */
/* - P pic. : Based on the config params. */
/* - B/b pic: Based on the Max/Min MV from prev. P and config. param. */
/*************************************************************************/
hme_set_mv_limit_using_dvsr_data(
ps_ctxt, ps_curr_layer, as_mv_limit, &i2_prev_enc_frm_max_mv_y, num_act_ref_pics);
s_srch_cand_init_data.pu1_num_fpel_search_cands = ps_refine_prms->au1_num_fpel_search_cands;
s_srch_cand_init_data.i4_num_act_ref_l0 = ps_ctxt->s_frm_prms.u1_num_active_ref_l0;
s_srch_cand_init_data.i4_num_act_ref_l1 = ps_ctxt->s_frm_prms.u1_num_active_ref_l1;
s_srch_cand_init_data.ps_coarse_layer = ps_coarse_layer;
s_srch_cand_init_data.ps_curr_layer = ps_curr_layer;
s_srch_cand_init_data.i4_max_num_init_cands = num_init_candts;
s_srch_cand_init_data.ps_search_cands = ps_search_candts;
s_srch_cand_init_data.u1_num_results_in_mvbank = s_mv_update_prms.i4_num_results_to_store;
s_srch_cand_init_data.pi4_ref_id_lc_to_l0_map = ps_ctxt->a_ref_idx_lc_to_l0;
s_srch_cand_init_data.pi4_ref_id_lc_to_l1_map = ps_ctxt->a_ref_idx_lc_to_l1;
s_srch_cand_init_data.e_search_blk_size = e_search_blk_size;
while(0 == end_of_frame)
{
job_queue_t *ps_job;
frm_ctb_ctxt_t *ps_frm_ctb_prms;
ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb;
WORD32 i4_max_mv_x_in_ctb;
WORD32 i4_max_mv_y_in_ctb;
void *pv_dep_mngr_encloop_dep_me;
WORD32 offset_val, check_dep_pos, set_dep_pos;
WORD32 left_ctb_in_diff_tile, i4_first_ctb_x = 0;
pv_dep_mngr_encloop_dep_me = ps_ctxt->pv_dep_mngr_encloop_dep_me;
ps_frm_ctb_prms = (frm_ctb_ctxt_t *)ps_thrd_ctxt->pv_ext_frm_prms;
/* Get the current row from the job queue */
ps_job = (job_queue_t *)ihevce_enc_grp_get_next_job(
ps_multi_thrd_ctxt, lyr_job_type, 1, me_frm_id);
/* If all rows are done, set the end of process flag to 1, */
/* and the current row to -1 */
if(NULL == ps_job)
{
blk_y = -1;
i4_ctb_y = -1;
tile_col_idx = -1;
end_of_frame = 1;
continue;
}
/* set the output dependency after picking up the row */
ihevce_enc_grp_job_set_out_dep(ps_multi_thrd_ctxt, ps_job, me_frm_id);
/* Obtain the current row's details from the job */
{
ihevce_tile_params_t *ps_col_tile_params;
i4_ctb_y = ps_job->s_job_info.s_me_job_info.i4_vert_unit_row_no;
/* Obtain the current colum tile index from the job */
tile_col_idx = ps_job->s_job_info.s_me_job_info.i4_tile_col_idx;
/* in encode layer block are 16x16 and CTB is 64 x 64 */
/* note if ctb is 32x32 the this calc needs to be changed */
num_sync_units_in_row = (i4_pic_wd + ((1 << ps_ctxt->log_ctb_size) - 1)) >>
ps_ctxt->log_ctb_size;
/* The tile parameter for the col. idx. Use only the properties
which is same for all the bottom tiles like width, start_x, etc.
Don't use height, start_y, etc. */
ps_col_tile_params =
((ihevce_tile_params_t *)ps_thrd_ctxt->pv_tile_params_base + tile_col_idx);
/* in encode layer block are 16x16 and CTB is 64 x 64 */
/* note if ctb is 32x32 the this calc needs to be changed */
num_sync_units_in_tile =
(ps_col_tile_params->i4_curr_tile_width + ((1 << ps_ctxt->log_ctb_size) - 1)) >>
ps_ctxt->log_ctb_size;
i4_first_ctb_x = ps_col_tile_params->i4_first_ctb_x;
i4_ctb_x = i4_first_ctb_x;
if(!num_act_ref_pics)
{
for(i4_ctb_x = i4_first_ctb_x;
i4_ctb_x < (ps_col_tile_params->i4_first_ctb_x + num_sync_units_in_tile);
i4_ctb_x++)
{
S32 blk_i = 0, blk_j = 0;
/* set the dependency for the corresponding row in enc loop */
ihevce_dmgr_set_row_row_sync(
pv_dep_mngr_encloop_dep_me,
(i4_ctb_x + 1),
i4_ctb_y,
tile_col_idx /* Col Tile No. */);
}
continue;
}
/* increment the number of rows proc */
num_rows_proc++;
/* Set Variables for Dep. Checking and Setting */
set_dep_pos = i4_ctb_y + 1;
if(i4_ctb_y > 0)
{
offset_val = 2;
check_dep_pos = i4_ctb_y - 1;
}
else
{
/* First row should run without waiting */
offset_val = -1;
check_dep_pos = 0;
}
/* row ctb out pointer */
ps_ctxt->ps_ctb_analyse_curr_row =
ps_ctxt->ps_ctb_analyse_base + i4_ctb_y * ps_frm_ctb_prms->i4_num_ctbs_horz;
/* Row level CU Tree buffer */
ps_ctxt->ps_cu_tree_curr_row =
ps_ctxt->ps_cu_tree_base +
i4_ctb_y * ps_frm_ctb_prms->i4_num_ctbs_horz * MAX_NUM_NODES_CU_TREE;
ps_ctxt->ps_me_ctb_data_curr_row =
ps_ctxt->ps_me_ctb_data_base + i4_ctb_y * ps_frm_ctb_prms->i4_num_ctbs_horz;
}
/* This flag says the CTB under processing is at the start of tile in horz dir.*/
left_ctb_in_diff_tile = 1;
/* To make sure no 64-bit overflow happens when inv_wt is multiplied with un-normalized src_var, */
/* the shift value will be passed onto the functions wherever inv_wt isused so that inv_wt is appropriately shift and multiplied */
{
S32 i4_ref_id, i4_bits_req;
for(i4_ref_id = 0; i4_ref_id < (ps_ctxt->s_frm_prms.u1_num_active_ref_l0 +
ps_ctxt->s_frm_prms.u1_num_active_ref_l1);
i4_ref_id++)
{
GETRANGE(i4_bits_req, ps_ctxt->s_wt_pred.a_inv_wpred_wt[i4_ref_id]);
if(i4_bits_req > 12)
{
ps_ctxt->s_wt_pred.ai4_shift_val[i4_ref_id] = (i4_bits_req - 12);
}
else
{
ps_ctxt->s_wt_pred.ai4_shift_val[i4_ref_id] = 0;
}
}
s_common_frm_prms.pi4_inv_wt_shift_val = ps_ctxt->s_wt_pred.ai4_shift_val;
}
/* if non-encode layer then i4_ctb_x will be same as blk_x */
/* loop over all the units is a row */
for(i4_ctb_x = i4_first_ctb_x; i4_ctb_x < (i4_first_ctb_x + num_sync_units_in_tile);
i4_ctb_x++)
{
ihevce_ctb_noise_params *ps_ctb_noise_params =
&ps_ctxt->ps_ctb_analyse_curr_row[i4_ctb_x].s_ctb_noise_params;
s_common_frm_prms.i4_ctb_x_off = i4_ctb_x << 6;
s_common_frm_prms.i4_ctb_y_off = i4_ctb_y << 6;
ps_ctxt->s_mc_ctxt.i4_ctb_frm_pos_y = i4_ctb_y << 6;
ps_ctxt->s_mc_ctxt.i4_ctb_frm_pos_x = i4_ctb_x << 6;
/* Initialize ptr to current IPE CTB */
ps_cur_ipe_ctb = ps_ctxt->ps_ipe_l0_ctb_frm_base + i4_ctb_x +
i4_ctb_y * ps_frm_ctb_prms->i4_num_ctbs_horz;
{
ps_ctb_bound_attrs =
get_ctb_attrs(i4_ctb_x << 6, i4_ctb_y << 6, i4_pic_wd, i4_pic_ht, ps_ctxt);
en_merge_32x32 = ps_ctb_bound_attrs->u1_merge_to_32x32_flag;
num_blks_in_this_ctb = ps_ctb_bound_attrs->u1_num_blks_in_ctb;
}
/* Block to initialise pointers to part_type_results_t */
/* in each size-specific inter_cu_results_t */
{
WORD32 i;
for(i = 0; i < 64; i++)
{
ps_ctxt->as_cu8x8_results[i].ps_best_results =
ps_ctxt->ps_me_ctb_data_curr_row[i4_ctb_x]
.as_8x8_block_data[i]
.as_best_results;
ps_ctxt->as_cu8x8_results[i].u1_num_best_results = 0;
}
for(i = 0; i < 16; i++)
{
ps_ctxt->as_cu16x16_results[i].ps_best_results =
ps_ctxt->ps_me_ctb_data_curr_row[i4_ctb_x].as_block_data[i].as_best_results;
ps_ctxt->as_cu16x16_results[i].u1_num_best_results = 0;
}
for(i = 0; i < 4; i++)
{
ps_ctxt->as_cu32x32_results[i].ps_best_results =
ps_ctxt->ps_me_ctb_data_curr_row[i4_ctb_x]
.as_32x32_block_data[i]
.as_best_results;
ps_ctxt->as_cu32x32_results[i].u1_num_best_results = 0;
}
ps_ctxt->s_cu64x64_results.ps_best_results =
ps_ctxt->ps_me_ctb_data_curr_row[i4_ctb_x].s_64x64_block_data.as_best_results;
ps_ctxt->s_cu64x64_results.u1_num_best_results = 0;
}
if(ME_PRISTINE_QUALITY == e_me_quality_presets)
{
ps_ctb_cluster_info->blk_32x32_mask = en_merge_32x32;
ps_ctb_cluster_info->ps_cur_ipe_ctb = ps_cur_ipe_ctb;
ps_ctb_cluster_info->ps_cu_tree_root =
ps_ctxt->ps_cu_tree_curr_row + (i4_ctb_x * MAX_NUM_NODES_CU_TREE);
ps_ctb_cluster_info->nodes_created_in_cu_tree = 1;
}
if(ME_PRISTINE_QUALITY != e_me_quality_presets)
{
S32 i4_nodes_created_in_cu_tree = 1;
ihevce_cu_tree_init(
(ps_ctxt->ps_cu_tree_curr_row + (i4_ctb_x * MAX_NUM_NODES_CU_TREE)),
(ps_ctxt->ps_cu_tree_curr_row + (i4_ctb_x * MAX_NUM_NODES_CU_TREE)),
&i4_nodes_created_in_cu_tree,
0,
POS_NA,
POS_NA,
POS_NA);
}
memset(ai4_blk_8x8_mask, 0, 16 * sizeof(S32));
if(ps_refine_prms->u1_use_lambda_derived_from_min_8x8_act_in_ctb)
{
S32 j;
ipe_l0_ctb_analyse_for_me_t *ps_cur_ipe_ctb;
ps_cur_ipe_ctb =
ps_ctxt->ps_ipe_l0_ctb_frm_base + i4_ctb_x + i4_ctb_y * num_sync_units_in_row;
lambda_recon =
hme_recompute_lambda_from_min_8x8_act_in_ctb(ps_ctxt, ps_cur_ipe_ctb);
lambda_recon = ((float)lambda_recon * (100.0f - ME_LAMBDA_DISCOUNT) / 100.0f);
for(i = 0; i < 4; i++)
{
ps_search_results = &ps_ctxt->as_search_results_32x32[i];
for(j = 0; j < 2; j++)
{
ps_search_results->as_pred_ctxt[j].lambda = lambda_recon;
}
}
ps_search_results = &ps_ctxt->s_search_results_64x64;
for(j = 0; j < 2; j++)
{
ps_search_results->as_pred_ctxt[j].lambda = lambda_recon;
}
s_common_frm_prms.i4_lamda = lambda_recon;
}
else
{
lambda_recon = ps_refine_prms->lambda_recon;
}
/*********************************************************************/
/* replicate the inp buffer at blk or ctb level for each ref id, */
/* Instead of searching with wk * ref(k), we search with Ik = I / wk */
/* thereby avoiding a bloat up of memory. If we did all references */
/* weighted pred, we will end up with a duplicate copy of each ref */
/* at each layer, since we need to preserve the original reference. */
/* ToDo: Need to observe performance with this mechanism and compare */
/* with case where ref is weighted. */
/*********************************************************************/
fp_get_wt_inp(
ps_curr_layer,
&ps_ctxt->s_wt_pred,
unit_size,
s_common_frm_prms.i4_ctb_x_off,
s_common_frm_prms.i4_ctb_y_off,
unit_size,
ps_ctxt->num_ref_future + ps_ctxt->num_ref_past,
ps_ctxt->i4_wt_pred_enable_flag);
if(ps_thrd_ctxt->s_init_prms.u1_is_stasino_enabled)
{
#if TEMPORAL_NOISE_DETECT
{
WORD32 had_block_size = 16;
WORD32 ctb_width = ((i4_pic_wd - s_common_frm_prms.i4_ctb_x_off) >= 64)
? 64
: i4_pic_wd - s_common_frm_prms.i4_ctb_x_off;
WORD32 ctb_height = ((i4_pic_ht - s_common_frm_prms.i4_ctb_y_off) >= 64)
? 64
: i4_pic_ht - s_common_frm_prms.i4_ctb_y_off;
WORD32 num_pred_dir = i4_num_pred_dir;
WORD32 i4_x_off = s_common_frm_prms.i4_ctb_x_off;
WORD32 i4_y_off = s_common_frm_prms.i4_ctb_y_off;
WORD32 i;
WORD32 noise_detected;
WORD32 ctb_size;
WORD32 num_comp_had_blocks;
WORD32 noisy_block_cnt;
WORD32 index_8x8_block;
WORD32 num_8x8_in_ctb_row;
WORD32 ht_offset;
WORD32 wd_offset;
WORD32 block_ht;
WORD32 block_wd;
WORD32 num_horz_blocks;
WORD32 num_vert_blocks;
WORD32 mean;
UWORD32 variance_8x8;
WORD32 hh_energy_percent;
/* variables to hold the constant values. The variable values held are decided by the HAD block size */
WORD32 min_noisy_block_cnt;
WORD32 min_coeffs_above_avg;
WORD32 min_coeff_avg_energy;
/* to store the mean and variance of each 8*8 block and find the variance of any higher block sizes later on. block */
WORD32 i4_cu_x_off, i4_cu_y_off;
WORD32 is_noisy;
/* intialise the variables holding the constants */
if(had_block_size == 8)
{
min_noisy_block_cnt = MIN_NOISY_BLOCKS_CNT_8x8; //6;//
min_coeffs_above_avg = MIN_NUM_COEFFS_ABOVE_AVG_8x8;
min_coeff_avg_energy = MIN_COEFF_AVG_ENERGY_8x8;
}
else
{
min_noisy_block_cnt = MIN_NOISY_BLOCKS_CNT_16x16; //7;//
min_coeffs_above_avg = MIN_NUM_COEFFS_ABOVE_AVG_16x16;
min_coeff_avg_energy = MIN_COEFF_AVG_ENERGY_16x16;
}
/* initialize the variables */
noise_detected = 0;
noisy_block_cnt = 0;
hh_energy_percent = 0;
variance_8x8 = 0;
block_ht = ctb_height;
block_wd = ctb_width;
mean = 0;
ctb_size = block_ht * block_wd; //ctb_width * ctb_height;
num_comp_had_blocks = ctb_size / (had_block_size * had_block_size);
num_horz_blocks = block_wd / had_block_size; //ctb_width / had_block_size;
num_vert_blocks = block_ht / had_block_size; //ctb_height / had_block_size;
ht_offset = -had_block_size;
wd_offset = -had_block_size;
num_8x8_in_ctb_row = block_wd / 8; // number of 8x8 in this ctb
for(i = 0; i < num_comp_had_blocks; i++)
{
if(i % num_horz_blocks == 0)
{
wd_offset = -had_block_size;
ht_offset += had_block_size;
}
wd_offset += had_block_size;
/* CU level offsets */
i4_cu_x_off = i4_x_off + (i % 4) * 16; //+ (i % 4) * 16
i4_cu_y_off = i4_y_off + (i / 4) * 16;
/* if 50 % or more of the CU is noisy then the return value is 1 */
is_noisy = ihevce_determine_cu_noise_based_on_8x8Blk_data(
ps_ctb_noise_params->au1_is_8x8Blk_noisy,
(i % 4) * 16,
(i / 4) * 16,
16);
/* only if the CU is noisy then check the temporal noise detect call is made on the CU */
if(is_noisy)
{
index_8x8_block = (i / num_horz_blocks) * 2 * num_8x8_in_ctb_row +
(i % num_horz_blocks) * 2;
noisy_block_cnt += ihevce_16x16block_temporal_noise_detect(
16,
((i4_pic_wd - s_common_frm_prms.i4_ctb_x_off) >= 64)
? 64
: i4_pic_wd - s_common_frm_prms.i4_ctb_x_off,
((i4_pic_ht - s_common_frm_prms.i4_ctb_y_off) >= 64)
? 64
: i4_pic_ht - s_common_frm_prms.i4_ctb_y_off,
ps_ctb_noise_params,
&s_srch_cand_init_data,
&s_search_prms_blk,
ps_ctxt,
num_pred_dir,
i4_num_act_ref_l0,
i4_num_act_ref_l1,
i4_cu_x_off,
i4_cu_y_off,
&ps_ctxt->s_wt_pred,
unit_size,
index_8x8_block,
num_horz_blocks,
/*num_8x8_in_ctb_row*/ 8, // this should be a variable extra
i);
} /* if 16x16 is noisy */
} /* loop over for all 16x16*/
if(noisy_block_cnt >= min_noisy_block_cnt)
{
noise_detected = 1;
}
/* write back the noise presence detected for the current CTB to the structure */
ps_ctb_noise_params->i4_noise_present = noise_detected;
}
#endif
#if EVERYWHERE_NOISY && USE_NOISE_TERM_IN_L0_ME
if(ps_thrd_ctxt->s_init_prms.u1_is_stasino_enabled &&
ps_ctb_noise_params->i4_noise_present)
{
memset(
ps_ctb_noise_params->au1_is_8x8Blk_noisy,
1,
sizeof(ps_ctb_noise_params->au1_is_8x8Blk_noisy));
}
#endif
for(i = 0; i < 16; i++)
{
au1_is_16x16Blk_noisy[i] = ihevce_determine_cu_noise_based_on_8x8Blk_data(
ps_ctb_noise_params->au1_is_8x8Blk_noisy, (i % 4) * 16, (i / 4) * 16, 16);
}
for(i = 0; i < 4; i++)
{
au1_is_32x32Blk_noisy[i] = ihevce_determine_cu_noise_based_on_8x8Blk_data(
ps_ctb_noise_params->au1_is_8x8Blk_noisy, (i % 2) * 32, (i / 2) * 32, 32);
}
for(i = 0; i < 1; i++)
{
au1_is_64x64Blk_noisy[i] = ihevce_determine_cu_noise_based_on_8x8Blk_data(
ps_ctb_noise_params->au1_is_8x8Blk_noisy, 0, 0, 64);
}
if(ps_ctxt->s_frm_prms.bidir_enabled &&
(ps_ctxt->s_frm_prms.i4_temporal_layer_id <=
MAX_LAYER_ID_OF_B_PICS_WITHOUT_NOISE_DETECTION))
{
ps_ctb_noise_params->i4_noise_present = 0;
memset(
ps_ctb_noise_params->au1_is_8x8Blk_noisy,
0,
sizeof(ps_ctb_noise_params->au1_is_8x8Blk_noisy));
}
#if ME_LAMBDA_DISCOUNT_WHEN_NOISY
for(i = 0; i < 4; i++)
{
S32 j;
S32 lambda;
if(au1_is_32x32Blk_noisy[i])
{
lambda = lambda_recon;
lambda =
((float)lambda * (100.0f - ME_LAMBDA_DISCOUNT_WHEN_NOISY) / 100.0f);
ps_search_results = &ps_ctxt->as_search_results_32x32[i];
for(j = 0; j < 2; j++)
{
ps_search_results->as_pred_ctxt[j].lambda = lambda;
}
}
}
{
S32 j;
S32 lambda;
if(au1_is_64x64Blk_noisy[0])
{
lambda = lambda_recon;
lambda =
((float)lambda * (100.0f - ME_LAMBDA_DISCOUNT_WHEN_NOISY) / 100.0f);
ps_search_results = &ps_ctxt->s_search_results_64x64;
for(j = 0; j < 2; j++)
{
ps_search_results->as_pred_ctxt[j].lambda = lambda;
}
}
}
#endif
if(au1_is_64x64Blk_noisy[0])
{
U08 *pu1_inp = ps_curr_layer->pu1_inp + (s_common_frm_prms.i4_ctb_x_off +
(s_common_frm_prms.i4_ctb_y_off *
ps_curr_layer->i4_inp_stride));
hme_compute_sigmaX_and_sigmaXSquared(
pu1_inp,
ps_curr_layer->i4_inp_stride,
ps_ctxt->au4_4x4_src_sigmaX,
ps_ctxt->au4_4x4_src_sigmaXSquared,
4,
4,
64,
64,
1,
16);
}
else
{
for(i = 0; i < 4; i++)
{
if(au1_is_32x32Blk_noisy[i])
{
U08 *pu1_inp =
ps_curr_layer->pu1_inp +
(s_common_frm_prms.i4_ctb_x_off +
(s_common_frm_prms.i4_ctb_y_off * ps_curr_layer->i4_inp_stride));
U08 u1_cu_size = 32;
WORD32 i4_inp_buf_offset =
(((i / 2) * (u1_cu_size * ps_curr_layer->i4_inp_stride)) +
((i % 2) * u1_cu_size));
U16 u2_sigma_arr_start_index_of_3rd_32x32_blk_in_ctb = 128;
U16 u2_sigma_arr_start_index_of_2nd_32x32_blk_in_ctb = 8;
S32 i4_sigma_arr_offset =
(((i / 2) * u2_sigma_arr_start_index_of_3rd_32x32_blk_in_ctb) +
((i % 2) * u2_sigma_arr_start_index_of_2nd_32x32_blk_in_ctb));
hme_compute_sigmaX_and_sigmaXSquared(
pu1_inp + i4_inp_buf_offset,
ps_curr_layer->i4_inp_stride,
ps_ctxt->au4_4x4_src_sigmaX + i4_sigma_arr_offset,
ps_ctxt->au4_4x4_src_sigmaXSquared + i4_sigma_arr_offset,
4,
4,
32,
32,
1,
16);
}
else
{
S32 j;
U08 u1_16x16_blk_start_index_in_3rd_32x32_blk_of_ctb = 8;
U08 u1_16x16_blk_start_index_in_2nd_32x32_blk_of_ctb = 2;
S32 i4_16x16_blk_start_index_in_i_th_32x32_blk =
(((i / 2) * u1_16x16_blk_start_index_in_3rd_32x32_blk_of_ctb) +
((i % 2) * u1_16x16_blk_start_index_in_2nd_32x32_blk_of_ctb));
for(j = 0; j < 4; j++)
{
U08 u1_3rd_16x16_blk_index_in_32x32_blk = 4;
U08 u1_2nd_16x16_blk_index_in_32x32_blk = 1;
S32 i4_16x16_blk_index_in_ctb =
i4_16x16_blk_start_index_in_i_th_32x32_blk +
((j % 2) * u1_2nd_16x16_blk_index_in_32x32_blk) +
((j / 2) * u1_3rd_16x16_blk_index_in_32x32_blk);
//S32 k = (((i / 2) * 8) + ((i % 2) * 2)) + ((j % 2) * 1) + ((j / 2) * 4);
if(au1_is_16x16Blk_noisy[i4_16x16_blk_index_in_ctb])
{
U08 *pu1_inp =
ps_curr_layer->pu1_inp + (s_common_frm_prms.i4_ctb_x_off +
(s_common_frm_prms.i4_ctb_y_off *
ps_curr_layer->i4_inp_stride));
U08 u1_cu_size = 16;
WORD32 i4_inp_buf_offset =
(((i4_16x16_blk_index_in_ctb % 4) * u1_cu_size) +
((i4_16x16_blk_index_in_ctb / 4) *
(u1_cu_size * ps_curr_layer->i4_inp_stride)));
U16 u2_sigma_arr_start_index_of_3rd_16x16_blk_in_32x32_blk = 64;
U16 u2_sigma_arr_start_index_of_2nd_16x16_blk_in_32x32_blk = 4;
S32 i4_sigma_arr_offset =
(((i4_16x16_blk_index_in_ctb % 4) *
u2_sigma_arr_start_index_of_2nd_16x16_blk_in_32x32_blk) +
((i4_16x16_blk_index_in_ctb / 4) *
u2_sigma_arr_start_index_of_3rd_16x16_blk_in_32x32_blk));
hme_compute_sigmaX_and_sigmaXSquared(
pu1_inp + i4_inp_buf_offset,
ps_curr_layer->i4_inp_stride,
(ps_ctxt->au4_4x4_src_sigmaX + i4_sigma_arr_offset),
(ps_ctxt->au4_4x4_src_sigmaXSquared + i4_sigma_arr_offset),
4,
4,
16,
16,
1,
16);
}
}
}
}
}
}
else
{
memset(au1_is_16x16Blk_noisy, 0, sizeof(au1_is_16x16Blk_noisy));
memset(au1_is_32x32Blk_noisy, 0, sizeof(au1_is_32x32Blk_noisy));
memset(au1_is_64x64Blk_noisy, 0, sizeof(au1_is_64x64Blk_noisy));
}
for(blk_id_in_ctb = 0; blk_id_in_ctb < num_blks_in_this_ctb; blk_id_in_ctb++)
{
S32 ref_ctr;
U08 au1_pred_dir_searched[2];
U08 u1_is_cu_noisy;
ULWORD64 au8_final_src_sigmaX[17], au8_final_src_sigmaXSquared[17];
{
blk_x = (i4_ctb_x << 2) +
(ps_ctb_bound_attrs->as_blk_attrs[blk_id_in_ctb].u1_blk_x);
blk_y = (i4_ctb_y << 2) +
(ps_ctb_bound_attrs->as_blk_attrs[blk_id_in_ctb].u1_blk_y);
blk_id_in_full_ctb =
ps_ctb_bound_attrs->as_blk_attrs[blk_id_in_ctb].u1_blk_id_in_full_ctb;
blk_8x8_mask = ps_ctb_bound_attrs->as_blk_attrs[blk_id_in_ctb].u1_blk_8x8_mask;
ai4_blk_8x8_mask[blk_id_in_full_ctb] = blk_8x8_mask;
s_search_prms_blk.i4_cu_x_off = (blk_x << blk_size_shift) - (i4_ctb_x << 6);
s_search_prms_blk.i4_cu_y_off = (blk_y << blk_size_shift) - (i4_ctb_y << 6);
}
/* get the current input blk point */
pos_x = blk_x << blk_size_shift;
pos_y = blk_y << blk_size_shift;
pu1_inp = ps_curr_layer->pu1_inp + pos_x + (pos_y * i4_inp_stride);
/*********************************************************************/
/* For every blk in the picture, the search range needs to be derived*/
/* Any blk can have any mv, but practical search constraints are */
/* imposed by the picture boundary and amt of padding. */
/*********************************************************************/
/* MV limit is different based on ref. PIC */
for(ref_ctr = 0; ref_ctr < num_act_ref_pics; ref_ctr++)
{
if(!s_search_prms_blk.i4_use_rec)
{
hme_derive_search_range(
&as_range_prms_inp[ref_ctr],
&s_pic_limit_inp,
&as_mv_limit[ref_ctr],
pos_x,
pos_y,
blk_wd,
blk_ht);
}
else
{
hme_derive_search_range(
&as_range_prms_rec[ref_ctr],
&s_pic_limit_rec,
&as_mv_limit[ref_ctr],
pos_x,
pos_y,
blk_wd,
blk_ht);
}
}
s_search_prms_blk.i4_x_off = blk_x << blk_size_shift;
s_search_prms_blk.i4_y_off = blk_y << blk_size_shift;
/* Select search results from a suitable search result in the context */
{
ps_search_results = &ps_ctxt->as_search_results_16x16[blk_id_in_full_ctb];
if(ps_refine_prms->u1_use_lambda_derived_from_min_8x8_act_in_ctb)
{
S32 i;
for(i = 0; i < 2; i++)
{
ps_search_results->as_pred_ctxt[i].lambda = lambda_recon;
}
}
}
u1_is_cu_noisy = au1_is_16x16Blk_noisy
[(s_search_prms_blk.i4_cu_x_off >> 4) + (s_search_prms_blk.i4_cu_y_off >> 2)];
s_subpel_prms.u1_is_cu_noisy = u1_is_cu_noisy;
#if ME_LAMBDA_DISCOUNT_WHEN_NOISY
if(u1_is_cu_noisy)
{
S32 j;
S32 lambda;
lambda = lambda_recon;
lambda = ((float)lambda * (100.0f - ME_LAMBDA_DISCOUNT_WHEN_NOISY) / 100.0f);
for(j = 0; j < 2; j++)
{
ps_search_results->as_pred_ctxt[j].lambda = lambda;
}
}
else
{
S32 j;
S32 lambda;
lambda = lambda_recon;
for(j = 0; j < 2; j++)
{
ps_search_results->as_pred_ctxt[j].lambda = lambda;
}
}
#endif
s_search_prms_blk.ps_search_results = ps_search_results;
s_search_prms_blk.i4_part_mask = hme_part_mask_populator(
pu1_inp,
i4_inp_stride,
ps_refine_prms->limit_active_partitions,
ps_ctxt->ps_hme_frm_prms->bidir_enabled,
ps_ctxt->u1_is_curFrame_a_refFrame,
blk_8x8_mask,
e_me_quality_presets);
if(ME_PRISTINE_QUALITY == e_me_quality_presets)
{
ps_ctb_cluster_info->ai4_part_mask[blk_id_in_full_ctb] =
s_search_prms_blk.i4_part_mask;
}
/* RESET ALL SEARCH RESULTS FOR THE NEW BLK */
{
/* Setting u1_num_active_refs to 2 */
/* for the sole purpose of the */
/* function called below */
ps_search_results->u1_num_active_ref = (ps_refine_prms->bidir_enabled) ? 2 : 1;
hme_reset_search_results(
ps_search_results, s_search_prms_blk.i4_part_mask, MV_RES_FPEL);
ps_search_results->u1_num_active_ref = i4_num_pred_dir;
}
if(0 == blk_id_in_ctb)
{
UWORD8 u1_ctr;
for(u1_ctr = 0; u1_ctr < (ps_ctxt->s_frm_prms.u1_num_active_ref_l0 +
ps_ctxt->s_frm_prms.u1_num_active_ref_l1);
u1_ctr++)
{
WORD32 i4_max_dep_ctb_y;
WORD32 i4_max_dep_ctb_x;
/* Set max mv in ctb units */
i4_max_mv_x_in_ctb =
(ps_curr_layer->i2_max_mv_x + ((1 << ps_ctxt->log_ctb_size) - 1)) >>
ps_ctxt->log_ctb_size;
i4_max_mv_y_in_ctb =
(as_mv_limit[u1_ctr].i2_max_y + ((1 << ps_ctxt->log_ctb_size) - 1)) >>
ps_ctxt->log_ctb_size;
/********************************************************************/
/* Set max ctb_x and ctb_y dependency on reference picture */
/* Note +1 is due to delayed deblock, SAO, subpel plan dependency */
/********************************************************************/
i4_max_dep_ctb_x = CLIP3(
(i4_ctb_x + i4_max_mv_x_in_ctb + 1),
0,
ps_frm_ctb_prms->i4_num_ctbs_horz - 1);
i4_max_dep_ctb_y = CLIP3(
(i4_ctb_y + i4_max_mv_y_in_ctb + 1),
0,
ps_frm_ctb_prms->i4_num_ctbs_vert - 1);
ihevce_dmgr_map_chk_sync(
ps_curr_layer->ppv_dep_mngr_recon[u1_ctr],
ps_ctxt->thrd_id,
i4_ctb_x,
i4_ctb_y,
i4_max_mv_x_in_ctb,
i4_max_mv_y_in_ctb);
}
}
/* Loop across different Ref IDx */
for(u1_pred_dir_ctr = 0; u1_pred_dir_ctr < i4_num_pred_dir; u1_pred_dir_ctr++)
{
S32 resultid;
S08 u1_default_ref_id;
S32 i4_num_srch_cands = 0;
S32 i4_num_refinement_iterations;
S32 i4_refine_iter_ctr;
if((i4_num_pred_dir == 2) || (!ps_ctxt->s_frm_prms.bidir_enabled) ||
(ps_ctxt->s_frm_prms.u1_num_active_ref_l1 == 0))
{
u1_pred_dir = u1_pred_dir_ctr;
}
else if(ps_ctxt->s_frm_prms.u1_num_active_ref_l0 == 0)
{
u1_pred_dir = 1;
}
u1_default_ref_id = (u1_pred_dir == 0) ? ps_ctxt->ai1_past_list[0]
: ps_ctxt->ai1_future_list[0];
au1_pred_dir_searched[u1_pred_dir_ctr] = u1_pred_dir;
i4_num_srch_cands = 0;
resultid = 0;
/* START OF NEW CTB MEANS FILL UP NEOGHBOURS IN 18x18 GRID */
if(0 == blk_id_in_ctb)
{
/*****************************************************************/
/* Initialize the mv grid with results of neighbours for the next*/
/* ctb. */
/*****************************************************************/
hme_fill_ctb_neighbour_mvs(
ps_curr_layer,
blk_x,
blk_y,
aps_mv_grid[u1_pred_dir],
u1_pred_dir_ctr,
u1_default_ref_id,
ps_ctxt->s_frm_prms.u1_num_active_ref_l0);
}
s_search_prms_blk.i1_ref_idx = u1_pred_dir;
{
if((blk_id_in_full_ctb % 4) == 0)
{
ps_ctxt->as_search_results_32x32[blk_id_in_full_ctb >> 2]
.as_pred_ctxt[u1_pred_dir]
.proj_used = (blk_id_in_full_ctb == 8) ? 0 : 1;
}
if(blk_id_in_full_ctb == 0)
{
ps_ctxt->s_search_results_64x64.as_pred_ctxt[u1_pred_dir].proj_used = 1;
}
ps_search_results->as_pred_ctxt[u1_pred_dir].proj_used =
!gau1_encode_to_raster_y[blk_id_in_full_ctb];
}
{
S32 x = gau1_encode_to_raster_x[blk_id_in_full_ctb];
S32 y = gau1_encode_to_raster_y[blk_id_in_full_ctb];
U08 u1_is_blk_at_ctb_boundary = !y;
s_srch_cand_init_data.u1_is_left_available =
!(left_ctb_in_diff_tile && !s_search_prms_blk.i4_cu_x_off);
if(u1_is_blk_at_ctb_boundary)
{
s_srch_cand_init_data.u1_is_topRight_available = 0;
s_srch_cand_init_data.u1_is_topLeft_available = 0;
s_srch_cand_init_data.u1_is_top_available = 0;
}
else
{
s_srch_cand_init_data.u1_is_topRight_available =
gau1_cu_tr_valid[y][x] && ((pos_x + blk_wd) < i4_pic_wd);
s_srch_cand_init_data.u1_is_top_available = 1;
s_srch_cand_init_data.u1_is_topLeft_available =
s_srch_cand_init_data.u1_is_left_available;
}
}
s_srch_cand_init_data.i1_default_ref_id = u1_default_ref_id;
s_srch_cand_init_data.i1_alt_default_ref_id = ps_ctxt->ai1_past_list[1];
s_srch_cand_init_data.i4_pos_x = pos_x;
s_srch_cand_init_data.i4_pos_y = pos_y;
s_srch_cand_init_data.u1_pred_dir = u1_pred_dir;
s_srch_cand_init_data.u1_pred_dir_ctr = u1_pred_dir_ctr;
s_srch_cand_init_data.u1_search_candidate_list_index =
au1_search_candidate_list_index[u1_pred_dir];
i4_num_srch_cands = hme_populate_search_candidates(&s_srch_cand_init_data);
/* Note this block also clips the MV range for all candidates */
{
S08 i1_check_for_mult_refs;
i1_check_for_mult_refs = u1_pred_dir ? (ps_ctxt->num_ref_future > 1)
: (ps_ctxt->num_ref_past > 1);
ps_me_optimised_function_list->pf_mv_clipper(
&s_search_prms_blk,
i4_num_srch_cands,
i1_check_for_mult_refs,
ps_refine_prms->i4_num_steps_fpel_refine,
ps_refine_prms->i4_num_steps_hpel_refine,
ps_refine_prms->i4_num_steps_qpel_refine);
}
#if ENABLE_EXPLICIT_SEARCH_IN_P_IN_L0
i4_num_refinement_iterations =
((!ps_ctxt->s_frm_prms.bidir_enabled) && (i4_num_act_ref_l0 > 1))
? ((e_me_quality_presets == ME_HIGH_QUALITY) ? 2 : i4_num_act_ref_l0)
: 1;
#else
i4_num_refinement_iterations =
((!ps_ctxt->s_frm_prms.bidir_enabled) && (i4_num_act_ref_l0 > 1)) ? 2 : 1;
#endif
#if ENABLE_EXPLICIT_SEARCH_IN_PQ
if(e_me_quality_presets == ME_PRISTINE_QUALITY)
{
i4_num_refinement_iterations = (u1_pred_dir == 0) ? i4_num_act_ref_l0
: i4_num_act_ref_l1;
}
#endif
for(i4_refine_iter_ctr = 0; i4_refine_iter_ctr < i4_num_refinement_iterations;
i4_refine_iter_ctr++)
{
S32 center_x;
S32 center_y;
S32 center_ref_idx;
S08 *pi1_pred_dir_to_ref_idx =
(u1_pred_dir == 0) ? ps_ctxt->ai1_past_list : ps_ctxt->ai1_future_list;
{
WORD32 i4_i;
for(i4_i = 0; i4_i < TOT_NUM_PARTS; i4_i++)
{
ps_fullpel_refine_ctxt->i2_tot_cost[0][i4_i] = MAX_SIGNED_16BIT_VAL;
ps_fullpel_refine_ctxt->i2_mv_cost[0][i4_i] = MAX_SIGNED_16BIT_VAL;
ps_fullpel_refine_ctxt->i2_stim_injected_cost[0][i4_i] =
MAX_SIGNED_16BIT_VAL;
ps_fullpel_refine_ctxt->i2_mv_x[0][i4_i] = 0;
ps_fullpel_refine_ctxt->i2_mv_y[0][i4_i] = 0;
ps_fullpel_refine_ctxt->i2_ref_idx[0][i4_i] = u1_default_ref_id;
if(ps_refine_prms->i4_num_results_per_part == 2)
{
ps_fullpel_refine_ctxt->i2_tot_cost[1][i4_i] =
MAX_SIGNED_16BIT_VAL;
ps_fullpel_refine_ctxt->i2_mv_cost[1][i4_i] =
MAX_SIGNED_16BIT_VAL;
ps_fullpel_refine_ctxt->i2_stim_injected_cost[1][i4_i] =
MAX_SIGNED_16BIT_VAL;
ps_fullpel_refine_ctxt->i2_mv_x[1][i4_i] = 0;
ps_fullpel_refine_ctxt->i2_mv_y[1][i4_i] = 0;
ps_fullpel_refine_ctxt->i2_ref_idx[1][i4_i] = u1_default_ref_id;
}
}
s_search_prms_blk.ps_fullpel_refine_ctxt = ps_fullpel_refine_ctxt;
s_subpel_prms.ps_subpel_refine_ctxt = ps_fullpel_refine_ctxt;
}
{
search_node_t *ps_coloc_node;
S32 i = 0;
if(i4_num_refinement_iterations > 1)
{
for(i = 0; i < ai4_num_coloc_cands[u1_pred_dir]; i++)
{
ps_coloc_node =
s_search_prms_blk.ps_search_candts[ai4_id_coloc[i]]
.ps_search_node;
if(pi1_pred_dir_to_ref_idx[i4_refine_iter_ctr] ==
ps_coloc_node->i1_ref_idx)
{
break;
}
}
if(i == ai4_num_coloc_cands[u1_pred_dir])
{
i = 0;
}
}
else
{
ps_coloc_node = s_search_prms_blk.ps_search_candts[ai4_id_coloc[0]]
.ps_search_node;
}
hme_set_mvp_node(
ps_search_results,
ps_coloc_node,
u1_pred_dir,
(i4_num_refinement_iterations > 1)
? pi1_pred_dir_to_ref_idx[i4_refine_iter_ctr]
: u1_default_ref_id);
center_x = ps_coloc_node->ps_mv->i2_mvx;
center_y = ps_coloc_node->ps_mv->i2_mvy;
center_ref_idx = ps_coloc_node->i1_ref_idx;
}
/* Full-Pel search */
{
S32 num_unique_nodes;
memset(au4_unique_node_map, 0, sizeof(au4_unique_node_map));
num_unique_nodes = hme_remove_duplicate_fpel_search_candidates(
as_unique_search_nodes,
s_search_prms_blk.ps_search_candts,
au4_unique_node_map,
pi1_pred_dir_to_ref_idx,
i4_num_srch_cands,
s_search_prms_blk.i4_num_init_candts,
i4_refine_iter_ctr,
i4_num_refinement_iterations,
i4_num_act_ref_l0,
center_ref_idx,
center_x,
center_y,
ps_ctxt->s_frm_prms.bidir_enabled,
e_me_quality_presets);
/*************************************************************************/
/* This array stores the ids of the partitions whose */
/* SADs are updated. Since the partitions whose SADs are updated may not */
/* be in contiguous order, we supply another level of indirection. */
/*************************************************************************/
ps_fullpel_refine_ctxt->i4_num_valid_parts = hme_create_valid_part_ids(
s_search_prms_blk.i4_part_mask,
&ps_fullpel_refine_ctxt->ai4_part_id[0]);
if(!i4_refine_iter_ctr && !u1_pred_dir_ctr && u1_is_cu_noisy)
{
S32 i;
/*i4_sigma_array_offset : takes care of pointing to the appropriate 4x4 block's sigmaX and sigmaX-squared value in a CTB out of 256 values*/
S32 i4_sigma_array_offset = (s_search_prms_blk.i4_cu_x_off / 4) +
(s_search_prms_blk.i4_cu_y_off * 4);
for(i = 0; i < ps_fullpel_refine_ctxt->i4_num_valid_parts; i++)
{
S32 i4_part_id = ps_fullpel_refine_ctxt->ai4_part_id[i];
hme_compute_final_sigma_of_pu_from_base_blocks(
ps_ctxt->au4_4x4_src_sigmaX + i4_sigma_array_offset,
ps_ctxt->au4_4x4_src_sigmaXSquared + i4_sigma_array_offset,
au8_final_src_sigmaX,
au8_final_src_sigmaXSquared,
16,
4,
i4_part_id,
16);
}
s_common_frm_prms.pu8_part_src_sigmaX = au8_final_src_sigmaX;
s_common_frm_prms.pu8_part_src_sigmaXSquared =
au8_final_src_sigmaXSquared;
s_search_prms_blk.pu8_part_src_sigmaX = au8_final_src_sigmaX;
s_search_prms_blk.pu8_part_src_sigmaXSquared =
au8_final_src_sigmaXSquared;
}
if(0 == num_unique_nodes)
{
continue;
}
if(num_unique_nodes >= 2)
{
s_search_prms_blk.ps_search_nodes = &as_unique_search_nodes[0];
s_search_prms_blk.i4_num_search_nodes = num_unique_nodes;
if(ps_ctxt->i4_pic_type != IV_P_FRAME)
{
if(ps_ctxt->i4_temporal_layer == 1)
{
hme_fullpel_cand_sifter(
&s_search_prms_blk,
ps_curr_layer,
&ps_ctxt->s_wt_pred,
ALPHA_FOR_NOISE_TERM_IN_ME,
u1_is_cu_noisy,
ps_me_optimised_function_list);
}
else
{
hme_fullpel_cand_sifter(
&s_search_prms_blk,
ps_curr_layer,
&ps_ctxt->s_wt_pred,
ALPHA_FOR_NOISE_TERM_IN_ME,
u1_is_cu_noisy,
ps_me_optimised_function_list);
}
}
else
{
hme_fullpel_cand_sifter(
&s_search_prms_blk,
ps_curr_layer,
&ps_ctxt->s_wt_pred,
ALPHA_FOR_NOISE_TERM_IN_ME_P,
u1_is_cu_noisy,
ps_me_optimised_function_list);
}
}
s_search_prms_blk.ps_search_nodes = &as_unique_search_nodes[0];
hme_fullpel_refine(
ps_refine_prms,
&s_search_prms_blk,
ps_curr_layer,
&ps_ctxt->s_wt_pred,
au4_unique_node_map,
num_unique_nodes,
blk_8x8_mask,
center_x,
center_y,
center_ref_idx,
e_me_quality_presets,
ps_me_optimised_function_list);
}
/* Sub-Pel search */
{
hme_reset_wkg_mem(&ps_ctxt->s_buf_mgr);
s_subpel_prms.pu1_wkg_mem = (U08 *)hme_get_wkg_mem(
&ps_ctxt->s_buf_mgr,
INTERP_INTERMED_BUF_SIZE + INTERP_OUT_BUF_SIZE);
/* MV limit is different based on ref. PIC */
for(ref_ctr = 0; ref_ctr < num_act_ref_pics; ref_ctr++)
{
SCALE_RANGE_PRMS(
as_range_prms_hpel[ref_ctr], as_range_prms_rec[ref_ctr], 1);
SCALE_RANGE_PRMS(
as_range_prms_qpel[ref_ctr], as_range_prms_rec[ref_ctr], 2);
}
s_subpel_prms.i4_ctb_x_off = i4_ctb_x << 6;
s_subpel_prms.i4_ctb_y_off = i4_ctb_y << 6;
hme_subpel_refine_cu_hs(
&s_subpel_prms,
ps_curr_layer,
ps_search_results,
u1_pred_dir,
&ps_ctxt->s_wt_pred,
blk_8x8_mask,
ps_ctxt->ps_func_selector,
ps_cmn_utils_optimised_function_list,
ps_me_optimised_function_list);
}
}
}
/* Populate the new PU struct with the results post subpel refinement*/
{
inter_cu_results_t *ps_cu_results;
WORD32 best_inter_cost, intra_cost, posx, posy;
UWORD8 intra_8x8_enabled = 0;
/* cost of 16x16 cu parent */
WORD32 parent_cost = MAX_32BIT_VAL;
/* cost of 8x8 cu children */
/*********************************************************************/
/* Assuming parent is not split, then we signal 1 bit for this parent*/
/* CU. If split, then 1 bit for parent CU + 4 bits for each child CU */
/* So, 4*lambda is extra for children cost. */
/*********************************************************************/
WORD32 child_cost = 0;
ps_cu_results = ps_search_results->ps_cu_results;
/* Initialize the pu_results pointers to the first struct in the stack array */
ps_pu_results = as_inter_pu_results;
hme_reset_wkg_mem(&ps_ctxt->s_buf_mgr);
hme_populate_pus(
ps_thrd_ctxt,
ps_ctxt,
&s_subpel_prms,
ps_search_results,
ps_cu_results,
ps_pu_results,
&(as_pu_results[0][0][0]),
&s_common_frm_prms,
&ps_ctxt->s_wt_pred,
ps_curr_layer,
au1_pred_dir_searched,
i4_num_pred_dir);
ps_cu_results->i4_inp_offset =
(ps_cu_results->u1_x_off) + (ps_cu_results->u1_y_off * 64);
hme_decide_part_types(
ps_cu_results,
ps_pu_results,
&s_common_frm_prms,
ps_ctxt,
ps_cmn_utils_optimised_function_list,
ps_me_optimised_function_list
);
/* UPDATE the MIN and MAX MVs for Dynamical Search Range for each ref. pic. */
/* Only for P pic. For P, both are 0, I&B has them mut. exclusive */
if(ps_ctxt->s_frm_prms.is_i_pic == ps_ctxt->s_frm_prms.bidir_enabled)
{
WORD32 res_ctr;
for(res_ctr = 0; res_ctr < ps_cu_results->u1_num_best_results; res_ctr++)
{
WORD32 num_part = 2, part_ctr;
part_type_results_t *ps_best_results =
&ps_cu_results->ps_best_results[res_ctr];
if(PRT_2Nx2N == ps_best_results->u1_part_type)
num_part = 1;
for(part_ctr = 0; part_ctr < num_part; part_ctr++)
{
pu_result_t *ps_pu_results =
&ps_best_results->as_pu_results[part_ctr];
ASSERT(PRED_L0 == ps_pu_results->pu.b2_pred_mode);
hme_update_dynamic_search_params(
&ps_ctxt->as_l0_dyn_range_prms[i4_idx_dvsr_p]
.as_dyn_range_prms[ps_pu_results->pu.mv.i1_l0_ref_idx],
ps_pu_results->pu.mv.s_l0_mv.i2_mvy);
/* Sanity Check */
ASSERT(
ps_pu_results->pu.mv.i1_l0_ref_idx <
ps_ctxt->s_frm_prms.u1_num_active_ref_l0);
/* No L1 for P Pic. */
ASSERT(PRED_L1 != ps_pu_results->pu.b2_pred_mode);
/* No BI for P Pic. */
ASSERT(PRED_BI != ps_pu_results->pu.b2_pred_mode);
}
}
}
/*****************************************************************/
/* INSERT INTRA RESULTS AT 16x16 LEVEL. */
/*****************************************************************/
#if DISABLE_INTRA_IN_BPICS
if(1 != ((ME_XTREME_SPEED_25 == e_me_quality_presets) &&
(ps_ctxt->s_frm_prms.i4_temporal_layer_id > TEMPORAL_LAYER_DISABLE)))
#endif
{
if(!(DISABLE_INTRA_WHEN_NOISY && s_common_frm_prms.u1_is_cu_noisy))
{
hme_insert_intra_nodes_post_bipred(
ps_cu_results, ps_cur_ipe_ctb, ps_ctxt->frm_qstep);
}
}
#if DISABLE_INTRA_IN_BPICS
if((ME_XTREME_SPEED_25 == e_me_quality_presets) &&
(ps_ctxt->s_frm_prms.i4_temporal_layer_id > TEMPORAL_LAYER_DISABLE))
{
intra_8x8_enabled = 0;
}
else
#endif
{
/*TRAQO intra flag updation*/
if(1 == ps_cu_results->ps_best_results->as_pu_results[0].pu.b1_intra_flag)
{
best_inter_cost =
ps_cu_results->ps_best_results->as_pu_results[1].i4_tot_cost;
intra_cost =
ps_cu_results->ps_best_results->as_pu_results[0].i4_tot_cost;
/*@16x16 level*/
posx = (ps_cu_results->ps_best_results->as_pu_results[1].pu.b4_pos_x
<< 2) >>
4;
posy = (ps_cu_results->ps_best_results->as_pu_results[1].pu.b4_pos_y
<< 2) >>
4;
}
else
{
best_inter_cost =
ps_cu_results->ps_best_results->as_pu_results[0].i4_tot_cost;
posx = (ps_cu_results->ps_best_results->as_pu_results[0].pu.b4_pos_x
<< 2) >>
3;
posy = (ps_cu_results->ps_best_results->as_pu_results[0].pu.b4_pos_y
<< 2) >>
3;
}
/* Disable intra16/32/64 flags based on split flags recommended by IPE */
if(ps_cur_ipe_ctb->u1_split_flag)
{
/* Id of the 32x32 block, 16x16 block in a CTB */
WORD32 i4_32x32_id =
(ps_cu_results->u1_y_off >> 5) * 2 + (ps_cu_results->u1_x_off >> 5);
WORD32 i4_16x16_id = ((ps_cu_results->u1_y_off >> 4) & 0x1) * 2 +
((ps_cu_results->u1_x_off >> 4) & 0x1);
if(ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id].b1_split_flag)
{
if(ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id]
.as_intra16_analyse[i4_16x16_id]
.b1_split_flag)
{
intra_8x8_enabled =
ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id]
.as_intra16_analyse[i4_16x16_id]
.as_intra8_analyse[0]
.b1_valid_cu;
intra_8x8_enabled &=
ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id]
.as_intra16_analyse[i4_16x16_id]
.as_intra8_analyse[1]
.b1_valid_cu;
intra_8x8_enabled &=
ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id]
.as_intra16_analyse[i4_16x16_id]
.as_intra8_analyse[2]
.b1_valid_cu;
intra_8x8_enabled &=
ps_cur_ipe_ctb->as_intra32_analyse[i4_32x32_id]
.as_intra16_analyse[i4_16x16_id]
.as_intra8_analyse[3]
.b1_valid_cu;
}
}
}
}
if(blk_8x8_mask == 0xf)
{
parent_cost =
ps_search_results->ps_cu_results->ps_best_results[0].i4_tot_cost;
ps_search_results->u1_split_flag = 0;
}
else
{
ps_search_results->u1_split_flag = 1;
}
ps_cu_results = &ps_ctxt->as_cu8x8_results[blk_id_in_full_ctb << 2];
if(s_common_frm_prms.u1_is_cu_noisy)
{
intra_8x8_enabled = 0;
}
/* Evalaute 8x8 if NxN part id is enabled */
if((ps_search_results->i4_part_mask & ENABLE_NxN) || intra_8x8_enabled)
{
/* Populates the PU's for the 4 8x8's in one call */
hme_populate_pus_8x8_cu(
ps_thrd_ctxt,
ps_ctxt,
&s_subpel_prms,
ps_search_results,
ps_cu_results,
ps_pu_results,
&(as_pu_results[0][0][0]),
&s_common_frm_prms,
au1_pred_dir_searched,
i4_num_pred_dir,
blk_8x8_mask);
/* Re-initialize the pu_results pointers to the first struct in the stack array */
ps_pu_results = as_inter_pu_results;
for(i = 0; i < 4; i++)
{
if((blk_8x8_mask & (1 << i)))
{
if(ps_cu_results->i4_part_mask)
{
hme_decide_part_types(
ps_cu_results,
ps_pu_results,
&s_common_frm_prms,
ps_ctxt,
ps_cmn_utils_optimised_function_list,
ps_me_optimised_function_list
);
}
/*****************************************************************/
/* INSERT INTRA RESULTS AT 8x8 LEVEL. */
/*****************************************************************/
#if DISABLE_INTRA_IN_BPICS
if(1 != ((ME_XTREME_SPEED_25 == e_me_quality_presets) &&
(ps_ctxt->s_frm_prms.i4_temporal_layer_id >
TEMPORAL_LAYER_DISABLE)))
#endif
{
if(!(DISABLE_INTRA_WHEN_NOISY &&
s_common_frm_prms.u1_is_cu_noisy))
{
hme_insert_intra_nodes_post_bipred(
ps_cu_results, ps_cur_ipe_ctb, ps_ctxt->frm_qstep);
}
}
child_cost += ps_cu_results->ps_best_results[0].i4_tot_cost;
}
ps_cu_results++;
ps_pu_results++;
}
/* Compare 16x16 vs 8x8 cost */
if(child_cost < parent_cost)
{
ps_search_results->best_cu_cost = child_cost;
ps_search_results->u1_split_flag = 1;
}
}
}
hme_update_mv_bank_encode(
ps_search_results,
ps_curr_layer->ps_layer_mvbank,
blk_x,
blk_y,
&s_mv_update_prms,
au1_pred_dir_searched,
i4_num_act_ref_l0);
/*********************************************************************/
/* Map the best results to an MV Grid. This is a 18x18 grid that is */
/* useful for doing things like predictor for cost calculation or */
/* also for merge calculations if need be. */
/*********************************************************************/
hme_map_mvs_to_grid(
&aps_mv_grid[0], ps_search_results, au1_pred_dir_searched, i4_num_pred_dir);
}
/* Set the CU tree nodes appropriately */
if(e_me_quality_presets != ME_PRISTINE_QUALITY)
{
WORD32 i, j;
for(i = 0; i < 16; i++)
{
cur_ctb_cu_tree_t *ps_tree_node =
ps_ctxt->ps_cu_tree_curr_row + (i4_ctb_x * MAX_NUM_NODES_CU_TREE);
search_results_t *ps_results = &ps_ctxt->as_search_results_16x16[i];
switch(i >> 2)
{
case 0:
{
ps_tree_node = ps_tree_node->ps_child_node_tl;
break;
}
case 1:
{
ps_tree_node = ps_tree_node->ps_child_node_tr;
break;
}
case 2:
{
ps_tree_node = ps_tree_node->ps_child_node_bl;
break;
}
case 3:
{
ps_tree_node = ps_tree_node->ps_child_node_br;
break;
}
}
switch(i % 4)
{
case 0:
{
ps_tree_node = ps_tree_node->ps_child_node_tl;
break;
}
case 1:
{
ps_tree_node = ps_tree_node->ps_child_node_tr;
break;
}
case 2:
{
ps_tree_node = ps_tree_node->ps_child_node_bl;
break;
}
case 3:
{
ps_tree_node = ps_tree_node->ps_child_node_br;
break;
}
}
if(ai4_blk_8x8_mask[i] == 15)
{
if(!ps_results->u1_split_flag)
{
ps_tree_node->is_node_valid = 1;
NULLIFY_THE_CHILDREN_NODES(ps_tree_node);
}
else
{
ps_tree_node->is_node_valid = 0;
ENABLE_THE_CHILDREN_NODES(ps_tree_node);
}
}
else
{
cur_ctb_cu_tree_t *ps_tree_child;
ps_tree_node->is_node_valid = 0;
for(j = 0; j < 4; j++)
{
switch(j)
{
case 0:
{
ps_tree_child = ps_tree_node->ps_child_node_tl;
break;
}
case 1:
{
ps_tree_child = ps_tree_node->ps_child_node_tr;
break;
}
case 2:
{
ps_tree_child = ps_tree_node->ps_child_node_bl;
break;
}
case 3:
{
ps_tree_child = ps_tree_node->ps_child_node_br;
break;
}
}
ps_tree_child->is_node_valid = !!(ai4_blk_8x8_mask[i] & (1 << j));
}
}
}
}
if(ME_PRISTINE_QUALITY == e_me_quality_presets)
{
cur_ctb_cu_tree_t *ps_tree = ps_ctb_cluster_info->ps_cu_tree_root;
hme_analyse_mv_clustering(
ps_ctxt->as_search_results_16x16,
ps_ctxt->as_cu16x16_results,
ps_ctxt->as_cu8x8_results,
ps_ctxt->ps_ctb_cluster_info,
ps_ctxt->ai1_future_list,
ps_ctxt->ai1_past_list,
ps_ctxt->s_frm_prms.bidir_enabled,
e_me_quality_presets);
#if DISABLE_BLK_MERGE_WHEN_NOISY
ps_tree->ps_child_node_tl->is_node_valid = !au1_is_32x32Blk_noisy[0];
ps_tree->ps_child_node_tr->is_node_valid = !au1_is_32x32Blk_noisy[1];
ps_tree->ps_child_node_bl->is_node_valid = !au1_is_32x32Blk_noisy[2];
ps_tree->ps_child_node_br->is_node_valid = !au1_is_32x32Blk_noisy[3];
ps_tree->ps_child_node_tl->u1_inter_eval_enable = !au1_is_32x32Blk_noisy[0];
ps_tree->ps_child_node_tr->u1_inter_eval_enable = !au1_is_32x32Blk_noisy[1];
ps_tree->ps_child_node_bl->u1_inter_eval_enable = !au1_is_32x32Blk_noisy[2];
ps_tree->ps_child_node_br->u1_inter_eval_enable = !au1_is_32x32Blk_noisy[3];
ps_tree->is_node_valid = !au1_is_64x64Blk_noisy[0];
ps_tree->u1_inter_eval_enable = !au1_is_64x64Blk_noisy[0];
#endif
en_merge_32x32 = (ps_tree->ps_child_node_tl->is_node_valid << 0) |
(ps_tree->ps_child_node_tr->is_node_valid << 1) |
(ps_tree->ps_child_node_bl->is_node_valid << 2) |
(ps_tree->ps_child_node_br->is_node_valid << 3);
en_merge_execution = (ps_tree->ps_child_node_tl->u1_inter_eval_enable << 0) |
(ps_tree->ps_child_node_tr->u1_inter_eval_enable << 1) |
(ps_tree->ps_child_node_bl->u1_inter_eval_enable << 2) |
(ps_tree->ps_child_node_br->u1_inter_eval_enable << 3) |
(ps_tree->u1_inter_eval_enable << 4);
}
else
{
en_merge_execution = 0x1f;
#if DISABLE_BLK_MERGE_WHEN_NOISY
en_merge_32x32 = ((!au1_is_32x32Blk_noisy[0] << 0) & (en_merge_32x32 & 1)) |
((!au1_is_32x32Blk_noisy[1] << 1) & (en_merge_32x32 & 2)) |
((!au1_is_32x32Blk_noisy[2] << 2) & (en_merge_32x32 & 4)) |
((!au1_is_32x32Blk_noisy[3] << 3) & (en_merge_32x32 & 8));
#endif
}
/* Re-initialize the pu_results pointers to the first struct in the stack array */
ps_pu_results = as_inter_pu_results;
{
WORD32 ref_ctr;
s_ctb_prms.i4_ctb_x = i4_ctb_x << 6;
s_ctb_prms.i4_ctb_y = i4_ctb_y << 6;
/* MV limit is different based on ref. PIC */
for(ref_ctr = 0; ref_ctr < num_act_ref_pics; ref_ctr++)
{
SCALE_RANGE_PRMS(as_range_prms_hpel[ref_ctr], as_range_prms_rec[ref_ctr], 1);
SCALE_RANGE_PRMS(as_range_prms_qpel[ref_ctr], as_range_prms_rec[ref_ctr], 2);
}
e_merge_result = CU_SPLIT;
merge_count_32x32 = 0;
if((en_merge_32x32 & 1) && (en_merge_execution & 1))
{
range_prms_t *ps_pic_limit;
if(s_merge_prms_32x32_tl.i4_use_rec == 1)
{
ps_pic_limit = &s_pic_limit_rec;
}
else
{
ps_pic_limit = &s_pic_limit_inp;
}
/* MV limit is different based on ref. PIC */
for(ref_ctr = 0; ref_ctr < num_act_ref_pics; ref_ctr++)
{
hme_derive_search_range(
s_merge_prms_32x32_tl.aps_mv_range[ref_ctr],
ps_pic_limit,
&as_mv_limit[ref_ctr],
i4_ctb_x << 6,
i4_ctb_y << 6,
32,
32);
SCALE_RANGE_PRMS_POINTERS(
s_merge_prms_32x32_tl.aps_mv_range[ref_ctr],
s_merge_prms_32x32_tl.aps_mv_range[ref_ctr],
2);
}
s_merge_prms_32x32_tl.i4_ctb_x_off = i4_ctb_x << 6;
s_merge_prms_32x32_tl.i4_ctb_y_off = i4_ctb_y << 6;
s_subpel_prms.u1_is_cu_noisy = au1_is_32x32Blk_noisy[0];
e_merge_result = hme_try_merge_high_speed(
ps_thrd_ctxt,
ps_ctxt,
ps_cur_ipe_ctb,
&s_subpel_prms,
&s_merge_prms_32x32_tl,
ps_pu_results,
&as_pu_results[0][0][0]);
if(e_merge_result == CU_MERGED)
{
inter_cu_results_t *ps_cu_results =
s_merge_prms_32x32_tl.ps_results_merge->ps_cu_results;
if(!((ps_cu_results->u1_num_best_results == 1) &&
(ps_cu_results->ps_best_results->as_pu_results->pu.b1_intra_flag)))
{
hme_map_mvs_to_grid(
&aps_mv_grid[0],
s_merge_prms_32x32_tl.ps_results_merge,
s_merge_prms_32x32_tl.au1_pred_dir_searched,
s_merge_prms_32x32_tl.i4_num_pred_dir_actual);
}
if(ME_PRISTINE_QUALITY != e_me_quality_presets)
{
ps_ctxt->ps_cu_tree_curr_row[(i4_ctb_x * MAX_NUM_NODES_CU_TREE)]
.ps_child_node_tl->is_node_valid = 1;
NULLIFY_THE_CHILDREN_NODES(
ps_ctxt->ps_cu_tree_curr_row[(i4_ctb_x * MAX_NUM_NODES_CU_TREE)]
.ps_child_node_tl);
}
merge_count_32x32++;
e_merge_result = CU_SPLIT;
}
else if(ME_PRISTINE_QUALITY == e_me_quality_presets)
{
#if ENABLE_CU_TREE_CULLING
cur_ctb_cu_tree_t *ps_tree =
ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_tl;
ps_ctb_cluster_info->ps_cu_tree_root->is_node_valid = 0;
en_merge_execution = (en_merge_execution & (~(1 << 4)));
ENABLE_THE_CHILDREN_NODES(ps_tree);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tr);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_bl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_br);
#endif
}
}
else if((en_merge_32x32 & 1) && (!(en_merge_execution & 1)))
{
#if ENABLE_CU_TREE_CULLING
cur_ctb_cu_tree_t *ps_tree =
ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_tl;
ENABLE_THE_CHILDREN_NODES(ps_tree);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tr);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_bl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_br);
#endif
if(au1_is_32x32Blk_noisy[0] && DISABLE_INTRA_WHEN_NOISY)
{
ps_tree->is_node_valid = 0;
ps_ctb_cluster_info->ps_cu_tree_root->is_node_valid = 0;
en_merge_execution = (en_merge_execution & (~(1 << 4)));
}
}
if((en_merge_32x32 & 2) && (en_merge_execution & 2))
{
range_prms_t *ps_pic_limit;
if(s_merge_prms_32x32_tr.i4_use_rec == 1)
{
ps_pic_limit = &s_pic_limit_rec;
}
else
{
ps_pic_limit = &s_pic_limit_inp;
}
/* MV limit is different based on ref. PIC */
for(ref_ctr = 0; ref_ctr < num_act_ref_pics; ref_ctr++)
{
hme_derive_search_range(
s_merge_prms_32x32_tr.aps_mv_range[ref_ctr],
ps_pic_limit,
&as_mv_limit[ref_ctr],
(i4_ctb_x << 6) + 32,
i4_ctb_y << 6,
32,
32);
SCALE_RANGE_PRMS_POINTERS(
s_merge_prms_32x32_tr.aps_mv_range[ref_ctr],
s_merge_prms_32x32_tr.aps_mv_range[ref_ctr],
2);
}
s_merge_prms_32x32_tr.i4_ctb_x_off = i4_ctb_x << 6;
s_merge_prms_32x32_tr.i4_ctb_y_off = i4_ctb_y << 6;
s_subpel_prms.u1_is_cu_noisy = au1_is_32x32Blk_noisy[1];
e_merge_result = hme_try_merge_high_speed(
ps_thrd_ctxt,
ps_ctxt,
ps_cur_ipe_ctb,
&s_subpel_prms,
&s_merge_prms_32x32_tr,
ps_pu_results,
&as_pu_results[0][0][0]);
if(e_merge_result == CU_MERGED)
{
inter_cu_results_t *ps_cu_results =
s_merge_prms_32x32_tr.ps_results_merge->ps_cu_results;
if(!((ps_cu_results->u1_num_best_results == 1) &&
(ps_cu_results->ps_best_results->as_pu_results->pu.b1_intra_flag)))
{
hme_map_mvs_to_grid(
&aps_mv_grid[0],
s_merge_prms_32x32_tr.ps_results_merge,
s_merge_prms_32x32_tr.au1_pred_dir_searched,
s_merge_prms_32x32_tr.i4_num_pred_dir_actual);
}
if(ME_PRISTINE_QUALITY != e_me_quality_presets)
{
ps_ctxt->ps_cu_tree_curr_row[(i4_ctb_x * MAX_NUM_NODES_CU_TREE)]
.ps_child_node_tr->is_node_valid = 1;
NULLIFY_THE_CHILDREN_NODES(
ps_ctxt->ps_cu_tree_curr_row[(i4_ctb_x * MAX_NUM_NODES_CU_TREE)]
.ps_child_node_tr);
}
merge_count_32x32++;
e_merge_result = CU_SPLIT;
}
else if(ME_PRISTINE_QUALITY == e_me_quality_presets)
{
#if ENABLE_CU_TREE_CULLING
cur_ctb_cu_tree_t *ps_tree =
ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_tr;
ps_ctb_cluster_info->ps_cu_tree_root->is_node_valid = 0;
en_merge_execution = (en_merge_execution & (~(1 << 4)));
ENABLE_THE_CHILDREN_NODES(ps_tree);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tr);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_bl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_br);
#endif
}
}
else if((en_merge_32x32 & 2) && (!(en_merge_execution & 2)))
{
#if ENABLE_CU_TREE_CULLING
cur_ctb_cu_tree_t *ps_tree =
ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_tr;
ENABLE_THE_CHILDREN_NODES(ps_tree);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tr);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_bl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_br);
#endif
if(au1_is_32x32Blk_noisy[1] && DISABLE_INTRA_WHEN_NOISY)
{
ps_tree->is_node_valid = 0;
ps_ctb_cluster_info->ps_cu_tree_root->is_node_valid = 0;
en_merge_execution = (en_merge_execution & (~(1 << 4)));
}
}
if((en_merge_32x32 & 4) && (en_merge_execution & 4))
{
range_prms_t *ps_pic_limit;
if(s_merge_prms_32x32_bl.i4_use_rec == 1)
{
ps_pic_limit = &s_pic_limit_rec;
}
else
{
ps_pic_limit = &s_pic_limit_inp;
}
/* MV limit is different based on ref. PIC */
for(ref_ctr = 0; ref_ctr < num_act_ref_pics; ref_ctr++)
{
hme_derive_search_range(
s_merge_prms_32x32_bl.aps_mv_range[ref_ctr],
ps_pic_limit,
&as_mv_limit[ref_ctr],
i4_ctb_x << 6,
(i4_ctb_y << 6) + 32,
32,
32);
SCALE_RANGE_PRMS_POINTERS(
s_merge_prms_32x32_bl.aps_mv_range[ref_ctr],
s_merge_prms_32x32_bl.aps_mv_range[ref_ctr],
2);
}
s_merge_prms_32x32_bl.i4_ctb_x_off = i4_ctb_x << 6;
s_merge_prms_32x32_bl.i4_ctb_y_off = i4_ctb_y << 6;
s_subpel_prms.u1_is_cu_noisy = au1_is_32x32Blk_noisy[2];
e_merge_result = hme_try_merge_high_speed(
ps_thrd_ctxt,
ps_ctxt,
ps_cur_ipe_ctb,
&s_subpel_prms,
&s_merge_prms_32x32_bl,
ps_pu_results,
&as_pu_results[0][0][0]);
if(e_merge_result == CU_MERGED)
{
inter_cu_results_t *ps_cu_results =
s_merge_prms_32x32_bl.ps_results_merge->ps_cu_results;
if(!((ps_cu_results->u1_num_best_results == 1) &&
(ps_cu_results->ps_best_results->as_pu_results->pu.b1_intra_flag)))
{
hme_map_mvs_to_grid(
&aps_mv_grid[0],
s_merge_prms_32x32_bl.ps_results_merge,
s_merge_prms_32x32_bl.au1_pred_dir_searched,
s_merge_prms_32x32_bl.i4_num_pred_dir_actual);
}
if(ME_PRISTINE_QUALITY != e_me_quality_presets)
{
ps_ctxt->ps_cu_tree_curr_row[(i4_ctb_x * MAX_NUM_NODES_CU_TREE)]
.ps_child_node_bl->is_node_valid = 1;
NULLIFY_THE_CHILDREN_NODES(
ps_ctxt->ps_cu_tree_curr_row[(i4_ctb_x * MAX_NUM_NODES_CU_TREE)]
.ps_child_node_bl);
}
merge_count_32x32++;
e_merge_result = CU_SPLIT;
}
else if(ME_PRISTINE_QUALITY == e_me_quality_presets)
{
#if ENABLE_CU_TREE_CULLING
cur_ctb_cu_tree_t *ps_tree =
ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_bl;
ps_ctb_cluster_info->ps_cu_tree_root->is_node_valid = 0;
en_merge_execution = (en_merge_execution & (~(1 << 4)));
ENABLE_THE_CHILDREN_NODES(ps_tree);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tr);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_bl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_br);
#endif
}
}
else if((en_merge_32x32 & 4) && (!(en_merge_execution & 4)))
{
#if ENABLE_CU_TREE_CULLING
cur_ctb_cu_tree_t *ps_tree =
ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_bl;
ENABLE_THE_CHILDREN_NODES(ps_tree);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tr);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_bl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_br);
#endif
if(au1_is_32x32Blk_noisy[2] && DISABLE_INTRA_WHEN_NOISY)
{
ps_tree->is_node_valid = 0;
ps_ctb_cluster_info->ps_cu_tree_root->is_node_valid = 0;
en_merge_execution = (en_merge_execution & (~(1 << 4)));
}
}
if((en_merge_32x32 & 8) && (en_merge_execution & 8))
{
range_prms_t *ps_pic_limit;
if(s_merge_prms_32x32_br.i4_use_rec == 1)
{
ps_pic_limit = &s_pic_limit_rec;
}
else
{
ps_pic_limit = &s_pic_limit_inp;
}
/* MV limit is different based on ref. PIC */
for(ref_ctr = 0; ref_ctr < num_act_ref_pics; ref_ctr++)
{
hme_derive_search_range(
s_merge_prms_32x32_br.aps_mv_range[ref_ctr],
ps_pic_limit,
&as_mv_limit[ref_ctr],
(i4_ctb_x << 6) + 32,
(i4_ctb_y << 6) + 32,
32,
32);
SCALE_RANGE_PRMS_POINTERS(
s_merge_prms_32x32_br.aps_mv_range[ref_ctr],
s_merge_prms_32x32_br.aps_mv_range[ref_ctr],
2);
}
s_merge_prms_32x32_br.i4_ctb_x_off = i4_ctb_x << 6;
s_merge_prms_32x32_br.i4_ctb_y_off = i4_ctb_y << 6;
s_subpel_prms.u1_is_cu_noisy = au1_is_32x32Blk_noisy[3];
e_merge_result = hme_try_merge_high_speed(
ps_thrd_ctxt,
ps_ctxt,
ps_cur_ipe_ctb,
&s_subpel_prms,
&s_merge_prms_32x32_br,
ps_pu_results,
&as_pu_results[0][0][0]);
if(e_merge_result == CU_MERGED)
{
/*inter_cu_results_t *ps_cu_results = s_merge_prms_32x32_br.ps_results_merge->ps_cu_results;
if(!((ps_cu_results->u1_num_best_results == 1) &&
(ps_cu_results->ps_best_results->as_pu_results->pu.b1_intra_flag)))
{
hme_map_mvs_to_grid
(
&aps_mv_grid[0],
s_merge_prms_32x32_br.ps_results_merge,
s_merge_prms_32x32_br.au1_pred_dir_searched,
s_merge_prms_32x32_br.i4_num_pred_dir_actual
);
}*/
if(ME_PRISTINE_QUALITY != e_me_quality_presets)
{
ps_ctxt->ps_cu_tree_curr_row[(i4_ctb_x * MAX_NUM_NODES_CU_TREE)]
.ps_child_node_br->is_node_valid = 1;
NULLIFY_THE_CHILDREN_NODES(
ps_ctxt->ps_cu_tree_curr_row[(i4_ctb_x * MAX_NUM_NODES_CU_TREE)]
.ps_child_node_br);
}
merge_count_32x32++;
e_merge_result = CU_SPLIT;
}
else if(ME_PRISTINE_QUALITY == e_me_quality_presets)
{
#if ENABLE_CU_TREE_CULLING
cur_ctb_cu_tree_t *ps_tree =
ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_br;
ps_ctb_cluster_info->ps_cu_tree_root->is_node_valid = 0;
en_merge_execution = (en_merge_execution & (~(1 << 4)));
ENABLE_THE_CHILDREN_NODES(ps_tree);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tr);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_bl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_br);
#endif
}
}
else if((en_merge_32x32 & 8) && (!(en_merge_execution & 8)))
{
#if ENABLE_CU_TREE_CULLING
cur_ctb_cu_tree_t *ps_tree =
ps_ctb_cluster_info->ps_cu_tree_root->ps_child_node_br;
ENABLE_THE_CHILDREN_NODES(ps_tree);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_tr);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_bl);
ENABLE_THE_CHILDREN_NODES(ps_tree->ps_child_node_br);
#endif
if(au1_is_32x32Blk_noisy[3] && DISABLE_INTRA_WHEN_NOISY)
{
ps_tree->is_node_valid = 0;
ps_ctb_cluster_info->ps_cu_tree_root->is_node_valid = 0;
en_merge_execution = (en_merge_execution & (~(1 << 4)));
}
}
/* Try merging all 32x32 to 64x64 candts */
if(((en_merge_32x32 & 0xf) == 0xf) &&
(((merge_count_32x32 == 4) && (e_me_quality_presets != ME_PRISTINE_QUALITY)) ||
((en_merge_execution & 16) && (e_me_quality_presets == ME_PRISTINE_QUALITY))))
if((((e_me_quality_presets == ME_XTREME_SPEED_25) &&
!DISABLE_64X64_BLOCK_MERGE_IN_ME_IN_XS25) ||
(e_me_quality_presets != ME_XTREME_SPEED_25)))
{
range_prms_t *ps_pic_limit;
if(s_merge_prms_64x64.i4_use_rec == 1)
{
ps_pic_limit = &s_pic_limit_rec;
}
else
{
ps_pic_limit = &s_pic_limit_inp;
}
/* MV limit is different based on ref. PIC */
for(ref_ctr = 0; ref_ctr < num_act_ref_pics; ref_ctr++)
{
hme_derive_search_range(
s_merge_prms_64x64.aps_mv_range[ref_ctr],
ps_pic_limit,
&as_mv_limit[ref_ctr],
i4_ctb_x << 6,
i4_ctb_y << 6,
64,
64);
SCALE_RANGE_PRMS_POINTERS(
s_merge_prms_64x64.aps_mv_range[ref_ctr],
s_merge_prms_64x64.aps_mv_range[ref_ctr],
2);
}
s_merge_prms_64x64.i4_ctb_x_off = i4_ctb_x << 6;
s_merge_prms_64x64.i4_ctb_y_off = i4_ctb_y << 6;
s_subpel_prms.u1_is_cu_noisy = au1_is_64x64Blk_noisy[0];
e_merge_result = hme_try_merge_high_speed(
ps_thrd_ctxt,
ps_ctxt,
ps_cur_ipe_ctb,
&s_subpel_prms,
&s_merge_prms_64x64,
ps_pu_results,
&as_pu_results[0][0][0]);
if((e_merge_result == CU_MERGED) &&
(ME_PRISTINE_QUALITY != e_me_quality_presets))
{
ps_ctxt->ps_cu_tree_curr_row[(i4_ctb_x * MAX_NUM_NODES_CU_TREE)]
.is_node_valid = 1;
NULLIFY_THE_CHILDREN_NODES(
ps_ctxt->ps_cu_tree_curr_row + (i4_ctb_x * MAX_NUM_NODES_CU_TREE));
}
else if(
(e_merge_result == CU_SPLIT) &&
(ME_PRISTINE_QUALITY == e_me_quality_presets))
{
ps_ctxt->ps_cu_tree_curr_row[(i4_ctb_x * MAX_NUM_NODES_CU_TREE)]
.is_node_valid = 0;
}
}
/*****************************************************************/
/* UPDATION OF RESULT TO EXTERNAL STRUCTURES */
/*****************************************************************/
pf_ext_update_fxn((void *)ps_thrd_ctxt, (void *)ps_ctxt, i4_ctb_x, i4_ctb_y);
{
#ifdef _DEBUG
S32 wd = ((i4_pic_wd - s_common_frm_prms.i4_ctb_x_off) >= 64)
? 64
: i4_pic_wd - s_common_frm_prms.i4_ctb_x_off;
S32 ht = ((i4_pic_ht - s_common_frm_prms.i4_ctb_y_off) >= 64)
? 64
: i4_pic_ht - s_common_frm_prms.i4_ctb_y_off;
ASSERT(
(wd * ht) ==
ihevce_compute_area_of_valid_cus_in_ctb(
&ps_ctxt->ps_cu_tree_curr_row[(i4_ctb_x * MAX_NUM_NODES_CU_TREE)]));
#endif
}
}
/* set the dependency for the corresponding row in enc loop */
ihevce_dmgr_set_row_row_sync(
pv_dep_mngr_encloop_dep_me,
(i4_ctb_x + 1),
i4_ctb_y,
tile_col_idx /* Col Tile No. */);
left_ctb_in_diff_tile = 0;
}
}
}
/**
********************************************************************************
* @fn void hme_refine_no_encode(coarse_me_ctxt_t *ps_ctxt,
* refine_layer_prms_t *ps_refine_prms)
*
* @brief Top level entry point for refinement ME
*
* @param[in,out] ps_ctxt: ME Handle
*
* @param[in] ps_refine_prms : refinement layer prms
*
* @return None
********************************************************************************
*/
void hme_refine_no_encode(
coarse_me_ctxt_t *ps_ctxt,
refine_prms_t *ps_refine_prms,
multi_thrd_ctxt_t *ps_multi_thrd_ctxt,
S32 lyr_job_type,
WORD32 i4_ping_pong,
void **ppv_dep_mngr_hme_sync)
{
BLK_SIZE_T e_search_blk_size, e_result_blk_size;
ME_QUALITY_PRESETS_T e_me_quality_presets =
ps_ctxt->s_init_prms.s_me_coding_tools.e_me_quality_presets;
/*************************************************************************/
/* Complexity of search: Low to High */
/*************************************************************************/
SEARCH_COMPLEXITY_T e_search_complexity;
/*************************************************************************/
/* Config parameter structures for varius ME submodules */
/*************************************************************************/
hme_search_prms_t s_search_prms_blk;
mvbank_update_prms_t s_mv_update_prms;
/*************************************************************************/
/* All types of search candidates for predictor based search. */
/*************************************************************************/
S32 num_init_candts = 0;
search_candt_t *ps_search_candts, as_search_candts[MAX_INIT_CANDTS];
search_node_t as_top_neighbours[4], as_left_neighbours[3];
search_node_t *ps_candt_zeromv, *ps_candt_tl, *ps_candt_tr;
search_node_t *ps_candt_l, *ps_candt_t;
search_node_t *ps_candt_prj_br[2], *ps_candt_prj_b[2], *ps_candt_prj_r[2];
search_node_t *ps_candt_prj_bl[2];
search_node_t *ps_candt_prj_tr[2], *ps_candt_prj_t[2], *ps_candt_prj_tl[2];
search_node_t *ps_candt_prj_coloc[2];
pf_get_wt_inp fp_get_wt_inp;
search_node_t as_unique_search_nodes[MAX_INIT_CANDTS * 9];
U32 au4_unique_node_map[MAP_X_MAX * 2];
/*EIID */
WORD32 i4_num_inter_wins = 0; //debug code to find stat of
WORD32 i4_num_comparisions = 0; //debug code
WORD32 i4_threshold_multiplier;
WORD32 i4_threshold_divider;
WORD32 i4_temporal_layer =
ps_multi_thrd_ctxt->aps_curr_inp_pre_enc[i4_ping_pong]->s_lap_out.i4_temporal_lyr_id;
/*************************************************************************/
/* points ot the search results for the blk level search (8x8/16x16) */
/*************************************************************************/
search_results_t *ps_search_results;
/*************************************************************************/
/* Coordinates */
/*************************************************************************/
S32 blk_x, i4_ctb_x, blk_id_in_ctb;
//S32 i4_ctb_y;
S32 pos_x, pos_y;
S32 blk_id_in_full_ctb;
S32 i4_num_srch_cands;
S32 blk_y;
/*************************************************************************/
/* Related to dimensions of block being searched and pic dimensions */
/*************************************************************************/
S32 blk_wd, blk_ht, blk_size_shift, num_blks_in_row, num_blks_in_pic;
S32 i4_pic_wd, i4_pic_ht, num_blks_in_this_ctb;
S32 num_results_prev_layer;
/*************************************************************************/
/* Size of a basic unit for this layer. For non encode layers, we search */
/* in block sizes of 8x8. For encode layers, though we search 16x16s the */
/* basic unit size is the ctb size. */
/*************************************************************************/
S32 unit_size;
/*************************************************************************/
/* Pointers to context in current and coarser layers */
/*************************************************************************/
layer_ctxt_t *ps_curr_layer, *ps_coarse_layer;
/*************************************************************************/
/* to store mv range per blk, and picture limit, allowed search range */
/* range prms in hpel and qpel units as well */
/*************************************************************************/
range_prms_t s_range_prms_inp, s_range_prms_rec;
range_prms_t s_pic_limit_inp, s_pic_limit_rec, as_mv_limit[MAX_NUM_REF];
/*************************************************************************/
/* These variables are used to track number of references at different */
/* stages of ME. */
/*************************************************************************/
S32 i4_num_ref_fpel, i4_num_ref_before_merge;
S32 i4_num_ref_each_dir, i, i4_num_ref_prev_layer;
S32 lambda_inp = ps_refine_prms->lambda_inp;
/*************************************************************************/
/* When a layer is implicit, it means that it searches on 1 or 2 ref idx */
/* Explicit means it searches on all active ref idx. */
/*************************************************************************/
S32 curr_layer_implicit, prev_layer_implicit;
/*************************************************************************/
/* Variables for loop counts */
/*************************************************************************/
S32 id;
S08 i1_ref_idx;
/*************************************************************************/
/* Input pointer and stride */
/*************************************************************************/
U08 *pu1_inp;
S32 i4_inp_stride;
S32 end_of_frame;
S32 num_sync_units_in_row;
PF_HME_PROJECT_COLOC_CANDT_FXN pf_hme_project_coloc_candt;
ASSERT(ps_refine_prms->i4_layer_id < ps_ctxt->num_layers - 1);
/*************************************************************************/
/* Pointers to current and coarse layer are needed for projection */
/* Pointer to prev layer are needed for other candts like coloc */
/*************************************************************************/
ps_curr_layer = ps_ctxt->ps_curr_descr->aps_layers[ps_refine_prms->i4_layer_id];
ps_coarse_layer = ps_ctxt->ps_curr_descr->aps_layers[ps_refine_prms->i4_layer_id + 1];
num_results_prev_layer = ps_coarse_layer->ps_layer_mvbank->i4_num_mvs_per_ref;
/* Function pointer is selected based on the C vc X86 macro */
fp_get_wt_inp = ((ihevce_me_optimised_function_list_t *)ps_ctxt->pv_me_optimised_function_list)
->pf_get_wt_inp_8x8;
i4_inp_stride = ps_curr_layer->i4_inp_stride;
i4_pic_wd = ps_curr_layer->i4_wd;
i4_pic_ht = ps_curr_layer->i4_ht;
e_search_complexity = ps_refine_prms->e_search_complexity;
end_of_frame = 0;
/* If the previous layer is non-encode layer, then use dyadic projection */
if(0 == ps_ctxt->u1_encode[ps_refine_prms->i4_layer_id + 1])
pf_hme_project_coloc_candt = hme_project_coloc_candt_dyadic;
else
pf_hme_project_coloc_candt = hme_project_coloc_candt;
/* This points to all the initial candts */
ps_search_candts = &as_search_candts[0];
{
e_search_blk_size = BLK_8x8;
blk_wd = blk_ht = 8;
blk_size_shift = 3;
s_mv_update_prms.i4_shift = 0;
/*********************************************************************/
/* In case we do not encode this layer, we search 8x8 with or without*/
/* enable 4x4 SAD. */
/*********************************************************************/
{
S32 i4_mask = (ENABLE_2Nx2N);
e_result_blk_size = BLK_8x8;
if(ps_refine_prms->i4_enable_4x4_part)
{
i4_mask |= (ENABLE_NxN);
e_result_blk_size = BLK_4x4;
s_mv_update_prms.i4_shift = 1;
}
s_search_prms_blk.i4_part_mask = i4_mask;
}
unit_size = blk_wd;
s_search_prms_blk.i4_inp_stride = unit_size;
}
/* This is required to properly update the layer mv bank */
s_mv_update_prms.e_search_blk_size = e_search_blk_size;
s_search_prms_blk.e_blk_size = e_search_blk_size;
/*************************************************************************/
/* If current layer is explicit, then the number of ref frames are to */
/* be same as previous layer. Else it will be 2 */
/*************************************************************************/
i4_num_ref_prev_layer = ps_coarse_layer->ps_layer_mvbank->i4_num_ref;
if(ps_refine_prms->explicit_ref)
{
curr_layer_implicit = 0;
i4_num_ref_fpel = i4_num_ref_prev_layer;
/* 100578 : Using same mv cost fun. for all presets. */
s_search_prms_blk.pf_mv_cost_compute = compute_mv_cost_refine;
}
else
{
i4_num_ref_fpel = 2;
curr_layer_implicit = 1;
{
if(ME_MEDIUM_SPEED > e_me_quality_presets)
{
s_search_prms_blk.pf_mv_cost_compute = compute_mv_cost_implicit;
}
else
{
#if USE_MODIFIED == 1
s_search_prms_blk.pf_mv_cost_compute = compute_mv_cost_implicit_high_speed_modified;
#else
s_search_prms_blk.pf_mv_cost_compute = compute_mv_cost_implicit_high_speed;
#endif
}
}
}
i4_num_ref_fpel = MIN(i4_num_ref_fpel, i4_num_ref_prev_layer);
if(ps_multi_thrd_ctxt->aps_curr_inp_pre_enc[i4_ping_pong]->s_lap_out.i4_pic_type ==
IV_IDR_FRAME ||
ps_multi_thrd_ctxt->aps_curr_inp_pre_enc[i4_ping_pong]->s_lap_out.i4_pic_type == IV_I_FRAME)
{
i4_num_ref_fpel = 1;
}
if(i4_num_ref_prev_layer <= 2)
{
prev_layer_implicit = 1;
curr_layer_implicit = 1;
i4_num_ref_each_dir = 1;
}
else
{
/* It is assumed that we have equal number of references in each dir */
//ASSERT(!(i4_num_ref_prev_layer & 1));
prev_layer_implicit = 0;
i4_num_ref_each_dir = i4_num_ref_prev_layer >> 1;
}
s_mv_update_prms.i4_num_ref = i4_num_ref_fpel;
s_mv_update_prms.i4_num_active_ref_l0 = ps_ctxt->s_frm_prms.u1_num_active_ref_l0;
s_mv_update_prms.i4_num_active_ref_l1 = ps_ctxt->s_frm_prms.u1_num_active_ref_l1;
/* this can be kept to 1 or 2 */
i4_num_ref_before_merge = 2;
i4_num_ref_before_merge = MIN(i4_num_ref_before_merge, i4_num_ref_fpel);
/* Set up place holders to hold the search nodes of each initial candt */
for(i = 0; i < MAX_INIT_CANDTS; i++)
{
ps_search_candts[i].ps_search_node = &ps_ctxt->s_init_search_node[i];
INIT_SEARCH_NODE(ps_search_candts[i].ps_search_node, 0);
}
/* redundant, but doing it here since it is used in pred ctxt init */
ps_candt_zeromv = ps_search_candts[0].ps_search_node;
for(i = 0; i < 3; i++)
{
search_node_t *ps_search_node;
ps_search_node = &as_left_neighbours[i];
INIT_SEARCH_NODE(ps_search_node, 0);
ps_search_node = &as_top_neighbours[i];
INIT_SEARCH_NODE(ps_search_node, 0);
}
INIT_SEARCH_NODE(&as_top_neighbours[3], 0);
/* bottom left node always not available for the blk being searched */
as_left_neighbours[2].u1_is_avail = 0;
/*************************************************************************/
/* Initialize all the search results structure here. We update all the */
/* search results to default values, and configure things like blk sizes */
/*************************************************************************/
if(ps_refine_prms->i4_encode == 0)
{
S32 pred_lx;
search_results_t *ps_search_results;
ps_search_results = &ps_ctxt->s_search_results_8x8;
hme_init_search_results(
ps_search_results,
i4_num_ref_fpel,
ps_refine_prms->i4_num_fpel_results,
ps_refine_prms->i4_num_results_per_part,
e_search_blk_size,
0,
0,
&ps_ctxt->au1_is_past[0]);
for(pred_lx = 0; pred_lx < 2; pred_lx++)
{
hme_init_pred_ctxt_no_encode(
&ps_search_results->as_pred_ctxt[pred_lx],
ps_search_results,
&as_top_neighbours[0],
&as_left_neighbours[0],
&ps_candt_prj_coloc[0],
ps_candt_zeromv,
ps_candt_zeromv,
pred_lx,
lambda_inp,
ps_refine_prms->lambda_q_shift,
&ps_ctxt->apu1_ref_bits_tlu_lc[0],
&ps_ctxt->ai2_ref_scf[0]);
}
}
/*********************************************************************/
/* Initialize the dyn. search range params. for each reference index */
/* in current layer ctxt */
/*********************************************************************/
/* Only for P pic. For P, both are 0, I&B has them mut. exclusive */
if(ps_ctxt->s_frm_prms.is_i_pic == ps_ctxt->s_frm_prms.bidir_enabled)
{
WORD32 ref_ctr;
for(ref_ctr = 0; ref_ctr < s_mv_update_prms.i4_num_ref; ref_ctr++)
{
INIT_DYN_SEARCH_PRMS(
&ps_ctxt->s_coarse_dyn_range_prms
.as_dyn_range_prms[ps_refine_prms->i4_layer_id][ref_ctr],
ps_ctxt->ai4_ref_idx_to_poc_lc[ref_ctr]);
}
}
/* Next set up initial candidates according to a given set of rules. */
/* The number of initial candidates affects the quality of ME in the */
/* case of motion with multiple degrees of freedom. In case of simple */
/* translational motion, a current and a few causal and non causal */
/* candts would suffice. More candidates help to cover more complex */
/* cases like partitions, rotation/zoom, occlusion in/out, fine motion */
/* where multiple ref helps etc. */
/* The candidate choice also depends on the following parameters. */
/* e_search_complexity: SRCH_CX_LOW, SRCH_CX_MED, SRCH_CX_HIGH */
/* Whether we encode or not, and the type of search across reference */
/* i.e. the previous layer may have been explicit/implicit and curr */
/* layer may be explicit/implicit */
/* 0, 0, L, T, projected coloc best always presnt by default */
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(ZERO_MV, e_me_quality_presets);
ps_candt_zeromv = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 0;
ps_candt_zeromv->s_mv.i2_mvx = 0;
ps_candt_zeromv->s_mv.i2_mvy = 0;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(SPATIAL_LEFT0, e_me_quality_presets);
ps_candt_l = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 0;
/* Even in ME_HIGH_SPEED mode, in layer 0, blocks */
/* not at the CTB boundary use the causal T and */
/* not the projected T, although the candidate is */
/* still pointed to by ps_candt_prj_t[0] */
if(ME_MEDIUM_SPEED <= e_me_quality_presets)
{
/* Using Projected top to eliminate sync */
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_TOP0, e_me_quality_presets);
ps_candt_prj_t[0] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
}
else
{
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
SPATIAL_TOP0, e_me_quality_presets);
ps_candt_t = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 0;
}
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_COLOC0, e_me_quality_presets);
ps_candt_prj_coloc[0] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_COLOC1, e_me_quality_presets);
ps_candt_prj_coloc[1] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
if(ME_MEDIUM_SPEED <= e_me_quality_presets)
{
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_TOP_RIGHT0, e_me_quality_presets);
ps_candt_prj_tr[0] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_TOP_LEFT0, e_me_quality_presets);
ps_candt_prj_tl[0] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
}
else
{
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
SPATIAL_TOP_RIGHT0, e_me_quality_presets);
ps_candt_tr = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 0;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
SPATIAL_TOP_LEFT0, e_me_quality_presets);
ps_candt_tl = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 0;
}
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_RIGHT0, e_me_quality_presets);
ps_candt_prj_r[0] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_BOTTOM0, e_me_quality_presets);
ps_candt_prj_b[0] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_BOTTOM_RIGHT0, e_me_quality_presets);
ps_candt_prj_br[0] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_BOTTOM_LEFT0, e_me_quality_presets);
ps_candt_prj_bl[0] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_RIGHT1, e_me_quality_presets);
ps_candt_prj_r[1] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_BOTTOM1, e_me_quality_presets);
ps_candt_prj_b[1] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_BOTTOM_RIGHT1, e_me_quality_presets);
ps_candt_prj_br[1] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_BOTTOM_LEFT1, e_me_quality_presets);
ps_candt_prj_bl[1] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(PROJECTED_TOP1, e_me_quality_presets);
ps_candt_prj_t[1] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_TOP_RIGHT1, e_me_quality_presets);
ps_candt_prj_tr[1] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
id = hme_decide_search_candidate_priority_in_l1_and_l2_me(
PROJECTED_TOP_LEFT1, e_me_quality_presets);
ps_candt_prj_tl[1] = ps_search_candts[id].ps_search_node;
ps_search_candts[id].u1_num_steps_refine = 1;
/*************************************************************************/
/* Now that the candidates have been ordered, to choose the right number */
/* of initial candidates. */
/*************************************************************************/
if(curr_layer_implicit && !prev_layer_implicit)
{
if(e_search_complexity == SEARCH_CX_LOW)
num_init_candts = 7;
else if(e_search_complexity == SEARCH_CX_MED)
num_init_candts = 13;
else if(e_search_complexity == SEARCH_CX_HIGH)
num_init_candts = 18;
else
ASSERT(0);
}
else
{
if(e_search_complexity == SEARCH_CX_LOW)
num_init_candts = 5;
else if(e_search_complexity == SEARCH_CX_MED)
num_init_candts = 11;
else if(e_search_complexity == SEARCH_CX_HIGH)
num_init_candts = 16;
else
ASSERT(0);
}
if(ME_XTREME_SPEED_25 == e_me_quality_presets)
{
num_init_candts = NUM_INIT_SEARCH_CANDS_IN_L1_AND_L2_ME_IN_XS25;
}
/*************************************************************************/
/* The following search parameters are fixed throughout the search across*/
/* all blks. So these are configured outside processing loop */
/*************************************************************************/
s_search_prms_blk.i4_num_init_candts = num_init_candts;
s_search_prms_blk.i4_start_step = 1;
s_search_prms_blk.i4_use_satd = 0;
s_search_prms_blk.i4_num_steps_post_refine = ps_refine_prms->i4_num_steps_post_refine_fpel;
/* we use recon only for encoded layers, otherwise it is not available */
s_search_prms_blk.i4_use_rec = ps_refine_prms->i4_encode & ps_refine_prms->i4_use_rec_in_fpel;
s_search_prms_blk.ps_search_candts = ps_search_candts;
/* We use the same mv_range for all ref. pic. So assign to member 0 */
if(s_search_prms_blk.i4_use_rec)
s_search_prms_blk.aps_mv_range[0] = &s_range_prms_rec;
else
s_search_prms_blk.aps_mv_range[0] = &s_range_prms_inp;
/*************************************************************************/
/* Initialize coordinates. Meaning as follows */
/* blk_x : x coordinate of the 16x16 blk, in terms of number of blks */
/* blk_y : same as above, y coord. */
/* num_blks_in_this_ctb : number of blks in this given ctb that starts */
/* at i4_ctb_x, i4_ctb_y. This may not be 16 at picture boundaries. */
/* i4_ctb_x, i4_ctb_y: pixel coordinate of the ctb realtive to top left */
/* corner of the picture. Always multiple of 64. */
/* blk_id_in_ctb : encode order id of the blk in the ctb. */
/*************************************************************************/
blk_y = 0;
blk_id_in_ctb = 0;
GET_NUM_BLKS_IN_PIC(i4_pic_wd, i4_pic_ht, blk_size_shift, num_blks_in_row, num_blks_in_pic);
/* Get the number of sync units in a row based on encode/non enocde layer */
num_sync_units_in_row = num_blks_in_row;
/*************************************************************************/
/* Picture limit on all 4 sides. This will be used to set mv limits for */
/* every block given its coordinate. Note thsi assumes that the min amt */
/* of padding to right of pic is equal to the blk size. If we go all the */
/* way upto 64x64, then the min padding on right size of picture should */
/* be 64, and also on bottom side of picture. */
/*************************************************************************/
SET_PIC_LIMIT(
s_pic_limit_inp,
ps_curr_layer->i4_pad_x_inp,
ps_curr_layer->i4_pad_y_inp,
ps_curr_layer->i4_wd,
ps_curr_layer->i4_ht,
s_search_prms_blk.i4_num_steps_post_refine);
SET_PIC_LIMIT(
s_pic_limit_rec,
ps_curr_layer->i4_pad_x_rec,
ps_curr_layer->i4_pad_y_rec,
ps_curr_layer->i4_wd,
ps_curr_layer->i4_ht,
s_search_prms_blk.i4_num_steps_post_refine);
/*************************************************************************/
/* set the MV limit per ref. pic. */
/* - P pic. : Based on the config params. */
/* - B/b pic: Based on the Max/Min MV from prev. P and config. param. */
/*************************************************************************/
{
WORD32 ref_ctr;
/* Only for B/b pic. */
if(1 == ps_ctxt->s_frm_prms.bidir_enabled)
{
WORD16 i2_mv_y_per_poc, i2_max_mv_y;
WORD32 cur_poc, ref_poc, abs_poc_diff;
cur_poc = ps_ctxt->i4_curr_poc;
/* Get abs MAX for symmetric search */
i2_mv_y_per_poc = MAX(
ps_ctxt->s_coarse_dyn_range_prms.i2_dyn_max_y_per_poc[ps_refine_prms->i4_layer_id],
(ABS(ps_ctxt->s_coarse_dyn_range_prms
.i2_dyn_min_y_per_poc[ps_refine_prms->i4_layer_id])));
for(ref_ctr = 0; ref_ctr < i4_num_ref_fpel; ref_ctr++)
{
ref_poc = ps_ctxt->ai4_ref_idx_to_poc_lc[ref_ctr];
abs_poc_diff = ABS((cur_poc - ref_poc));
/* Get the cur. max MV based on POC distance */
i2_max_mv_y = i2_mv_y_per_poc * abs_poc_diff;
i2_max_mv_y = MIN(i2_max_mv_y, ps_curr_layer->i2_max_mv_y);
as_mv_limit[ref_ctr].i2_min_x = -ps_curr_layer->i2_max_mv_x;
as_mv_limit[ref_ctr].i2_min_y = -i2_max_mv_y;
as_mv_limit[ref_ctr].i2_max_x = ps_curr_layer->i2_max_mv_x;
as_mv_limit[ref_ctr].i2_max_y = i2_max_mv_y;
}
}
else
{
/* Set the Config. File Params for P pic. */
for(ref_ctr = 0; ref_ctr < i4_num_ref_fpel; ref_ctr++)
{
as_mv_limit[ref_ctr].i2_min_x = -ps_curr_layer->i2_max_mv_x;
as_mv_limit[ref_ctr].i2_min_y = -ps_curr_layer->i2_max_mv_y;
as_mv_limit[ref_ctr].i2_max_x = ps_curr_layer->i2_max_mv_x;
as_mv_limit[ref_ctr].i2_max_y = ps_curr_layer->i2_max_mv_y;
}
}
}
/* EIID: Calculate threshold based on quality preset and/or temporal layers */
if(e_me_quality_presets == ME_MEDIUM_SPEED)
{
i4_threshold_multiplier = 1;
i4_threshold_divider = 4;
}
else if(e_me_quality_presets == ME_HIGH_SPEED)
{
i4_threshold_multiplier = 1;
i4_threshold_divider = 2;
}
else if((e_me_quality_presets == ME_XTREME_SPEED) || (e_me_quality_presets == ME_XTREME_SPEED_25))
{
#if OLD_XTREME_SPEED
/* Hard coding the temporal ID value to 1, if it is older xtreme speed */
i4_temporal_layer = 1;
#endif
if(i4_temporal_layer == 0)
{
i4_threshold_multiplier = 3;
i4_threshold_divider = 4;
}
else if(i4_temporal_layer == 1)
{
i4_threshold_multiplier = 3;
i4_threshold_divider = 4;
}
else if(i4_temporal_layer == 2)
{
i4_threshold_multiplier = 1;
i4_threshold_divider = 1;
}
else
{
i4_threshold_multiplier = 5;
i4_threshold_divider = 4;
}
}
else if(e_me_quality_presets == ME_HIGH_QUALITY)
{
i4_threshold_multiplier = 1;
i4_threshold_divider = 1;
}
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
/* START OF THE CORE LOOP */
/* If Encode is 0, then we just loop over each blk */
/*************************************************************************/
/*************************************************************************/
/*************************************************************************/
while(0 == end_of_frame)
{
job_queue_t *ps_job;
ihevce_ed_blk_t *ps_ed_blk_ctxt_curr_row; //EIID
WORD32 i4_ctb_row_ctr; //counter to calculate CTB row counter. It's (row_ctr /4)
WORD32 i4_num_ctbs_in_row = (num_blks_in_row + 3) / 4; //calculations verified for L1 only
//+3 to get ceil values when divided by 4
WORD32 i4_num_4x4_blocks_in_ctb_at_l1 =
8 * 8; //considering CTB size 32x32 at L1. hardcoded for now
//if there is variable for ctb size use that and this variable can be derived
WORD32 offset_val, check_dep_pos, set_dep_pos;
void *pv_hme_dep_mngr;
ihevce_ed_ctb_l1_t *ps_ed_ctb_l1_row;
/* Get the current layer HME Dep Mngr */
/* Note : Use layer_id - 1 in HME layers */
pv_hme_dep_mngr = ppv_dep_mngr_hme_sync[ps_refine_prms->i4_layer_id - 1];
/* Get the current row from the job queue */
ps_job = (job_queue_t *)ihevce_pre_enc_grp_get_next_job(
ps_multi_thrd_ctxt, lyr_job_type, 1, i4_ping_pong);
/* If all rows are done, set the end of process flag to 1, */
/* and the current row to -1 */
if(NULL == ps_job)
{
blk_y = -1;
end_of_frame = 1;
continue;
}
if(1 == ps_ctxt->s_frm_prms.is_i_pic)
{
/* set the output dependency of current row */
ihevce_pre_enc_grp_job_set_out_dep(ps_multi_thrd_ctxt, ps_job, i4_ping_pong);
continue;
}
blk_y = ps_job->s_job_info.s_me_job_info.i4_vert_unit_row_no;
blk_x = 0;
i4_ctb_x = 0;
/* wait for Corresponding Pre intra Job to be completed */
if(1 == ps_refine_prms->i4_layer_id)
{
volatile UWORD32 i4_l1_done;
volatile UWORD32 *pi4_l1_done;
pi4_l1_done = (volatile UWORD32 *)&ps_multi_thrd_ctxt
->aai4_l1_pre_intra_done[i4_ping_pong][blk_y >> 2];
i4_l1_done = *pi4_l1_done;
while(!i4_l1_done)
{
i4_l1_done = *pi4_l1_done;
}
}
/* Set Variables for Dep. Checking and Setting */
set_dep_pos = blk_y + 1;
if(blk_y > 0)
{
offset_val = 2;
check_dep_pos = blk_y - 1;
}
else
{
/* First row should run without waiting */
offset_val = -1;
check_dep_pos = 0;
}
/* EIID: calculate ed_blk_ctxt pointer for current row */
/* valid for only layer-1. not varified and used for other layers */
i4_ctb_row_ctr = blk_y / 4;
ps_ed_blk_ctxt_curr_row =
ps_ctxt->ps_ed_blk + (i4_ctb_row_ctr * i4_num_ctbs_in_row *
i4_num_4x4_blocks_in_ctb_at_l1); //valid for L1 only
ps_ed_ctb_l1_row = ps_ctxt->ps_ed_ctb_l1 + (i4_ctb_row_ctr * i4_num_ctbs_in_row);
/* if non-encode layer then i4_ctb_x will be same as blk_x */
/* loop over all the units is a row */
for(; i4_ctb_x < num_sync_units_in_row; i4_ctb_x++)
{
ihevce_ed_blk_t *ps_ed_blk_ctxt_curr_ctb; //EIDD
ihevce_ed_ctb_l1_t *ps_ed_ctb_l1_curr;
WORD32 i4_ctb_blk_ctr = i4_ctb_x / 4;
/* Wait till top row block is processed */
/* Currently checking till top right block*/
/* Disabled since all candidates, except for */
/* L and C, are projected from the coarser layer, */
/* only in ME_HIGH_SPEED mode */
if((ME_MEDIUM_SPEED > e_me_quality_presets))
{
if(i4_ctb_x < (num_sync_units_in_row - 1))
{
ihevce_dmgr_chk_row_row_sync(
pv_hme_dep_mngr,
i4_ctb_x,
offset_val,
check_dep_pos,
0, /* Col Tile No. : Not supported in PreEnc*/
ps_ctxt->thrd_id);
}
}
{
/* for non encoder layer only one block is processed */
num_blks_in_this_ctb = 1;
}
/* EIID: derive ed_ctxt ptr for current CTB */
ps_ed_blk_ctxt_curr_ctb =
ps_ed_blk_ctxt_curr_row +
(i4_ctb_blk_ctr *
i4_num_4x4_blocks_in_ctb_at_l1); //currently valid for l1 layer only
ps_ed_ctb_l1_curr = ps_ed_ctb_l1_row + i4_ctb_blk_ctr;
/* loop over all the blocks in CTB will always be 1 */
for(blk_id_in_ctb = 0; blk_id_in_ctb < num_blks_in_this_ctb; blk_id_in_ctb++)
{
{
/* non encode layer */
blk_x = i4_ctb_x;
blk_id_in_full_ctb = 0;
s_search_prms_blk.i4_cu_x_off = s_search_prms_blk.i4_cu_y_off = 0;
}
/* get the current input blk point */
pos_x = blk_x << blk_size_shift;
pos_y = blk_y << blk_size_shift;
pu1_inp = ps_curr_layer->pu1_inp + pos_x + (pos_y * i4_inp_stride);
/*********************************************************************/
/* replicate the inp buffer at blk or ctb level for each ref id, */
/* Instead of searching with wk * ref(k), we search with Ik = I / wk */
/* thereby avoiding a bloat up of memory. If we did all references */
/* weighted pred, we will end up with a duplicate copy of each ref */
/* at each layer, since we need to preserve the original reference. */
/* ToDo: Need to observe performance with this mechanism and compare */
/* with case where ref is weighted. */
/*********************************************************************/
if(blk_id_in_ctb == 0)
{
fp_get_wt_inp(
ps_curr_layer,
&ps_ctxt->s_wt_pred,
unit_size,
pos_x,
pos_y,
unit_size,
ps_ctxt->num_ref_future + ps_ctxt->num_ref_past,
ps_ctxt->i4_wt_pred_enable_flag);
}
s_search_prms_blk.i4_x_off = blk_x << blk_size_shift;
s_search_prms_blk.i4_y_off = blk_y << blk_size_shift;
/* Select search results from a suitable search result in the context */
{
ps_search_results = &ps_ctxt->s_search_results_8x8;
}
s_search_prms_blk.ps_search_results = ps_search_results;
/* RESET ALL SEARCH RESULTS FOR THE NEW BLK */
hme_reset_search_results(
ps_search_results, s_search_prms_blk.i4_part_mask, MV_RES_FPEL);
/* Loop across different Ref IDx */
for(i1_ref_idx = 0; i1_ref_idx < i4_num_ref_fpel; i1_ref_idx++)
{
S32 next_blk_offset = (e_search_blk_size == BLK_16x16) ? 22 : 12;
S32 prev_blk_offset = 6;
S32 resultid;
/*********************************************************************/
/* For every blk in the picture, the search range needs to be derived*/
/* Any blk can have any mv, but practical search constraints are */
/* imposed by the picture boundary and amt of padding. */
/*********************************************************************/
/* MV limit is different based on ref. PIC */
hme_derive_search_range(
&s_range_prms_inp,
&s_pic_limit_inp,
&as_mv_limit[i1_ref_idx],
pos_x,
pos_y,
blk_wd,
blk_ht);
hme_derive_search_range(
&s_range_prms_rec,
&s_pic_limit_rec,
&as_mv_limit[i1_ref_idx],
pos_x,
pos_y,
blk_wd,
blk_ht);
s_search_prms_blk.i1_ref_idx = i1_ref_idx;
ps_candt_zeromv->i1_ref_idx = i1_ref_idx;
i4_num_srch_cands = 1;
if(1 != ps_refine_prms->i4_layer_id)
{
S32 x, y;
x = gau1_encode_to_raster_x[blk_id_in_full_ctb];
y = gau1_encode_to_raster_y[blk_id_in_full_ctb];
if(ME_MEDIUM_SPEED > e_me_quality_presets)
{
hme_get_spatial_candt(
ps_curr_layer,
e_search_blk_size,
blk_x,
blk_y,
i1_ref_idx,
&as_top_neighbours[0],
&as_left_neighbours[0],
0,
((ps_refine_prms->i4_encode) ? gau1_cu_tr_valid[y][x] : 1),
0,
ps_refine_prms->i4_encode);
*ps_candt_tr = as_top_neighbours[3];
*ps_candt_t = as_top_neighbours[1];
*ps_candt_tl = as_top_neighbours[0];
i4_num_srch_cands += 3;
}
else
{
layer_mv_t *ps_layer_mvbank = ps_curr_layer->ps_layer_mvbank;
S32 i4_blk_size1 = gau1_blk_size_to_wd[ps_layer_mvbank->e_blk_size];
S32 i4_blk_size2 = gau1_blk_size_to_wd[e_search_blk_size];
search_node_t *ps_search_node;
S32 i4_offset, blk_x_temp = blk_x, blk_y_temp = blk_y;
hme_mv_t *ps_mv, *ps_mv_base;
S08 *pi1_ref_idx, *pi1_ref_idx_base;
S32 jump = 1, mvs_in_blk, mvs_in_row;
S32 shift = (ps_refine_prms->i4_encode ? 2 : 0);
if(i4_blk_size1 != i4_blk_size2)
{
blk_x_temp <<= 1;
blk_y_temp <<= 1;
jump = 2;
if((i4_blk_size1 << 2) == i4_blk_size2)
{
blk_x_temp <<= 1;
blk_y_temp <<= 1;
jump = 4;
}
}
mvs_in_blk = ps_layer_mvbank->i4_num_mvs_per_blk;
mvs_in_row = ps_layer_mvbank->i4_num_mvs_per_row;
/* Adjust teh blk coord to point to top left locn */
blk_x_temp -= 1;
blk_y_temp -= 1;
/* Pick up the mvs from the location */
i4_offset = (blk_x_temp * ps_layer_mvbank->i4_num_mvs_per_blk);
i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * blk_y_temp);
ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;
ps_mv += (i1_ref_idx * ps_layer_mvbank->i4_num_mvs_per_ref);
pi1_ref_idx += (i1_ref_idx * ps_layer_mvbank->i4_num_mvs_per_ref);
ps_mv_base = ps_mv;
pi1_ref_idx_base = pi1_ref_idx;
ps_search_node = &as_left_neighbours[0];
ps_mv = ps_mv_base + mvs_in_row;
pi1_ref_idx = pi1_ref_idx_base + mvs_in_row;
COPY_MV_TO_SEARCH_NODE(
ps_search_node, ps_mv, pi1_ref_idx, i1_ref_idx, shift);
i4_num_srch_cands++;
}
}
else
{
S32 x, y;
x = gau1_encode_to_raster_x[blk_id_in_full_ctb];
y = gau1_encode_to_raster_y[blk_id_in_full_ctb];
if(ME_MEDIUM_SPEED > e_me_quality_presets)
{
hme_get_spatial_candt_in_l1_me(
ps_curr_layer,
e_search_blk_size,
blk_x,
blk_y,
i1_ref_idx,
!ps_search_results->pu1_is_past[i1_ref_idx],
&as_top_neighbours[0],
&as_left_neighbours[0],
0,
((ps_refine_prms->i4_encode) ? gau1_cu_tr_valid[y][x] : 1),
0,
ps_ctxt->s_frm_prms.u1_num_active_ref_l0,
ps_ctxt->s_frm_prms.u1_num_active_ref_l1);
*ps_candt_tr = as_top_neighbours[3];
*ps_candt_t = as_top_neighbours[1];
*ps_candt_tl = as_top_neighbours[0];
i4_num_srch_cands += 3;
}
else
{
layer_mv_t *ps_layer_mvbank = ps_curr_layer->ps_layer_mvbank;
S32 i4_blk_size1 = gau1_blk_size_to_wd[ps_layer_mvbank->e_blk_size];
S32 i4_blk_size2 = gau1_blk_size_to_wd[e_search_blk_size];
S32 i4_mv_pos_in_implicit_array;
search_node_t *ps_search_node;
S32 i4_offset, blk_x_temp = blk_x, blk_y_temp = blk_y;
hme_mv_t *ps_mv, *ps_mv_base;
S08 *pi1_ref_idx, *pi1_ref_idx_base;
S32 jump = 1, mvs_in_blk, mvs_in_row;
S32 shift = (ps_refine_prms->i4_encode ? 2 : 0);
U08 u1_pred_dir = !ps_search_results->pu1_is_past[i1_ref_idx];
S32 i4_num_results_in_given_dir =
((u1_pred_dir == 1) ? (ps_layer_mvbank->i4_num_mvs_per_ref *
ps_ctxt->s_frm_prms.u1_num_active_ref_l1)
: (ps_layer_mvbank->i4_num_mvs_per_ref *
ps_ctxt->s_frm_prms.u1_num_active_ref_l0));
if(i4_blk_size1 != i4_blk_size2)
{
blk_x_temp <<= 1;
blk_y_temp <<= 1;
jump = 2;
if((i4_blk_size1 << 2) == i4_blk_size2)
{
blk_x_temp <<= 1;
blk_y_temp <<= 1;
jump = 4;
}
}
mvs_in_blk = ps_layer_mvbank->i4_num_mvs_per_blk;
mvs_in_row = ps_layer_mvbank->i4_num_mvs_per_row;
/* Adjust teh blk coord to point to top left locn */
blk_x_temp -= 1;
blk_y_temp -= 1;
/* Pick up the mvs from the location */
i4_offset = (blk_x_temp * ps_layer_mvbank->i4_num_mvs_per_blk);
i4_offset += (ps_layer_mvbank->i4_num_mvs_per_row * blk_y_temp);
i4_offset +=
((u1_pred_dir == 1) ? (ps_layer_mvbank->i4_num_mvs_per_ref *
ps_ctxt->s_frm_prms.u1_num_active_ref_l0)
: 0);
ps_mv = ps_layer_mvbank->ps_mv + i4_offset;
pi1_ref_idx = ps_layer_mvbank->pi1_ref_idx + i4_offset;
ps_mv_base = ps_mv;
pi1_ref_idx_base = pi1_ref_idx;
{
/* ps_mv and pi1_ref_idx now point to the top left locn */
ps_search_node = &as_left_neighbours[0];
ps_mv = ps_mv_base + mvs_in_row;
pi1_ref_idx = pi1_ref_idx_base + mvs_in_row;
i4_mv_pos_in_implicit_array =
hme_find_pos_of_implicitly_stored_ref_id(
pi1_ref_idx, i1_ref_idx, 0, i4_num_results_in_given_dir);
if(-1 != i4_mv_pos_in_implicit_array)
{
COPY_MV_TO_SEARCH_NODE(
ps_search_node,
&ps_mv[i4_mv_pos_in_implicit_array],
&pi1_ref_idx[i4_mv_pos_in_implicit_array],
i1_ref_idx,
shift);
}
else
{
ps_search_node->u1_is_avail = 0;
ps_search_node->s_mv.i2_mvx = 0;
ps_search_node->s_mv.i2_mvy = 0;
ps_search_node->i1_ref_idx = i1_ref_idx;
}
i4_num_srch_cands++;
}
}
}
*ps_candt_l = as_left_neighbours[0];
/* when 16x16 is searched in an encode layer, and the prev layer */
/* stores results for 4x4 blks, we project 5 candts corresponding */
/* to (2,2), (2,14), (14,2), 14,14) and 2nd best of (2,2) */
/* However in other cases, only 2,2 best and 2nd best reqd */
resultid = 0;
pf_hme_project_coloc_candt(
ps_candt_prj_coloc[0],
ps_curr_layer,
ps_coarse_layer,
pos_x + 2,
pos_y + 2,
i1_ref_idx,
resultid);
i4_num_srch_cands++;
resultid = 1;
if(num_results_prev_layer > 1)
{
pf_hme_project_coloc_candt(
ps_candt_prj_coloc[1],
ps_curr_layer,
ps_coarse_layer,
pos_x + 2,
pos_y + 2,
i1_ref_idx,
resultid);
i4_num_srch_cands++;
}
resultid = 0;
if(ME_MEDIUM_SPEED <= e_me_quality_presets)
{
pf_hme_project_coloc_candt(
ps_candt_prj_t[0],
ps_curr_layer,
ps_coarse_layer,
pos_x,
pos_y - prev_blk_offset,
i1_ref_idx,
resultid);
i4_num_srch_cands++;
}
{
pf_hme_project_coloc_candt(
ps_candt_prj_br[0],
ps_curr_layer,
ps_coarse_layer,
pos_x + next_blk_offset,
pos_y + next_blk_offset,
i1_ref_idx,
resultid);
pf_hme_project_coloc_candt(
ps_candt_prj_bl[0],
ps_curr_layer,
ps_coarse_layer,
pos_x - prev_blk_offset,
pos_y + next_blk_offset,
i1_ref_idx,
resultid);
pf_hme_project_coloc_candt(
ps_candt_prj_r[0],
ps_curr_layer,
ps_coarse_layer,
pos_x + next_blk_offset,
pos_y,
i1_ref_idx,
resultid);
pf_hme_project_coloc_candt(
ps_candt_prj_b[0],
ps_curr_layer,
ps_coarse_layer,
pos_x,
pos_y + next_blk_offset,
i1_ref_idx,
resultid);
i4_num_srch_cands += 4;
if(ME_MEDIUM_SPEED <= e_me_quality_presets)
{
pf_hme_project_coloc_candt(
ps_candt_prj_tr[0],
ps_curr_layer,
ps_coarse_layer,
pos_x + next_blk_offset,
pos_y - prev_blk_offset,
i1_ref_idx,
resultid);
pf_hme_project_coloc_candt(
ps_candt_prj_tl[0],
ps_curr_layer,
ps_coarse_layer,
pos_x - prev_blk_offset,
pos_y - prev_blk_offset,
i1_ref_idx,
resultid);
i4_num_srch_cands += 2;
}
}
if((num_results_prev_layer > 1) && (e_search_complexity >= SEARCH_CX_MED))
{
resultid = 1;
pf_hme_project_coloc_candt(
ps_candt_prj_br[1],
ps_curr_layer,
ps_coarse_layer,
pos_x + next_blk_offset,
pos_y + next_blk_offset,
i1_ref_idx,
resultid);
pf_hme_project_coloc_candt(
ps_candt_prj_bl[1],
ps_curr_layer,
ps_coarse_layer,
pos_x - prev_blk_offset,
pos_y + next_blk_offset,
i1_ref_idx,
resultid);
pf_hme_project_coloc_candt(
ps_candt_prj_r[1],
ps_curr_layer,
ps_coarse_layer,
pos_x + next_blk_offset,
pos_y,
i1_ref_idx,
resultid);
pf_hme_project_coloc_candt(
ps_candt_prj_b[1],
ps_curr_layer,
ps_coarse_layer,
pos_x,
pos_y + next_blk_offset,
i1_ref_idx,
resultid);
i4_num_srch_cands += 4;
pf_hme_project_coloc_candt(
ps_candt_prj_tr[1],
ps_curr_layer,
ps_coarse_layer,
pos_x + next_blk_offset,
pos_y - prev_blk_offset,
i1_ref_idx,
resultid);
pf_hme_project_coloc_candt(
ps_candt_prj_tl[1],
ps_curr_layer,
ps_coarse_layer,
pos_x - prev_blk_offset,
pos_y - prev_blk_offset,
i1_ref_idx,
resultid);
pf_hme_project_coloc_candt(
ps_candt_prj_t[1],
ps_curr_layer,
ps_coarse_layer,
pos_x,
pos_y - prev_blk_offset,
i1_ref_idx,
resultid);
i4_num_srch_cands += 3;
}
/* Note this block also clips the MV range for all candidates */
#ifdef _DEBUG
{
S32 candt;
range_prms_t *ps_range_prms;
S32 num_ref_valid = ps_ctxt->num_ref_future + ps_ctxt->num_ref_past;
for(candt = 0; candt < i4_num_srch_cands; candt++)
{
search_node_t *ps_search_node;
ps_search_node =
s_search_prms_blk.ps_search_candts[candt].ps_search_node;
ps_range_prms = s_search_prms_blk.aps_mv_range[0];
if((ps_search_node->i1_ref_idx >= num_ref_valid) ||
(ps_search_node->i1_ref_idx < 0))
{
ASSERT(0);
}
}
}
#endif
{
S32 srch_cand;
S32 num_unique_nodes = 0;
S32 num_nodes_searched = 0;
S32 num_best_cand = 0;
S08 i1_grid_enable = 0;
search_node_t as_best_two_proj_node[TOT_NUM_PARTS * 2];
/* has list of valid partition to search terminated by -1 */
S32 ai4_valid_part_ids[TOT_NUM_PARTS + 1];
S32 center_x;
S32 center_y;
/* indicates if the centre point of grid needs to be explicitly added for search */
S32 add_centre = 0;
memset(au4_unique_node_map, 0, sizeof(au4_unique_node_map));
center_x = ps_candt_prj_coloc[0]->s_mv.i2_mvx;
center_y = ps_candt_prj_coloc[0]->s_mv.i2_mvy;
for(srch_cand = 0;
(srch_cand < i4_num_srch_cands) &&
(num_unique_nodes <= s_search_prms_blk.i4_num_init_candts);
srch_cand++)
{
search_node_t s_search_node_temp =
s_search_prms_blk.ps_search_candts[srch_cand].ps_search_node[0];
s_search_node_temp.i1_ref_idx = i1_ref_idx; //TEMP FIX;
/* Clip the motion vectors as well here since after clipping
two candidates can become same and they will be removed during deduplication */
CLIP_MV_WITHIN_RANGE(
s_search_node_temp.s_mv.i2_mvx,
s_search_node_temp.s_mv.i2_mvy,
s_search_prms_blk.aps_mv_range[0],
ps_refine_prms->i4_num_steps_fpel_refine,
ps_refine_prms->i4_num_steps_hpel_refine,
ps_refine_prms->i4_num_steps_qpel_refine);
/* PT_C */
INSERT_NEW_NODE(
as_unique_search_nodes,
num_unique_nodes,
s_search_node_temp,
0,
au4_unique_node_map,
center_x,
center_y,
1);
num_nodes_searched += 1;
}
num_unique_nodes =
MIN(num_unique_nodes, s_search_prms_blk.i4_num_init_candts);
/* If number of candidates projected/number of candidates to be refined are more than 2,
then filter out and choose the best two here */
if(num_unique_nodes >= 2)
{
S32 num_results;
S32 cnt;
S32 *pi4_valid_part_ids;
s_search_prms_blk.ps_search_nodes = &as_unique_search_nodes[0];
s_search_prms_blk.i4_num_search_nodes = num_unique_nodes;
pi4_valid_part_ids = &ai4_valid_part_ids[0];
/* pi4_valid_part_ids is updated inside */
hme_pred_search_no_encode(
&s_search_prms_blk,
ps_curr_layer,
&ps_ctxt->s_wt_pred,
pi4_valid_part_ids,
1,
e_me_quality_presets,
i1_grid_enable,
(ihevce_me_optimised_function_list_t *)
ps_ctxt->pv_me_optimised_function_list
);
num_best_cand = 0;
cnt = 0;
num_results = ps_search_results->u1_num_results_per_part;
while((id = pi4_valid_part_ids[cnt++]) >= 0)
{
num_results =
MIN(ps_refine_prms->pu1_num_best_results[id], num_results);
for(i = 0; i < num_results; i++)
{
search_node_t s_search_node_temp;
s_search_node_temp =
*(ps_search_results->aps_part_results[i1_ref_idx][id] + i);
if(s_search_node_temp.i1_ref_idx >= 0)
{
INSERT_NEW_NODE_NOMAP(
as_best_two_proj_node,
num_best_cand,
s_search_node_temp,
0);
}
}
}
}
else
{
add_centre = 1;
num_best_cand = num_unique_nodes;
as_best_two_proj_node[0] = as_unique_search_nodes[0];
}
num_unique_nodes = 0;
num_nodes_searched = 0;
if(1 == num_best_cand)
{
search_node_t s_search_node_temp = as_best_two_proj_node[0];
S16 i2_mv_x = s_search_node_temp.s_mv.i2_mvx;
S16 i2_mv_y = s_search_node_temp.s_mv.i2_mvy;
S08 i1_ref_idx = s_search_node_temp.i1_ref_idx;
i1_grid_enable = 1;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvx = i2_mv_x - 1;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvy = i2_mv_y - 1;
as_unique_search_nodes[num_unique_nodes++].i1_ref_idx = i1_ref_idx;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvx = i2_mv_x;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvy = i2_mv_y - 1;
as_unique_search_nodes[num_unique_nodes++].i1_ref_idx = i1_ref_idx;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvx = i2_mv_x + 1;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvy = i2_mv_y - 1;
as_unique_search_nodes[num_unique_nodes++].i1_ref_idx = i1_ref_idx;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvx = i2_mv_x - 1;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvy = i2_mv_y;
as_unique_search_nodes[num_unique_nodes++].i1_ref_idx = i1_ref_idx;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvx = i2_mv_x + 1;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvy = i2_mv_y;
as_unique_search_nodes[num_unique_nodes++].i1_ref_idx = i1_ref_idx;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvx = i2_mv_x - 1;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvy = i2_mv_y + 1;
as_unique_search_nodes[num_unique_nodes++].i1_ref_idx = i1_ref_idx;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvx = i2_mv_x;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvy = i2_mv_y + 1;
as_unique_search_nodes[num_unique_nodes++].i1_ref_idx = i1_ref_idx;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvx = i2_mv_x + 1;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvy = i2_mv_y + 1;
as_unique_search_nodes[num_unique_nodes++].i1_ref_idx = i1_ref_idx;
if(add_centre)
{
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvx = i2_mv_x;
as_unique_search_nodes[num_unique_nodes].s_mv.i2_mvy = i2_mv_y;
as_unique_search_nodes[num_unique_nodes++].i1_ref_idx = i1_ref_idx;
}
}
else
{
/* For the candidates where refinement was required, choose the best two */
for(srch_cand = 0; srch_cand < num_best_cand; srch_cand++)
{
search_node_t s_search_node_temp = as_best_two_proj_node[srch_cand];
WORD32 mv_x = s_search_node_temp.s_mv.i2_mvx;
WORD32 mv_y = s_search_node_temp.s_mv.i2_mvy;
/* Because there may not be two best unique candidates (because of clipping),
second best candidate can be uninitialized, ignore that */
if(s_search_node_temp.s_mv.i2_mvx == INTRA_MV ||
s_search_node_temp.i1_ref_idx < 0)
{
num_nodes_searched++;
continue;
}
/* PT_C */
/* Since the center point has already be evaluated and best results are persistent,
it will not be evaluated again */
if(add_centre) /* centre point added explicitly again if search results is not updated */
{
INSERT_NEW_NODE(
as_unique_search_nodes,
num_unique_nodes,
s_search_node_temp,
0,
au4_unique_node_map,
center_x,
center_y,
1);
}
/* PT_L */
s_search_node_temp.s_mv.i2_mvx = mv_x - 1;
s_search_node_temp.s_mv.i2_mvy = mv_y;
INSERT_NEW_NODE(
as_unique_search_nodes,
num_unique_nodes,
s_search_node_temp,
0,
au4_unique_node_map,
center_x,
center_y,
1);
/* PT_T */
s_search_node_temp.s_mv.i2_mvx = mv_x;
s_search_node_temp.s_mv.i2_mvy = mv_y - 1;
INSERT_NEW_NODE(
as_unique_search_nodes,
num_unique_nodes,
s_search_node_temp,
0,
au4_unique_node_map,
center_x,
center_y,
1);
/* PT_R */
s_search_node_temp.s_mv.i2_mvx = mv_x + 1;
s_search_node_temp.s_mv.i2_mvy = mv_y;
INSERT_NEW_NODE(
as_unique_search_nodes,
num_unique_nodes,
s_search_node_temp,
0,
au4_unique_node_map,
center_x,
center_y,
1);
/* PT_B */
s_search_node_temp.s_mv.i2_mvx = mv_x;
s_search_node_temp.s_mv.i2_mvy = mv_y + 1;
INSERT_NEW_NODE(
as_unique_search_nodes,
num_unique_nodes,
s_search_node_temp,
0,
au4_unique_node_map,
center_x,
center_y,
1);
/* PT_TL */
s_search_node_temp.s_mv.i2_mvx = mv_x - 1;
s_search_node_temp.s_mv.i2_mvy = mv_y - 1;
INSERT_NEW_NODE(
as_unique_search_nodes,
num_unique_nodes,
s_search_node_temp,
0,
au4_unique_node_map,
center_x,
center_y,
1);
/* PT_TR */
s_search_node_temp.s_mv.i2_mvx = mv_x + 1;
s_search_node_temp.s_mv.i2_mvy = mv_y - 1;
INSERT_NEW_NODE(
as_unique_search_nodes,
num_unique_nodes,
s_search_node_temp,
0,
au4_unique_node_map,
center_x,
center_y,
1);
/* PT_BL */
s_search_node_temp.s_mv.i2_mvx = mv_x - 1;
s_search_node_temp.s_mv.i2_mvy = mv_y + 1;
INSERT_NEW_NODE(
as_unique_search_nodes,
num_unique_nodes,
s_search_node_temp,
0,
au4_unique_node_map,
center_x,
center_y,
1);
/* PT_BR */
s_search_node_temp.s_mv.i2_mvx = mv_x + 1;
s_search_node_temp.s_mv.i2_mvy = mv_y + 1;
INSERT_NEW_NODE(
as_unique_search_nodes,
num_unique_nodes,
s_search_node_temp,
0,
au4_unique_node_map,
center_x,
center_y,
1);
}
}
s_search_prms_blk.ps_search_nodes = &as_unique_search_nodes[0];
s_search_prms_blk.i4_num_search_nodes = num_unique_nodes;
/*****************************************************************/
/* Call the search algorithm, this includes: */
/* Pre-Search-Refinement (for coarse candts) */
/* Search on each candidate */
/* Post Search Refinement on winners/other new candidates */
/*****************************************************************/
hme_pred_search_no_encode(
&s_search_prms_blk,
ps_curr_layer,
&ps_ctxt->s_wt_pred,
ai4_valid_part_ids,
0,
e_me_quality_presets,
i1_grid_enable,
(ihevce_me_optimised_function_list_t *)
ps_ctxt->pv_me_optimised_function_list);
i1_grid_enable = 0;
}
}
/* for non encode layer update MV and end processing for block */
{
WORD32 i4_ref_id, min_cost = 0x7fffffff, min_sad = 0;
search_node_t *ps_search_node;
/* now update the reqd results back to the layer mv bank. */
if(1 == ps_refine_prms->i4_layer_id)
{
hme_update_mv_bank_in_l1_me(
ps_search_results,
ps_curr_layer->ps_layer_mvbank,
blk_x,
blk_y,
&s_mv_update_prms);
}
else
{
hme_update_mv_bank_noencode(
ps_search_results,
ps_curr_layer->ps_layer_mvbank,
blk_x,
blk_y,
&s_mv_update_prms);
}
/* UPDATE the MIN and MAX MVs for Dynamical Search Range for each ref. pic. */
/* Only for P pic. For P, both are 0, I&B has them mut. exclusive */
if(ps_ctxt->s_frm_prms.is_i_pic == ps_ctxt->s_frm_prms.bidir_enabled)
{
WORD32 i4_j;
layer_mv_t *ps_layer_mv = ps_curr_layer->ps_layer_mvbank;
//if (ps_layer_mv->e_blk_size == s_mv_update_prms.e_search_blk_size)
/* Not considering this for Dyn. Search Update */
{
for(i4_ref_id = 0; i4_ref_id < (S32)s_mv_update_prms.i4_num_ref;
i4_ref_id++)
{
ps_search_node =
ps_search_results->aps_part_results[i4_ref_id][PART_ID_2Nx2N];
for(i4_j = 0; i4_j < ps_layer_mv->i4_num_mvs_per_ref; i4_j++)
{
hme_update_dynamic_search_params(
&ps_ctxt->s_coarse_dyn_range_prms
.as_dyn_range_prms[ps_refine_prms->i4_layer_id]
[i4_ref_id],
ps_search_node->s_mv.i2_mvy);
ps_search_node++;
}
}
}
}
if(1 == ps_refine_prms->i4_layer_id)
{
WORD32 wt_pred_val, log_wt_pred_val;
WORD32 ref_id_of_nearest_poc = 0;
WORD32 max_val = 0x7fffffff;
WORD32 max_l0_val = 0x7fffffff;
WORD32 max_l1_val = 0x7fffffff;
WORD32 cur_val;
WORD32 i4_local_weighted_sad, i4_local_cost_weighted_pred;
WORD32 bestl0_sad = 0x7fffffff;
WORD32 bestl1_sad = 0x7fffffff;
search_node_t *ps_best_l0_blk = NULL, *ps_best_l1_blk = NULL;
for(i4_ref_id = 0; i4_ref_id < (S32)s_mv_update_prms.i4_num_ref;
i4_ref_id++)
{
wt_pred_val = ps_ctxt->s_wt_pred.a_wpred_wt[i4_ref_id];
log_wt_pred_val = ps_ctxt->s_wt_pred.wpred_log_wdc;
ps_search_node =
ps_search_results->aps_part_results[i4_ref_id][PART_ID_2Nx2N];
i4_local_weighted_sad = ((ps_search_node->i4_sad * wt_pred_val) +
((1 << log_wt_pred_val) >> 1)) >>
log_wt_pred_val;
i4_local_cost_weighted_pred =
i4_local_weighted_sad +
(ps_search_node->i4_tot_cost - ps_search_node->i4_sad);
//the loop is redundant as the results are already sorted based on total cost
//for (i4_j = 0; i4_j < ps_curr_layer->ps_layer_mvbank->i4_num_mvs_per_ref; i4_j++)
{
if(i4_local_cost_weighted_pred < min_cost)
{
min_cost = i4_local_cost_weighted_pred;
min_sad = i4_local_weighted_sad;
}
}
/* For P frame, calculate the nearest poc which is either P or I frame*/
if(ps_ctxt->s_frm_prms.is_i_pic == ps_ctxt->s_frm_prms.bidir_enabled)
{
if(-1 != ps_coarse_layer->ai4_ref_id_to_poc_lc[i4_ref_id])
{
cur_val =
ABS(ps_ctxt->i4_curr_poc -
ps_coarse_layer->ai4_ref_id_to_poc_lc[i4_ref_id]);
if(cur_val < max_val)
{
max_val = cur_val;
ref_id_of_nearest_poc = i4_ref_id;
}
}
}
}
/*Store me cost wrt. to past frame only for P frame */
if(ps_ctxt->s_frm_prms.is_i_pic == ps_ctxt->s_frm_prms.bidir_enabled)
{
if(-1 != ps_coarse_layer->ai4_ref_id_to_poc_lc[ref_id_of_nearest_poc])
{
WORD16 i2_mvx, i2_mvy;
WORD32 i4_diff_col_ctr = blk_x - (i4_ctb_blk_ctr * 4);
WORD32 i4_diff_row_ctr = blk_y - (i4_ctb_row_ctr * 4);
WORD32 z_scan_idx =
gau1_raster_scan_to_ctb[i4_diff_row_ctr][i4_diff_col_ctr];
WORD32 wt, log_wt;
/*ASSERT((ps_ctxt->i4_curr_poc - ps_coarse_layer->ai4_ref_id_to_poc_lc[ref_id_of_nearest_poc])
<= (1 + ps_ctxt->num_b_frms));*/
/*obtain mvx and mvy */
i2_mvx =
ps_search_results
->aps_part_results[ref_id_of_nearest_poc][PART_ID_2Nx2N]
->s_mv.i2_mvx;
i2_mvy =
ps_search_results
->aps_part_results[ref_id_of_nearest_poc][PART_ID_2Nx2N]
->s_mv.i2_mvy;
/*register the min cost for l1 me in blk context */
wt = ps_ctxt->s_wt_pred.a_wpred_wt[ref_id_of_nearest_poc];
log_wt = ps_ctxt->s_wt_pred.wpred_log_wdc;
/*register the min cost for l1 me in blk context */
ps_ed_ctb_l1_curr->i4_sad_me_for_ref[z_scan_idx >> 2] =
((ps_search_results
->aps_part_results[ref_id_of_nearest_poc][PART_ID_2Nx2N]
->i4_sad *
wt) +
((1 << log_wt) >> 1)) >>
log_wt;
ps_ed_ctb_l1_curr->i4_sad_cost_me_for_ref[z_scan_idx >> 2] =
ps_ed_ctb_l1_curr->i4_sad_me_for_ref[z_scan_idx >> 2] +
(ps_search_results
->aps_part_results[ref_id_of_nearest_poc][PART_ID_2Nx2N]
->i4_tot_cost -
ps_search_results
->aps_part_results[ref_id_of_nearest_poc][PART_ID_2Nx2N]
->i4_sad);
/*for complexity change detection*/
ps_ctxt->i4_num_blks++;
if(ps_ed_ctb_l1_curr->i4_sad_cost_me_for_ref[z_scan_idx >> 2] >
(8 /*blk width*/ * 8 /*blk height*/ * (1 + ps_ctxt->num_b_frms)))
{
ps_ctxt->i4_num_blks_high_sad++;
}
}
}
}
/* EIID: Early inter intra decisions */
/* tap L1 level SAD for inter intra decisions */
if((e_me_quality_presets >= ME_MEDIUM_SPEED) &&
(!ps_ctxt->s_frm_prms
.is_i_pic)) //for high-quality preset->disable early decisions
{
if(1 == ps_refine_prms->i4_layer_id)
{
WORD32 i4_min_sad_cost_8x8_block = min_cost;
ihevce_ed_blk_t *ps_curr_ed_blk_ctxt;
WORD32 i4_diff_col_ctr = blk_x - (i4_ctb_blk_ctr * 4);
WORD32 i4_diff_row_ctr = blk_y - (i4_ctb_row_ctr * 4);
WORD32 z_scan_idx =
gau1_raster_scan_to_ctb[i4_diff_row_ctr][i4_diff_col_ctr];
ps_curr_ed_blk_ctxt = ps_ed_blk_ctxt_curr_ctb + z_scan_idx;
/*register the min cost for l1 me in blk context */
ps_ed_ctb_l1_curr->i4_best_sad_cost_8x8_l1_me[z_scan_idx >> 2] =
i4_min_sad_cost_8x8_block;
i4_num_comparisions++;
/* take early inter-intra decision here */
ps_curr_ed_blk_ctxt->intra_or_inter = 3; /*init saying eval both */
#if DISABLE_INTRA_IN_BPICS
if((e_me_quality_presets == ME_XTREME_SPEED_25) &&
(ps_ctxt->s_frm_prms.i4_temporal_layer_id > TEMPORAL_LAYER_DISABLE))
{
ps_curr_ed_blk_ctxt->intra_or_inter =
2; /*eval only inter if inter cost is less */
i4_num_inter_wins++;
}
else
#endif
{
if(ps_ed_ctb_l1_curr->i4_best_sad_cost_8x8_l1_me[z_scan_idx >> 2] <
((ps_ed_ctb_l1_curr->i4_best_sad_cost_8x8_l1_ipe[z_scan_idx >> 2] *
i4_threshold_multiplier) /
i4_threshold_divider))
{
ps_curr_ed_blk_ctxt->intra_or_inter =
2; /*eval only inter if inter cost is less */
i4_num_inter_wins++;
}
}
//{
// DBG_PRINTF ("(blk x, blk y):(%d, %d)\t me:(ctb_x, ctb_y):(%d, %d)\t intra_SAD_COST: %d\tInter_SAD_COST: %d\n",
// blk_x,blk_y,
// i4_ctb_blk_ctr, i4_ctb_row_ctr,
// ps_curr_ed_blk_ctxt->i4_best_sad_8x8_l1_ipe,
// i4_min_sad_cost_8x8_block
// );
//}
} //end of layer-1
} //end of if (e_me_quality_presets >= ME_MEDIUM_SPEED)
else
{
if(1 == ps_refine_prms->i4_layer_id)
{
WORD32 i4_min_sad_cost_8x8_block = min_cost;
WORD32 i4_diff_col_ctr = blk_x - (i4_ctb_blk_ctr * 4);
WORD32 i4_diff_row_ctr = blk_y - (i4_ctb_row_ctr * 4);
WORD32 z_scan_idx =
gau1_raster_scan_to_ctb[i4_diff_row_ctr][i4_diff_col_ctr];
/*register the min cost for l1 me in blk context */
ps_ed_ctb_l1_curr->i4_best_sad_cost_8x8_l1_me[z_scan_idx >> 2] =
i4_min_sad_cost_8x8_block;
}
}
if(1 == ps_refine_prms->i4_layer_id)
{
WORD32 i4_diff_col_ctr = blk_x - (i4_ctb_blk_ctr * 4);
WORD32 i4_diff_row_ctr = blk_y - (i4_ctb_row_ctr * 4);
WORD32 z_scan_idx =
gau1_raster_scan_to_ctb[i4_diff_row_ctr][i4_diff_col_ctr];
ps_ed_ctb_l1_curr->i4_best_sad_8x8_l1_me_for_decide[z_scan_idx >> 2] =
min_sad;
if(min_cost <
ps_ed_ctb_l1_curr->i4_best_sad_cost_8x8_l1_ipe[z_scan_idx >> 2])
{
ps_ctxt->i4_L1_hme_best_cost += min_cost;
ps_ctxt->i4_L1_hme_sad += min_sad;
ps_ed_ctb_l1_curr->i4_best_sad_8x8_l1_me[z_scan_idx >> 2] = min_sad;
}
else
{
ps_ctxt->i4_L1_hme_best_cost +=
ps_ed_ctb_l1_curr->i4_best_sad_cost_8x8_l1_ipe[z_scan_idx >> 2];
ps_ctxt->i4_L1_hme_sad +=
ps_ed_ctb_l1_curr->i4_best_sad_8x8_l1_ipe[z_scan_idx >> 2];
ps_ed_ctb_l1_curr->i4_best_sad_8x8_l1_me[z_scan_idx >> 2] =
ps_ed_ctb_l1_curr->i4_best_sad_8x8_l1_ipe[z_scan_idx >> 2];
}
}
}
}
/* Update the number of blocks processed in the current row */
if((ME_MEDIUM_SPEED > e_me_quality_presets))
{
ihevce_dmgr_set_row_row_sync(
pv_hme_dep_mngr,
(i4_ctb_x + 1),
blk_y,
0 /* Col Tile No. : Not supported in PreEnc*/);
}
}
/* set the output dependency after completion of row */
ihevce_pre_enc_grp_job_set_out_dep(ps_multi_thrd_ctxt, ps_job, i4_ping_pong);
}
}
Reference in New Issue View Git Blame Copy Permalink