| /****************************************************************************** |
| * |
| * 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 |
| * ihevce_stasino_helpers.c |
| * |
| * @brief |
| * |
| * @author |
| * Ittiam |
| * |
| * @par List of Functions: |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| |
| /*****************************************************************************/ |
| /* File Includes */ |
| /*****************************************************************************/ |
| /* System include files */ |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <assert.h> |
| #include <string.h> |
| |
| /* User include files */ |
| #include "ihevc_typedefs.h" |
| #include "itt_video_api.h" |
| #include "ihevce_api.h" |
| |
| #include "rc_cntrl_param.h" |
| #include "rc_frame_info_collector.h" |
| #include "rc_look_ahead_params.h" |
| |
| #include "ihevc_defs.h" |
| #include "ihevc_structs.h" |
| #include "ihevc_platform_macros.h" |
| #include "ihevc_deblk.h" |
| #include "ihevc_itrans_recon.h" |
| #include "ihevc_chroma_itrans_recon.h" |
| #include "ihevc_chroma_intra_pred.h" |
| #include "ihevc_intra_pred.h" |
| #include "ihevc_inter_pred.h" |
| #include "ihevc_mem_fns.h" |
| #include "ihevc_padding.h" |
| #include "ihevc_weighted_pred.h" |
| #include "ihevc_sao.h" |
| #include "ihevc_resi_trans.h" |
| #include "ihevc_quant_iquant_ssd.h" |
| #include "ihevc_cabac_tables.h" |
| |
| #include "ihevce_defs.h" |
| #include "ihevce_lap_enc_structs.h" |
| #include "ihevce_multi_thrd_structs.h" |
| #include "ihevce_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_stasino_helpers.h" |
| |
| /*****************************************************************************/ |
| /* Function Definitions */ |
| /*****************************************************************************/ |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * This function calculates the variance of given data set. |
| * |
| * @par Description: |
| * This function is mainly used to find the variance of the block of pixel values. |
| * The block can be rectangular also. Single pass variance calculation |
| * implementation. |
| * |
| * @param[in] p_input |
| * The input buffer to calculate the variance. |
| * |
| * @param[out] pi4_mean |
| * Pointer ot the mean of the datset |
| * |
| * @param[out] pi4_variance |
| * Pointer tot he variabce of the data set |
| * |
| * @param[in] u1_is_hbd |
| * 1 if the data is in high bit depth |
| * |
| * @param[in] stride |
| * Stride for the input buffer |
| * |
| * @param[in] block_height |
| * height of the pixel block |
| * |
| * @param[in] block_width |
| * width of the pixel block |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| void ihevce_calc_variance( |
| void *pv_input, |
| WORD32 i4_stride, |
| WORD32 *pi4_mean, |
| UWORD32 *pu4_variance, |
| UWORD8 u1_block_height, |
| UWORD8 u1_block_width, |
| UWORD8 u1_is_hbd, |
| UWORD8 u1_disable_normalization) |
| { |
| UWORD8 *pui1_buffer; // pointer for 8 bit usecase |
| WORD32 i, j; |
| WORD32 total_elements; |
| |
| LWORD64 mean; |
| ULWORD64 variance; |
| ULWORD64 sum; |
| ULWORD64 sq_sum; |
| |
| /* intialisation */ |
| total_elements = u1_block_height * u1_block_width; |
| mean = 0; |
| variance = 0; |
| sum = 0; |
| sq_sum = 0; |
| |
| /* handle the case of 8/10 bit depth separately */ |
| if(!u1_is_hbd) |
| { |
| pui1_buffer = (UWORD8 *)pv_input; |
| |
| /* loop over all the values in the block */ |
| for(i = 0; i < u1_block_height; i++) |
| { |
| /* loop over a row in the block */ |
| for(j = 0; j < u1_block_width; j++) |
| { |
| sum += pui1_buffer[i * i4_stride + j]; |
| sq_sum += (pui1_buffer[i * i4_stride + j] * pui1_buffer[i * i4_stride + j]); |
| } |
| } |
| |
| if(!u1_disable_normalization) |
| { |
| mean = sum / total_elements; |
| variance = |
| ((total_elements * sq_sum) - (sum * sum)) / (total_elements * (total_elements)); |
| } |
| else |
| { |
| mean = sum; |
| variance = ((total_elements * sq_sum) - (sum * sum)); |
| } |
| } |
| |
| /* copy back the values to the output variables */ |
| *pi4_mean = mean; |
| *pu4_variance = variance; |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * This function calcluates the variance of given data set which is WORD16 |
| * |
| * @par Description: |
| * This function is mainly used to find the variance of the block of pixel values. |
| * Single pass variance calculation implementation. |
| * |
| * @param[in] pv_input |
| * The input buffer to calculate the variance. |
| * |
| * |
| * @param[in] stride |
| * Stride for the input buffer |
| * |
| * @param[out] pi4_mean |
| * Pointer ot the mean of the datset |
| * |
| * @param[out] pi4_variance |
| * Pointer tot he variabce of the data set |
| * |
| * @param[in] block_height |
| * height of the pixel block |
| * |
| * @param[in] block_width |
| * width of the pixel block |
| * |
| * |
| * @remarks |
| * None |
| * |
| *******************************************************************************/ |
| void ihevce_calc_variance_signed( |
| WORD16 *pv_input, |
| WORD32 i4_stride, |
| WORD32 *pi4_mean, |
| UWORD32 *pu4_variance, |
| UWORD8 u1_block_height, |
| UWORD8 u1_block_width) |
| { |
| WORD16 *pi2_buffer; // poinbter for 10 bit use case |
| |
| WORD32 i, j; |
| WORD32 total_elements; |
| |
| LWORD64 mean; |
| LWORD64 variance; |
| LWORD64 sum; |
| LWORD64 sq_sum; |
| |
| /* intialisation */ |
| total_elements = u1_block_height * u1_block_width; |
| mean = 0; |
| variance = 0; |
| sum = 0; |
| sq_sum = 0; |
| |
| pi2_buffer = pv_input; |
| |
| for(i = 0; i < u1_block_height; i++) |
| { |
| for(j = 0; j < u1_block_width; j++) |
| { |
| sum += pi2_buffer[i * i4_stride + j]; |
| sq_sum += (pi2_buffer[i * i4_stride + j] * pi2_buffer[i * i4_stride + j]); |
| } |
| } |
| |
| mean = sum; /// total_elements; |
| variance = ((total_elements * sq_sum) - (sum * sum)); // / (total_elements * (total_elements) ) |
| |
| /* copy back the values to the output variables */ |
| *pi4_mean = mean; |
| *pu4_variance = variance; |
| } |
| |
| /** |
| ******************************************************************************* |
| * |
| * @brief |
| * This function calculates the variance of a chrominance plane for 420SP data |
| * |
| * @par Description: |
| * This function is mainly used to find the variance of the block of pixel values. |
| * The block can be rectangular also. Single pass variance calculation |
| * implementation. |
| * |
| * @param[in] p_input |
| * The input buffer to calculate the variance. |
| * |
| * @param[in] stride |
| * Stride for the input buffer |
| * |
| * @param[out] pi4_mean |
| * Pointer ot the mean of the datset |
| * |
| * @param[out] pi4_variance |
| * Pointer tot he variabce of the data set |
| * |
| * @param[in] block_height |
| * height of the pixel block |
| * |
| * @param[in] block_width |
| * width of the pixel block |
| * |
| * @param[in] u1_is_hbd |
| * 1 if the data is in high bit depth |
| * |
| * @param[in] e_chroma_plane |
| * is U or V |
| * |
| * @remarks |
| * None |
| * |
| ******************************************************************************* |
| */ |
| void ihevce_calc_chroma_variance( |
| void *pv_input, |
| WORD32 i4_stride, |
| WORD32 *pi4_mean, |
| UWORD32 *pu4_variance, |
| UWORD8 u1_block_height, |
| UWORD8 u1_block_width, |
| UWORD8 u1_is_hbd, |
| CHROMA_PLANE_ID_T e_chroma_plane) |
| { |
| UWORD8 *pui1_buffer; // pointer for 8 bit usecase |
| WORD32 i, j; |
| WORD32 total_elements; |
| |
| LWORD64 mean; |
| ULWORD64 variance; |
| LWORD64 sum; |
| LWORD64 sq_sum; |
| |
| /* intialisation */ |
| total_elements = u1_block_height * u1_block_width; |
| mean = 0; |
| variance = 0; |
| sum = 0; |
| sq_sum = 0; |
| |
| /* handle the case of 8/10 bit depth separately */ |
| if(!u1_is_hbd) |
| { |
| pui1_buffer = (UWORD8 *)pv_input; |
| |
| pui1_buffer += e_chroma_plane; |
| |
| /* loop over all the values in the block */ |
| for(i = 0; i < u1_block_height; i++) |
| { |
| /* loop over a row in the block */ |
| for(j = 0; j < u1_block_width; j++) |
| { |
| sum += pui1_buffer[i * i4_stride + j * 2]; |
| sq_sum += (pui1_buffer[i * i4_stride + j * 2] * pui1_buffer[i * i4_stride + j * 2]); |
| } |
| } |
| |
| mean = sum / total_elements; |
| variance = ((total_elements * sq_sum) - (sum * sum)) / (total_elements * (total_elements)); |
| } |
| |
| /* copy back the values to the output variables */ |
| *pi4_mean = mean; |
| *pu4_variance = variance; |
| } |
| |
| LWORD64 ihevce_inject_stim_into_distortion( |
| void *pv_src, |
| WORD32 i4_src_stride, |
| void *pv_pred, |
| WORD32 i4_pred_stride, |
| LWORD64 i8_distortion, |
| WORD32 i4_alpha_stim_multiplier, |
| UWORD8 u1_blk_size, |
| UWORD8 u1_is_hbd, |
| UWORD8 u1_enable_psyRDOPT, |
| CHROMA_PLANE_ID_T e_chroma_plane) |
| { |
| if(!u1_enable_psyRDOPT) |
| { |
| UWORD32 u4_src_variance; |
| UWORD32 u4_pred_variance; |
| WORD32 i4_mean; |
| WORD32 i4_noise_term; |
| |
| if(NULL_PLANE == e_chroma_plane) |
| { |
| ihevce_calc_variance( |
| pv_src, |
| i4_src_stride, |
| &i4_mean, |
| &u4_src_variance, |
| u1_blk_size, |
| u1_blk_size, |
| u1_is_hbd, |
| 0); |
| |
| ihevce_calc_variance( |
| pv_pred, |
| i4_pred_stride, |
| &i4_mean, |
| &u4_pred_variance, |
| u1_blk_size, |
| u1_blk_size, |
| u1_is_hbd, |
| 0); |
| } |
| else |
| { |
| ihevce_calc_chroma_variance( |
| pv_src, |
| i4_src_stride, |
| &i4_mean, |
| &u4_src_variance, |
| u1_blk_size, |
| u1_blk_size, |
| u1_is_hbd, |
| e_chroma_plane); |
| |
| ihevce_calc_chroma_variance( |
| pv_pred, |
| i4_pred_stride, |
| &i4_mean, |
| &u4_pred_variance, |
| u1_blk_size, |
| u1_blk_size, |
| u1_is_hbd, |
| e_chroma_plane); |
| } |
| |
| i4_noise_term = |
| ihevce_compute_noise_term(i4_alpha_stim_multiplier, u4_src_variance, u4_pred_variance); |
| |
| MULTIPLY_STIM_WITH_DISTORTION(i8_distortion, i4_noise_term, STIM_Q_FORMAT, ALPHA_Q_FORMAT); |
| |
| return i8_distortion; |
| } |
| else |
| { |
| return i8_distortion; |
| } |
| } |
| |
| UWORD8 ihevce_determine_cu_noise_based_on_8x8Blk_data( |
| UWORD8 *pu1_is_8x8Blk_noisy, UWORD8 u1_cu_x_pos, UWORD8 u1_cu_y_pos, UWORD8 u1_cu_size) |
| { |
| UWORD8 u1_num_noisy_children = 0; |
| UWORD8 u1_start_index = (u1_cu_x_pos / 8) + u1_cu_y_pos; |
| |
| if(8 == u1_cu_size) |
| { |
| return pu1_is_8x8Blk_noisy[u1_start_index]; |
| } |
| |
| u1_num_noisy_children += ihevce_determine_cu_noise_based_on_8x8Blk_data( |
| pu1_is_8x8Blk_noisy, u1_cu_x_pos, u1_cu_y_pos, u1_cu_size / 2); |
| |
| u1_num_noisy_children += ihevce_determine_cu_noise_based_on_8x8Blk_data( |
| pu1_is_8x8Blk_noisy, u1_cu_x_pos + (u1_cu_size / 2), u1_cu_y_pos, u1_cu_size / 2); |
| |
| u1_num_noisy_children += ihevce_determine_cu_noise_based_on_8x8Blk_data( |
| pu1_is_8x8Blk_noisy, u1_cu_x_pos, u1_cu_y_pos + (u1_cu_size / 2), u1_cu_size / 2); |
| |
| u1_num_noisy_children += ihevce_determine_cu_noise_based_on_8x8Blk_data( |
| pu1_is_8x8Blk_noisy, |
| u1_cu_x_pos + (u1_cu_size / 2), |
| u1_cu_y_pos + (u1_cu_size / 2), |
| u1_cu_size / 2); |
| |
| return (u1_num_noisy_children >= 2); |
| } |
| |
| /*! |
| ****************************************************************************** |
| * \if Function name : ihevce_psy_rd_cost_croma \endif |
| * |
| * \brief |
| * Calculates the psyco visual cost for RD opt. This is |
| * |
| * \param[in] pui4_source_satd |
| * This is the pointer to the array of 8x8 satd of the corresponding source CTB. This is pre calculated. |
| * \param[in] *pui1_recon |
| * This si the pointer to the pred data. |
| * \param[in] recon_stride |
| * This si the pred stride |
| * \param[in] pic_type |
| * Picture type. |
| * \param[in] layer_id |
| * Indicates the temporal layer. |
| * \param[in] lambda |
| * This is the weighting factor for the cost. |
| * \param[in] is_hbd |
| * This is the high bit depth flag which indicates if the bit depth of the pixels is 10 bit or 8 bit. |
| * \param[in] sub_sampling_type |
| * This is the chroma subsampling type. 11 - for 420 and 13 for 422 |
| * \return |
| * the cost for the psyRDopt |
| * |
| * \author |
| * Ittiam |
| * |
| ***************************************************************************** |
| */ |
| LWORD64 ihevce_psy_rd_cost_croma( |
| LWORD64 *pui4_source_satd, |
| void *p_recon, |
| WORD32 recon_stride_vert, |
| WORD32 recond_stride_horz, |
| WORD32 cu_size_luma, |
| WORD32 pic_type, |
| WORD32 layer_id, |
| WORD32 lambda, |
| WORD32 start_index, |
| WORD32 is_hbd, |
| WORD32 sub_sampling_type, |
| ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list) |
| { |
| /* declare local variables to store the SATD values for the pred for the current block. */ |
| LWORD64 psy_rd_cost; |
| UWORD32 lambda_mod; |
| WORD32 psy_factor; |
| |
| /* declare local variables */ |
| WORD32 i; |
| WORD32 cu_total_size; |
| WORD32 num_comp_had_blocks; |
| |
| UWORD8 *pu1_l0_block; |
| UWORD8 *pu1_l0_block_prev; |
| UWORD8 *pu1_recon; |
| WORD32 ht_offset; |
| WORD32 wd_offset; |
| WORD32 cu_ht; |
| WORD32 cu_wd; |
| |
| WORD32 num_horz_blocks; |
| |
| WORD16 pi2_residue_had[64]; |
| /* this is used as a buffer with all values equal to 0. This is emulate the case with |
| pred being zero in HAD fucntion */ |
| UWORD8 ai1_zeros_buffer[64]; |
| |
| WORD32 had_block_size; |
| LWORD64 source_satd; // to hold source for current 8x8 block |
| LWORD64 recon_satd; // holds the current recon 8x8 satd |
| |
| WORD32 index_for_src_satd; |
| |
| (void)recond_stride_horz; |
| (void)pic_type; |
| (void)layer_id; |
| if(!is_hbd) |
| { |
| pu1_recon = (UWORD8 *)p_recon; |
| } |
| |
| /**** initialize the variables ****/ |
| had_block_size = 4; |
| |
| if(sub_sampling_type == 1) // 420 |
| { |
| cu_ht = cu_size_luma / 2; |
| cu_wd = cu_size_luma / 2; |
| } |
| else |
| { |
| cu_ht = cu_size_luma; |
| cu_wd = cu_size_luma / 2; |
| } |
| |
| num_horz_blocks = 2 * cu_wd / had_block_size; //ctb_width / had_block_size; |
| ht_offset = -had_block_size; |
| wd_offset = 0; //-had_block_size; |
| |
| cu_total_size = cu_ht * cu_wd; |
| num_comp_had_blocks = 2 * cu_total_size / (had_block_size * had_block_size); |
| |
| index_for_src_satd = start_index; |
| |
| for(i = 0; i < 64; i++) |
| { |
| ai1_zeros_buffer[i] = 0; |
| } |
| |
| psy_factor = PSY_STRENGTH_CHROMA; |
| psy_rd_cost = 0; |
| lambda_mod = lambda * psy_factor; |
| |
| /************************************************************/ |
| /* loop over for every 4x4 blocks in the CU for Cb */ |
| for(i = 0; i < num_comp_had_blocks; i++) |
| { |
| if(i % num_horz_blocks == 0) |
| { |
| wd_offset = -had_block_size; |
| ht_offset += had_block_size; |
| } |
| wd_offset += had_block_size; |
| |
| /* source satd for the current 8x8 block */ |
| source_satd = pui4_source_satd[index_for_src_satd]; |
| |
| if(i % 2 != 0) |
| { |
| if(!is_hbd) |
| { |
| pu1_l0_block = pu1_l0_block_prev + 1; |
| } |
| } |
| else |
| { |
| if(!is_hbd) |
| { |
| /* get memory pointers for each of L0 and L1 blocks whose hadamard has to be computed */ |
| pu1_l0_block = pu1_recon + recon_stride_vert * ht_offset + wd_offset; |
| pu1_l0_block_prev = pu1_l0_block; |
| } |
| } |
| |
| if(had_block_size == 4) |
| { |
| if(!is_hbd) |
| { |
| recon_satd = ps_cmn_utils_optimised_function_list->pf_chroma_AC_HAD_4x4_8bit( |
| pu1_l0_block, |
| recon_stride_vert, |
| ai1_zeros_buffer, |
| had_block_size, |
| pi2_residue_had, |
| had_block_size); |
| } |
| |
| /* get the additional cost function based on the absolute SATD diff of source and recon. */ |
| psy_rd_cost += (lambda_mod * llabs(source_satd - recon_satd)); |
| |
| index_for_src_satd++; |
| |
| if((i % num_horz_blocks) == (num_horz_blocks - 1)) |
| { |
| index_for_src_satd -= num_horz_blocks; |
| index_for_src_satd += |
| (MAX_CU_SIZE / 8); /* Assuming CTB size = 64 and blocksize = 8 */ |
| } |
| |
| } // if had block size ==4 |
| } // for loop for all 4x4 block in the cu |
| |
| psy_rd_cost = psy_rd_cost >> (Q_PSY_STRENGTH_CHROMA + LAMBDA_Q_SHIFT); |
| /* reutrn the additional cost for the psy RD opt */ |
| return (psy_rd_cost); |
| } |
| |
| /*! |
| ****************************************************************************** |
| * \if Function name : ihevce_psy_rd_cost \endif |
| * |
| * \brief |
| * Calculates the psyco visual cost for RD opt. This is |
| * |
| * \param[in] pui4_source_satd |
| * This is the pointer to the array of 8x8 satd of the corresponding source CTB. This is pre calculated. |
| * \param[in] *pui1_recon |
| * This si the pointer to the pred data. |
| * \param[in] recon_stride |
| * This si the pred stride |
| * \param[in] pic_type |
| * Picture type. |
| * \param[in] layer_id |
| * Indicates the temporal layer. |
| * \param[in] lambda |
| * This is the weighting factor for the cost. |
| * |
| * \return |
| * the cost for the psyRDopt |
| * |
| * \author |
| * Ittiam |
| * |
| ***************************************************************************** |
| */ |
| LWORD64 ihevce_psy_rd_cost( |
| LWORD64 *pui4_source_satd, |
| void *pv_recon, |
| WORD32 recon_stride_vert, |
| WORD32 recond_stride_horz, |
| WORD32 cu_size, |
| WORD32 pic_type, |
| WORD32 layer_id, |
| WORD32 lambda, |
| WORD32 start_index, |
| WORD32 is_hbd, |
| UWORD32 u4_psy_strength, |
| ihevce_cmn_opt_func_t *ps_cmn_utils_optimised_function_list) |
| { |
| /* declare local variables to store the SATD values for the pred for the current block. */ |
| LWORD64 psy_rd_cost; // TODO : check if overflow is there. |
| UWORD32 lambda_mod; |
| WORD32 psy_factor; |
| |
| /* declare local variables */ |
| WORD32 i; |
| WORD32 cu_total_size; |
| WORD32 num_comp_had_blocks; |
| |
| UWORD8 *pu1_l0_block; |
| UWORD8 *pu1_recon; |
| |
| WORD32 ht_offset; |
| WORD32 wd_offset; |
| WORD32 cu_ht; |
| WORD32 cu_wd; |
| |
| WORD32 num_horz_blocks; |
| |
| //WORD16 pi2_residue_had[64]; |
| WORD16 pi2_residue_had_zscan[64]; |
| //WORD16 pi2_residue[64]; |
| /* this is used as a buffer with all values equal to 0. This is emulate the case with |
| pred being zero in HAD fucntion */ |
| UWORD8 ai1_zeros_buffer[64]; |
| |
| WORD32 had_block_size; |
| LWORD64 source_satd; // to hold source for current 8x8 block |
| LWORD64 recon_satd; // holds the current recon 8x8 satd |
| |
| WORD32 index_for_src_satd; |
| |
| (void)recond_stride_horz; |
| (void)pic_type; |
| (void)layer_id; |
| /***** initialize the variables ****/ |
| had_block_size = 8; |
| cu_ht = cu_size; |
| cu_wd = cu_size; |
| |
| num_horz_blocks = cu_wd / had_block_size; //ctb_width / had_block_size; |
| |
| ht_offset = -had_block_size; |
| wd_offset = 0 - had_block_size; |
| |
| cu_total_size = cu_ht * cu_wd; |
| num_comp_had_blocks = cu_total_size / (had_block_size * had_block_size); |
| |
| index_for_src_satd = start_index; |
| |
| for(i = 0; i < 64; i++) |
| { |
| ai1_zeros_buffer[i] = 0; |
| } |
| psy_factor = u4_psy_strength; //PSY_STRENGTH; |
| psy_rd_cost = 0; |
| lambda_mod = lambda * psy_factor; |
| |
| if(!is_hbd) |
| { |
| pu1_recon = (UWORD8 *)pv_recon; |
| } |
| |
| /**************************************************************/ |
| /* loop over for every 8x8 blocks in the CU */ |
| for(i = 0; i < num_comp_had_blocks; i++) |
| { |
| if(i % num_horz_blocks == 0) |
| { |
| wd_offset = -had_block_size; |
| ht_offset += had_block_size; |
| } |
| wd_offset += had_block_size; |
| |
| /* source satd for the current 8x8 block */ |
| source_satd = pui4_source_satd[index_for_src_satd]; |
| |
| if(had_block_size == 8) |
| { |
| //WORD32 index; |
| //WORD32 u4_satd; |
| //WORD32 dst_strd = 8; |
| //WORD32 i4_frm_qstep = 0; |
| //WORD32 early_cbf; |
| if(!is_hbd) |
| { |
| /* get memory pointers for each of L0 and L1 blocks whose hadamard has to be computed */ |
| pu1_l0_block = pu1_recon + recon_stride_vert * ht_offset + wd_offset; |
| |
| recon_satd = ps_cmn_utils_optimised_function_list->pf_AC_HAD_8x8_8bit( |
| pu1_l0_block, |
| recon_stride_vert, |
| ai1_zeros_buffer, |
| had_block_size, |
| pi2_residue_had_zscan, |
| had_block_size); |
| } |
| |
| /* get the additional cost function based on the absolute SATD diff of source and recon. */ |
| psy_rd_cost += (lambda_mod * llabs(source_satd - recon_satd)); |
| |
| index_for_src_satd++; |
| if((i % num_horz_blocks) == (num_horz_blocks - 1)) |
| { |
| index_for_src_satd -= num_horz_blocks; |
| index_for_src_satd += |
| (MAX_CU_SIZE / 8); /* Assuming CTB size = 64 and blocksize = 8 */ |
| } |
| } // if |
| } // for loop |
| psy_rd_cost = psy_rd_cost >> (Q_PSY_STRENGTH + LAMBDA_Q_SHIFT); |
| |
| /* reutrn the additional cost for the psy RD opt */ |
| return (psy_rd_cost); |
| } |
| |
| unsigned long ihevce_calc_stim_injected_variance( |
| ULWORD64 *pu8_sigmaX, |
| ULWORD64 *pu8_sigmaXSquared, |
| ULWORD64 *u8_var, |
| WORD32 i4_inv_wpred_wt, |
| WORD32 i4_inv_wt_shift_val, |
| WORD32 i4_wpred_log_wdc, |
| WORD32 i4_part_id) |
| { |
| ULWORD64 u8_X_Square, u8_temp_var; |
| WORD32 i4_bits_req; |
| |
| const WORD32 i4_default_src_wt = ((1 << 15) + (WGHT_DEFAULT >> 1)) / WGHT_DEFAULT; |
| |
| u8_X_Square = (pu8_sigmaX[i4_part_id] * pu8_sigmaX[i4_part_id]); |
| u8_temp_var = pu8_sigmaXSquared[i4_part_id] - u8_X_Square; |
| |
| if(i4_inv_wpred_wt != i4_default_src_wt) |
| { |
| i4_inv_wpred_wt = i4_inv_wpred_wt >> i4_inv_wt_shift_val; |
| |
| u8_temp_var = SHR_NEG( |
| (u8_temp_var * i4_inv_wpred_wt * i4_inv_wpred_wt), |
| (30 - (2 * i4_inv_wt_shift_val) - i4_wpred_log_wdc * 2)); |
| } |
| |
| GETRANGE64(i4_bits_req, u8_temp_var); |
| |
| if(i4_bits_req > 27) |
| { |
| *u8_var = u8_temp_var >> (i4_bits_req - 27); |
| return (i4_bits_req - 27); |
| } |
| else |
| { |
| *u8_var = u8_temp_var; |
| return 0; |
| } |
| } |
| |
| unsigned long ihevce_calc_variance_for_diff_weights( |
| ULWORD64 *pu8_sigmaX, |
| ULWORD64 *pu8_sigmaXSquared, |
| ULWORD64 *u8_var, |
| WORD32 *pi4_inv_wt, |
| WORD32 *pi4_inv_wt_shift_val, |
| pu_result_t *ps_result, |
| WORD32 i4_wpred_log_wdc, |
| PART_ID_T *pe_part_id, |
| UWORD8 u1_cu_size, |
| UWORD8 u1_num_parts, |
| UWORD8 u1_is_for_src) |
| { |
| WORD32 i4_k; |
| UWORD32 u4_wd, u4_ht; |
| UWORD8 u1_num_base_blks; |
| UWORD32 u4_num_pixels_in_part; |
| UWORD8 u1_index; |
| WORD32 i4_bits_req; |
| |
| UWORD8 u1_base_blk_size = 4; |
| UWORD32 u4_tot_num_pixels = u1_cu_size * u1_cu_size; |
| ULWORD64 u8_temp_sigmaX[MAX_NUM_INTER_PARTS] = { 0, 0 }; |
| ULWORD64 u8_temp_sigmaXsquared[MAX_NUM_INTER_PARTS] = { 0, 0 }; |
| ULWORD64 u8_z; |
| |
| const WORD32 i4_default_src_wt = ((1 << 15) + (WGHT_DEFAULT >> 1)) / WGHT_DEFAULT; |
| |
| for(i4_k = 0; i4_k < u1_num_parts; i4_k++) |
| { |
| u4_wd = ps_result[i4_k].pu.b4_wd + 1; |
| u4_ht = ps_result[i4_k].pu.b4_ht + 1; |
| u1_num_base_blks = u4_wd * u4_ht; |
| u4_num_pixels_in_part = u1_num_base_blks * u1_base_blk_size * u1_base_blk_size; |
| |
| if(u1_is_for_src) |
| { |
| u1_index = pe_part_id[i4_k]; |
| } |
| else |
| { |
| u1_index = i4_k; |
| } |
| |
| u8_temp_sigmaXsquared[i4_k] = pu8_sigmaXSquared[u1_index] / u4_num_pixels_in_part; |
| u8_temp_sigmaX[i4_k] = pu8_sigmaX[u1_index]; |
| |
| if(u1_is_for_src) |
| { |
| if(pi4_inv_wt[i4_k] != i4_default_src_wt) |
| { |
| pi4_inv_wt[i4_k] = pi4_inv_wt[i4_k] >> pi4_inv_wt_shift_val[i4_k]; |
| u8_temp_sigmaX[i4_k] = SHR_NEG( |
| (u8_temp_sigmaX[i4_k] * pi4_inv_wt[i4_k]), |
| (15 - pi4_inv_wt_shift_val[i4_k] - i4_wpred_log_wdc)); |
| u8_temp_sigmaXsquared[i4_k] = SHR_NEG( |
| (u8_temp_sigmaXsquared[i4_k] * pi4_inv_wt[i4_k] * pi4_inv_wt[i4_k]), |
| (30 - (2 * pi4_inv_wt_shift_val[i4_k]) - i4_wpred_log_wdc * 2)); |
| } |
| } |
| } |
| |
| u8_z = (u4_tot_num_pixels * (u8_temp_sigmaXsquared[0] + u8_temp_sigmaXsquared[1])) - |
| ((u8_temp_sigmaX[0] + u8_temp_sigmaX[1]) * (u8_temp_sigmaX[0] + u8_temp_sigmaX[1])); |
| |
| GETRANGE64(i4_bits_req, u8_z); |
| |
| if(i4_bits_req > 27) |
| { |
| *u8_var = u8_z >> (i4_bits_req - 27); |
| return (i4_bits_req - 27); |
| } |
| else |
| { |
| *u8_var = u8_z; |
| return 0; |
| } |
| } |
