| /****************************************************************************** |
| * |
| * 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_cabac_rdo.c |
| * |
| * @brief |
| * This file contains function definitions for rdopt cabac entropy modules |
| * |
| * @author |
| * ittiam |
| * |
| * @List of Functions |
| * ihevce_entropy_rdo_frame_init() |
| * ihevce_entropy_rdo_ctb_init() |
| * ihevce_entropy_rdo_encode_cu() |
| * ihevce_cabac_rdo_encode_sao() |
| * ihevce_update_best_sao_cabac_state() |
| * ihevce_entropy_update_best_cu_states() |
| * ihevce_entropy_rdo_encode_tu() |
| * ihevce_entropy_rdo_encode_tu_rdoq() |
| * ihevce_entropy_rdo_copy_states() |
| * |
| ****************************************************************************** |
| */ |
| |
| /*****************************************************************************/ |
| /* 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_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_cabac_rdo.h" |
| #include "ihevce_trace.h" |
| |
| /*****************************************************************************/ |
| /* Function Definitions */ |
| /*****************************************************************************/ |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Cabac rdopt frame level initialization. |
| * |
| * @par Description |
| * Registers the sps,vps,pps,slice header pointers in rdopt enntropy contexts |
| * and intializes cabac engine (init states) for each init cu and scratch cu |
| * contexts |
| * |
| * @param[inout] ps_rdopt_entropy_ctxt |
| * pointer to rdopt entropy context (handle) |
| * |
| * @param[in] ps_slice_hdr |
| * pointer to current slice header |
| * |
| * @param[in] ps_sps |
| * pointer to active SPS params |
| * |
| * @param[in] ps_pps |
| * pointer to active PPS params |
| * |
| * @param[in] ps_vps |
| * pointer to active VPS params |
| * |
| * @param[in] pu1_cu_skip_top_row |
| * pointer to top row cu skip flags (registered at frame level) |
| * |
| * @return none |
| * |
| ****************************************************************************** |
| */ |
| void ihevce_entropy_rdo_frame_init( |
| rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, |
| slice_header_t *ps_slice_hdr, |
| pps_t *ps_pps, |
| sps_t *ps_sps, |
| vps_t *ps_vps, |
| UWORD8 *pu1_cu_skip_top_row, |
| rc_quant_t *ps_rc_quant_ctxt) |
| { |
| WORD32 slice_qp = ps_slice_hdr->i1_slice_qp_delta + ps_pps->i1_pic_init_qp; |
| |
| /* Initialize the CTB size from sps parameters */ |
| WORD32 log2_ctb_size = |
| ps_sps->i1_log2_min_coding_block_size + ps_sps->i1_log2_diff_max_min_coding_block_size; |
| |
| WORD32 cabac_init_idc; |
| |
| (void)ps_rc_quant_ctxt; |
| /* sanity checks */ |
| ASSERT((log2_ctb_size >= 3) && (log2_ctb_size <= 6)); |
| ASSERT((slice_qp >= ps_rc_quant_ctxt->i2_min_qp) && (slice_qp <= ps_rc_quant_ctxt->i2_max_qp)); |
| |
| /* register the sps,vps,pps, slice header pts in all cu entropy ctxts */ |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].ps_vps = ps_vps; |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].ps_sps = ps_sps; |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].ps_pps = ps_pps; |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].ps_slice_hdr = ps_slice_hdr; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].ps_vps = ps_vps; |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].ps_sps = ps_sps; |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].ps_pps = ps_pps; |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].ps_slice_hdr = ps_slice_hdr; |
| |
| /* initialze the skip cu top row ptrs for all rdo entropy contexts */ |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].pu1_skip_cu_top = pu1_cu_skip_top_row; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].pu1_skip_cu_top = pu1_cu_skip_top_row; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].i1_log2_ctb_size = log2_ctb_size; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].i1_log2_ctb_size = log2_ctb_size; |
| |
| /* initialze the skip cu left flagd for all rdo entropy contexts */ |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].u4_skip_cu_left = 0; |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].u4_skip_cu_left = 0; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].i1_ctb_num_pcm_blks = 0; |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].i1_ctb_num_pcm_blks = 0; |
| |
| /* residue encoding should be enaled if ZERO_CBF eval is disabled */ |
| #if((!RDOPT_ZERO_CBF_ENABLE) && (RDOPT_ENABLE)) |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].i4_enable_res_encode = 1; |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].i4_enable_res_encode = 1; |
| #else |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].i4_enable_res_encode = 0; |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].i4_enable_res_encode = 0; |
| #endif |
| |
| /*************************************************************************/ |
| /* Note pu1_cbf_cb, pu1_cbf_cr initialization are done with array idx 1 */ |
| /* This is because these flags are accessed as pu1_cbf_cb[tfr_depth - 1] */ |
| /* without cheking for tfr_depth= 0 */ |
| /*************************************************************************/ |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].apu1_cbf_cb[0] = |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].au1_cbf_cb[0][1]; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].apu1_cbf_cb[0] = |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].au1_cbf_cb[0][1]; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].apu1_cbf_cr[0] = |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].au1_cbf_cr[0][1]; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].apu1_cbf_cr[0] = |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].au1_cbf_cr[0][1]; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].apu1_cbf_cb[1] = |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].au1_cbf_cb[1][1]; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].apu1_cbf_cb[1] = |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].au1_cbf_cb[1][1]; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].apu1_cbf_cr[1] = |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].au1_cbf_cr[1][1]; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].apu1_cbf_cr[1] = |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].au1_cbf_cr[1][1]; |
| |
| memset( |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].au1_cbf_cb, |
| 0, |
| (MAX_TFR_DEPTH + 1) * 2 * sizeof(UWORD8)); |
| |
| memset( |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].au1_cbf_cb, |
| 0, |
| (MAX_TFR_DEPTH + 1) * 2 * sizeof(UWORD8)); |
| |
| memset( |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].au1_cbf_cr, |
| 0, |
| (MAX_TFR_DEPTH + 1) * 2 * sizeof(UWORD8)); |
| |
| memset( |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].au1_cbf_cr, |
| 0, |
| (MAX_TFR_DEPTH + 1) * 2 * sizeof(UWORD8)); |
| |
| /* initialize the cabac init idc based on slice type */ |
| if(ps_slice_hdr->i1_slice_type == ISLICE) |
| { |
| cabac_init_idc = 0; |
| } |
| else if(ps_slice_hdr->i1_slice_type == PSLICE) |
| { |
| cabac_init_idc = ps_slice_hdr->i1_cabac_init_flag ? 2 : 1; |
| } |
| else |
| { |
| cabac_init_idc = ps_slice_hdr->i1_cabac_init_flag ? 1 : 2; |
| } |
| |
| /* all the entropy contexts in rdo initialized in bit compute mode */ |
| ihevce_cabac_init( |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].s_cabac_ctxt, |
| NULL, /* bitstream buffer not required in bits compute mode */ |
| CLIP3(slice_qp, 0, IHEVC_MAX_QP), |
| cabac_init_idc, |
| CABAC_MODE_COMPUTE_BITS); |
| |
| ihevce_cabac_init( |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].s_cabac_ctxt, |
| NULL, /* bitstream buffer not required in bits compute mode */ |
| CLIP3(slice_qp, 0, IHEVC_MAX_QP), |
| cabac_init_idc, |
| CABAC_MODE_COMPUTE_BITS); |
| |
| /* initialize the entropy states in rdopt struct */ |
| COPY_CABAC_STATES( |
| &ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states[0], |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].s_cabac_ctxt.au1_ctxt_models[0], |
| sizeof(ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states)); |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Cabac rdopt ctb level initialization. |
| * |
| * @par Description |
| * initialzes the ctb x and y co-ordinates for all the rdopt entropy contexts |
| * |
| * @param[inout] ps_rdopt_entropy_ctxt |
| * pointer to rdopt entropy context (handle) |
| * |
| * @param[in] ctb_x |
| * current ctb x offset w.r.t frame start (ctb units) |
| * |
| * @param[in] ctb_y |
| * current ctb y offset w.r.t frame start (ctb units) |
| * |
| * @return none |
| * |
| ****************************************************************************** |
| */ |
| void ihevce_entropy_rdo_ctb_init( |
| rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, WORD32 ctb_x, WORD32 ctb_y) |
| { |
| /* initialze the ctb x and y co-ordinates for all the rdopt entropy contexts */ |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].i4_ctb_x = ctb_x; |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].i4_ctb_x = ctb_x; |
| |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].i4_ctb_y = ctb_y; |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].i4_ctb_y = ctb_y; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Cabac rdopt cu encode function to compute luma bits for a given cu |
| * only luma bits are used for rd optimization currently |
| * |
| * @par Description |
| * use a scratch CU entropy context (indicated by rdopt_buf_idx) whose cabac |
| * states are reset (to CU init state) and calls the cabac entropy coding |
| * unit function to compute the total bits for current CU |
| * |
| * A local CU structutre is prepared (in stack) as the structures that entropy |
| * encode expects and the rdopt gets are different |
| * |
| * @param[inout] ps_rdopt_entropy_ctxt |
| * pointer to rdopt entropy context (handle) |
| * |
| * @param[in] ps_cu_prms |
| * pointer to current CU params whose bits are computed |
| * |
| * @param[in] cu_pos_x |
| * current CU x position w.r.t ctb (in 8x8 units) |
| * |
| * @param[in] cu_pos_y |
| * current CU y position w.r.t ctb (in 8x8 units) |
| * |
| * @param[in] cu_size |
| * current cu size (in pel units) |
| * |
| * @param[in] top_avail |
| * top avaialability flag for current CU (required for encoding skip flag) |
| * |
| * @param[in] left_avail |
| * left avaialability flag for current CU (required for encoding skip flag) |
| * |
| * @param[in] pv_ecd_coeff |
| * Compressed coeff residue buffer (for luma) |
| * |
| * @param[in] rdopt_buf_idx |
| * corresponds to the id of the scratch CU entropy context that needs to be |
| * used for bit estimation |
| * |
| * @param[out] pi4_cu_rdopt_tex_bits |
| * returns cbf bits if zer0 cbf eval flag is enabled otherwiese returns total |
| * tex(including cbf bits) |
| * |
| * @return total bits required to encode the current CU |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_entropy_rdo_encode_cu( |
| rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, |
| enc_loop_cu_final_prms_t *ps_cu_prms, |
| WORD32 cu_pos_x, |
| WORD32 cu_pos_y, |
| WORD32 cu_size, |
| WORD32 top_avail, |
| WORD32 left_avail, |
| void *pv_ecd_coeff, |
| WORD32 *pi4_cu_rdopt_tex_bits) |
| { |
| /* local cu structure for passing to entrop encode cu module */ |
| cu_enc_loop_out_t s_enc_cu; |
| WORD32 rdopt_buf_idx = ps_rdopt_entropy_ctxt->i4_curr_buf_idx; |
| |
| entropy_context_t *ps_cur_cu_entropy = |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[rdopt_buf_idx]; |
| |
| WORD32 total_bits = 0; |
| |
| WORD32 log2_ctb_size = ps_cur_cu_entropy->i1_log2_ctb_size; |
| WORD32 log2_cu_size; |
| |
| WORD32 cu_depth; |
| |
| /* sanity checks */ |
| ASSERT((rdopt_buf_idx == 0) || (rdopt_buf_idx == 1)); |
| ASSERT((cu_size >= 8) && (cu_size <= (1 << log2_ctb_size))); |
| ASSERT((cu_pos_x >= 0) && (cu_pos_x <= (1 << (log2_ctb_size - 3)))); |
| ASSERT((cu_pos_y >= 0) && (cu_pos_y <= (1 << (log2_ctb_size - 3)))); |
| |
| GETRANGE(log2_cu_size, cu_size); |
| log2_cu_size -= 1; |
| cu_depth = log2_ctb_size - log2_cu_size; |
| |
| { |
| /**********************************************************/ |
| /* prepare local cu structure before calling cabac encode */ |
| /**********************************************************/ |
| |
| /* default be canged to have orred val*/ |
| s_enc_cu.b1_no_residual_syntax_flag = 0; |
| |
| /* initialize cu posx, posy and size */ |
| s_enc_cu.b3_cu_pos_x = cu_pos_x; |
| s_enc_cu.b3_cu_pos_y = cu_pos_y; |
| s_enc_cu.b4_cu_size = (cu_size >> 3); |
| |
| /* PCM not supported */ |
| s_enc_cu.b1_pcm_flag = 0; |
| s_enc_cu.b1_pred_mode_flag = ps_cu_prms->u1_intra_flag; |
| s_enc_cu.b3_part_mode = ps_cu_prms->u1_part_mode; |
| |
| s_enc_cu.b1_skip_flag = ps_cu_prms->u1_skip_flag; |
| s_enc_cu.b1_tq_bypass_flag = 0; |
| s_enc_cu.pv_coeff = pv_ecd_coeff; |
| |
| /* store the number of TUs */ |
| s_enc_cu.u2_num_tus_in_cu = ps_cu_prms->u2_num_tus_in_cu; |
| |
| /* ---- intialize the PUs and TUs start ptrs for cur CU ----- */ |
| s_enc_cu.ps_pu = &ps_cu_prms->as_pu_enc_loop[0]; |
| s_enc_cu.ps_enc_tu = &ps_cu_prms->as_tu_enc_loop[0]; |
| |
| /* Corner case : If Part is 2Nx2N and Merge has all TU with zero cbf */ |
| /* then it has to be coded as skip CU */ |
| if((SIZE_2Nx2N == ps_cu_prms->u1_part_mode) && |
| /*(1 == ps_cu_prms->u2_num_tus_in_cu) &&*/ |
| (1 == ps_cu_prms->as_pu_enc_loop[0].b1_merge_flag) && (0 == ps_cu_prms->u1_skip_flag) && |
| (0 == ps_cu_prms->u1_is_cu_coded)) |
| { |
| s_enc_cu.b1_skip_flag = 1; |
| } |
| |
| if(s_enc_cu.b1_pred_mode_flag == PRED_MODE_INTER) |
| { |
| s_enc_cu.b1_no_residual_syntax_flag = !ps_cu_prms->u1_is_cu_coded; |
| } |
| else /* b1_pred_mode_flag == PRED_MODE_INTRA */ |
| { |
| /* copy prev_mode_flag, mpm_idx and rem_intra_pred_mode for each PU */ |
| memcpy( |
| &s_enc_cu.as_prev_rem[0], |
| &ps_cu_prms->as_intra_prev_rem[0], |
| ps_cu_prms->u2_num_tus_in_cu * sizeof(intra_prev_rem_flags_t)); |
| |
| s_enc_cu.b3_chroma_intra_pred_mode = ps_cu_prms->u1_chroma_intra_pred_mode; |
| } |
| } |
| |
| /* reset the total bits in cabac engine to zero */ |
| ps_cur_cu_entropy->s_cabac_ctxt.u4_bits_estimated_q12 = 0; |
| ps_cur_cu_entropy->s_cabac_ctxt.u4_texture_bits_estimated_q12 = 0; |
| ps_cur_cu_entropy->s_cabac_ctxt.u4_cbf_bits_q12 = 0; |
| ps_cur_cu_entropy->i1_encode_qp_delta = 0; |
| |
| /* Call the cabac encode function of current cu to compute bits */ |
| ihevce_cabac_encode_coding_unit(ps_cur_cu_entropy, &s_enc_cu, cu_depth, top_avail, left_avail); |
| |
| /* return total bits after rounding the fractional bits */ |
| total_bits = |
| (ps_cur_cu_entropy->s_cabac_ctxt.u4_bits_estimated_q12 + (1 << (CABAC_FRAC_BITS_Q - 1))) >> |
| CABAC_FRAC_BITS_Q; |
| #if RDOPT_ZERO_CBF_ENABLE |
| ASSERT(ps_cur_cu_entropy->s_cabac_ctxt.u4_texture_bits_estimated_q12 == 0); |
| #endif |
| /* return total texture bits rounding the fractional bits */ |
| *pi4_cu_rdopt_tex_bits = |
| (ps_cur_cu_entropy->s_cabac_ctxt.u4_cbf_bits_q12 + (1 << (CABAC_FRAC_BITS_Q - 1))) >> |
| CABAC_FRAC_BITS_Q; |
| |
| /* ( ps_cur_cu_entropy->s_cabac_ctxt.u4_texture_bits_estimated_q12 + |
| (1 << (CABAC_FRAC_BITS_Q - 1)) |
| ) >> CABAC_FRAC_BITS_Q;*/ |
| |
| return (total_bits); |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Cabac rdo encode sao function to compute bits required for a given |
| * ctb to be encoded with any sao type or no SAO. |
| * |
| * @par Description |
| * use a scratch CU entropy context (indicated by rdopt_buf_idx) and init cabac |
| * states are reset (to CU init state) and calls the cabac encode sao |
| * function to compute the total bits for current CTB |
| * |
| * @param[inout] ps_rdopt_entropy_ctxt |
| * pointer to rdopt entropy context (handle) |
| * |
| * @param[in] ps_ctb_enc_loop_out |
| * pointer to current enc loop CTB output structure |
| * |
| * @return total bits required to encode the current CTB |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_cabac_rdo_encode_sao( |
| rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, ctb_enc_loop_out_t *ps_ctb_enc_loop_out) |
| { |
| /* index to curr buf*/ |
| WORD32 rdopt_buf_idx = ps_rdopt_entropy_ctxt->i4_curr_buf_idx; |
| WORD32 total_bits = 0; |
| entropy_context_t *ps_cur_ctb_entropy = |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[rdopt_buf_idx]; |
| |
| /* copy the intial entropy states from backuped buf to curr buf */ |
| memcpy( |
| &ps_cur_ctb_entropy->s_cabac_ctxt.au1_ctxt_models[0], |
| &ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states[0], |
| sizeof(ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states)); |
| |
| /* reset the total bits in cabac engine to zero */ |
| ps_cur_ctb_entropy->s_cabac_ctxt.u4_bits_estimated_q12 = 0; |
| ps_cur_ctb_entropy->s_cabac_ctxt.u4_texture_bits_estimated_q12 = 0; |
| ps_cur_ctb_entropy->s_cabac_ctxt.u4_cbf_bits_q12 = 0; |
| ps_cur_ctb_entropy->i1_encode_qp_delta = 0; |
| //ps_cur_ctb_entropy->s_cabac_ctxt.u4_range = 0; |
| |
| ASSERT(ps_cur_ctb_entropy->s_cabac_ctxt.u4_range == 0); |
| ihevce_cabac_encode_sao(ps_cur_ctb_entropy, ps_ctb_enc_loop_out); |
| |
| /* return total bits after rounding the fractional bits */ |
| total_bits = |
| (ps_cur_ctb_entropy->s_cabac_ctxt.u4_bits_estimated_q12 + (1 << (CABAC_FRAC_BITS_Q - 1))) >> |
| CABAC_FRAC_BITS_Q; |
| |
| return (total_bits); |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Updates best sao cabac state. |
| * |
| * @par Description |
| * Copies the cabac states of best cand to init states buf for next ctb. |
| * |
| * @param[inout] ps_rdopt_entropy_ctxt |
| * pointer to rdopt entropy context (handle) |
| * |
| * @param[in] i4_best_buf_idx |
| * Index to the buffer having the cabac states of best candidate |
| * |
| * @return Success/failure |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_update_best_sao_cabac_state( |
| rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, WORD32 i4_best_buf_idx) |
| { |
| /* local cu structure for passing to entrop encode cu module */ |
| WORD32 rdopt_buf_idx = i4_best_buf_idx; |
| entropy_context_t *ps_cur_ctb_entropy = |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[rdopt_buf_idx]; |
| |
| /* copy the intial entropy states from best buf to intial states buf */ |
| memcpy( |
| &ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states[0], |
| &ps_cur_ctb_entropy->s_cabac_ctxt.au1_ctxt_models[0], |
| sizeof(ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states)); |
| |
| /* reset the total bits in cabac engine to zero */ |
| ps_cur_ctb_entropy->s_cabac_ctxt.u4_bits_estimated_q12 = 0; |
| ps_cur_ctb_entropy->s_cabac_ctxt.u4_texture_bits_estimated_q12 = 0; |
| ps_cur_ctb_entropy->s_cabac_ctxt.u4_cbf_bits_q12 = 0; |
| ps_cur_ctb_entropy->i1_encode_qp_delta = 0; |
| |
| return (1); |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Cabac rdopt cu encode function to compute luma bits for a given cu |
| * only luma bits are used for rd optimization currently |
| * |
| * @par Description |
| * use a scratch CU entropy context (indicated by rdopt_buf_idx) whose cabac |
| * states are reset (to CU init state) and calls the cabac entropy coding |
| * unit function to compute the total bits for current CU |
| * |
| * A local CU structutre is prepared (in stack) as the structures that entropy |
| * encode expects and the rdopt gets are different |
| * |
| * @param[inout] ps_rdopt_entropy_ctxt |
| * pointer to rdopt entropy context (handle) |
| * |
| * @param[in] cu_pos_x |
| * current CU x position w.r.t ctb (in 8x8 units) |
| * |
| * @param[in] cu_pos_y |
| * current CU y position w.r.t ctb (in 8x8 units) |
| * |
| * @param[in] cu_size |
| * current cu size (in pel units) |
| * |
| * @param[in] rdopt_best_cu_idx |
| * id of the best CU entropy ctxt (rdopt winner candidate) |
| * |
| * @return total bits required to encode the current CU |
| * |
| ****************************************************************************** |
| */ |
| void ihevce_entropy_update_best_cu_states( |
| rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, |
| WORD32 cu_pos_x, |
| WORD32 cu_pos_y, |
| WORD32 cu_size, |
| WORD32 cu_skip_flag, |
| WORD32 rdopt_best_cu_idx) |
| { |
| entropy_context_t *ps_best_cu_entropy = |
| &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[rdopt_best_cu_idx]; |
| |
| /* CTB x co-ordinate w.r.t frame start */ |
| WORD32 ctb_x0_frm = (ps_best_cu_entropy->i4_ctb_x << ps_best_cu_entropy->i1_log2_ctb_size); |
| |
| /* CU x co-ordinate w.r.t frame start */ |
| WORD32 cu_x0_frm = cu_pos_x + ctb_x0_frm; |
| |
| /* bit postion from where top skip flag is extracted; 1bit per 8 pel */ |
| WORD32 x_pos = ((cu_x0_frm >> 3) & 0x7); |
| |
| /* bit postion from where left skip flag is extracted; 1bit per 8 pel */ |
| WORD32 y_pos = ((cu_pos_y >> 3) & 0x7); |
| |
| /* top and left skip flags computed based on nbr availability */ |
| UWORD8 *pu1_top_skip_flags = ps_best_cu_entropy->pu1_skip_cu_top + (cu_x0_frm >> 6); |
| |
| UWORD32 u4_skip_left_flags = ps_best_cu_entropy->u4_skip_cu_left; |
| |
| ps_best_cu_entropy = &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[rdopt_best_cu_idx]; |
| |
| /* copy the entropy states from best rdopt cu states to init states */ |
| COPY_CABAC_STATES( |
| &ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states[0], |
| &ps_best_cu_entropy->s_cabac_ctxt.au1_ctxt_models[0], |
| sizeof(ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states)); |
| |
| /* replicate skip flag in left and top row cu skip flags */ |
| if(cu_skip_flag) |
| { |
| SET_BITS(pu1_top_skip_flags[0], x_pos, (cu_size >> 3)); |
| SET_BITS(u4_skip_left_flags, y_pos, (cu_size >> 3)); |
| } |
| else |
| { |
| CLEAR_BITS(pu1_top_skip_flags[0], x_pos, (cu_size >> 3)); |
| CLEAR_BITS(u4_skip_left_flags, y_pos, (cu_size >> 3)); |
| } |
| |
| /* copy the left skip flags in both the rdopt contexts */ |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[0].u4_skip_cu_left = |
| ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[1].u4_skip_cu_left = u4_skip_left_flags; |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Cabac rdopt tu encode function to compute luma bits for a given tu |
| * only luma bits are used for rd optimization currently |
| * |
| * @par Description |
| * use a scratch CU entropy context (indicated by rdopt_buf_idx) whose cabac |
| * states are reset (to CU init state for first tu) and calls the cabac residue |
| * coding function to compute the total bits for current TU |
| * |
| * Note : TU includes only residual coding bits and does not include |
| * tu split, cbf and qp delta encoding bits for a TU |
| * |
| * @param[inout] ps_rdopt_entropy_ctxt |
| * pointer to rdopt entropy context (handle) |
| * |
| * @param[in] pv_ecd_coeff |
| * Compressed coeff residue buffer (for luma) |
| * |
| * @param[in] transform_size |
| * current tu size in pel units |
| * |
| * @param[in] is_luma |
| * indicates if it is luma or chrom TU (required for residue encode) |
| * |
| * @return total bits required to encode the current TU |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_entropy_rdo_encode_tu( |
| rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, |
| void *pv_ecd_coeff, |
| WORD32 transform_size, |
| WORD32 is_luma, |
| WORD32 perform_sbh) |
| { |
| WORD32 log2_tfr_size; |
| WORD32 total_bits = 0; |
| WORD32 curr_buf_idx = ps_rdopt_entropy_ctxt->i4_curr_buf_idx; |
| entropy_context_t *ps_cur_tu_entropy; |
| |
| ps_cur_tu_entropy = &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[curr_buf_idx]; |
| |
| ASSERT((transform_size >= 4) && (transform_size <= 32)); |
| |
| /* transform size to log2transform size */ |
| GETRANGE(log2_tfr_size, transform_size); |
| log2_tfr_size -= 1; |
| |
| /* reset the total bits in cabac engine to zero */ |
| ps_cur_tu_entropy->s_cabac_ctxt.u4_bits_estimated_q12 = 0; |
| ps_cur_tu_entropy->i1_encode_qp_delta = 0; |
| |
| /* Call the cabac residue encode function to compute TU bits */ |
| ihevce_cabac_residue_encode_rdopt( |
| ps_cur_tu_entropy, pv_ecd_coeff, log2_tfr_size, is_luma, perform_sbh); |
| |
| /* return total bits after rounding the fractional bits */ |
| total_bits = |
| (ps_cur_tu_entropy->s_cabac_ctxt.u4_bits_estimated_q12 + (1 << (CABAC_FRAC_BITS_Q - 1))) >> |
| CABAC_FRAC_BITS_Q; |
| |
| return (total_bits); |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Cabac rdopt tu encode function to compute bits for a given tu. Actual |
| * RDOQ algorithm is performed by the ihevce_cabac_residue_encode_rdoq function |
| * called by this function. |
| * |
| * @par Description |
| * use a scratch CU entropy context (indicated by rdopt_buf_idx) whose cabac |
| * states are reset (to CU init state for first tu) and calls the cabac residue |
| * coding function to compute the total bits for current TU |
| * |
| * Note : TU includes only residual coding bits and does not include |
| * tu split, cbf and qp delta encoding bits for a TU |
| * |
| * @param[inout] ps_rdopt_entropy_ctxt |
| * pointer to rdopt entropy context (handle) |
| * |
| * @param[in] pv_ecd_coeff |
| * Compressed coeff residue buffer |
| * |
| * @param[in] transform_size |
| * current tu size in pel units |
| * |
| * @param[in] first_tu_of_cu |
| * indicates if the tu is the first unit of cu (required for initializing |
| * cabac ctxts) |
| * |
| * @param[in] rdopt_buf_idx |
| * corresponds to the id of the rdopt CU entropy context that needs to be |
| * used for bit estimation |
| * |
| * @param[in] is_luma |
| * indicates if it is luma or chrom TU (required for residue encode) |
| * |
| * @param[in] intra_nxn_mode |
| * indicates if it is luma or chrom TU (required for residue encode) |
| * |
| * @param[inout] ps_rdoq_ctxt |
| * pointer to rdoq context structure |
| * |
| * @param[inout] pi4_coded_tu_dist |
| * Pointer to the variable which will contain the transform domain distortion |
| * of the entire TU, when any of the coeffs in the TU are coded |
| * |
| * @param[inout] pi4_not_coded_tu_dist |
| * Pointer to the variable which will contain the transform domain distortion |
| * of the enture TU, when all the coeffs in the TU are coded |
| * |
| * @return total bits required to encode the current TU |
| * |
| ****************************************************************************** |
| */ |
| WORD32 ihevce_entropy_rdo_encode_tu_rdoq( |
| rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, |
| void *pv_ecd_coeff, |
| WORD32 transform_size, |
| WORD32 is_luma, |
| rdoq_sbh_ctxt_t *ps_rdoq_ctxt, |
| LWORD64 *pi8_coded_tu_dist, |
| LWORD64 *pi8_not_coded_tu_dist, |
| WORD32 perform_sbh) |
| { |
| WORD32 log2_tfr_size; |
| WORD32 total_bits = 0; |
| WORD32 curr_buf_idx = ps_rdopt_entropy_ctxt->i4_curr_buf_idx; |
| entropy_context_t *ps_cur_tu_entropy; |
| |
| ps_cur_tu_entropy = &ps_rdopt_entropy_ctxt->as_cu_entropy_ctxt[curr_buf_idx]; |
| |
| ASSERT((transform_size >= 4) && (transform_size <= 32)); |
| |
| /* transform size to log2transform size */ |
| GETRANGE(log2_tfr_size, transform_size); |
| log2_tfr_size -= 1; |
| |
| /* reset the total bits in cabac engine to zero */ |
| ps_cur_tu_entropy->s_cabac_ctxt.u4_bits_estimated_q12 = 0; |
| ps_cur_tu_entropy->i1_encode_qp_delta = 0; |
| |
| /* Call the cabac residue encode function to compute TU bits */ |
| ihevce_cabac_residue_encode_rdoq( |
| ps_cur_tu_entropy, |
| pv_ecd_coeff, |
| log2_tfr_size, |
| is_luma, |
| (void *)ps_rdoq_ctxt, |
| pi8_coded_tu_dist, |
| pi8_not_coded_tu_dist, |
| perform_sbh); |
| |
| /* return total bits after rounding the fractional bits */ |
| total_bits = |
| (ps_cur_tu_entropy->s_cabac_ctxt.u4_bits_estimated_q12 + (1 << (CABAC_FRAC_BITS_Q - 1))) >> |
| CABAC_FRAC_BITS_Q; |
| |
| return (total_bits); |
| } |
| |
| /** |
| ****************************************************************************** |
| * |
| * @brief Cabac rdopt copy functions for copying states (which will be used later) |
| * |
| * @par Description |
| * Does the HEVC style of entropy sync by copying the state to/from rdo context |
| * from/to row level cabac states at start of row/2nd ctb of row |
| * |
| * Caller needs to make sure UPDATE_ENT_SYNC_RDO_STATE is used for first ctb of |
| * every row (leaving first row of slice) and STORE_ENT_SYNC_RDO_STATE is used for |
| * storing the cabac states at the end of 2nd ctb of a row. |
| * |
| * @param[inout] ps_rdopt_entropy_ctxt |
| * pointer to rdopt entropy context (handle) |
| * |
| * @param[in] pu1_entropy_sync_states |
| * pointer to entropy sync cabac states |
| * |
| * @param[in] copy_mode |
| * mode of copying cabac states. Shall be either UPDATE_ENT_SYNC_RDO_STATE and |
| * STORE_ENT_SYNC_RDO_STATE |
| * |
| ****************************************************************************** |
| */ |
| void ihevce_entropy_rdo_copy_states( |
| rdopt_entropy_ctxt_t *ps_rdopt_entropy_ctxt, UWORD8 *pu1_entropy_sync_states, WORD32 copy_mode) |
| { |
| /* sanity checks */ |
| ASSERT((copy_mode == STORE_ENT_SYNC_RDO_STATE) || (copy_mode == UPDATE_ENT_SYNC_RDO_STATE)); |
| |
| if(STORE_ENT_SYNC_RDO_STATE == copy_mode) |
| { |
| COPY_CABAC_STATES( |
| pu1_entropy_sync_states, |
| &ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states[0], |
| IHEVC_CAB_CTXT_END); |
| } |
| else if(UPDATE_ENT_SYNC_RDO_STATE == copy_mode) |
| { |
| COPY_CABAC_STATES( |
| &ps_rdopt_entropy_ctxt->au1_init_cabac_ctxt_states[0], |
| pu1_entropy_sync_states, |
| IHEVC_CAB_CTXT_END); |
| } |
| } |