/******************************************************************************
*
* 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_coarse.c
*
* @brief
* Contains ME algorithm for the coarse layer.
*
* @author
* Ittiam
*
*
* List of Functions
* hme_update_mv_bank_coarse()
* hme_coarse()
******************************************************************************
*/
/*****************************************************************************/
/* 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_refine.h"
#include "hme_err_compute.h"
#include "hme_common_utils.h"
#include "hme_search_algo.h"
/*******************************************************************************
* MACROS
*******************************************************************************/
#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; \
}
/*****************************************************************************/
/* Function Definitions */
/*****************************************************************************/
/**
********************************************************************************
* @fn void hme_update_mv_bank_coarse(search_results_t *ps_search_results,
* layer_mv_t *ps_layer_mv,
* S32 i4_blk_x,
* S32 i4_blk_y,
* search_node_t *ps_search_node_4x8_l,
* search_node_t *ps_search_node_8x4_t,
* S08 i1_ref_idx,
* mvbank_update_prms_t *ps_prms
*
* @brief Updates the coarse layer MV Bank for a given ref id and blk pos
*
* @param[in] ps_search_results: Search results data structure
*
* @param[in, out] ps_layer_mv : MV Bank for this layer
*
* @param[in] i4_search_blk_x: column number of the 4x4 blk searched
*
* @param[in] i4_search_blk_y: row number of the 4x4 blk searched
*
* @param[in] ps_search_node_4x8_t: Best MV of the 4x8T blk
*
* @param[in] ps_search_node_8x4_l: Best MV of the 8x4L blk
*
* @param[in] i1_ref_idx : Reference ID that has been searched
*
* @param[in] ps_prms : Parameters pertaining to the MV Bank update
*
* @return None
********************************************************************************
*/
void hme_update_mv_bank_coarse(
search_results_t *ps_search_results,
layer_mv_t *ps_layer_mv,
S32 i4_search_blk_x,
S32 i4_search_blk_y,
search_node_t *ps_search_node_4x8_t,
search_node_t *ps_search_node_8x4_l,
S08 i1_ref_idx,
mvbank_update_prms_t *ps_prms)
{
/* These point to the MV and ref idx posn to be udpated */
hme_mv_t *ps_mv;
S08 *pi1_ref_idx;
/* Offset within the bank */
S32 i4_offset;
S32 i, j, i4_blk_x, i4_blk_y;
/* Best results for 8x4R and 4x8B blocks */
search_node_t *ps_search_node_8x4_r, *ps_search_node_4x8_b;
/* Number of MVs in a block */
S32 num_mvs = ps_layer_mv->i4_num_mvs_per_ref;
search_node_t *aps_search_nodes[4];
/* The search blk may be different in size from the blk used to hold MV */
i4_blk_x = i4_search_blk_x << ps_prms->i4_shift;
i4_blk_y = i4_search_blk_y << ps_prms->i4_shift;
/* Compute the offset in the MV bank */
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 + (num_mvs * i1_ref_idx));
pi1_ref_idx = ps_layer_mv->pi1_ref_idx + (i4_offset + (num_mvs * i1_ref_idx));
/*************************************************************************/
/* We have atleast 4 distinct results: the 4x8 top (coming from top blk) */
/* 8x4 left (coming from left blk), 8x4 and 4x8 right and bot resp. */
/* If number of results to be stored is 4, then we store all these 4 */
/* results, else we pick best ones */
/*************************************************************************/
ps_search_node_8x4_r = ps_search_results->aps_part_results[i1_ref_idx][PART_ID_2NxN_B];
ps_search_node_4x8_b = ps_search_results->aps_part_results[i1_ref_idx][PART_ID_Nx2N_R];
ASSERT(num_mvs <= 4);
/* Doing this to sort best results */
aps_search_nodes[0] = ps_search_node_8x4_r;
aps_search_nodes[1] = ps_search_node_4x8_b;
aps_search_nodes[2] = ps_search_node_8x4_l;
aps_search_nodes[3] = ps_search_node_4x8_t;
if(num_mvs == 4)
{
COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, aps_search_nodes[0], 0);
ps_mv++;
pi1_ref_idx++;
COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, aps_search_nodes[1], 0);
ps_mv++;
pi1_ref_idx++;
COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, aps_search_nodes[2], 0);
ps_mv++;
pi1_ref_idx++;
COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, aps_search_nodes[3], 0);
ps_mv++;
pi1_ref_idx++;
return;
}
/* Run through the results, store them in best to worst order */
for(i = 0; i < num_mvs; i++)
{
for(j = i + 1; j < 4; j++)
{
if(aps_search_nodes[j]->i4_tot_cost < aps_search_nodes[i]->i4_tot_cost)
{
SWAP_HME(aps_search_nodes[j], aps_search_nodes[i], search_node_t *);
}
}
COPY_SEARCH_RESULT(ps_mv, pi1_ref_idx, aps_search_nodes[i], 0);
ps_mv++;
pi1_ref_idx++;
}
}
/**
********************************************************************************
* @fn void hme_coarse_frm_init(me_ctxt_t *ps_ctxt, coarse_prms_t *ps_coarse_prms)
*
* @brief Frame init entry point Coarse ME.
*
* @param[in,out] ps_ctxt: ME Handle
*
* @param[in] ps_coarse_prms : Coarse layer config params
*
* @return None
********************************************************************************
*/
void hme_coarse_frm_init(coarse_me_ctxt_t *ps_ctxt, coarse_prms_t *ps_coarse_prms)
{
layer_ctxt_t *ps_curr_layer;
S32 i4_pic_wd, i4_pic_ht;
S32 num_blks_in_pic, num_blks_in_row;
BLK_SIZE_T e_search_blk_size = BLK_4x4;
S32 blk_size_shift = 2, blk_wd = 4, blk_ht = 4;
/* Number of references to search */
S32 i4_num_ref;
ps_curr_layer = ps_ctxt->ps_curr_descr->aps_layers[ps_coarse_prms->i4_layer_id];
i4_num_ref = ps_coarse_prms->i4_num_ref;
i4_pic_wd = ps_curr_layer->i4_wd;
i4_pic_ht = ps_curr_layer->i4_ht;
/* Macro updates num_blks_in_pic and num_blks_in_row*/
GET_NUM_BLKS_IN_PIC(i4_pic_wd, i4_pic_ht, blk_size_shift, num_blks_in_row, num_blks_in_pic);
/************************************************************************/
/* Initialize the mv bank that holds results of this layer. */
/************************************************************************/
hme_init_mv_bank(
ps_curr_layer,
BLK_4x4,
i4_num_ref,
ps_coarse_prms->num_results,
ps_ctxt->u1_encode[ps_coarse_prms->i4_layer_id]);
return;
}
/**
********************************************************************************
* @fn void hme_derive_worst_case_search_range(range_prms_t *ps_range,
* range_prms_t *ps_pic_limit,
* range_prms_t *ps_mv_limit,
* S32 i4_x,
* S32 i4_y,
* S32 blk_wd,
* S32 blk_ht)
*
* @brief given picture limits and blk dimensions and mv search limits, obtains
* teh valid search range such that the blk stays within pic boundaries,
* where picture boundaries include padded portions of picture
*
* @param[out] ps_range: updated with actual search range
*
* @param[in] ps_pic_limit : picture boundaries
*
* @param[in] ps_mv_limit: Search range limits for the mvs
*
* @param[in] i4_x : x coordinate of the blk
*
* @param[in] i4_y : y coordinate of the blk
*
* @param[in] blk_wd : blk width
*
* @param[in] blk_ht : blk height
*
* @return void
********************************************************************************
*/
void hme_derive_worst_case_search_range(
range_prms_t *ps_range,
range_prms_t *ps_pic_limit,
range_prms_t *ps_mv_limit,
S32 i4_x,
S32 i4_y,
S32 blk_wd,
S32 blk_ht)
{
/* Taking max x of left block, min x of current block */
ps_range->i2_max_x =
MIN((ps_pic_limit->i2_max_x - (S16)blk_wd - (S16)(i4_x - 4)), ps_mv_limit->i2_max_x);
ps_range->i2_min_x = MAX((ps_pic_limit->i2_min_x - (S16)i4_x), ps_mv_limit->i2_min_x);
/* Taking max y of top block, min y of current block */
ps_range->i2_max_y =
MIN((ps_pic_limit->i2_max_y - (S16)blk_ht - (S16)(i4_y - 4)), ps_mv_limit->i2_max_y);
ps_range->i2_min_y = MAX((ps_pic_limit->i2_min_y - (S16)i4_y), ps_mv_limit->i2_min_y);
}
/**
********************************************************************************
* @fn void hme_combine_4x4_sads_and_compute_cost(S08 i1_ref_idx,
* range_prms_t *ps_mv_range,
* range_prms_t *ps_mv_limit,
* hme_mv_t *ps_best_mv_4x8,
* hme_mv_t *ps_best_mv_8x4,
* pred_ctxt_t *ps_pred_ctxt,
* PF_MV_COST_FXN pf_mv_cost_compute,
* ME_QUALITY_PRESETS_T e_me_quality_preset,
* S16 *pi2_sads_4x4_current,
* S16 *pi2_sads_4x4_east,
* S16 *pi2_sads_4x4_south,
* FILE *fp_dump_sad)
*
* @brief Does a full search on entire srch window with a given step size in coarse layer
*
* @param[in] i1_ref_idx : Cur ref idx
*
* @param[in] ps_layer_ctxt: All info about this layer
*
* @param[out] ps_best_mv : type hme_mv_t contains best mv x and y
*
* @param[in] ps_pred_ctxt : Prediction ctxt for cost computation
*
* @param[in] pf_mv_cost_compute : mv cost computation function
*
* @return void
********************************************************************************
*/
void hme_combine_4x4_sads_and_compute_cost_high_quality(
S08 i1_ref_idx,
range_prms_t *ps_mv_range,
range_prms_t *ps_mv_limit,
hme_mv_t *ps_best_mv_4x8,
hme_mv_t *ps_best_mv_8x4,
pred_ctxt_t *ps_pred_ctxt,
PF_MV_COST_FXN pf_mv_cost_compute,
S16 *pi2_sads_4x4_current,
S16 *pi2_sads_4x4_east,
S16 *pi2_sads_4x4_south)
{
/* These control number of parts and number of pts in grid to search */
S32 stepy, stepx, best_mv_y_4x8, best_mv_x_4x8, best_mv_y_8x4, best_mv_x_8x4;
S32 step_shift_x, step_shift_y;
S32 mvx, mvy, mv_x_offset, mv_y_offset, mv_x_range, mv_y_range;
S32 min_cost_4x8 = MAX_32BIT_VAL;
S32 min_cost_8x4 = MAX_32BIT_VAL;
search_node_t s_search_node;
s_search_node.i1_ref_idx = i1_ref_idx;
stepx = stepy = HME_COARSE_STEP_SIZE_HIGH_QUALITY;
/*TODO: Calculate Step shift from the #define HME_COARSE_STEP_SIZE_HIGH_QUALITY */
step_shift_x = step_shift_y = 1;
mv_x_offset = (-ps_mv_limit->i2_min_x >> step_shift_x);
mv_y_offset = (-ps_mv_limit->i2_min_y >> step_shift_y);
mv_x_range = (-ps_mv_limit->i2_min_x + ps_mv_limit->i2_max_x) >> step_shift_x;
mv_y_range = (-ps_mv_limit->i2_min_y + ps_mv_limit->i2_max_y) >> step_shift_y;
/* Run 2loops to sweep over the reference area */
for(mvy = ps_mv_range->i2_min_y; mvy < ps_mv_range->i2_max_y; mvy += stepy)
{
for(mvx = ps_mv_range->i2_min_x; mvx < ps_mv_range->i2_max_x; mvx += stepx)
{
S32 sad_4x8, cost_4x8, sad_8x4, cost_8x4;
S32 sad_pos = ((mvx >> step_shift_x) + mv_x_offset) +
((mvy >> step_shift_y) + mv_y_offset) * mv_x_range;
/* Get SAD by adding SAD for current and neighbour S */
sad_4x8 = pi2_sads_4x4_current[sad_pos] + pi2_sads_4x4_south[sad_pos];
sad_8x4 = pi2_sads_4x4_current[sad_pos] + pi2_sads_4x4_east[sad_pos];
// fprintf(fp_dump_sad,"%d\t",sad);
s_search_node.s_mv.i2_mvx = mvx;
s_search_node.s_mv.i2_mvy = mvy;
cost_4x8 = cost_8x4 =
pf_mv_cost_compute(&s_search_node, ps_pred_ctxt, PART_ID_2Nx2N, MV_RES_FPEL);
cost_4x8 += sad_4x8;
cost_8x4 += sad_8x4;
if(cost_4x8 < min_cost_4x8)
{
best_mv_x_4x8 = mvx;
best_mv_y_4x8 = mvy;
min_cost_4x8 = cost_4x8;
}
if(cost_8x4 < min_cost_8x4)
{
best_mv_x_8x4 = mvx;
best_mv_y_8x4 = mvy;
min_cost_8x4 = cost_8x4;
}
}
}
ps_best_mv_4x8->i2_mv_x = best_mv_x_4x8;
ps_best_mv_4x8->i2_mv_y = best_mv_y_4x8;
ps_best_mv_8x4->i2_mv_x = best_mv_x_8x4;
ps_best_mv_8x4->i2_mv_y = best_mv_y_8x4;
}
void hme_combine_4x4_sads_and_compute_cost_high_speed(
S08 i1_ref_idx,
range_prms_t *ps_mv_range,
range_prms_t *ps_mv_limit,
hme_mv_t *ps_best_mv_4x8,
hme_mv_t *ps_best_mv_8x4,
pred_ctxt_t *ps_pred_ctxt,
PF_MV_COST_FXN pf_mv_cost_compute,
S16 *pi2_sads_4x4_current,
S16 *pi2_sads_4x4_east,
S16 *pi2_sads_4x4_south)
{
/* These control number of parts and number of pts in grid to search */
S32 stepy, stepx, best_mv_y_4x8, best_mv_x_4x8, best_mv_y_8x4, best_mv_x_8x4;
S32 step_shift_x, step_shift_y;
S32 mvx, mvy, mv_x_offset, mv_y_offset, mv_x_range, mv_y_range;
S32 rnd, lambda, lambda_q_shift;
S32 min_cost_4x8 = MAX_32BIT_VAL;
S32 min_cost_8x4 = MAX_32BIT_VAL;
(void)pf_mv_cost_compute;
stepx = stepy = HME_COARSE_STEP_SIZE_HIGH_SPEED;
/*TODO: Calculate Step shift from the #define HME_COARSE_STEP_SIZE_HIGH_SPEED */
step_shift_x = step_shift_y = 2;
mv_x_offset = (-ps_mv_limit->i2_min_x >> step_shift_x);
mv_y_offset = (-ps_mv_limit->i2_min_y >> step_shift_y);
mv_x_range = (-ps_mv_limit->i2_min_x + ps_mv_limit->i2_max_x) >> step_shift_x;
mv_y_range = (-ps_mv_limit->i2_min_y + ps_mv_limit->i2_max_y) >> step_shift_y;
lambda = ps_pred_ctxt->lambda;
lambda_q_shift = ps_pred_ctxt->lambda_q_shift;
rnd = 1 << (lambda_q_shift - 1);
ASSERT(MAX_MVX_SUPPORTED_IN_COARSE_LAYER >= ABS(ps_mv_range->i2_max_x));
ASSERT(MAX_MVY_SUPPORTED_IN_COARSE_LAYER >= ABS(ps_mv_range->i2_max_y));
/* Run 2loops to sweep over the reference area */
for(mvy = ps_mv_range->i2_min_y; mvy < ps_mv_range->i2_max_y; mvy += stepy)
{
for(mvx = ps_mv_range->i2_min_x; mvx < ps_mv_range->i2_max_x; mvx += stepx)
{
S32 sad_4x8, cost_4x8, sad_8x4, cost_8x4;
S32 sad_pos = ((mvx >> step_shift_x) + mv_x_offset) +
((mvy >> step_shift_y) + mv_y_offset) * mv_x_range;
/* Get SAD by adding SAD for current and neighbour S */
sad_4x8 = pi2_sads_4x4_current[sad_pos] + pi2_sads_4x4_south[sad_pos];
sad_8x4 = pi2_sads_4x4_current[sad_pos] + pi2_sads_4x4_east[sad_pos];
// fprintf(fp_dump_sad,"%d\t",sad);
cost_4x8 = cost_8x4 =
(2 * hme_get_range(ABS(mvx)) - 1) + (2 * hme_get_range(ABS(mvy)) - 1) + i1_ref_idx;
cost_4x8 += (mvx != 0) ? 1 : 0;
cost_4x8 += (mvy != 0) ? 1 : 0;
cost_4x8 = (cost_4x8 * lambda + rnd) >> lambda_q_shift;
cost_8x4 += (mvx != 0) ? 1 : 0;
cost_8x4 += (mvy != 0) ? 1 : 0;
cost_8x4 = (cost_8x4 * lambda + rnd) >> lambda_q_shift;
cost_4x8 += sad_4x8;
cost_8x4 += sad_8x4;
if(cost_4x8 < min_cost_4x8)
{
best_mv_x_4x8 = mvx;
best_mv_y_4x8 = mvy;
min_cost_4x8 = cost_4x8;
}
if(cost_8x4 < min_cost_8x4)
{
best_mv_x_8x4 = mvx;
best_mv_y_8x4 = mvy;
min_cost_8x4 = cost_8x4;
}
}
}
ps_best_mv_4x8->i2_mv_x = best_mv_x_4x8;
ps_best_mv_4x8->i2_mv_y = best_mv_y_4x8;
ps_best_mv_8x4->i2_mv_x = best_mv_x_8x4;
ps_best_mv_8x4->i2_mv_y = best_mv_y_8x4;
}
/**
********************************************************************************
* @fn hme_store_4x4_sads(hme_search_prms_t *ps_search_prms,
* layer_ctxt_t *ps_layer_ctxt)
*
* @brief Does a 4x4 sad computation on a given range and stores it in memory
*
* @param[in] ps_search_prms : Search prms structure containing info like
* blk dimensions, search range etc
*
* @param[in] ps_layer_ctxt: All info about this layer
*
* @param[in] ps_wt_inp_prms: All info about weighted input
*
* @param[in] e_me_quality_preset: motion estimation quality preset
*
* @param[in] pi2_sads_4x4: Memory to store all 4x4 SADs for given range
*
* @return void
********************************************************************************
*/
void hme_store_4x4_sads_high_quality(
hme_search_prms_t *ps_search_prms,
layer_ctxt_t *ps_layer_ctxt,
range_prms_t *ps_mv_limit,
wgt_pred_ctxt_t *ps_wt_inp_prms,
S16 *pi2_sads_4x4)
{
S32 sad, i, j;
/* Input and reference attributes */
U08 *pu1_inp, *pu1_inp_orig, *pu1_ref;
S32 i4_inp_stride, i4_ref_stride, i4_ref_offset;
/* The reference is actually an array of ptrs since there are several */
/* reference id. So an array gets passed form calling function */
U08 **ppu1_ref, *pu1_ref_coloc;
S32 stepy, stepx, step_shift_x, step_shift_y;
S32 mvx, mvy, mv_x_offset, mv_y_offset, mv_x_range, mv_y_range;
/* Points to the range limits for mv */
range_prms_t *ps_range_prms;
/* Reference index to be searched */
S32 i4_search_idx = ps_search_prms->i1_ref_idx;
/* Using the member 0 to store for all ref. idx. */
ps_range_prms = ps_search_prms->aps_mv_range[0];
pu1_inp_orig = ps_wt_inp_prms->apu1_wt_inp[i4_search_idx];
i4_inp_stride = ps_search_prms->i4_inp_stride;
/* Move to the location of the search blk in inp buffer */
pu1_inp_orig += ps_search_prms->i4_cu_x_off;
pu1_inp_orig += ps_search_prms->i4_cu_y_off * i4_inp_stride;
/*************************************************************************/
/* we use either input of previously encoded pictures as reference */
/* in coarse layer */
/*************************************************************************/
i4_ref_stride = ps_layer_ctxt->i4_inp_stride;
ppu1_ref = ps_layer_ctxt->ppu1_list_inp;
/* colocated position in reference picture */
i4_ref_offset = (i4_ref_stride * ps_search_prms->i4_y_off) + ps_search_prms->i4_x_off;
pu1_ref_coloc = ppu1_ref[i4_search_idx] + i4_ref_offset;
stepx = stepy = HME_COARSE_STEP_SIZE_HIGH_QUALITY;
/*TODO: Calculate Step shift from the #define HME_COARSE_STEP_SIZE_HIGH_QUALITY */
step_shift_x = step_shift_y = 1;
mv_x_offset = -(ps_mv_limit->i2_min_x >> step_shift_x);
mv_y_offset = -(ps_mv_limit->i2_min_y >> step_shift_y);
mv_x_range = (-ps_mv_limit->i2_min_x + ps_mv_limit->i2_max_x) >> step_shift_x;
mv_y_range = (-ps_mv_limit->i2_min_y + ps_mv_limit->i2_max_y) >> step_shift_y;
/* Run 2loops to sweep over the reference area */
for(mvy = ps_range_prms->i2_min_y; mvy < ps_range_prms->i2_max_y; mvy += stepy)
{
for(mvx = ps_range_prms->i2_min_x; mvx < ps_range_prms->i2_max_x; mvx += stepx)
{
/* Set up the reference and inp ptr */
pu1_ref = pu1_ref_coloc + mvx + (mvy * i4_ref_stride);
pu1_inp = pu1_inp_orig;
/* SAD computation */
{
sad = 0;
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
sad += (ABS(((S32)pu1_inp[j] - (S32)pu1_ref[j])));
}
pu1_inp += i4_inp_stride;
pu1_ref += i4_ref_stride;
}
}
pi2_sads_4x4
[((mvx >> step_shift_x) + mv_x_offset) +
((mvy >> step_shift_y) + mv_y_offset) * mv_x_range] = sad;
}
}
}
void hme_store_4x4_sads_high_speed(
hme_search_prms_t *ps_search_prms,
layer_ctxt_t *ps_layer_ctxt,
range_prms_t *ps_mv_limit,
wgt_pred_ctxt_t *ps_wt_inp_prms,
S16 *pi2_sads_4x4)
{
S32 sad, i, j;
/* Input and reference attributes */
U08 *pu1_inp, *pu1_inp_orig, *pu1_ref;
S32 i4_inp_stride, i4_ref_stride, i4_ref_offset;
/* The reference is actually an array of ptrs since there are several */
/* reference id. So an array gets passed form calling function */
U08 **ppu1_ref, *pu1_ref_coloc;
S32 stepy, stepx, step_shift_x, step_shift_y;
S32 mvx, mvy, mv_x_offset, mv_y_offset, mv_x_range, mv_y_range;
/* Points to the range limits for mv */
range_prms_t *ps_range_prms;
/* Reference index to be searched */
S32 i4_search_idx = ps_search_prms->i1_ref_idx;
/* Using the member 0 for all ref. idx */
ps_range_prms = ps_search_prms->aps_mv_range[0];
pu1_inp_orig = ps_wt_inp_prms->apu1_wt_inp[i4_search_idx];
i4_inp_stride = ps_search_prms->i4_inp_stride;
/* Move to the location of the search blk in inp buffer */
pu1_inp_orig += ps_search_prms->i4_cu_x_off;
pu1_inp_orig += ps_search_prms->i4_cu_y_off * i4_inp_stride;
/*************************************************************************/
/* we use either input of previously encoded pictures as reference */
/* in coarse layer */
/*************************************************************************/
i4_ref_stride = ps_layer_ctxt->i4_inp_stride;
ppu1_ref = ps_layer_ctxt->ppu1_list_inp;
/* colocated position in reference picture */
i4_ref_offset = (i4_ref_stride * ps_search_prms->i4_y_off) + ps_search_prms->i4_x_off;
pu1_ref_coloc = ppu1_ref[i4_search_idx] + i4_ref_offset;
stepx = stepy = HME_COARSE_STEP_SIZE_HIGH_SPEED;
/*TODO: Calculate Step shift from the #define HME_COARSE_STEP_SIZE_HIGH_SPEED */
step_shift_x = step_shift_y = 2;
mv_x_offset = -(ps_mv_limit->i2_min_x >> step_shift_x);
mv_y_offset = -(ps_mv_limit->i2_min_y >> step_shift_y);
mv_x_range = (-ps_mv_limit->i2_min_x + ps_mv_limit->i2_max_x) >> step_shift_x;
mv_y_range = (-ps_mv_limit->i2_min_y + ps_mv_limit->i2_max_y) >> step_shift_y;
/* Run 2loops to sweep over the reference area */
for(mvy = ps_range_prms->i2_min_y; mvy < ps_range_prms->i2_max_y; mvy += stepy)
{
for(mvx = ps_range_prms->i2_min_x; mvx < ps_range_prms->i2_max_x; mvx += stepx)
{
/* Set up the reference and inp ptr */
pu1_ref = pu1_ref_coloc + mvx + (mvy * i4_ref_stride);
pu1_inp = pu1_inp_orig;
/* SAD computation */
{
sad = 0;
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
sad += (ABS(((S32)pu1_inp[j] - (S32)pu1_ref[j])));
}
pu1_inp += i4_inp_stride;
pu1_ref += i4_ref_stride;
}
}
pi2_sads_4x4
[((mvx >> step_shift_x) + mv_x_offset) +
((mvy >> step_shift_y) + mv_y_offset) * mv_x_range] = sad;
}
}
}
/**
********************************************************************************
* @fn void hme_coarsest(me_ctxt_t *ps_ctxt, coarse_prms_t *ps_coarse_prms)
*
* @brief Top level entry point for Coarse ME. Runs across blks and searches
* at a 4x4 blk granularity by using 4x8 and 8x4 patterns.
*
* @param[in,out] ps_ctxt: ME Handle
*
* @param[in] ps_coarse_prms : Coarse layer config params
*
* @param[in] ps_multi_thrd_ctxt : Multi thread context
*
* @return None
********************************************************************************
*/
void hme_coarsest(
coarse_me_ctxt_t *ps_ctxt,
coarse_prms_t *ps_coarse_prms,
multi_thrd_ctxt_t *ps_multi_thrd_ctxt,
WORD32 i4_ping_pong,
void **ppv_dep_mngr_hme_sync)
{
S16 *pi2_cur_ref_sads_4x4;
S32 ai4_sad_4x4_block_size[MAX_NUM_REF], ai4_sad_4x4_block_stride[MAX_NUM_REF];
S32 num_rows_coarse;
S32 sad_top_offset, sad_current_offset;
S32 search_node_top_offset, search_node_left_offset;
ME_QUALITY_PRESETS_T e_me_quality_preset =
ps_ctxt->s_init_prms.s_me_coding_tools.e_me_quality_presets;
search_results_t *ps_search_results;
mvbank_update_prms_t s_mv_update_prms;
BLK_SIZE_T e_search_blk_size = BLK_4x4;
hme_search_prms_t s_search_prms_4x8, s_search_prms_8x4, s_search_prms_4x4;
S32 global_id_8x4, global_id_4x8;
/*************************************************************************/
/* These directly point to the best search result nodes that will be */
/* updated by the search algorithm, rather than have to go through an */
/* elaborate structure */
/*************************************************************************/
search_node_t *aps_best_search_node_8x4[MAX_NUM_REF];
search_node_t *aps_best_search_node_4x8[MAX_NUM_REF];
/* These point to various spatial candts */
search_node_t *ps_candt_8x4_l, *ps_candt_8x4_t, *ps_candt_8x4_tl;
search_node_t *ps_candt_4x8_l, *ps_candt_4x8_t, *ps_candt_4x8_tl;
search_node_t *ps_candt_zeromv_8x4, *ps_candt_zeromv_4x8;
search_node_t *ps_candt_fs_8x4, *ps_candt_fs_4x8;
search_node_t as_top_neighbours[4], as_left_neighbours[3];
/* Holds the global mv for a given ref index */
search_node_t s_candt_global[MAX_NUM_REF];
/* All the search candidates */
search_candt_t as_search_candts_8x4[MAX_INIT_CANDTS];
search_candt_t as_search_candts_4x8[MAX_INIT_CANDTS];
search_candt_t *ps_search_candts_8x4, *ps_search_candts_4x8;
/* Actual range per blk and the pic level boundaries */
range_prms_t s_range_prms, s_pic_limit, as_mv_limit[MAX_NUM_REF];
/* Current and prev pic layer ctxt at the coarsest layer */
layer_ctxt_t *ps_curr_layer, *ps_prev_layer;
/* best mv of full search */
hme_mv_t best_mv_4x8, best_mv_8x4;
/* Book keeping at blk level */
S32 blk_x, num_blks_in_pic, num_blks_in_row, num_4x4_blks_in_row;
S32 blk_y;
/* Block dimensions */
S32 blk_size_shift = 2, blk_wd = 4, blk_ht = 4;
S32 lambda = ps_coarse_prms->lambda;
/* Number of references to search */
S32 i4_num_ref;
S32 i4_i, id, i;
S08 i1_ref_idx;
S32 i4_pic_wd, i4_pic_ht;
S32 i4_layer_id;
S32 end_of_frame;
pf_get_wt_inp fp_get_wt_inp;
/* Maximum search iterations around any candidate */
S32 i4_max_iters = ps_coarse_prms->i4_max_iters;
ps_curr_layer = ps_ctxt->ps_curr_descr->aps_layers[ps_coarse_prms->i4_layer_id];
ps_prev_layer = hme_coarse_get_past_layer_ctxt(ps_ctxt, ps_coarse_prms->i4_layer_id);
/* We need only one instance of search results structure */
ps_search_results = &ps_ctxt->s_search_results_8x8;
ps_search_candts_8x4 = &as_search_candts_8x4[0];
ps_search_candts_4x8 = &as_search_candts_4x8[0];
end_of_frame = 0;
i4_pic_wd = ps_curr_layer->i4_wd;
i4_pic_ht = ps_curr_layer->i4_ht;
fp_get_wt_inp = ((ihevce_me_optimised_function_list_t *)ps_ctxt->pv_me_optimised_function_list)
->pf_get_wt_inp_8x8;
num_rows_coarse = ps_ctxt->i4_num_row_bufs;
/*************************************************************************/
/* Coarse Layer always does explicit search. Number of reference frames */
/* to search is a configurable parameter supplied by the application */
/*************************************************************************/
i4_num_ref = ps_coarse_prms->i4_num_ref;
i4_layer_id = ps_coarse_prms->i4_layer_id;
/*************************************************************************/
/* The search algorithm goes as follows: */
/* */
/* ___ */
/* | e | */
/* ___|___|___ */
/* | c | a | b | */
/* |___|___|___| */
/* | d | */
/* |___| */
/* */
/* For the target block a, we collect best results from 2 8x4 blks */
/* These are c-a and a-b. The 4x8 blks are e-a and a-d */
/* c-a result is already available from results of blk c. a-b is */
/* evaluated in this blk. Likewise e-a result is stored in a row buffer */
/* a-d is evaluated this blk */
/* So we store a row buffer which stores best 4x8 results of all top blk */
/*************************************************************************/
/************************************************************************/
/* Initialize the pointers to the best node. */
/************************************************************************/
for(i4_i = 0; i4_i < i4_num_ref; i4_i++)
{
aps_best_search_node_8x4[i4_i] = ps_search_results->aps_part_results[i4_i][PART_ID_2NxN_B];
aps_best_search_node_4x8[i4_i] = ps_search_results->aps_part_results[i4_i][PART_ID_Nx2N_R];
}
/************************************************************************/
/* Initialize the "searchresults" structure. This will set up the number*/
/* of search types, result updates etc */
/************************************************************************/
{
S32 num_results_per_part;
/* We evaluate 4 types of results per 4x4 blk. 8x4L and 8x4R and */
/* 4x8 T and 4x8B. So if we are to give 4 results, then we need to */
/* only evaluate 1 result per part. In the coarse layer, we are */
/* limited to 2 results max per part, and max of 8 results. */
num_results_per_part = (ps_coarse_prms->num_results + 3) >> 2;
hme_init_search_results(
ps_search_results,
i4_num_ref,
ps_coarse_prms->num_results,
num_results_per_part,
BLK_8x8,
0,
0,
ps_ctxt->au1_is_past);
}
/* Macro updates num_blks_in_pic and num_blks_in_row*/
GET_NUM_BLKS_IN_PIC(i4_pic_wd, i4_pic_ht, blk_size_shift, num_blks_in_row, num_blks_in_pic);
num_4x4_blks_in_row = num_blks_in_row + 1;
s_mv_update_prms.e_search_blk_size = e_search_blk_size;
s_mv_update_prms.i4_num_ref = i4_num_ref;
s_mv_update_prms.i4_shift = 0;
/* For full search, support 2 or 4 step size */
if(ps_coarse_prms->do_full_search)
{
ASSERT((ps_coarse_prms->full_search_step == 2) || (ps_coarse_prms->full_search_step == 4));
}
for(i4_i = 0; i4_i < i4_num_ref; i4_i++)
{
S32 blk, delta_poc;
S32 mv_x_clip, mv_y_clip;
/* Initialize only the first row */
for(blk = 0; blk < num_blks_in_row; blk++)
{
INIT_SEARCH_NODE(&ps_ctxt->aps_best_search_nodes_4x8_n_rows[i4_i][blk], i4_i);
}
delta_poc = ABS(ps_curr_layer->i4_poc - ps_curr_layer->ai4_ref_id_to_poc_lc[i4_i]);
/* Setting search range for different references based on the delta poc */
/*************************************************************************/
/* 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. */
/*************************************************************************/
{
/* TO DO : Remove hard coding of P-P dist. of 4 */
mv_x_clip = (ps_curr_layer->i2_max_mv_x * delta_poc) / 4;
/* Only for B/b pic. */
if(1 == ps_ctxt->s_frm_prms.bidir_enabled)
{
WORD16 i2_mv_y_per_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[i4_layer_id],
(ABS(ps_ctxt->s_coarse_dyn_range_prms.i2_dyn_min_y_per_poc[i4_layer_id])));
mv_y_clip = i2_mv_y_per_poc * delta_poc;
}
/* Set the Config. File Params for P pic. */
else
{
/* TO DO : Remove hard coding of P-P dist. of 4 */
mv_y_clip = (ps_curr_layer->i2_max_mv_y * delta_poc) / 4;
}
/* Making mv_x and mv_y range multiple of 4 */
mv_x_clip = (((mv_x_clip + 3) >> 2) << 2);
mv_y_clip = (((mv_y_clip + 3) >> 2) << 2);
/* Clipping the range of mv_x and mv_y */
mv_x_clip = CLIP3(mv_x_clip, 4, MAX_MVX_SUPPORTED_IN_COARSE_LAYER);
mv_y_clip = CLIP3(mv_y_clip, 4, MAX_MVY_SUPPORTED_IN_COARSE_LAYER);
as_mv_limit[i4_i].i2_min_x = -mv_x_clip;
as_mv_limit[i4_i].i2_min_y = -mv_y_clip;
as_mv_limit[i4_i].i2_max_x = mv_x_clip;
as_mv_limit[i4_i].i2_max_y = mv_y_clip;
}
/*Populating SAD block size based on search range */
ai4_sad_4x4_block_size[i4_i] = ((2 * mv_x_clip) / ps_coarse_prms->full_search_step) *
((2 * mv_y_clip) / ps_coarse_prms->full_search_step);
ai4_sad_4x4_block_stride[i4_i] = (num_blks_in_row + 1) * ai4_sad_4x4_block_size[i4_i];
}
for(i = 0; i < 2 * MAX_INIT_CANDTS; i++)
{
search_node_t *ps_search_node;
ps_search_node = &ps_ctxt->s_init_search_node[i];
INIT_SEARCH_NODE(ps_search_node, 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);
/* Set up place holders to hold the search nodes of each initial candt */
for(i = 0; i < MAX_INIT_CANDTS; i++)
{
ps_search_candts_8x4[i].ps_search_node = &ps_ctxt->s_init_search_node[i];
ps_search_candts_4x8[i].ps_search_node = &ps_ctxt->s_init_search_node[MAX_INIT_CANDTS + i];
ps_search_candts_8x4[i].u1_num_steps_refine = (U08)i4_max_iters;
ps_search_candts_4x8[i].u1_num_steps_refine = (U08)i4_max_iters;
}
/* For Top,TopLeft and Left cand., no need for refinement */
id = 0;
if((ps_coarse_prms->do_full_search) && (ME_XTREME_SPEED_25 == e_me_quality_preset))
{
/* This search candt has the full search result */
ps_candt_fs_8x4 = ps_search_candts_8x4[id].ps_search_node;
id++;
}
ps_candt_8x4_l = ps_search_candts_8x4[id].ps_search_node;
ps_search_candts_8x4[id].u1_num_steps_refine = 0;
id++;
ps_candt_8x4_t = ps_search_candts_8x4[id].ps_search_node;
ps_search_candts_8x4[id].u1_num_steps_refine = 0;
id++;
ps_candt_8x4_tl = ps_search_candts_8x4[id].ps_search_node;
ps_search_candts_8x4[id].u1_num_steps_refine = 0;
id++;
/* This search candt stores the global candt */
global_id_8x4 = id;
id++;
if((ps_coarse_prms->do_full_search) && (ME_XTREME_SPEED_25 != e_me_quality_preset))
{
/* This search candt has the full search result */
ps_candt_fs_8x4 = ps_search_candts_8x4[id].ps_search_node;
id++;
}
/* Don't increment id as (0,0) is removed from cand. list. Initializing */
/* the pointer for hme_init_pred_ctxt_no_encode() */
ps_candt_zeromv_8x4 = ps_search_candts_8x4[id].ps_search_node;
/* For Top,TopLeft and Left cand., no need for refinement */
id = 0;
if((ps_coarse_prms->do_full_search) && (ME_XTREME_SPEED_25 == e_me_quality_preset))
{
/* This search candt has the full search result */
ps_candt_fs_4x8 = ps_search_candts_4x8[id].ps_search_node;
id++;
}
ps_candt_4x8_l = ps_search_candts_4x8[id].ps_search_node;
ps_search_candts_4x8[id].u1_num_steps_refine = 0;
id++;
ps_candt_4x8_t = ps_search_candts_4x8[id].ps_search_node;
ps_search_candts_4x8[id].u1_num_steps_refine = 0;
id++;
ps_candt_4x8_tl = ps_search_candts_4x8[id].ps_search_node;
ps_search_candts_4x8[id].u1_num_steps_refine = 0;
id++;
/* This search candt stores the global candt */
global_id_4x8 = id;
id++;
if((ps_coarse_prms->do_full_search) && (ME_XTREME_SPEED_25 != e_me_quality_preset))
{
/* This search candt has the full search result */
ps_candt_fs_4x8 = ps_search_candts_4x8[id].ps_search_node;
id++;
}
/* Don't increment id4as (0,0) is removed from cand. list. Initializing */
/* the pointer for hme_init_pred_ctxt_no_encode() */
ps_candt_zeromv_4x8 = ps_search_candts_4x8[id].ps_search_node;
/* Zero mv always has 0 mvx and y componnent, ref idx initialized inside */
ps_candt_zeromv_8x4->s_mv.i2_mvx = 0;
ps_candt_zeromv_8x4->s_mv.i2_mvy = 0;
ps_candt_zeromv_4x8->s_mv.i2_mvx = 0;
ps_candt_zeromv_4x8->s_mv.i2_mvy = 0;
/* SET UP THE PRED CTXT FOR L0 AND L1 */
{
S32 pred_lx;
/* Bottom left always not available */
as_left_neighbours[2].u1_is_avail = 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_no_encode(
ps_pred_ctxt,
ps_search_results,
as_top_neighbours,
as_left_neighbours,
NULL,
ps_candt_zeromv_8x4,
ps_candt_zeromv_8x4,
pred_lx,
lambda,
ps_coarse_prms->lambda_q_shift,
ps_ctxt->apu1_ref_bits_tlu_lc,
ps_ctxt->ai2_ref_scf);
}
}
/*************************************************************************/
/* Initialize the search parameters for search algo with the following */
/* parameters: No SATD, calculated number of initial candidates, */
/* No post refinement, initial step size and number of iterations as */
/* passed by the calling function. */
/* Also, we use input for this layer search, and not recon. */
/*************************************************************************/
if(e_me_quality_preset == ME_XTREME_SPEED_25)
s_search_prms_8x4.i4_num_init_candts = 1;
else
s_search_prms_8x4.i4_num_init_candts = id;
s_search_prms_8x4.i4_use_satd = 0;
s_search_prms_8x4.i4_start_step = ps_coarse_prms->i4_start_step;
s_search_prms_8x4.i4_num_steps_post_refine = 0;
s_search_prms_8x4.i4_use_rec = 0;
s_search_prms_8x4.ps_search_candts = ps_search_candts_8x4;
s_search_prms_8x4.e_blk_size = BLK_8x4;
s_search_prms_8x4.i4_max_iters = ps_coarse_prms->i4_max_iters;
/* Coarse layer is always explicit */
if(ME_MEDIUM_SPEED > e_me_quality_preset)
{
s_search_prms_8x4.pf_mv_cost_compute = compute_mv_cost_coarse;
}
else
{
s_search_prms_8x4.pf_mv_cost_compute = compute_mv_cost_coarse_high_speed;
}
s_search_prms_8x4.i4_inp_stride = 8;
s_search_prms_8x4.i4_cu_x_off = s_search_prms_8x4.i4_cu_y_off = 0;
if(ps_coarse_prms->do_full_search)
s_search_prms_8x4.i4_max_iters = 1;
s_search_prms_8x4.i4_part_mask = (1 << PART_ID_2NxN_B);
/* Using the member 0 to store for all ref. idx. */
s_search_prms_8x4.aps_mv_range[0] = &s_range_prms;
s_search_prms_8x4.ps_search_results = ps_search_results;
s_search_prms_8x4.full_search_step = ps_coarse_prms->full_search_step;
s_search_prms_4x8 = s_search_prms_8x4;
s_search_prms_4x8.ps_search_candts = ps_search_candts_4x8;
s_search_prms_4x8.e_blk_size = BLK_4x8;
s_search_prms_4x8.i4_part_mask = (1 << PART_ID_Nx2N_R);
s_search_prms_4x4 = s_search_prms_8x4;
/* Since s_search_prms_4x4 is used only to computer sad at 4x4 level, search candidate is not used */
s_search_prms_4x4.ps_search_candts = ps_search_candts_4x8;
s_search_prms_4x4.e_blk_size = BLK_4x4;
s_search_prms_4x4.i4_part_mask = (1 << PART_ID_2Nx2N);
/*************************************************************************/
/* Picture limit on all 4 sides. This will be used to set mv limits for */
/* every block given its coordinate. */
/*************************************************************************/
SET_PIC_LIMIT(
s_pic_limit,
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_4x4.i4_num_steps_post_refine);
/* Pick the global mv from previous reference */
for(i1_ref_idx = 0; i1_ref_idx < i4_num_ref; i1_ref_idx++)
{
if(ME_XTREME_SPEED_25 != e_me_quality_preset)
{
/* Distance of current pic from reference */
S32 i4_delta_poc;
hme_mv_t s_mv;
i4_delta_poc = ps_curr_layer->i4_poc - ps_curr_layer->ai4_ref_id_to_poc_lc[i1_ref_idx];
hme_get_global_mv(ps_prev_layer, &s_mv, i4_delta_poc);
s_candt_global[i1_ref_idx].s_mv.i2_mvx = s_mv.i2_mv_x;
s_candt_global[i1_ref_idx].s_mv.i2_mvy = s_mv.i2_mv_y;
s_candt_global[i1_ref_idx].i1_ref_idx = i1_ref_idx;
/*********************************************************************/
/* Initialize the histogram for each reference index in current */
/* layer ctxt */
/*********************************************************************/
hme_init_histogram(
ps_ctxt->aps_mv_hist[i1_ref_idx],
(S32)as_mv_limit[i1_ref_idx].i2_max_x,
(S32)as_mv_limit[i1_ref_idx].i2_max_y);
}
/*********************************************************************/
/* 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)
{
INIT_DYN_SEARCH_PRMS(
&ps_ctxt->s_coarse_dyn_range_prms.as_dyn_range_prms[i4_layer_id][i1_ref_idx],
ps_curr_layer->ai4_ref_id_to_poc_lc[i1_ref_idx]);
}
}
/*************************************************************************/
/* if exhaustive algorithmm then we use only 1 candt 0, 0 */
/* else we use a lot of causal and non causal candts */
/* finally set number to the configured number of candts */
/*************************************************************************/
/* Loop in raster order over each 4x4 blk in a given row till end of frame */
while(0 == end_of_frame)
{
job_queue_t *ps_job;
void *pv_hme_dep_mngr;
WORD32 offset_val, check_dep_pos, set_dep_pos;
/* 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_coarse_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, ps_multi_thrd_ctxt->i4_me_coarsest_lyr_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;
}
else
{
ASSERT(ps_multi_thrd_ctxt->i4_me_coarsest_lyr_type == ps_job->i4_pre_enc_task_type);
/* Obtain the current row's details from the job */
blk_y = ps_job->s_job_info.s_me_job_info.i4_vert_unit_row_no;
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;
}
/* 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;
}
/* Loop over all the blocks in current row */
/* One block extra, since the last block in a row needs East block */
for(blk_x = 0; blk_x < (num_blks_in_row + 1); blk_x++)
{
/* Wait till top row block is processed */
/* Currently checking till top right block*/
if(blk_x < (num_blks_in_row))
{
ihevce_dmgr_chk_row_row_sync(
pv_hme_dep_mngr,
blk_x,
offset_val,
check_dep_pos,
0, /* Col Tile No. : Not supported in PreEnc*/
ps_ctxt->thrd_id);
}
/***************************************************************/
/* Get Weighted input for all references */
/***************************************************************/
fp_get_wt_inp(
ps_curr_layer,
&ps_ctxt->s_wt_pred,
1 << (blk_size_shift + 1),
blk_x << blk_size_shift,
(blk_y - 1) << blk_size_shift,
1 << (blk_size_shift + 1),
i4_num_ref,
ps_ctxt->i4_wt_pred_enable_flag);
/* RESET ALL SEARCH RESULTS FOR THE NEW BLK */
hme_reset_search_results(
ps_search_results,
s_search_prms_8x4.i4_part_mask | s_search_prms_4x8.i4_part_mask,
MV_RES_FPEL);
/* Compute the search node offsets */
/* MAX is used to clip when left and top neighbours are not availbale at coarse boundaries */
search_node_top_offset =
blk_x + ps_ctxt->ai4_row_index[MAX((blk_y - 2), 0)] * num_blks_in_row;
search_node_left_offset =
MAX((blk_x - 1), 0) +
ps_ctxt->ai4_row_index[MAX((blk_y - 1), 0)] * num_blks_in_row;
/* Input offset: wrt CU start. Offset for South block */
s_search_prms_4x4.i4_cu_x_off = 0;
s_search_prms_4x4.i4_cu_y_off = 4;
s_search_prms_4x4.i4_inp_stride = 8;
s_search_prms_4x4.i4_x_off = blk_x << blk_size_shift;
s_search_prms_4x4.i4_y_off = blk_y << blk_size_shift;
s_search_prms_4x8.i4_x_off = s_search_prms_8x4.i4_x_off = blk_x << blk_size_shift;
s_search_prms_4x8.i4_y_off = s_search_prms_8x4.i4_y_off = (blk_y - 1)
<< blk_size_shift;
/* This layer will always use explicit ME */
/* Loop across different Ref IDx */
for(i1_ref_idx = 0; i1_ref_idx < i4_num_ref; i1_ref_idx++)
{
sad_top_offset = (blk_x * ai4_sad_4x4_block_size[i1_ref_idx]) +
ps_ctxt->ai4_row_index[MAX((blk_y - 1), 0)] *
ai4_sad_4x4_block_stride[i1_ref_idx];
sad_current_offset =
(blk_x * ai4_sad_4x4_block_size[i1_ref_idx]) +
ps_ctxt->ai4_row_index[blk_y] * ai4_sad_4x4_block_stride[i1_ref_idx];
/* Initialize search node if blk_x == 0, as it doesn't have left neighbours */
if(0 == blk_x)
INIT_SEARCH_NODE(
&ps_ctxt->aps_best_search_nodes_8x4_n_rows[i1_ref_idx][blk_x],
i1_ref_idx);
pi2_cur_ref_sads_4x4 = ps_ctxt->api2_sads_4x4_n_rows[i1_ref_idx];
/* Initialize changing params here */
s_search_prms_8x4.i1_ref_idx = i1_ref_idx;
s_search_prms_4x8.i1_ref_idx = i1_ref_idx;
s_search_prms_4x4.i1_ref_idx = i1_ref_idx;
if(num_blks_in_row == blk_x)
{
S16 *pi2_sads_4x4_current;
/* Since the current 4x4 block will be a padded region, which may not match with any of the reference */
pi2_sads_4x4_current = pi2_cur_ref_sads_4x4 + sad_current_offset;
memset(pi2_sads_4x4_current, 0, ai4_sad_4x4_block_size[i1_ref_idx]);
}
/* SAD to be computed and stored for the 4x4 block in 1st row and the last block of all rows*/
if((0 == blk_y) || (num_blks_in_row == blk_x))
{
S16 *pi2_sads_4x4_current;
/* Computer 4x4 SADs for current block */
/* Pointer to store SADs */
pi2_sads_4x4_current = pi2_cur_ref_sads_4x4 + sad_current_offset;
hme_derive_worst_case_search_range(
&s_range_prms,
&s_pic_limit,
&as_mv_limit[i1_ref_idx],
blk_x << blk_size_shift,
blk_y << blk_size_shift,
blk_wd,
blk_ht);
if(ME_PRISTINE_QUALITY >= e_me_quality_preset)
{
((ihevce_me_optimised_function_list_t *)
ps_ctxt->pv_me_optimised_function_list)
->pf_store_4x4_sads_high_quality(
&s_search_prms_4x4,
ps_curr_layer,
&as_mv_limit[i1_ref_idx],
&ps_ctxt->s_wt_pred,
pi2_sads_4x4_current);
}
else
{
((ihevce_me_optimised_function_list_t *)
ps_ctxt->pv_me_optimised_function_list)
->pf_store_4x4_sads_high_speed(
&s_search_prms_4x4,
ps_curr_layer,
&as_mv_limit[i1_ref_idx],
&ps_ctxt->s_wt_pred,
pi2_sads_4x4_current);
}
}
else
{
/* For the zero mv candt, the ref idx to be modified */
ps_candt_zeromv_8x4->i1_ref_idx = i1_ref_idx;
ps_candt_zeromv_4x8->i1_ref_idx = i1_ref_idx;
if(ME_XTREME_SPEED_25 != e_me_quality_preset)
{
/* For the global mvs alone, the search node points to a local variable */
ps_search_candts_8x4[global_id_8x4].ps_search_node =
&s_candt_global[i1_ref_idx];
ps_search_candts_4x8[global_id_4x8].ps_search_node =
&s_candt_global[i1_ref_idx];
}
hme_get_spatial_candt(
ps_curr_layer,
BLK_4x4,
blk_x,
blk_y - 1,
i1_ref_idx,
as_top_neighbours,
as_left_neighbours,
0,
1,
0,
0);
/* set up the various candts */
*ps_candt_4x8_l = as_left_neighbours[0];
*ps_candt_4x8_t = as_top_neighbours[1];
*ps_candt_4x8_tl = as_top_neighbours[0];
*ps_candt_8x4_l = *ps_candt_4x8_l;
*ps_candt_8x4_tl = *ps_candt_4x8_tl;
*ps_candt_8x4_t = *ps_candt_4x8_t;
{
S32 pred_lx;
S16 *pi2_sads_4x4_current, *pi2_sads_4x4_top;
pred_ctxt_t *ps_pred_ctxt;
PF_MV_COST_FXN pf_mv_cost_compute;
/* Computer 4x4 SADs for current block */
/* Pointer to store SADs */
pi2_sads_4x4_current = pi2_cur_ref_sads_4x4 + sad_current_offset;
hme_derive_worst_case_search_range(
&s_range_prms,
&s_pic_limit,
&as_mv_limit[i1_ref_idx],
blk_x << blk_size_shift,
blk_y << blk_size_shift,
blk_wd,
blk_ht);
if(i4_pic_ht == blk_y)
{
memset(pi2_sads_4x4_current, 0, ai4_sad_4x4_block_size[i1_ref_idx]);
}
else
{
if(ME_PRISTINE_QUALITY >= e_me_quality_preset)
{
((ihevce_me_optimised_function_list_t *)
ps_ctxt->pv_me_optimised_function_list)
->pf_store_4x4_sads_high_quality(
&s_search_prms_4x4,
ps_curr_layer,
&as_mv_limit[i1_ref_idx],
&ps_ctxt->s_wt_pred,
pi2_sads_4x4_current);
}
else
{
((ihevce_me_optimised_function_list_t *)
ps_ctxt->pv_me_optimised_function_list)
->pf_store_4x4_sads_high_speed(
&s_search_prms_4x4,
ps_curr_layer,
&as_mv_limit[i1_ref_idx],
&ps_ctxt->s_wt_pred,
pi2_sads_4x4_current);
}
}
/* Set pred direction to L0 or L1 */
pred_lx = 1 - ps_search_results->pu1_is_past[i1_ref_idx];
/* Suitable context (L0 or L1) */
ps_pred_ctxt = &ps_search_results->as_pred_ctxt[pred_lx];
/* Coarse layer is always explicit */
if(ME_PRISTINE_QUALITY > e_me_quality_preset)
{
pf_mv_cost_compute = compute_mv_cost_coarse;
}
else
{
/* Cost function is not called in high speed case. Below one is just a dummy function */
pf_mv_cost_compute = compute_mv_cost_coarse_high_speed;
}
/*********************************************************************/
/* Now, compute the mv for the top block */
/*********************************************************************/
pi2_sads_4x4_top = pi2_cur_ref_sads_4x4 + sad_top_offset;
/*********************************************************************/
/* 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. */
/*********************************************************************/
hme_derive_search_range(
&s_range_prms,
&s_pic_limit,
&as_mv_limit[i1_ref_idx],
blk_x << blk_size_shift,
(blk_y - 1) << blk_size_shift,
blk_wd,
blk_ht);
/* Computer the mv for the top block */
if(ME_PRISTINE_QUALITY >= e_me_quality_preset)
{
((ihevce_me_optimised_function_list_t *)
ps_ctxt->pv_me_optimised_function_list)
->pf_combine_4x4_sads_and_compute_cost_high_quality(
i1_ref_idx,
&s_range_prms, /* Both 4x8 and 8x4 has same search range */
&as_mv_limit[i1_ref_idx],
&best_mv_4x8,
&best_mv_8x4,
ps_pred_ctxt,
pf_mv_cost_compute,
pi2_sads_4x4_top, /* Current SAD block */
(pi2_sads_4x4_top +
ai4_sad_4x4_block_size[i1_ref_idx]), /* East SAD block */
pi2_sads_4x4_current); /* South SAD block */
}
else
{
((ihevce_me_optimised_function_list_t *)
ps_ctxt->pv_me_optimised_function_list)
->pf_combine_4x4_sads_and_compute_cost_high_speed(
i1_ref_idx,
&s_range_prms, /* Both 4x8 and 8x4 has same search range */
&as_mv_limit[i1_ref_idx],
&best_mv_4x8,
&best_mv_8x4,
ps_pred_ctxt,
pf_mv_cost_compute,
pi2_sads_4x4_top, /* Current SAD block */
(pi2_sads_4x4_top +
ai4_sad_4x4_block_size[i1_ref_idx]), /* East SAD block */
pi2_sads_4x4_current); /* South SAD block */
}
ps_candt_fs_4x8->s_mv.i2_mvx = best_mv_4x8.i2_mv_x;
ps_candt_fs_4x8->s_mv.i2_mvy = best_mv_4x8.i2_mv_y;
ps_candt_fs_4x8->i1_ref_idx = i1_ref_idx;
ps_candt_fs_8x4->s_mv.i2_mvx = best_mv_8x4.i2_mv_x;
ps_candt_fs_8x4->s_mv.i2_mvy = best_mv_8x4.i2_mv_y;
ps_candt_fs_8x4->i1_ref_idx = i1_ref_idx;
}
/* call the appropriate Search Algo for 4x8S. The 4x8N would */
/* have already been called by top block */
hme_pred_search_square_stepn(
&s_search_prms_8x4,
ps_curr_layer,
&ps_ctxt->s_wt_pred,
e_me_quality_preset,
(ihevce_me_optimised_function_list_t *)
ps_ctxt->pv_me_optimised_function_list
);
/* Call the appropriate search algo for 8x4E */
hme_pred_search_square_stepn(
&s_search_prms_4x8,
ps_curr_layer,
&ps_ctxt->s_wt_pred,
e_me_quality_preset,
(ihevce_me_optimised_function_list_t *)
ps_ctxt->pv_me_optimised_function_list);
if(ME_XTREME_SPEED_25 != e_me_quality_preset)
{
/* Histogram updates across different Ref ID for global MV */
hme_update_histogram(
ps_ctxt->aps_mv_hist[i1_ref_idx],
aps_best_search_node_8x4[i1_ref_idx]->s_mv.i2_mvx,
aps_best_search_node_8x4[i1_ref_idx]->s_mv.i2_mvy);
hme_update_histogram(
ps_ctxt->aps_mv_hist[i1_ref_idx],
aps_best_search_node_4x8[i1_ref_idx]->s_mv.i2_mvx,
aps_best_search_node_4x8[i1_ref_idx]->s_mv.i2_mvy);
}
/* update the best results to the mv bank */
hme_update_mv_bank_coarse(
ps_search_results,
ps_curr_layer->ps_layer_mvbank,
blk_x,
(blk_y - 1),
ps_ctxt->aps_best_search_nodes_4x8_n_rows[i1_ref_idx] +
search_node_top_offset, /* Top Candidate */
ps_ctxt->aps_best_search_nodes_8x4_n_rows[i1_ref_idx] +
search_node_left_offset, /* Left candidate */
i1_ref_idx,
&s_mv_update_prms);
/* Copy the best search result to 5 row array for future use */
*(ps_ctxt->aps_best_search_nodes_4x8_n_rows[i1_ref_idx] + blk_x +
ps_ctxt->ai4_row_index[blk_y - 1] * num_blks_in_row) =
*(aps_best_search_node_4x8[i1_ref_idx]);
*(ps_ctxt->aps_best_search_nodes_8x4_n_rows[i1_ref_idx] + blk_x +
ps_ctxt->ai4_row_index[blk_y - 1] * num_blks_in_row) =
*(aps_best_search_node_8x4[i1_ref_idx]);
/* 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 num_mvs, i, j;
search_node_t *aps_search_nodes[4];
/* Best results for 8x4R and 4x8B blocks */
search_node_t *ps_search_node_8x4_r, *ps_search_node_4x8_b;
num_mvs = ps_curr_layer->ps_layer_mvbank->i4_num_mvs_per_ref;
/*************************************************************************/
/* We have atleast 4 distinct results: the 4x8 top (coming from top blk) */
/* 8x4 left (coming from left blk), 8x4 and 4x8 right and bot resp. */
/* If number of results to be stored is 4, then we store all these 4 */
/* results, else we pick best ones */
/*************************************************************************/
ps_search_node_8x4_r =
ps_search_results->aps_part_results[i1_ref_idx][PART_ID_2NxN_B];
ps_search_node_4x8_b =
ps_search_results->aps_part_results[i1_ref_idx][PART_ID_Nx2N_R];
ASSERT(num_mvs <= 4);
/* Doing this to sort best results */
aps_search_nodes[0] = ps_search_node_8x4_r;
aps_search_nodes[1] = ps_search_node_4x8_b;
aps_search_nodes[2] =
ps_ctxt->aps_best_search_nodes_8x4_n_rows[i1_ref_idx] +
search_node_left_offset; /* Left candidate */
aps_search_nodes[3] =
ps_ctxt->aps_best_search_nodes_4x8_n_rows[i1_ref_idx] +
search_node_top_offset; /* Top Candidate */
/* Note : Need to be resolved!!! */
/* Added this to match with "hme_update_mv_bank_coarse" */
if(num_mvs != 4)
{
/* Run through the results, store them in best to worst order */
for(i = 0; i < num_mvs; i++)
{
for(j = i + 1; j < 4; j++)
{
if(aps_search_nodes[j]->i4_tot_cost <
aps_search_nodes[i]->i4_tot_cost)
{
SWAP_HME(
aps_search_nodes[j],
aps_search_nodes[i],
search_node_t *);
}
}
}
}
/* UPDATE the MIN and MAX MVs for Dynamical Search Range for each ref. pic. */
for(i = 0; i < num_mvs; i++)
{
hme_update_dynamic_search_params(
&ps_ctxt->s_coarse_dyn_range_prms
.as_dyn_range_prms[i4_layer_id][i1_ref_idx],
aps_search_nodes[i]->s_mv.i2_mvy);
}
}
}
}
/* Update the number of blocks processed in the current row */
ihevce_dmgr_set_row_row_sync(
pv_hme_dep_mngr,
(blk_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);
}
}
return;
}