| /****************************************************************************** |
| * |
| * 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_sub_pic_rc.c |
| * |
| * \brief |
| * |
| * \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_defs.h" |
| #include "ihevc_debug.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_buffer_que_interface.h" |
| #include "ihevce_hle_interface.h" |
| #include "ihevce_hle_q_func.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_checks.h" |
| #include "ihevce_error_codes.h" |
| #include "ihevce_bitstream.h" |
| #include "ihevce_cabac.h" |
| #include "ihevce_trace.h" |
| #include "ihevce_function_selector.h" |
| #include "ihevce_enc_structs.h" |
| #include "ihevce_global_tables.h" |
| #include "ihevce_cmn_utils_instr_set_router.h" |
| #include "ihevce_rdoq_macros.h" |
| #include "ihevce_entropy_structs.h" |
| #include "ihevce_entropy_interface.h" |
| #include "ihevce_enc_loop_structs.h" |
| #include "hme_datatype.h" |
| #include "hme_interface.h" |
| #include "hme_common_defs.h" |
| #include "hme_defs.h" |
| #include "ihevce_rc_enc_structs.h" |
| #include "ihevce_rc_interface.h" |
| #include "ihevce_sub_pic_rc.h" |
| |
| #include "cast_types.h" |
| #include "osal.h" |
| #include "osal_defaults.h" |
| |
| /*****************************************************************************/ |
| /* Globals */ |
| /*****************************************************************************/ |
| /* @ brief : Qp deviation of -6 to 6 is mapped */ |
| float qp_scale_dev[13] = { 0.5, 0.56, 0.630, 0.707, 0.794, 0.891, 1.00, |
| 1.122, 1.259, 1.414, 1.587, 1.782, 2.00 }; |
| |
| /*****************************************************************************/ |
| /* Constant Macros */ |
| /*****************************************************************************/ |
| #define IN_FRAME_RC_PRINT 0 |
| #define IN_FRAME_RC_FRAME_NUM 4 |
| |
| /*****************************************************************************/ |
| /* Function Definitions */ |
| /*****************************************************************************/ |
| |
| /*! |
| ****************************************************************************** |
| * \if Function name : ihevce_sub_pic_rc_bits_fill \endif |
| * |
| * \brief |
| * Sub-pic RC thread interface function |
| * |
| * \param[in] Frame process pointer |
| * |
| * \return |
| * None |
| * |
| * \author |
| * Ittiam |
| * |
| ***************************************************************************** |
| */ |
| void ihevce_sub_pic_rc_in_data( |
| void *pv_multi_thrd_ctxt, void *pv_ctxt, void *pv_ctb_ipe_analyse, void *pv_frm_ctb_prms) |
| { |
| multi_thrd_ctxt_t *ps_multi_thrd_ctxt = (multi_thrd_ctxt_t *)pv_multi_thrd_ctxt; |
| ihevce_enc_loop_ctxt_t *ps_ctxt = (ihevce_enc_loop_ctxt_t *)pv_ctxt; |
| ipe_l0_ctb_analyse_for_me_t *ps_ctb_ipe_analyse = |
| (ipe_l0_ctb_analyse_for_me_t *)pv_ctb_ipe_analyse; |
| frm_ctb_ctxt_t *ps_frm_ctb_prms = (frm_ctb_ctxt_t *)pv_frm_ctb_prms; |
| |
| WORD32 j = 0; |
| WORD32 i4_frm_id = ps_ctxt->i4_enc_frm_id; |
| WORD32 i4_br_id = ps_ctxt->i4_bitrate_instance_num; |
| WORD32 i4_thrd_id = ps_ctxt->thrd_id; |
| WORD32 i4_ctb_count_flag = 0; |
| WORD32 i4_is_intra_pic = (ISLICE == ps_ctxt->i1_slice_type); |
| |
| /*Accumalate all the variables in shared memory */ |
| for(j = 0; j < (MAX_CU_IN_CTB >> 2); j++) |
| { |
| ps_multi_thrd_ctxt->ai8_nctb_ipe_sad[i4_frm_id][i4_br_id][i4_thrd_id] += |
| ps_ctb_ipe_analyse->ai4_best_sad_8x8_l1_ipe[j]; |
| ps_multi_thrd_ctxt->ai8_nctb_me_sad[i4_frm_id][i4_br_id][i4_thrd_id] += |
| ps_ctb_ipe_analyse->ai4_best_sad_8x8_l1_me[j]; |
| |
| ps_multi_thrd_ctxt->ai8_nctb_act_factor[i4_frm_id][i4_br_id][i4_thrd_id] += |
| ps_ctb_ipe_analyse->ai4_8x8_act_factor[j]; |
| } |
| |
| ps_multi_thrd_ctxt->ai8_nctb_l0_ipe_sad[i4_frm_id][i4_br_id][i4_thrd_id] += |
| ps_ctb_ipe_analyse->i4_ctb_acc_satd; |
| |
| /*Accumalte L0 MPM bits for N CTB*/ |
| ps_multi_thrd_ctxt->ai8_nctb_mpm_bits_consumed[i4_frm_id][i4_br_id][i4_thrd_id] += |
| ps_ctb_ipe_analyse->i4_ctb_acc_mpm_bits; |
| |
| /*Accumate the total bits and hdr bits for N Ctbs*/ |
| ps_multi_thrd_ctxt->ai8_nctb_bits_consumed[i4_frm_id][i4_br_id][i4_thrd_id] += |
| ps_ctxt->u4_total_cu_bits; |
| ps_multi_thrd_ctxt->ai8_acc_bits_consumed[i4_frm_id][i4_br_id][i4_thrd_id] += |
| ps_ctxt->u4_total_cu_bits; |
| ps_multi_thrd_ctxt->ai8_acc_bits_mul_qs_consumed[i4_frm_id][i4_br_id][i4_thrd_id] += |
| ps_ctxt->u4_total_cu_bits_mul_qs; |
| ps_multi_thrd_ctxt->ai8_nctb_hdr_bits_consumed[i4_frm_id][i4_br_id][i4_thrd_id] += |
| ps_ctxt->u4_total_cu_hdr_bits; |
| |
| /*Reset the total CU bits, accumalated for all CTBS*/ |
| ps_ctxt->u4_total_cu_bits = 0; |
| ps_ctxt->u4_total_cu_hdr_bits = 0; |
| ps_ctxt->u4_total_cu_bits_mul_qs = 0; |
| |
| /*Put mutex lock for incrementing cb count */ |
| osal_mutex_lock(ps_multi_thrd_ctxt->pv_sub_pic_rc_mutex_lock_hdl); |
| |
| ps_multi_thrd_ctxt->ai4_acc_ctb_ctr[i4_frm_id][i4_br_id] += 1; |
| ps_multi_thrd_ctxt->ai4_ctb_ctr[i4_frm_id][i4_br_id] += 1; |
| |
| /*Check if the acc ctb counter across thread has reached the required threshold */ |
| if(ps_multi_thrd_ctxt->ai4_acc_ctb_ctr[i4_frm_id][i4_br_id] >= |
| ps_ctxt->i4_num_ctb_for_out_scale) |
| { |
| i4_ctb_count_flag = 1; |
| /*Reset accumalated CTB counter appropriately s */ |
| ps_multi_thrd_ctxt->ai4_acc_ctb_ctr[i4_frm_id][i4_br_id] = 0; |
| } |
| |
| /*Variables to be sent in the queue after required ctb count is reached */ |
| if(1 == i4_ctb_count_flag) |
| { |
| WORD32 i4_temp_thrd_id; |
| LWORD64 i8_nctb_l1_me_sad = 0, i8_nctb_l1_ipe_sad = 0; |
| LWORD64 i8_nctb_l0_ipe_satd = 0, i8_nctb_l1_activity_fact = 0; |
| LWORD64 i8_nctb_hdr_bits_consumed = 0, i8_nctb_l0_mpm_bits = 0; |
| LWORD64 i8_nctb_bits_consumed = 0, i8_acc_bits_consumed = 0, |
| i8_acc_bits_mul_qs_consumed = 0; |
| LWORD64 i8_frame_l1_ipe_sad, i8_frame_l0_ipe_satd, i8_frame_l1_me_sad; |
| LWORD64 i8_frame_l1_activity_fact, i8_frame_bits_estimated; |
| |
| for(i4_temp_thrd_id = 0; i4_temp_thrd_id < ps_ctxt->i4_num_proc_thrds; i4_temp_thrd_id++) |
| { |
| /*Accumalte only if thread id is valid */ |
| if(ps_multi_thrd_ctxt->ai4_thrd_id_valid_flag[i4_frm_id][i4_br_id][i4_temp_thrd_id] == |
| 1) |
| { |
| /*store complexities for the ctbs across all threads till then */ |
| i8_nctb_l1_me_sad += |
| ps_multi_thrd_ctxt->ai8_nctb_me_sad[i4_frm_id][i4_br_id][i4_temp_thrd_id]; |
| i8_nctb_l1_ipe_sad += |
| ps_multi_thrd_ctxt->ai8_nctb_ipe_sad[i4_frm_id][i4_br_id][i4_temp_thrd_id]; |
| i8_nctb_l0_ipe_satd += |
| ps_multi_thrd_ctxt->ai8_nctb_l0_ipe_sad[i4_frm_id][i4_br_id][i4_temp_thrd_id]; |
| i8_nctb_l1_activity_fact += |
| ps_multi_thrd_ctxt->ai8_nctb_act_factor[i4_frm_id][i4_br_id][i4_temp_thrd_id]; |
| |
| /*Set encoder total and hdr bits and mpm bits for that N ctbs */ |
| i8_nctb_hdr_bits_consumed += |
| ps_multi_thrd_ctxt |
| ->ai8_nctb_hdr_bits_consumed[i4_frm_id][i4_br_id][i4_temp_thrd_id]; |
| i8_nctb_l0_mpm_bits += |
| ps_multi_thrd_ctxt |
| ->ai8_nctb_mpm_bits_consumed[i4_frm_id][i4_br_id][i4_temp_thrd_id]; |
| i8_nctb_bits_consumed += |
| ps_multi_thrd_ctxt->ai8_nctb_bits_consumed[i4_frm_id][i4_br_id][i4_temp_thrd_id]; |
| |
| /*Set encoder total bits for ctbs till then */ |
| i8_acc_bits_consumed += |
| ps_multi_thrd_ctxt->ai8_acc_bits_consumed[i4_frm_id][i4_br_id][i4_temp_thrd_id]; |
| i8_acc_bits_mul_qs_consumed += |
| ps_multi_thrd_ctxt |
| ->ai8_acc_bits_mul_qs_consumed[i4_frm_id][i4_br_id][i4_temp_thrd_id]; |
| |
| /*Reset NCTB total and hdr, mpm bits counter to zero */ |
| ps_multi_thrd_ctxt->ai8_nctb_bits_consumed[i4_frm_id][i4_br_id][i4_temp_thrd_id] = |
| 0; |
| ps_multi_thrd_ctxt |
| ->ai8_nctb_hdr_bits_consumed[i4_frm_id][i4_br_id][i4_temp_thrd_id] = 0; |
| ps_multi_thrd_ctxt |
| ->ai8_nctb_mpm_bits_consumed[i4_frm_id][i4_br_id][i4_temp_thrd_id] = 0; |
| } |
| } |
| |
| /*Store all frame level params */ |
| i8_frame_l1_ipe_sad = ps_ctxt->i8_frame_l1_ipe_sad; |
| i8_frame_l0_ipe_satd = ps_ctxt->i8_frame_l0_ipe_satd; |
| i8_frame_l1_me_sad = ps_ctxt->i8_frame_l1_me_sad; |
| i8_frame_l1_activity_fact = ps_ctxt->i8_frame_l1_activity_fact; |
| i8_frame_bits_estimated = ps_ctxt->ai4_frame_bits_estimated[i4_frm_id][i4_br_id]; |
| |
| /*If CU level RC is disabled reset the nctb and frame level factor */ |
| if(0 == ps_ctxt->i4_qp_mod) |
| { |
| i8_frame_l1_activity_fact = 0; |
| } |
| |
| ASSERT(ps_ctxt->ai4_frame_bits_estimated[i4_frm_id][i4_br_id] != 0); |
| |
| { |
| float bits_estimated, activity_ratio = 1; |
| WORD32 i8_ctb_bits_estimated; |
| float f_bit_deviation; |
| WORD32 i4_tot_frame_ctb = |
| ps_frm_ctb_prms->i4_num_ctbs_vert * ps_frm_ctb_prms->i4_num_ctbs_horz; |
| |
| /*The QP limit can only increment/decrement by 3/1 */ |
| float f_qp_increase_limit = (1.414); |
| //float f_qp_decrease_limit = (0.891); |
| |
| /*Frame level activity is set to 0 for cu-level rc off*/ |
| if(i8_frame_l1_activity_fact != 0) |
| activity_ratio = |
| (float)(i8_frame_l1_activity_fact) / (float)(i8_nctb_l1_activity_fact); |
| |
| activity_ratio = 1; |
| |
| /*Estimate the bits to be consumed based on the intra and inter complexity */ |
| if(i4_is_intra_pic) |
| { |
| float sad_ratio = (float)(i8_nctb_l0_ipe_satd) / (float)(i8_frame_l0_ipe_satd); |
| bits_estimated = sad_ratio * activity_ratio * ((float)i8_frame_bits_estimated); |
| } |
| else |
| { |
| float sad_ratio = (float)(i8_nctb_l1_me_sad) / (float)(i8_frame_l1_me_sad); |
| bits_estimated = sad_ratio * activity_ratio * ((float)i8_frame_bits_estimated); |
| } |
| |
| i8_ctb_bits_estimated = (i8_frame_bits_estimated / i4_tot_frame_ctb); |
| |
| /*for better control on both sides*/ |
| f_bit_deviation = ((i8_acc_bits_consumed * 1.0) / bits_estimated); |
| //printf("\n dev = %f\t",f_bit_deviation); |
| /* if consumed bits is higher than 7.5% or consumed bits is lower by 20%)*/ |
| if((f_bit_deviation > 1.075) || |
| ((f_bit_deviation < 0.8) && |
| (ps_ctxt->i4_is_model_valid == 0 || |
| (ps_multi_thrd_ctxt->ai4_threshold_reached[i4_frm_id][i4_br_id])))) |
| { |
| float f_qscale_avg_factor; |
| WORD32 i4_cu_qp_sub_pic_rc_curr; |
| /*get the Qscale of Frame QP*/ |
| WORD32 i4_frm_qs_q3 = |
| (ps_ctxt->ps_rc_quant_ctxt->pi4_qp_to_qscale |
| [ps_ctxt->i4_frame_qp + ps_ctxt->ps_rc_quant_ctxt->i1_qp_offset]); |
| WORD32 i4_prev_qp = ps_ctxt->i4_frame_mod_qp; |
| |
| ps_multi_thrd_ctxt->ai4_threshold_reached[i4_frm_id][i4_br_id] = 1; |
| |
| /*Calculating Intra scale factor */ |
| if(i4_is_intra_pic) |
| { |
| /*In case of lower QP, Qscale increase at every step is very low, which doesn't allow QP increase |
| to meet the rate, hence disable deviation clip below QP 4 for all bitdepth*/ |
| if(i4_prev_qp > MIN_QP_NO_CLIP_DEV) |
| { |
| /* Clip the bits deviation such that it never cross +3 qp shifts from average QP so far coded with in-frame rc*/ |
| if(f_bit_deviation > f_qp_increase_limit) |
| { |
| f_bit_deviation = f_qp_increase_limit; |
| } |
| } |
| |
| /*The current qscale should do not deviate +/- 3 QP from the previous qscale */ |
| f_qscale_avg_factor = |
| (((float)(i8_acc_bits_mul_qs_consumed * (1 << QSCALE_Q_FAC_3))) / |
| (i8_acc_bits_consumed * i4_frm_qs_q3)); |
| i4_cu_qp_sub_pic_rc_curr = |
| f_qscale_avg_factor * f_bit_deviation * (1 << QP_LEVEL_MOD_ACT_FACTOR); |
| } |
| else /*Calculating Inter scale factor */ |
| { |
| /*In case of lower QP, Qscale increase at every step is very low, which doesn't allow QP increase |
| to meet the rate, hence disable deviation clip below QP 4 for all bitdepth*/ |
| if(i4_prev_qp > MIN_QP_NO_CLIP_DEV) |
| { |
| /* Clip the bits deviation such that it never cross +3 qp shifts from average QP so far coded with in-frame rc*/ |
| if(f_bit_deviation > f_qp_increase_limit) |
| { |
| f_bit_deviation = f_qp_increase_limit; |
| } |
| } |
| |
| /*The current qscale should do not deviate +/- 3 QP from the previous qscale */ |
| f_qscale_avg_factor = |
| (((float)(i8_acc_bits_mul_qs_consumed * (1 << QSCALE_Q_FAC_3))) / |
| (i8_acc_bits_consumed * i4_frm_qs_q3)); |
| i4_cu_qp_sub_pic_rc_curr = |
| f_qscale_avg_factor * f_bit_deviation * (1 << QP_LEVEL_MOD_ACT_FACTOR); |
| } |
| //printf("Avg_qscale = %f\t qs_inq3 = %d",f_qscale_avg_factor,i4_frm_qs_q3); |
| /*update of previous chunk QP in multi-thread context, so that all threads can use it from now onwards*/ |
| { |
| ps_multi_thrd_ctxt->ai4_prev_chunk_qp[i4_frm_id][i4_br_id] = |
| ps_ctxt->i4_frame_mod_qp; |
| } |
| /*Limit the qp from decreasing less than 6 compared to frame qp */ |
| { |
| osal_mutex_lock(ps_multi_thrd_ctxt->pv_sub_pic_rc_for_qp_update_mutex_lock_hdl); |
| ps_multi_thrd_ctxt->ai4_curr_qp_estimated[i4_frm_id][i4_br_id] = |
| i4_cu_qp_sub_pic_rc_curr; |
| osal_mutex_unlock( |
| ps_multi_thrd_ctxt->pv_sub_pic_rc_for_qp_update_mutex_lock_hdl); |
| } |
| } |
| } |
| } |
| osal_mutex_unlock(ps_multi_thrd_ctxt->pv_sub_pic_rc_mutex_lock_hdl); |
| return; |
| } |
| |
| /*! |
| ****************************************************************************** |
| * \if Function name : ihevce_sub_pic_rc_qp_query \endif |
| * |
| * \brief |
| * Sub-pic RC thread interface function |
| * |
| * \param[in] Frame process pointer |
| * |
| * \return |
| * None |
| * |
| * \author |
| * Ittiam |
| * |
| ***************************************************************************** |
| */ |
| void ihevce_sub_pic_rc_scale_query(void *pv_multi_thrd_ctxt, void *pv_ctxt) |
| { |
| multi_thrd_ctxt_t *ps_multi_thrd_ctxt = (multi_thrd_ctxt_t *)pv_multi_thrd_ctxt; |
| ihevce_enc_loop_ctxt_t *ps_ctxt = (ihevce_enc_loop_ctxt_t *)pv_ctxt; |
| WORD32 i4_mod_qp, i4_prev_qs; |
| WORD32 i4_previous_chunk_qp; |
| |
| WORD32 i4_qp_delata_max_limit, i4_qp_delata_min_limit; |
| |
| osal_mutex_lock(ps_multi_thrd_ctxt->pv_sub_pic_rc_for_qp_update_mutex_lock_hdl); |
| |
| i4_mod_qp = |
| (ps_ctxt->ps_rc_quant_ctxt |
| ->pi4_qp_to_qscale[ps_ctxt->i4_frame_qp + ps_ctxt->ps_rc_quant_ctxt->i1_qp_offset]); |
| i4_previous_chunk_qp = |
| ps_multi_thrd_ctxt |
| ->ai4_prev_chunk_qp[ps_ctxt->i4_enc_frm_id][ps_ctxt->i4_bitrate_instance_num]; |
| i4_prev_qs = |
| (ps_ctxt->ps_rc_quant_ctxt |
| ->pi4_qp_to_qscale[i4_previous_chunk_qp + ps_ctxt->ps_rc_quant_ctxt->i1_qp_offset]); |
| /*Limit the qp_delta_scale if it exceeds the limit of QP51 and QP 1 */ |
| |
| i4_qp_delata_max_limit = |
| ps_ctxt->ps_rc_quant_ctxt->i2_max_qscale * (1 << QP_LEVEL_MOD_ACT_FACTOR); |
| i4_qp_delata_max_limit = i4_qp_delata_max_limit / i4_mod_qp; |
| |
| i4_qp_delata_min_limit = |
| ps_ctxt->ps_rc_quant_ctxt->i2_min_qscale * (1 << QP_LEVEL_MOD_ACT_FACTOR); |
| i4_qp_delata_min_limit = i4_qp_delata_min_limit / i4_mod_qp; |
| { |
| /*For Non-I SCD and Frames after SCD*/ |
| /*The scale is tweeked to only increase qp (increased by 6) if the bits consumed is higher than bits |
| estimated */ |
| ps_ctxt->i4_cu_qp_sub_pic_rc = |
| ps_multi_thrd_ctxt |
| ->ai4_curr_qp_estimated[ps_ctxt->i4_enc_frm_id][ps_ctxt->i4_bitrate_instance_num]; |
| /*Limit the Qscale */ |
| if(ps_ctxt->i4_cu_qp_sub_pic_rc > i4_qp_delata_max_limit) |
| { |
| ps_ctxt->i4_cu_qp_sub_pic_rc = i4_qp_delata_max_limit; |
| } |
| else if(ps_ctxt->i4_cu_qp_sub_pic_rc < i4_qp_delata_min_limit) |
| { |
| ps_ctxt->i4_cu_qp_sub_pic_rc = i4_qp_delata_min_limit; |
| } |
| |
| ps_multi_thrd_ctxt |
| ->ai4_curr_qp_estimated[ps_ctxt->i4_enc_frm_id][ps_ctxt->i4_bitrate_instance_num] = |
| ps_ctxt->i4_cu_qp_sub_pic_rc; |
| } |
| |
| /*Accumalate the CTB level QP here and feed to rc as average qp*/ |
| { |
| WORD32 i4_mod_cur_qp, i4_mod_prev_qp; |
| |
| i4_mod_cur_qp = |
| ((i4_mod_qp * ps_ctxt->i4_cu_qp_sub_pic_rc) + (1 << (QP_LEVEL_MOD_ACT_FACTOR - 1))) >> |
| QP_LEVEL_MOD_ACT_FACTOR; |
| |
| /*Limit the qscale and qp */ |
| if(i4_mod_cur_qp > ps_ctxt->ps_rc_quant_ctxt->i2_max_qscale) |
| { |
| i4_mod_cur_qp = ps_ctxt->ps_rc_quant_ctxt->i2_max_qscale; |
| ASSERT(0); |
| } |
| else if(i4_mod_cur_qp < ps_ctxt->ps_rc_quant_ctxt->i2_min_qscale) |
| { |
| i4_mod_cur_qp = ps_ctxt->ps_rc_quant_ctxt->i2_min_qscale; |
| ASSERT(0); |
| } |
| |
| i4_mod_cur_qp = ps_ctxt->ps_rc_quant_ctxt->pi4_qscale_to_qp[i4_mod_cur_qp]; |
| /*limit the prev qs*/ |
| if(i4_prev_qs > ps_ctxt->ps_rc_quant_ctxt->i2_max_qscale) |
| { |
| i4_prev_qs = ps_ctxt->ps_rc_quant_ctxt->i2_max_qscale; |
| } |
| else if(i4_prev_qs < ps_ctxt->ps_rc_quant_ctxt->i2_min_qscale) |
| { |
| i4_prev_qs = ps_ctxt->ps_rc_quant_ctxt->i2_min_qscale; |
| } |
| |
| i4_mod_prev_qp = ps_ctxt->ps_rc_quant_ctxt->pi4_qscale_to_qp[i4_prev_qs]; |
| |
| /*cur qp < prev qp, then allow only -1*/ |
| if(i4_mod_cur_qp < i4_mod_prev_qp) |
| { |
| i4_mod_cur_qp = i4_mod_prev_qp - 1; |
| if(i4_mod_cur_qp < (ps_ctxt->i4_frame_qp - 6)) |
| { |
| i4_mod_cur_qp = (ps_ctxt->i4_frame_qp - 6); |
| } |
| } |
| |
| /*In case of lower QP, Qscale increase at every step is very low, which doesn't allow QP increase |
| to meet the rate, hence disable deviation clip below QP 4 for all bitdepth*/ |
| if(i4_mod_cur_qp > i4_mod_prev_qp) |
| { |
| i4_mod_cur_qp = MIN(i4_mod_prev_qp + 3, i4_mod_cur_qp); |
| } |
| |
| /* CLIP to maintain Qp between user configured and min and max Qp values*/ |
| if(i4_mod_cur_qp > ps_ctxt->ps_rc_quant_ctxt->i2_max_qp) |
| i4_mod_cur_qp = ps_ctxt->ps_rc_quant_ctxt->i2_max_qp; |
| else if(i4_mod_cur_qp < ps_ctxt->ps_rc_quant_ctxt->i2_min_qp) |
| i4_mod_cur_qp = ps_ctxt->ps_rc_quant_ctxt->i2_min_qp; |
| |
| /*Modify the qp based on delta*/ |
| ps_ctxt->i4_frame_mod_qp = i4_mod_cur_qp; |
| ps_ctxt->i4_is_first_query = 0; |
| if(ps_ctxt->i4_frame_mod_qp != ps_ctxt->i4_frame_qp) |
| { |
| ps_ctxt->i4_is_ctb_qp_modified = 1; |
| } |
| } |
| |
| ps_multi_thrd_ctxt->ai4_curr_qp_acc[ps_ctxt->i4_enc_frm_id][ps_ctxt->i4_bitrate_instance_num] += |
| ps_ctxt->i4_frame_mod_qp; |
| |
| osal_mutex_unlock(ps_multi_thrd_ctxt->pv_sub_pic_rc_for_qp_update_mutex_lock_hdl); |
| |
| return; |
| } |
