/******************************************************************************
|
*
|
* 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_ipe_pass.c
|
*
|
* \brief
|
* This file contains interface functions of Intra Prediction Estimation
|
* module
|
* \date
|
* 18/09/2012
|
*
|
* \author
|
* Ittiam
|
*
|
*
|
* List of Functions
|
*
|
*
|
******************************************************************************
|
*/
|
|
/*****************************************************************************/
|
/* File Includes */
|
/*****************************************************************************/
|
/* System include files */
|
#include <stdio.h>
|
#include <string.h>
|
#include <stdlib.h>
|
#include <assert.h>
|
#include <stdarg.h>
|
#include <math.h>
|
|
/* 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_debug.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 "ihevc_quant_tables.h"
|
|
#include "ihevce_defs.h"
|
#include "ihevce_hle_interface.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 "ihevc_weighted_pred.h"
|
#include "ihevce_ipe_instr_set_router.h"
|
#include "ihevce_ipe_structs.h"
|
#include "ihevce_ipe_pass.h"
|
#include "ihevce_decomp_pre_intra_structs.h"
|
#include "ihevce_decomp_pre_intra_pass.h"
|
#include "ihevce_recur_bracketing.h"
|
#include "ihevce_nbr_avail.h"
|
#include "ihevce_global_tables.h"
|
#include "ihevc_resi_trans.h"
|
|
#include "cast_types.h"
|
#include "osal.h"
|
#include "osal_defaults.h"
|
|
/*****************************************************************************/
|
/* Global Tables */
|
/*****************************************************************************/
|
|
/**
|
******************************************************************************
|
* @brief Look up table for choosing the appropriate function for
|
* Intra prediction
|
*
|
* @remarks Same look up table enums are used for luma & chroma but each
|
* have seperate functions implemented
|
******************************************************************************
|
*/
|
WORD32 g_i4_ipe_funcs[MAX_NUM_IP_MODES] = {
|
IPE_FUNC_MODE_0, /* Mode 0 */
|
IPE_FUNC_MODE_1, /* Mode 1 */
|
IPE_FUNC_MODE_2, /* Mode 2 */
|
IPE_FUNC_MODE_3TO9, /* Mode 3 */
|
IPE_FUNC_MODE_3TO9, /* Mode 4 */
|
IPE_FUNC_MODE_3TO9, /* Mode 5 */
|
IPE_FUNC_MODE_3TO9, /* Mode 6 */
|
IPE_FUNC_MODE_3TO9, /* Mode 7 */
|
IPE_FUNC_MODE_3TO9, /* Mode 8 */
|
IPE_FUNC_MODE_3TO9, /* Mode 9 */
|
IPE_FUNC_MODE_10, /* Mode 10 */
|
IPE_FUNC_MODE_11TO17, /* Mode 11 */
|
IPE_FUNC_MODE_11TO17, /* Mode 12 */
|
IPE_FUNC_MODE_11TO17, /* Mode 13 */
|
IPE_FUNC_MODE_11TO17, /* Mode 14 */
|
IPE_FUNC_MODE_11TO17, /* Mode 15 */
|
IPE_FUNC_MODE_11TO17, /* Mode 16 */
|
IPE_FUNC_MODE_11TO17, /* Mode 17 */
|
IPE_FUNC_MODE_18_34, /* Mode 18 */
|
IPE_FUNC_MODE_19TO25, /* Mode 19 */
|
IPE_FUNC_MODE_19TO25, /* Mode 20 */
|
IPE_FUNC_MODE_19TO25, /* Mode 21 */
|
IPE_FUNC_MODE_19TO25, /* Mode 22 */
|
IPE_FUNC_MODE_19TO25, /* Mode 23 */
|
IPE_FUNC_MODE_19TO25, /* Mode 24 */
|
IPE_FUNC_MODE_19TO25, /* Mode 25 */
|
IPE_FUNC_MODE_26, /* Mode 26 */
|
IPE_FUNC_MODE_27TO33, /* Mode 27 */
|
IPE_FUNC_MODE_27TO33, /* Mode 26 */
|
IPE_FUNC_MODE_27TO33, /* Mode 29 */
|
IPE_FUNC_MODE_27TO33, /* Mode 30 */
|
IPE_FUNC_MODE_27TO33, /* Mode 31 */
|
IPE_FUNC_MODE_27TO33, /* Mode 32 */
|
IPE_FUNC_MODE_27TO33, /* Mode 33 */
|
IPE_FUNC_MODE_18_34, /* Mode 34 */
|
};
|
|
/**
|
******************************************************************************
|
* @brief Look up table for deciding whether to use original samples or
|
* filtered reference samples for Intra prediction
|
*
|
* @remarks This table has the flags for transform size of 8, 16 and 32
|
* Input is log2nT - 3 and intra prediction mode
|
******************************************************************************
|
*/
|
UWORD8 gau1_ipe_filter_flag[3][MAX_NUM_IP_MODES] = {
|
{ 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
|
{ 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1,
|
1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 },
|
{ 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
|
1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 }
|
};
|
|
/*****************************************************************************/
|
/* Function Definitions */
|
/*****************************************************************************/
|
|
/*!
|
******************************************************************************
|
* \if Function name : ihevce_ipe_recompute_lambda_from_min_8x8_act_in_ctb \endif
|
*
|
* \brief
|
* This function recomputes lambda using min 8x8 act in CTB
|
*
|
* \author
|
* Ittiam
|
*
|
* \return
|
* Nothing
|
*
|
******************************************************************************
|
*/
|
void ihevce_ipe_recompute_lambda_from_min_8x8_act_in_ctb(
|
ihevce_ipe_ctxt_t *ps_ctxt, ihevce_ed_ctb_l1_t *ps_ed_ctb_l1)
|
{
|
WORD32 i4_cu_qp = 0;
|
WORD32 i4_mod_factor_num;
|
#if MODULATE_LAMDA_WHEN_SPATIAL_MOD_ON
|
WORD32 i4_activity;
|
#endif
|
WORD32 i4_qscale;
|
WORD32 i4_curr_satd;
|
long double ld_avg_satd;
|
|
#if MODULATE_LAMDA_WHEN_SPATIAL_MOD_ON
|
WORD32 i4_mod_factor_denom = QP_MOD_FACTOR_DEN;
|
#endif
|
|
if(ISLICE == ps_ctxt->i4_slice_type)
|
{
|
i4_mod_factor_num = INTRA_QP_MOD_FACTOR_NUM;
|
}
|
else
|
{
|
i4_mod_factor_num = INTER_QP_MOD_FACTOR_NUM;
|
}
|
|
#if LAMDA_BASED_ON_QUANT
|
i4_curr_satd = ps_ed_ctb_l1->i4_32x32_satd[0][2];
|
i8_avg_satd = ps_ctxt->i8_curr_frame_32x32_avg_act[2];
|
#else
|
i4_curr_satd = ps_ed_ctb_l1->i4_32x32_satd[0][3];
|
|
ld_avg_satd = 2.0 + ps_ctxt->ld_curr_frame_16x16_log_avg[0];
|
|
#endif
|
if(ps_ctxt->i4_l0ipe_qp_mod)
|
{
|
#if MODULATE_LAMDA_WHEN_SPATIAL_MOD_ON
|
i4_cu_qp = ihevce_cu_level_qp_mod(
|
ps_ctxt->i4_qscale,
|
i4_curr_satd,
|
ld_avg_satd,
|
ps_ctxt->f_strength,
|
&i4_activity,
|
&i4_qscale,
|
ps_ctxt->ps_rc_quant_ctxt);
|
#endif
|
}
|
ihevce_get_ipe_ol_cu_lambda_prms(ps_ctxt, i4_cu_qp);
|
}
|
/*!
|
******************************************************************************
|
* \if Function name : ihevce_ipe_pass_satd \endif
|
*
|
* \brief
|
* This function calcuates the SATD for a given size and returns the value
|
*
|
* \date
|
* 18/09/2012
|
*
|
* \author
|
* Ittiam
|
*
|
* \return
|
*
|
* List of Functions
|
*
|
******************************************************************************
|
*/
|
UWORD32 ihevce_ipe_pass_satd(WORD16 *pi2_coeff, WORD32 coeff_stride, WORD32 trans_size)
|
{
|
WORD32 i, j, satd;
|
|
satd = 0;
|
|
/* run a loop and find the satd by doing ABS */
|
for(i = 0; i < trans_size; i++)
|
{
|
for(j = 0; j < trans_size; j++)
|
{
|
satd += abs(*pi2_coeff++);
|
}
|
/* row level update */
|
pi2_coeff += coeff_stride - trans_size;
|
}
|
|
{
|
WORD32 transform_shift;
|
WORD32 log2_trans_size;
|
|
GETRANGE(log2_trans_size, trans_size);
|
log2_trans_size -= 1;
|
transform_shift = MAX_TR_DYNAMIC_RANGE - BIT_DEPTH - log2_trans_size;
|
satd >>= transform_shift;
|
}
|
|
return (satd);
|
}
|
|
/*!
|
******************************************************************************
|
* \if Function name : ihevce_ipe_get_num_mem_recs \endif
|
*
|
* \brief
|
* Number of memory records are returned for IPE module
|
*
|
*
|
* \return
|
* None
|
*
|
* \author
|
* Ittiam
|
*
|
*****************************************************************************
|
*/
|
WORD32 ihevce_ipe_get_num_mem_recs(void)
|
{
|
return (NUM_IPE_MEM_RECS);
|
}
|
|
/*!
|
******************************************************************************
|
* \if Function name : ihevce_ipe_get_mem_recs \endif
|
*
|
* \brief
|
* Memory requirements are returned for IPE.
|
*
|
* \param[in,out] ps_mem_tab : pointer to memory descriptors table
|
* \param[in] ps_init_prms : Create time static parameters
|
* \param[in] i4_num_proc_thrds : Number of processing threads for this module
|
* \param[in] i4_mem_space : memspace in whihc memory request should be done
|
*
|
* \return
|
* None
|
*
|
* \author
|
* Ittiam
|
*
|
*****************************************************************************
|
*/
|
WORD32
|
ihevce_ipe_get_mem_recs(iv_mem_rec_t *ps_mem_tab, WORD32 i4_num_proc_thrds, WORD32 i4_mem_space)
|
{
|
/* memories should be requested assuming worst case requirememnts */
|
|
/* Module context structure */
|
ps_mem_tab[IPE_CTXT].i4_mem_size = sizeof(ihevce_ipe_master_ctxt_t);
|
|
ps_mem_tab[IPE_CTXT].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space;
|
|
ps_mem_tab[IPE_CTXT].i4_mem_alignment = 8;
|
|
/* Threads ctxt structure */
|
ps_mem_tab[IPE_THRDS_CTXT].i4_mem_size = i4_num_proc_thrds * sizeof(ihevce_ipe_ctxt_t);
|
|
ps_mem_tab[IPE_THRDS_CTXT].e_mem_type = (IV_MEM_TYPE_T)i4_mem_space;
|
|
ps_mem_tab[IPE_THRDS_CTXT].i4_mem_alignment = 32;
|
|
return (NUM_IPE_MEM_RECS);
|
}
|
|
/*!
|
******************************************************************************
|
* \if Function name : ihevce_ipe_init \endif
|
*
|
* \brief
|
* Intialization for IPE context state structure .
|
*
|
* \param[in] ps_mem_tab : pointer to memory descriptors table
|
* \param[in] ps_init_prms : Create time static parameters
|
*
|
* \return
|
* None
|
*
|
* \author
|
* Ittiam
|
*
|
*****************************************************************************
|
*/
|
void *ihevce_ipe_init(
|
iv_mem_rec_t *ps_mem_tab,
|
ihevce_static_cfg_params_t *ps_init_prms,
|
WORD32 i4_num_proc_thrds,
|
WORD32 i4_ref_id,
|
func_selector_t *ps_func_selector,
|
rc_quant_t *ps_rc_quant_ctxt,
|
WORD32 i4_resolution_id,
|
UWORD8 u1_is_popcnt_available)
|
{
|
WORD32 i4_thrds;
|
UWORD32 u4_width, u4_ctb_in_a_row;
|
// WORD32 i4_ctr;
|
ihevce_ipe_master_ctxt_t *ps_master_ctxt;
|
ihevce_ipe_ctxt_t *ps_ctxt;
|
|
/* IPE master state structure */
|
ps_master_ctxt = (ihevce_ipe_master_ctxt_t *)ps_mem_tab[IPE_CTXT].pv_base;
|
|
ps_master_ctxt->i4_num_proc_thrds = i4_num_proc_thrds;
|
|
ps_ctxt = (ihevce_ipe_ctxt_t *)ps_mem_tab[IPE_THRDS_CTXT].pv_base;
|
|
ps_ctxt->ps_rc_quant_ctxt = ps_rc_quant_ctxt;
|
|
/*width of the input YUV to be encoded. */
|
u4_width = ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_width;
|
/*making the width a multiple of CTB size*/
|
u4_width += SET_CTB_ALIGN(
|
ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_width, MAX_CTB_SIZE);
|
|
u4_ctb_in_a_row = (u4_width / MAX_CTB_SIZE);
|
|
/* perform all one initialisation here */
|
for(i4_thrds = 0; i4_thrds < ps_master_ctxt->i4_num_proc_thrds; i4_thrds++)
|
{
|
ps_master_ctxt->aps_ipe_thrd_ctxt[i4_thrds] = ps_ctxt;
|
|
/* initialise the CU and TU sizes */
|
ps_ctxt->u1_ctb_size = (1 << ps_init_prms->s_config_prms.i4_max_log2_cu_size);
|
ps_ctxt->u1_min_cu_size = (1 << ps_init_prms->s_config_prms.i4_min_log2_cu_size);
|
ps_ctxt->u1_min_tu_size = (1 << ps_init_prms->s_config_prms.i4_min_log2_tu_size);
|
|
/** Register the function selector pointer*/
|
ps_ctxt->ps_func_selector = ps_func_selector;
|
|
/* Initiailize the encoder quality preset */
|
/* IPE algorithm is controlled based on this preset */
|
ps_ctxt->i4_quality_preset =
|
ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].i4_quality_preset;
|
|
if(ps_ctxt->i4_quality_preset == IHEVCE_QUALITY_P7)
|
{
|
ps_ctxt->i4_quality_preset = IHEVCE_QUALITY_P6;
|
}
|
|
/* initialise all the pointer to start of arrays */
|
ps_ctxt->ps_ipe_cu_tree = &ps_ctxt->as_ipe_cu_tree[0];
|
|
/* initialize QP */
|
ps_ctxt->i1_QP =
|
ps_init_prms->s_tgt_lyr_prms.as_tgt_params[i4_resolution_id].ai4_frame_qp[i4_ref_id];
|
ps_ctxt->u1_num_b_frames =
|
(1 << ps_init_prms->s_coding_tools_prms.i4_max_temporal_layers) - 1;
|
|
ps_ctxt->b_sad_type = IPE_SAD_TYPE;
|
ps_ctxt->u1_ipe_step_size = IPE_STEP_SIZE;
|
|
ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_0] =
|
ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_planar_fptr;
|
ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_1] =
|
ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_dc_fptr;
|
ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_2] =
|
ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_mode2_fptr;
|
ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_3TO9] =
|
ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_mode_3_to_9_fptr;
|
ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_10] =
|
ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_horz_fptr;
|
ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_11TO17] =
|
ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_mode_11_to_17_fptr;
|
ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_18_34] =
|
ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_mode_18_34_fptr;
|
ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_19TO25] =
|
ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_mode_19_to_25_fptr;
|
ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_26] =
|
ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_ver_fptr;
|
ps_ctxt->apf_ipe_lum_ip[IPE_FUNC_MODE_27TO33] =
|
ps_ctxt->ps_func_selector->ihevc_intra_pred_luma_mode_27_to_33_fptr;
|
|
/* nbr parameters initialization */
|
/* perform all one initialisation here */
|
|
ps_ctxt->i4_nbr_map_strd = MAX_PU_IN_CTB_ROW + 1 + 8;
|
|
ps_ctxt->pu1_ctb_nbr_map = ps_ctxt->au1_nbr_ctb_map[0];
|
|
/* move the pointer to 1,2 location */
|
ps_ctxt->pu1_ctb_nbr_map += ps_ctxt->i4_nbr_map_strd;
|
ps_ctxt->pu1_ctb_nbr_map++;
|
ps_ctxt->i4_l0ipe_qp_mod = ps_init_prms->s_config_prms.i4_cu_level_rc & 1;
|
ps_ctxt->i4_pass = ps_init_prms->s_pass_prms.i4_pass;
|
if(ps_init_prms->s_coding_tools_prms.i4_use_default_sc_mtx == 0)
|
{
|
/* initialise the scale & rescale matricies */
|
ps_ctxt->api2_scal_mat[0] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];
|
ps_ctxt->api2_scal_mat[1] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];
|
ps_ctxt->api2_scal_mat[2] = (WORD16 *)&gi2_flat_scale_mat_8x8[0];
|
ps_ctxt->api2_scal_mat[3] = (WORD16 *)&gi2_flat_scale_mat_16x16[0];
|
ps_ctxt->api2_scal_mat[4] = (WORD16 *)&gi2_flat_scale_mat_32x32[0];
|
/*init for inter matrix*/
|
ps_ctxt->api2_scal_mat[5] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];
|
ps_ctxt->api2_scal_mat[6] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];
|
ps_ctxt->api2_scal_mat[7] = (WORD16 *)&gi2_flat_scale_mat_8x8[0];
|
ps_ctxt->api2_scal_mat[8] = (WORD16 *)&gi2_flat_scale_mat_16x16[0];
|
ps_ctxt->api2_scal_mat[9] = (WORD16 *)&gi2_flat_scale_mat_32x32[0];
|
|
/*init for rescale matrix*/
|
ps_ctxt->api2_rescal_mat[0] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];
|
ps_ctxt->api2_rescal_mat[1] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];
|
ps_ctxt->api2_rescal_mat[2] = (WORD16 *)&gi2_flat_rescale_mat_8x8[0];
|
ps_ctxt->api2_rescal_mat[3] = (WORD16 *)&gi2_flat_rescale_mat_16x16[0];
|
ps_ctxt->api2_rescal_mat[4] = (WORD16 *)&gi2_flat_rescale_mat_32x32[0];
|
/*init for rescale inter matrix*/
|
ps_ctxt->api2_rescal_mat[5] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];
|
ps_ctxt->api2_rescal_mat[6] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];
|
ps_ctxt->api2_rescal_mat[7] = (WORD16 *)&gi2_flat_rescale_mat_8x8[0];
|
ps_ctxt->api2_rescal_mat[8] = (WORD16 *)&gi2_flat_rescale_mat_16x16[0];
|
ps_ctxt->api2_rescal_mat[9] = (WORD16 *)&gi2_flat_rescale_mat_32x32[0];
|
}
|
else if(ps_init_prms->s_coding_tools_prms.i4_use_default_sc_mtx == 1)
|
{
|
/* initialise the scale & rescale matricies */
|
ps_ctxt->api2_scal_mat[0] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];
|
ps_ctxt->api2_scal_mat[1] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];
|
ps_ctxt->api2_scal_mat[2] = (WORD16 *)&gi2_intra_default_scale_mat_8x8[0];
|
ps_ctxt->api2_scal_mat[3] = (WORD16 *)&gi2_intra_default_scale_mat_16x16[0];
|
ps_ctxt->api2_scal_mat[4] = (WORD16 *)&gi2_intra_default_scale_mat_32x32[0];
|
/*init for inter matrix*/
|
ps_ctxt->api2_scal_mat[5] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];
|
ps_ctxt->api2_scal_mat[6] = (WORD16 *)&gi2_flat_scale_mat_4x4[0];
|
ps_ctxt->api2_scal_mat[7] = (WORD16 *)&gi2_inter_default_scale_mat_8x8[0];
|
ps_ctxt->api2_scal_mat[8] = (WORD16 *)&gi2_inter_default_scale_mat_16x16[0];
|
ps_ctxt->api2_scal_mat[9] = (WORD16 *)&gi2_inter_default_scale_mat_32x32[0];
|
|
/*init for rescale matrix*/
|
ps_ctxt->api2_rescal_mat[0] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];
|
ps_ctxt->api2_rescal_mat[1] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];
|
ps_ctxt->api2_rescal_mat[2] = (WORD16 *)&gi2_intra_default_rescale_mat_8x8[0];
|
ps_ctxt->api2_rescal_mat[3] = (WORD16 *)&gi2_intra_default_rescale_mat_16x16[0];
|
ps_ctxt->api2_rescal_mat[4] = (WORD16 *)&gi2_intra_default_rescale_mat_32x32[0];
|
/*init for rescale inter matrix*/
|
ps_ctxt->api2_rescal_mat[5] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];
|
ps_ctxt->api2_rescal_mat[6] = (WORD16 *)&gi2_flat_rescale_mat_4x4[0];
|
ps_ctxt->api2_rescal_mat[7] = (WORD16 *)&gi2_inter_default_rescale_mat_8x8[0];
|
ps_ctxt->api2_rescal_mat[8] = (WORD16 *)&gi2_inter_default_rescale_mat_16x16[0];
|
ps_ctxt->api2_rescal_mat[9] = (WORD16 *)&gi2_inter_default_rescale_mat_32x32[0];
|
}
|
else
|
{
|
ASSERT(0);
|
}
|
|
ps_ctxt->u1_bit_depth = ps_init_prms->s_tgt_lyr_prms.i4_internal_bit_depth;
|
|
/**
|
* Initialize the intra prediction modes map for the CTB to INTRA_DC
|
**/
|
{
|
WORD32 row, col;
|
for(row = 0; row < (MAX_TU_ROW_IN_CTB + 1); row++)
|
for(col = 0; col < (MAX_TU_COL_IN_CTB + 1); col++)
|
ps_ctxt->au1_ctb_mode_map[row][col] = INTRA_DC;
|
}
|
|
ihevce_cmn_utils_instr_set_router(
|
&ps_ctxt->s_cmn_opt_func, u1_is_popcnt_available, ps_init_prms->e_arch_type);
|
|
ihevce_ipe_instr_set_router(
|
&ps_ctxt->s_ipe_optimised_function_list, ps_init_prms->e_arch_type);
|
|
/* increment the thread ctxt pointer */
|
ps_ctxt++;
|
}
|
|
/* return the handle to caller */
|
return ((void *)ps_master_ctxt);
|
}
|
/*!
|
******************************************************************************
|
* \if Function name : ihevce_ipe_get_frame_intra_satd_cost \endif
|
*
|
* \brief
|
* Function to export frame-level accumalated SATD .
|
*
|
* \param[in] pv_ctxt : pointer to IPE module
|
*
|
* \return
|
* None
|
*
|
* \author
|
* Ittiam
|
*
|
*****************************************************************************
|
*/
|
LWORD64 ihevce_ipe_get_frame_intra_satd_cost(
|
void *pv_ctxt,
|
LWORD64 *pi8_frame_satd_by_qpmod,
|
LWORD64 *pi8_frame_acc_mode_bits_cost,
|
LWORD64 *pi8_frame_acc_activity_factor,
|
LWORD64 *pi8_frame_l0_acc_satd)
|
{
|
WORD32 i4_thrds;
|
|
ihevce_ipe_master_ctxt_t *ps_master_ctxt;
|
ihevce_ipe_ctxt_t *ps_ctxt;
|
LWORD64 i8_frame_acc_satd_cost = 0;
|
LWORD64 i8_frame_acc_satd = 0;
|
LWORD64 i8_frame_satd_by_qpmod = 0;
|
LWORD64 i8_frame_acc_mode_bits_cost = 0;
|
LWORD64 i8_frame_acc_activity_factor = 0;
|
/* IPE master state structure */
|
ps_master_ctxt = (ihevce_ipe_master_ctxt_t *)pv_ctxt;
|
|
/* perform all one initialisation here */
|
for(i4_thrds = 0; i4_thrds < ps_master_ctxt->i4_num_proc_thrds; i4_thrds++)
|
{
|
ps_ctxt = ps_master_ctxt->aps_ipe_thrd_ctxt[i4_thrds];
|
|
i8_frame_acc_satd_cost += ps_ctxt->i8_frame_acc_satd_cost;
|
i8_frame_satd_by_qpmod += (ps_ctxt->i8_frame_acc_satd_by_modqp_q10 >> SATD_BY_ACT_Q_FAC);
|
i8_frame_acc_mode_bits_cost += ps_ctxt->i8_frame_acc_mode_bits_cost;
|
|
i8_frame_acc_activity_factor += ps_ctxt->i8_frame_acc_act_factor;
|
|
i8_frame_acc_satd += ps_ctxt->i8_frame_acc_satd;
|
}
|
*pi8_frame_satd_by_qpmod = i8_frame_satd_by_qpmod;
|
|
*pi8_frame_acc_mode_bits_cost = i8_frame_acc_mode_bits_cost;
|
|
*pi8_frame_acc_activity_factor = i8_frame_acc_activity_factor;
|
|
*pi8_frame_l0_acc_satd = i8_frame_acc_satd;
|
|
return (i8_frame_acc_satd_cost);
|
}
|
|
/**
|
*******************************************************************************
|
* \if Function name : ihevce_intra_pred_ref_filtering \endif
|
*
|
* \brief
|
* Intra prediction interpolation filter for ref_filtering for Encoder
|
*
|
* \par Description:
|
* Reference DC filtering for neighboring samples dependent on TU size and
|
* mode Refer to section 8.4.4.2.3 in the standard
|
*
|
* \param[in] pu1_src pointer to the source
|
* \param[out] pu1_dst pointer to the destination
|
* \param[in] nt integer Transform Block size
|
*
|
* \returns
|
* none
|
*
|
* \author
|
* Ittiam
|
*
|
*******************************************************************************
|
*/
|
|
#if IHEVCE_INTRA_REF_FILTERING == C
|
void ihevce_intra_pred_ref_filtering(UWORD8 *pu1_src, WORD32 nt, UWORD8 *pu1_dst)
|
{
|
WORD32 i; /* Generic indexing variable */
|
WORD32 four_nt = 4 * nt;
|
|
/* Extremities Untouched*/
|
pu1_dst[0] = pu1_src[0];
|
pu1_dst[4 * nt] = pu1_src[4 * nt];
|
/* Perform bilinear filtering of Reference Samples */
|
for(i = 0; i < (four_nt - 1); i++)
|
{
|
pu1_dst[i + 1] = (pu1_src[i] + 2 * pu1_src[i + 1] + pu1_src[i + 2] + 2) >> 2;
|
}
|
}
|
#endif
|
|
/*!
|
******************************************************************************
|
* \if Function name : ihevce_ipe_process_ctb \endif
|
*
|
* \brief
|
* CTB level IPE function
|
*
|
* \param[in] pv_ctxt : pointer to IPE module
|
* \param[in] ps_frm_ctb_prms : CTB characteristics parameters
|
* \param[in] ps_curr_src : pointer to input yuv buffer (row buffer)
|
* \param[out] ps_ctb_out : pointer to CTB analyse output structure (row buffer)
|
* \param[out] ps_row_cu : pointer to CU analyse output structure (row buffer)
|
*
|
* \return
|
* None
|
*
|
* Note : This function will receive CTB pointers which may point to
|
* blocks of CTB size or smaller (at the right and bottom edges of the picture)
|
* This function recursively creates smaller square partitions and passes them
|
* on for intra processing estimation
|
*
|
* \author
|
* Ittiam
|
*
|
*****************************************************************************
|
*/
|
void ihevce_ipe_process_ctb(
|
ihevce_ipe_ctxt_t *ps_ctxt,
|
frm_ctb_ctxt_t *ps_frm_ctb_prms,
|
iv_enc_yuv_buf_t *ps_curr_src,
|
ihevce_ipe_cu_tree_t *ps_curr_ctb_node,
|
ipe_l0_ctb_analyse_for_me_t *ps_l0_ipe_out_ctb,
|
ctb_analyse_t *ps_ctb_out,
|
//cu_analyse_t *ps_row_cu,
|
ihevce_ed_blk_t *ps_ed_l1_ctb,
|
ihevce_ed_blk_t *ps_ed_l2_ctb,
|
ihevce_ed_ctb_l1_t *ps_ed_ctb_l1)
|
{
|
/* reset the map buffer to 0*/
|
memset(
|
&ps_ctxt->au1_nbr_ctb_map[0][0],
|
0,
|
(MAX_PU_IN_CTB_ROW + 1 + 8) * (MAX_PU_IN_CTB_ROW + 1 + 8));
|
|
/* set the CTB neighbour availability flags */
|
ihevce_set_ctb_nbr(
|
&ps_ctxt->s_ctb_nbr_avail_flags,
|
ps_ctxt->pu1_ctb_nbr_map,
|
ps_ctxt->i4_nbr_map_strd,
|
ps_ctxt->u2_ctb_num_in_row,
|
ps_ctxt->u2_ctb_row_num,
|
ps_frm_ctb_prms);
|
|
/* IPE cu and mode decision */
|
ihevce_bracketing_analysis(
|
ps_ctxt,
|
ps_curr_ctb_node,
|
ps_curr_src,
|
ps_ctb_out,
|
//ps_row_cu,
|
ps_ed_l1_ctb,
|
ps_ed_l2_ctb,
|
ps_ed_ctb_l1,
|
ps_l0_ipe_out_ctb);
|
|
return;
|
}
|
|
/*!
|
******************************************************************************
|
* \if Function name : ihevce_ipe_process_row \endif
|
*
|
* \brief
|
* Row level IPE function
|
*
|
* \param[in] pv_ctxt : pointer to IPE module
|
* \param[in] ps_frm_ctb_prms : CTB characteristics parameters
|
* \param[in] ps_curr_src : pointer to input yuv buffer (row buffer)
|
* \param[out] ps_ctb_out : pointer to CTB analyse output structure (row buffer)
|
* \param[out] ps_cu_out : pointer to CU analyse output structure (row buffer)
|
*\param[out] pi4_num_ctbs_cur_row : pointer to store the number of ctbs processed in current row
|
*\param[in] pi4_num_ctbs_top_row : pointer to check the number of ctbs processed in top row
|
*
|
* \return
|
* None
|
*
|
* Note : Currently the frame level calculations done assumes that
|
* framewidth of the input are excat multiple of ctbsize
|
*
|
* \author
|
* Ittiam
|
*
|
*****************************************************************************
|
*/
|
void ihevce_ipe_process_row(
|
ihevce_ipe_ctxt_t *ps_ctxt,
|
frm_ctb_ctxt_t *ps_frm_ctb_prms,
|
iv_enc_yuv_buf_t *ps_curr_src,
|
ipe_l0_ctb_analyse_for_me_t *ps_ipe_ctb_out_row,
|
ctb_analyse_t *ps_ctb_out,
|
//cu_analyse_t *ps_row_cu,
|
ihevce_ed_blk_t *ps_ed_l1_row,
|
ihevce_ed_blk_t *ps_ed_l2_row,
|
ihevce_ed_ctb_l1_t *ps_ed_ctb_l1_row,
|
WORD32 blk_inc_ctb_l1,
|
WORD32 blk_inc_ctb_l2)
|
{
|
/* local variables */
|
UWORD16 ctb_ctr;
|
iv_enc_yuv_buf_t s_curr_src_bufs;
|
ipe_l0_ctb_analyse_for_me_t *ps_l0_ipe_out_ctb;
|
UWORD16 u2_pic_wdt;
|
UWORD16 u2_pic_hgt;
|
ihevce_ed_blk_t *ps_ed_l1_ctb;
|
ihevce_ed_blk_t *ps_ed_l2_ctb;
|
ihevce_ed_ctb_l1_t *ps_ed_ctb_l1;
|
|
UWORD8 u1_ctb_size;
|
|
u2_pic_wdt = ps_frm_ctb_prms->i4_cu_aligned_pic_wd;
|
u2_pic_hgt = ps_frm_ctb_prms->i4_cu_aligned_pic_ht;
|
|
u1_ctb_size = ps_ctxt->u1_ctb_size;
|
|
/* ----------------------------------------------------- */
|
/* store the stride and dimensions of source */
|
/* buffer pointers will be over written at every CTB row */
|
/* ----------------------------------------------------- */
|
memcpy(&s_curr_src_bufs, ps_curr_src, sizeof(iv_enc_yuv_buf_t));
|
ps_l0_ipe_out_ctb = ps_ipe_ctb_out_row;
|
|
/* --------- Loop over all the CTBs in a row --------------- */
|
for(ctb_ctr = 0; ctb_ctr < ps_frm_ctb_prms->i4_num_ctbs_horz; ctb_ctr++)
|
{
|
//UWORD8 num_cus_in_ctb;
|
|
UWORD8 *pu1_tmp;
|
|
/* Create pointer to ctb node */
|
ihevce_ipe_cu_tree_t *ps_ctb_node;
|
|
WORD32 nbr_flags;
|
|
WORD32 row;
|
/* luma src */
|
pu1_tmp = (UWORD8 *)ps_curr_src->pv_y_buf;
|
pu1_tmp += (ctb_ctr * ps_frm_ctb_prms->i4_ctb_size);
|
|
s_curr_src_bufs.pv_y_buf = pu1_tmp;
|
|
/* Cb & CR pixel interleaved src */
|
pu1_tmp = (UWORD8 *)ps_curr_src->pv_u_buf;
|
pu1_tmp += (ctb_ctr * (ps_frm_ctb_prms->i4_ctb_size >> 1));
|
|
s_curr_src_bufs.pv_u_buf = pu1_tmp;
|
|
/* Store the number of current ctb within row in the context */
|
ps_ctxt->u2_ctb_num_in_row = ctb_ctr;
|
|
/* Initialize number of coding units in ctb to 0 */
|
ps_ctb_out->u1_num_cus_in_ctb = 0;
|
/* Initialize split flag to 0 - No partition */
|
ps_ctb_out->u4_cu_split_flags = 0;
|
/* store the cu pointer for current ctb out */
|
//ps_ctb_out->ps_coding_units_in_ctb = ps_row_cu;
|
|
/* Initialize the CTB parameters at the root node level */
|
ps_ctb_node = ps_ctxt->ps_ipe_cu_tree;
|
ps_ctb_node->ps_parent = NULL;
|
ps_ctb_node->u1_depth = 0;
|
ps_ctb_node->u1_cu_size = u1_ctb_size;
|
ps_ctb_node->u2_x0 = 0;
|
ps_ctb_node->u2_y0 = 0;
|
|
ps_ctb_node->u2_orig_x = ctb_ctr * ps_ctb_node->u1_cu_size;
|
ps_ctb_node->u2_orig_y = ps_ctxt->u2_ctb_row_num * ps_ctb_node->u1_cu_size;
|
|
ps_ctb_node->u1_width = u1_ctb_size;
|
ps_ctb_node->u1_height = u1_ctb_size;
|
#if !(PIC_ALIGN_CTB_SIZE)
|
if(ps_ctxt->u2_ctb_num_in_row == (ps_frm_ctb_prms->i4_num_ctbs_horz - 1))
|
{
|
ps_ctb_node->u1_width = u2_pic_wdt - (ps_ctxt->u2_ctb_num_in_row) * (u1_ctb_size);
|
}
|
if(ps_ctxt->u2_ctb_row_num == (ps_frm_ctb_prms->i4_num_ctbs_vert - 1))
|
{
|
ps_ctb_node->u1_height = u2_pic_hgt - (ps_ctxt->u2_ctb_row_num) * (u1_ctb_size);
|
}
|
#endif
|
|
switch(ps_ctb_node->u1_cu_size)
|
{
|
case 64:
|
ps_ctb_node->u1_log2_nt = 6;
|
ps_ctb_node->u1_part_flag_pos = 0;
|
break;
|
case 32:
|
ps_ctb_node->u1_log2_nt = 5;
|
ps_ctb_node->u1_part_flag_pos = 4;
|
break;
|
case 16:
|
ps_ctb_node->u1_log2_nt = 4;
|
ps_ctb_node->u1_part_flag_pos = 8;
|
break;
|
}
|
|
/* Set neighbor flags for the CTB */
|
nbr_flags = 0;
|
|
if(ps_ctxt->u2_ctb_num_in_row != 0)
|
{
|
nbr_flags |= LEFT_FLAG; /* Set Left Flag if not in first column */
|
ps_ctb_node->u1_num_left_avail = ((u2_pic_hgt - ps_ctb_node->u2_orig_y) >= u1_ctb_size)
|
? u1_ctb_size
|
: u2_pic_hgt - ps_ctb_node->u2_orig_y;
|
}
|
else
|
{
|
ps_ctb_node->u1_num_left_avail = 0;
|
}
|
|
if((ps_ctxt->u2_ctb_num_in_row != 0) && (ps_ctxt->u2_ctb_row_num != 0))
|
nbr_flags |= TOP_LEFT_FLAG; /* Set Top-Left Flag if not in first row or first column */
|
|
if(ps_ctxt->u2_ctb_row_num != 0)
|
{
|
nbr_flags |= TOP_FLAG; /* Set Top Flag if not in first row */
|
ps_ctb_node->u1_num_top_avail = ((u2_pic_wdt - ps_ctb_node->u2_orig_x) >= u1_ctb_size)
|
? u1_ctb_size
|
: u2_pic_wdt - ps_ctb_node->u2_orig_x;
|
}
|
else
|
{
|
ps_ctb_node->u1_num_top_avail = 0;
|
}
|
|
if(ps_ctxt->u2_ctb_row_num != 0)
|
{
|
if(ps_ctxt->u2_ctb_num_in_row == (ps_frm_ctb_prms->i4_num_ctbs_horz - 1))
|
ps_ctb_node->u1_num_top_right_avail = 0;
|
else
|
{
|
ps_ctb_node->u1_num_top_right_avail =
|
((u2_pic_wdt - ps_ctb_node->u2_orig_x - u1_ctb_size) >= u1_ctb_size)
|
? u1_ctb_size
|
: u2_pic_wdt - ps_ctb_node->u2_orig_x - u1_ctb_size;
|
nbr_flags |=
|
TOP_RIGHT_FLAG; /* Set Top-Right Flag if not in first row or last column*/
|
}
|
}
|
else
|
{
|
ps_ctb_node->u1_num_top_right_avail = 0;
|
}
|
|
ps_ctb_node->u1_num_bottom_left_avail = 0;
|
|
ps_ctb_node->i4_nbr_flag = nbr_flags;
|
|
/**
|
* Update CTB Mode Map
|
* In case this is first CTB in a row, set left most column to INTRA_DC (NA)
|
* else copy last column to first column
|
**/
|
if(ctb_ctr == 0)
|
{
|
for(row = 0; row < (MAX_TU_ROW_IN_CTB + 1); row++)
|
{
|
ps_ctxt->au1_ctb_mode_map[row][0] = INTRA_DC;
|
}
|
}
|
else
|
{
|
for(row = 0; row < (MAX_TU_ROW_IN_CTB + 1); row++)
|
{
|
ps_ctxt->au1_ctb_mode_map[row][0] =
|
ps_ctxt->au1_ctb_mode_map[row][MAX_TU_COL_IN_CTB];
|
}
|
}
|
|
/* --------- IPE call at CTB level ------------------ */
|
|
/* IPE CTB function is expected to Decide on the CUs sizes */
|
/* and populate the best intra prediction modes and TX flags*/
|
/* Interface of this CTb level function is kept open */
|
|
ps_ed_l1_ctb = ps_ed_l1_row + ctb_ctr * blk_inc_ctb_l1;
|
ps_ed_l2_ctb = ps_ed_l2_row + ctb_ctr * blk_inc_ctb_l2;
|
ps_ed_ctb_l1 = ps_ed_ctb_l1_row + ctb_ctr;
|
|
if(ps_ctxt->u1_use_lambda_derived_from_min_8x8_act_in_ctb)
|
{
|
/*HACK : MAMATHA, This function assumes that data is accumalated
|
for all probable CU-TU combinations for INcomplete CTB, which is currently not the case,
|
hence not recomputing lamda for the incomplete CTB */
|
if((ps_ctb_node->u1_width == u1_ctb_size) && (ps_ctb_node->u1_height == u1_ctb_size))
|
{
|
ihevce_ipe_recompute_lambda_from_min_8x8_act_in_ctb(ps_ctxt, ps_ed_ctb_l1);
|
}
|
}
|
|
ihevce_ipe_process_ctb(
|
ps_ctxt,
|
ps_frm_ctb_prms,
|
&s_curr_src_bufs,
|
ps_ctb_node,
|
ps_l0_ipe_out_ctb,
|
ps_ctb_out,
|
//ps_row_cu,
|
ps_ed_l1_ctb,
|
ps_ed_l2_ctb,
|
ps_ed_ctb_l1);
|
|
/* -------------- ctb level updates ----------------- */
|
|
ps_l0_ipe_out_ctb++;
|
//num_cus_in_ctb = ps_ctb_out->u1_num_cus_in_ctb;
|
|
//ps_row_cu += num_cus_in_ctb;
|
|
ps_ctb_out++;
|
}
|
return;
|
}
|
|
/*!
|
******************************************************************************
|
* \if Function name : ihevce_ipe_process \endif
|
*
|
* \brief
|
* Frame level IPE function
|
*
|
* \param[in] pv_ctxt : pointer to IPE module
|
* \param[in] ps_frm_ctb_prms : CTB characteristics parameters
|
* \param[in] ps_inp : pointer to input yuv buffer (frame buffer)
|
* \param[out] ps_ctb_out : pointer to CTB analyse output structure (frame buffer)
|
* \param[out] ps_cu_out : pointer to CU analyse output structure (frame buffer)
|
*
|
* \return
|
* None
|
*
|
* Note : Currently the frame level calculations done assumes that
|
* framewidth of the input are excat multiple of ctbsize
|
*
|
* \author
|
* Ittiam
|
*
|
*****************************************************************************
|
*/
|
void ihevce_ipe_process(
|
void *pv_ctxt,
|
frm_ctb_ctxt_t *ps_frm_ctb_prms,
|
frm_lambda_ctxt_t *ps_frm_lamda,
|
ihevce_lap_enc_buf_t *ps_curr_inp,
|
pre_enc_L0_ipe_encloop_ctxt_t *ps_L0_IPE_curr_out_pre_enc,
|
ctb_analyse_t *ps_ctb_out,
|
//cu_analyse_t *ps_cu_out,
|
ipe_l0_ctb_analyse_for_me_t *ps_ipe_ctb_out,
|
void *pv_multi_thrd_ctxt,
|
WORD32 slice_type,
|
ihevce_ed_blk_t *ps_ed_pic_l1,
|
ihevce_ed_blk_t *ps_ed_pic_l2,
|
ihevce_ed_ctb_l1_t *ps_ed_ctb_l1_pic,
|
WORD32 thrd_id,
|
WORD32 i4_ping_pong)
|
{
|
/* local variables */
|
ihevce_ipe_master_ctxt_t *ps_master_ctxt;
|
iv_enc_yuv_buf_t *ps_inp = &ps_curr_inp->s_lap_out.s_input_buf;
|
ihevce_ipe_ctxt_t *ps_ctxt;
|
iv_enc_yuv_buf_t s_curr_src_bufs;
|
WORD32 end_of_frame;
|
|
ihevce_ed_blk_t *ps_ed_l1_row;
|
ihevce_ed_blk_t *ps_ed_l2_row;
|
ihevce_ed_ctb_l1_t *ps_ed_ctb_l1_row;
|
WORD32 blk_inc_ctb_l1 = 0;
|
WORD32 blk_inc_ctb_l2 = 0;
|
|
/* Layer 1 pre intra analysis related initilization.
|
* Compute no of 8x8 blks in the ctb which which is
|
* same as no of 4x4 blks in the ctb in layer 1 */
|
blk_inc_ctb_l1 = ps_frm_ctb_prms->i4_ctb_size >> 3;
|
blk_inc_ctb_l1 = blk_inc_ctb_l1 * blk_inc_ctb_l1;
|
|
/* Layer 2 pre intra analysis related initilization.
|
* Compute no of 16x16 blks in the ctb which which is
|
* same as no of 8x8 blks in the ctb in layer 2 */
|
blk_inc_ctb_l2 = ps_frm_ctb_prms->i4_ctb_size >> 4;
|
blk_inc_ctb_l2 = blk_inc_ctb_l2 * blk_inc_ctb_l2;
|
|
/* ----------------------------------------------------- */
|
/* store the stride and dimensions of source */
|
/* buffer pointers will be over written at every CTB row */
|
/* ----------------------------------------------------- */
|
memcpy(&s_curr_src_bufs, ps_inp, sizeof(iv_enc_yuv_buf_t));
|
|
ps_master_ctxt = (ihevce_ipe_master_ctxt_t *)pv_ctxt;
|
ps_ctxt = ps_master_ctxt->aps_ipe_thrd_ctxt[thrd_id];
|
end_of_frame = 0;
|
|
if(ISLICE == slice_type)
|
{
|
ps_ctxt->b_sad_type = IPE_SAD_TYPE;
|
ps_ctxt->i4_ol_satd_lambda = ps_frm_lamda->i4_ol_satd_lambda_qf;
|
ps_ctxt->i4_ol_sad_lambda = ps_frm_lamda->i4_ol_sad_lambda_qf;
|
}
|
else
|
{
|
ps_ctxt->b_sad_type = IPE_SAD_TYPE; /* SAD */
|
ps_ctxt->i4_ol_satd_lambda = ps_frm_lamda->i4_ol_satd_lambda_qf;
|
ps_ctxt->i4_ol_sad_lambda = ps_frm_lamda->i4_ol_sad_lambda_qf;
|
}
|
|
ihevce_populate_ipe_ol_cu_lambda_prms(
|
(void *)ps_ctxt,
|
ps_frm_lamda,
|
slice_type,
|
ps_curr_inp->s_lap_out.i4_temporal_lyr_id,
|
IPE_LAMBDA_TYPE);
|
|
/* register the slice type in the ctxt */
|
ps_ctxt->i4_slice_type = slice_type;
|
|
/** Frame-levelSATD cost accumalator init to 0 */
|
ps_ctxt->i8_frame_acc_satd_cost = 0;
|
|
/** Frame-levelSATD accumalator init to 0 */
|
ps_ctxt->i8_frame_acc_satd = 0;
|
|
/** Frame-level Activity factor accumalator init to 1 */
|
ps_ctxt->i8_frame_acc_act_factor = 1;
|
|
/** Frame-levelMode Bits cost accumalator init to 0 */
|
ps_ctxt->i8_frame_acc_mode_bits_cost = 0;
|
|
/** Frame -level SATD/qp acc init to 0*/
|
ps_ctxt->i8_frame_acc_satd_by_modqp_q10 = 0;
|
|
/* ------------ Loop over all the CTB rows --------------- */
|
while(0 == end_of_frame)
|
{
|
UWORD8 *pu1_tmp;
|
WORD32 vert_ctr;
|
//cu_analyse_t *ps_row_cu;
|
ctb_analyse_t *ps_ctb_out_row;
|
job_queue_t *ps_job;
|
ipe_l0_ctb_analyse_for_me_t *ps_ipe_ctb_out_row;
|
|
/* Get the current row from the job queue */
|
ps_job = (job_queue_t *)ihevce_pre_enc_grp_get_next_job(
|
pv_multi_thrd_ctxt, IPE_JOB_LYR0, 1, i4_ping_pong);
|
|
/* If all rows are done, set the end of process flag to 1, */
|
/* and the current row to -1 */
|
if(NULL == ps_job)
|
{
|
vert_ctr = -1;
|
end_of_frame = 1;
|
}
|
else
|
{
|
ASSERT(IPE_JOB_LYR0 == ps_job->i4_pre_enc_task_type);
|
|
/* Obtain the current row's details from the job */
|
vert_ctr = ps_job->s_job_info.s_ipe_job_info.i4_ctb_row_no;
|
//DBG_PRINTF("IPE PASS : Thread id %d, Vert Ctr %d\n",thrd_id,vert_ctr);
|
|
/* Update the ipe context with current row number */
|
ps_ctxt->u2_ctb_row_num = vert_ctr;
|
|
/* derive the current ctb row pointers */
|
|
/* luma src */
|
pu1_tmp = (UWORD8 *)ps_curr_inp->s_lap_out.s_input_buf.pv_y_buf;
|
pu1_tmp += (vert_ctr * ps_frm_ctb_prms->i4_ctb_size * ps_inp->i4_y_strd);
|
|
s_curr_src_bufs.pv_y_buf = pu1_tmp;
|
|
/* Cb & CR pixel interleaved src */
|
pu1_tmp = (UWORD8 *)ps_curr_inp->s_lap_out.s_input_buf.pv_u_buf;
|
pu1_tmp += (vert_ctr * (ps_frm_ctb_prms->i4_ctb_size >> 1) * ps_inp->i4_uv_strd);
|
|
s_curr_src_bufs.pv_u_buf = pu1_tmp;
|
|
/* row intra analyse cost buffer */
|
ps_ipe_ctb_out_row = ps_ipe_ctb_out + vert_ctr * ps_frm_ctb_prms->i4_num_ctbs_horz;
|
|
/* row ctb out structure */
|
ps_ctb_out_row = ps_ctb_out + vert_ctr * ps_frm_ctb_prms->i4_num_ctbs_horz;
|
|
/* call the row level processing function */
|
ps_ed_l1_row =
|
ps_ed_pic_l1 + ps_frm_ctb_prms->i4_num_ctbs_horz * blk_inc_ctb_l1 * vert_ctr;
|
ps_ed_l2_row =
|
ps_ed_pic_l2 + ps_frm_ctb_prms->i4_num_ctbs_horz * blk_inc_ctb_l2 * vert_ctr;
|
ps_ed_ctb_l1_row = ps_ed_ctb_l1_pic + ps_frm_ctb_prms->i4_num_ctbs_horz * vert_ctr;
|
ihevce_ipe_process_row(
|
ps_ctxt,
|
ps_frm_ctb_prms,
|
&s_curr_src_bufs,
|
ps_ipe_ctb_out_row,
|
ps_ctb_out_row,
|
//ps_row_cu,
|
ps_ed_l1_row,
|
ps_ed_l2_row,
|
ps_ed_ctb_l1_row,
|
blk_inc_ctb_l1,
|
blk_inc_ctb_l2);
|
|
memset(
|
ps_ed_l1_row,
|
0,
|
ps_frm_ctb_prms->i4_num_ctbs_horz * blk_inc_ctb_l1 * sizeof(ihevce_ed_blk_t));
|
memset(
|
ps_ed_l2_row,
|
0,
|
ps_frm_ctb_prms->i4_num_ctbs_horz * blk_inc_ctb_l2 * sizeof(ihevce_ed_blk_t));
|
|
/* set the output dependency */
|
ihevce_pre_enc_grp_job_set_out_dep(pv_multi_thrd_ctxt, ps_job, i4_ping_pong);
|
}
|
}
|
|
/* EIID: Print stat regarding how many 16x16 blocks are skipped in the frame, valid for single thread only */
|
//DBG_PRINTF("num_16x16_analyze_skipped: %d\n",ps_ctxt->u4_num_16x16_skips_at_L0_IPE);
|
|
return;
|
}
|
|
/*!
|
******************************************************************************
|
* \if Function name : ihevce_get_frame_lambda_prms \endif
|
*
|
* \brief
|
* Function whihc calculates the Lambda params for current picture
|
*
|
* \param[in] ps_enc_ctxt : encoder ctxt pointer
|
* \param[in] ps_cur_pic_ctxt : current pic ctxt
|
* \param[in] i4_cur_frame_qp : current pic QP
|
* \param[in] first_field : is first field flag
|
* \param[in] i4_temporal_lyr_id : Current picture layer id
|
*
|
* \return
|
* None
|
*
|
* \author
|
* Ittiam
|
*
|
*****************************************************************************
|
*/
|
void ihevce_get_ipe_ol_cu_lambda_prms(void *pv_ctxt, WORD32 i4_cur_cu_qp)
|
{
|
ihevce_ipe_ctxt_t *ps_ctxt = (ihevce_ipe_ctxt_t *)pv_ctxt;
|
//WORD32 chroma_qp = gau1_ihevc_chroma_qp_scale[i4_cur_cu_qp];
|
|
/* Store the params for IPE pass */
|
ps_ctxt->i4_ol_satd_lambda = ps_ctxt->i4_ol_satd_lambda_qf_array[i4_cur_cu_qp];
|
ps_ctxt->i4_ol_sad_lambda = ps_ctxt->i4_ol_sad_lambda_qf_array[i4_cur_cu_qp];
|
}
|
|
/*!
|
******************************************************************************
|
* \if Function name : ihevce_get_frame_lambda_prms \endif
|
*
|
* \brief
|
* Function whihc calculates the Lambda params for current picture
|
*
|
* \param[in] ps_enc_ctxt : encoder ctxt pointer
|
* \param[in] ps_cur_pic_ctxt : current pic ctxt
|
* \param[in] i4_cur_frame_qp : current pic QP
|
* \param[in] first_field : is first field flag
|
* \param[in] i4_temporal_lyr_id : Current picture layer id
|
*
|
* \return
|
* None
|
*
|
* \author
|
* Ittiam
|
*
|
*****************************************************************************
|
*/
|
void ihevce_populate_ipe_ol_cu_lambda_prms(
|
void *pv_ctxt,
|
frm_lambda_ctxt_t *ps_frm_lamda,
|
WORD32 i4_slice_type,
|
WORD32 i4_temporal_lyr_id,
|
WORD32 i4_lambda_type)
|
{
|
WORD32 i4_curr_cu_qp;
|
double lambda_modifier;
|
double lambda_uv_modifier;
|
double lambda;
|
double lambda_uv;
|
|
ihevce_ipe_ctxt_t *ps_ctxt = (ihevce_ipe_ctxt_t *)pv_ctxt;
|
|
WORD32 i4_qp_bd_offset = 6 * (ps_ctxt->u1_bit_depth - 8);
|
|
for(i4_curr_cu_qp =
|
ps_ctxt->ps_rc_quant_ctxt->i2_min_qp + ps_ctxt->ps_rc_quant_ctxt->i1_qp_offset;
|
i4_curr_cu_qp <= ps_ctxt->ps_rc_quant_ctxt->i2_max_qp;
|
i4_curr_cu_qp++)
|
{
|
WORD32 chroma_qp = i4_curr_cu_qp;
|
|
if((BSLICE == i4_slice_type) && (i4_temporal_lyr_id))
|
{
|
lambda_modifier = ps_frm_lamda->lambda_modifier *
|
CLIP3((((double)(i4_curr_cu_qp - 12)) / 6.0), 2.00, 4.00);
|
lambda_uv_modifier = ps_frm_lamda->lambda_uv_modifier *
|
CLIP3((((double)(chroma_qp - 12)) / 6.0), 2.00, 4.00);
|
}
|
else
|
{
|
lambda_modifier = ps_frm_lamda->lambda_modifier;
|
lambda_uv_modifier = ps_frm_lamda->lambda_uv_modifier;
|
}
|
if(ps_ctxt->i4_use_const_lamda_modifier)
|
{
|
if(ISLICE == i4_slice_type)
|
{
|
lambda_modifier = ps_ctxt->f_i_pic_lamda_modifier;
|
lambda_uv_modifier = ps_ctxt->f_i_pic_lamda_modifier;
|
}
|
else
|
{
|
lambda_modifier = CONST_LAMDA_MOD_VAL;
|
lambda_uv_modifier = CONST_LAMDA_MOD_VAL;
|
}
|
}
|
|
switch(i4_lambda_type)
|
{
|
case 0:
|
{
|
i4_qp_bd_offset = 0;
|
|
lambda = pow(2.0, (((double)(i4_curr_cu_qp + i4_qp_bd_offset - 12)) / 3.0));
|
|
lambda_uv = pow(2.0, (((double)(chroma_qp + i4_qp_bd_offset - 12)) / 3.0));
|
|
lambda *= lambda_modifier;
|
lambda_uv *= lambda_uv_modifier;
|
if(ps_ctxt->i4_use_const_lamda_modifier)
|
{
|
ps_ctxt->i4_ol_sad_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda)) * (1 << LAMBDA_Q_SHIFT));
|
|
ps_ctxt->i4_ol_satd_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda)) * (1 << LAMBDA_Q_SHIFT));
|
}
|
else
|
{
|
ps_ctxt->i4_ol_sad_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda) / 2) * (1 << LAMBDA_Q_SHIFT));
|
|
ps_ctxt->i4_ol_satd_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda * 1.9) / 2) * (1 << LAMBDA_Q_SHIFT));
|
}
|
|
ps_ctxt->i4_ol_sad_type2_lambda_qf_array[i4_curr_cu_qp] =
|
ps_ctxt->i4_ol_sad_lambda_qf_array[i4_curr_cu_qp];
|
|
ps_ctxt->i4_ol_satd_type2_lambda_qf_array[i4_curr_cu_qp] =
|
ps_ctxt->i4_ol_satd_lambda_qf_array[i4_curr_cu_qp];
|
|
break;
|
}
|
case 1:
|
{
|
ASSERT(0); /* should not enter the path for IPE*/
|
lambda = pow(2.0, (((double)(i4_curr_cu_qp + i4_qp_bd_offset - 12)) / 3.0));
|
|
lambda_uv = pow(2.0, (((double)(chroma_qp + i4_qp_bd_offset - 12)) / 3.0));
|
|
lambda *= lambda_modifier;
|
lambda_uv *= lambda_uv_modifier;
|
if(ps_ctxt->i4_use_const_lamda_modifier)
|
{
|
ps_ctxt->i4_ol_sad_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda)) * (1 << LAMBDA_Q_SHIFT));
|
|
ps_ctxt->i4_ol_satd_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda)) * (1 << LAMBDA_Q_SHIFT));
|
}
|
else
|
{
|
ps_ctxt->i4_ol_sad_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda) / 2) * (1 << LAMBDA_Q_SHIFT));
|
|
ps_ctxt->i4_ol_satd_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda * 1.9) / 2) * (1 << LAMBDA_Q_SHIFT));
|
}
|
|
ps_ctxt->i4_ol_sad_type2_lambda_qf_array[i4_curr_cu_qp] =
|
ps_ctxt->i4_ol_sad_lambda_qf_array[i4_curr_cu_qp];
|
|
ps_ctxt->i4_ol_satd_type2_lambda_qf_array[i4_curr_cu_qp] =
|
ps_ctxt->i4_ol_satd_lambda_qf_array[i4_curr_cu_qp];
|
|
break;
|
}
|
case 2:
|
{
|
ASSERT(0); /* should not enter the path for IPE*/
|
lambda = pow(2.0, (((double)(i4_curr_cu_qp + i4_qp_bd_offset - 12)) / 3.0));
|
|
lambda_uv = pow(2.0, (((double)(chroma_qp + i4_qp_bd_offset - 12)) / 3.0));
|
|
lambda *= lambda_modifier;
|
lambda_uv *= lambda_uv_modifier;
|
if(ps_ctxt->i4_use_const_lamda_modifier)
|
{
|
ps_ctxt->i4_ol_sad_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda)) * (1 << LAMBDA_Q_SHIFT));
|
|
ps_ctxt->i4_ol_satd_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda)) * (1 << LAMBDA_Q_SHIFT));
|
}
|
else
|
{
|
ps_ctxt->i4_ol_sad_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda) / 2) * (1 << LAMBDA_Q_SHIFT));
|
|
ps_ctxt->i4_ol_satd_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda * 1.9) / 2) * (1 << LAMBDA_Q_SHIFT));
|
}
|
i4_qp_bd_offset = 0;
|
|
lambda = pow(2.0, (((double)(i4_curr_cu_qp + i4_qp_bd_offset - 12)) / 3.0));
|
|
lambda_uv = pow(2.0, (((double)(chroma_qp + i4_qp_bd_offset - 12)) / 3.0));
|
|
lambda *= lambda_modifier;
|
lambda_uv *= lambda_uv_modifier;
|
if(ps_ctxt->i4_use_const_lamda_modifier)
|
{
|
ps_ctxt->i4_ol_sad_type2_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda)) * (1 << LAMBDA_Q_SHIFT));
|
|
ps_ctxt->i4_ol_satd_type2_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda)) * (1 << LAMBDA_Q_SHIFT));
|
}
|
else
|
{
|
ps_ctxt->i4_ol_sad_type2_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda) / 2) * (1 << LAMBDA_Q_SHIFT));
|
|
ps_ctxt->i4_ol_satd_type2_lambda_qf_array[i4_curr_cu_qp] =
|
(WORD32)((sqrt(lambda * 1.9) / 2) * (1 << LAMBDA_Q_SHIFT));
|
}
|
break;
|
}
|
default:
|
{
|
/* Intended to be a barren wasteland! */
|
ASSERT(0);
|
}
|
}
|
}
|
}
|
|
#define ME_COST_THRSHOLD 7
|
/*!
|
******************************************************************************
|
* \if Function name : ihevce_get_frame_lambda_prms \endif
|
*
|
* \brief
|
* Function whihc calculates the Lambda params for current picture
|
*
|
* \param[in] ps_enc_ctxt : encoder ctxt pointer
|
* \param[in] ps_cur_pic_ctxt : current pic ctxt
|
* \param[in] i4_cur_frame_qp : current pic QP
|
* \param[in] first_field : is first field flag
|
* \param[in] i4_temporal_lyr_id : Current picture layer id
|
*
|
* \return
|
* None
|
*
|
* \author
|
* Ittiam
|
*
|
*****************************************************************************
|
*/
|
#define MAX_64BIT_VAL 0x7fffffffffffffff
|
void ihevce_populate_ipe_frame_init(
|
void *pv_ctxt,
|
ihevce_static_cfg_params_t *ps_stat_prms,
|
WORD32 i4_curr_frm_qp,
|
WORD32 i4_slice_type,
|
WORD32 i4_thrd_id,
|
pre_enc_me_ctxt_t *ps_curr_out,
|
WORD8 i1_cu_qp_delta_enabled_flag,
|
rc_quant_t *ps_rc_quant_ctxt,
|
WORD32 i4_quality_preset,
|
WORD32 i4_temporal_lyr_id,
|
ihevce_lap_output_params_t *ps_lap_out)
|
{
|
ihevce_ipe_master_ctxt_t *ps_master_ctxt = (ihevce_ipe_master_ctxt_t *)pv_ctxt;
|
WORD32 i4_i;
|
WORD32 ai4_mod_factor_num[2];
|
|
ihevce_ipe_ctxt_t *ps_ctxt = ps_master_ctxt->aps_ipe_thrd_ctxt[i4_thrd_id];
|
ps_ctxt->i4_hevc_qp = i4_curr_frm_qp;
|
ps_ctxt->i4_quality_preset = i4_quality_preset;
|
ps_ctxt->i4_temporal_lyr_id = i4_temporal_lyr_id;
|
ps_ctxt->ps_rc_quant_ctxt = ps_rc_quant_ctxt;
|
ps_ctxt->i4_qscale =
|
ps_ctxt->ps_rc_quant_ctxt
|
->pi4_qp_to_qscale[i4_curr_frm_qp + ps_ctxt->ps_rc_quant_ctxt->i1_qp_offset];
|
|
ps_ctxt->i4_frm_qp = i4_curr_frm_qp + ps_ctxt->ps_rc_quant_ctxt->i1_qp_offset;
|
ps_ctxt->i4_slice_type = i4_slice_type; //EIID
|
ps_ctxt->i4_temporal_layer = ps_lap_out->i4_temporal_lyr_id;
|
ps_ctxt->i4_is_ref_pic = ps_lap_out->i4_is_ref_pic;
|
ps_ctxt->u4_num_16x16_skips_at_L0_IPE = 0;
|
ps_ctxt->i4_use_const_lamda_modifier = USE_CONSTANT_LAMBDA_MODIFIER;
|
ps_ctxt->i4_use_const_lamda_modifier =
|
ps_ctxt->i4_use_const_lamda_modifier ||
|
((ps_stat_prms->s_coding_tools_prms.i4_vqet &
|
(1 << BITPOS_IN_VQ_TOGGLE_FOR_CONTROL_TOGGLER)) &&
|
((ps_stat_prms->s_coding_tools_prms.i4_vqet &
|
(1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_NOISE_PRESERVATION)) ||
|
(ps_stat_prms->s_coding_tools_prms.i4_vqet &
|
(1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_PSYRDOPT_1)) ||
|
(ps_stat_prms->s_coding_tools_prms.i4_vqet &
|
(1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_PSYRDOPT_2)) ||
|
(ps_stat_prms->s_coding_tools_prms.i4_vqet &
|
(1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_PSYRDOPT_3))));
|
{
|
ps_ctxt->f_i_pic_lamda_modifier = ps_lap_out->f_i_pic_lamda_modifier;
|
}
|
#if POW_OPT
|
for(i4_i = 0; i4_i < 2; i4_i++)
|
{
|
ps_ctxt->ld_curr_frame_8x8_log_avg[i4_i] = ps_curr_out->ld_curr_frame_8x8_log_avg[i4_i];
|
ps_ctxt->ld_curr_frame_16x16_log_avg[i4_i] = ps_curr_out->ld_curr_frame_16x16_log_avg[i4_i];
|
ps_ctxt->ld_curr_frame_32x32_log_avg[i4_i] = ps_curr_out->ld_curr_frame_32x32_log_avg[i4_i];
|
}
|
|
ps_ctxt->ld_curr_frame_16x16_log_avg[2] = ps_curr_out->ld_curr_frame_16x16_log_avg[2];
|
ps_ctxt->ld_curr_frame_32x32_log_avg[2] = ps_curr_out->ld_curr_frame_32x32_log_avg[2];
|
ps_ctxt->i8_curr_frame_avg_mean_act = ps_curr_out->i8_curr_frame_avg_mean_act;
|
#else
|
for(i4_i = 0; i4_i < 2; i4_i++)
|
{
|
ps_ctxt->i8_curr_frame_8x8_avg_act[i4_i] = ps_curr_out->i8_curr_frame_8x8_avg_act[i4_i];
|
ps_ctxt->i8_curr_frame_16x16_avg_act[i4_i] = ps_curr_out->i8_curr_frame_16x16_avg_act[i4_i];
|
ps_ctxt->i8_curr_frame_32x32_avg_act[i4_i] = ps_curr_out->i8_curr_frame_32x32_avg_act[i4_i];
|
}
|
|
ps_ctxt->i8_curr_frame_16x16_avg_act[2] = ps_curr_out->i8_curr_frame_16x16_avg_act[2];
|
ps_ctxt->i8_curr_frame_32x32_avg_act[2] = ps_curr_out->i8_curr_frame_32x32_avg_act[2];
|
#endif
|
|
ps_ctxt->pi2_trans_out =
|
(WORD16 *)&ps_ctxt->au1_pred_samples[0]; //overlaying trans coeff memory with pred_samples
|
ps_ctxt->pi2_trans_tmp = (WORD16 *)&ps_ctxt->au1_pred_samples[2048];
|
|
/*Mod factor NUM */
|
ps_ctxt->ai4_mod_factor_derived_by_variance[0] =
|
ps_curr_out->ai4_mod_factor_derived_by_variance[0];
|
ps_ctxt->ai4_mod_factor_derived_by_variance[1] =
|
ps_curr_out->ai4_mod_factor_derived_by_variance[1];
|
|
ps_ctxt->f_strength = ps_curr_out->f_strength;
|
|
if(ps_stat_prms->s_coding_tools_prms.i4_vqet & (1 << BITPOS_IN_VQ_TOGGLE_FOR_CONTROL_TOGGLER))
|
{
|
if(ps_stat_prms->s_coding_tools_prms.i4_vqet &
|
(1 << BITPOS_IN_VQ_TOGGLE_FOR_ENABLING_NOISE_PRESERVATION))
|
{
|
ps_ctxt->i4_enable_noise_detection = 1;
|
}
|
else
|
{
|
ps_ctxt->i4_enable_noise_detection = 0;
|
}
|
}
|
else
|
{
|
ps_ctxt->i4_enable_noise_detection = 0;
|
}
|
|
{
|
if(ISLICE == ps_ctxt->i4_slice_type)
|
{
|
ai4_mod_factor_num[0] = INTRA_QP_MOD_FACTOR_NUM; //16;
|
ai4_mod_factor_num[1] = INTRA_QP_MOD_FACTOR_NUM; //16;
|
}
|
else
|
{
|
ai4_mod_factor_num[0] = INTER_QP_MOD_FACTOR_NUM; //4;
|
ai4_mod_factor_num[1] = INTER_QP_MOD_FACTOR_NUM; //4;
|
}
|
|
#if ENABLE_QP_MOD_BASED_ON_SPATIAL_VARIANCE
|
for(i4_i = 0; i4_i < 2; i4_i++)
|
{
|
WORD32 mod_factor_num_val =
|
ps_ctxt->ai4_mod_factor_derived_by_variance[i4_i] * QP_MOD_FACTOR_DEN;
|
|
ai4_mod_factor_num[i4_i] = CLIP3(mod_factor_num_val, 1, ai4_mod_factor_num[i4_i]);
|
ps_ctxt->ai4_mod_factor_derived_by_variance[i4_i] = ai4_mod_factor_num[i4_i];
|
}
|
#else
|
for(i4_i = 0; i4_i < 2; i4_i++)
|
{
|
ps_ctxt->ai4_mod_factor_derived_by_variance[i4_i] = ai4_mod_factor_num[i4_i];
|
}
|
#endif
|
}
|
|
ps_ctxt->u1_use_lambda_derived_from_min_8x8_act_in_ctb = MODULATE_LAMDA_WHEN_SPATIAL_MOD_ON &&
|
i1_cu_qp_delta_enabled_flag;
|
|
ps_ctxt->u1_use_satd = 1;
|
ps_ctxt->u1_level_1_refine_on = 1;
|
ps_ctxt->u1_disable_child_cu_decide = 0;
|
|
#if !OLD_XTREME_SPEED
|
if(((ps_ctxt->i4_quality_preset == IHEVCE_QUALITY_P5) ||
|
(ps_ctxt->i4_quality_preset == IHEVCE_QUALITY_P6)) &&
|
(ps_ctxt->i4_slice_type != ISLICE))
|
{
|
ps_ctxt->u1_use_satd = 0;
|
ps_ctxt->u1_level_1_refine_on = 1;
|
ps_ctxt->u1_disable_child_cu_decide = 0;
|
}
|
|
#endif
|
|
if((ps_ctxt->i4_quality_preset == IHEVCE_QUALITY_P4) && (ps_ctxt->i4_slice_type != ISLICE))
|
ps_ctxt->u1_use_satd = 0;
|
if(ps_ctxt->i4_quality_preset > IHEVCE_QUALITY_P3)
|
ps_ctxt->u1_use_satd = 0;
|
}
|
