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