/******************************************************************************
|
*
|
* 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_tu.c
|
*
|
* @brief
|
* This file contains function definitions for cabac entropy coding of
|
* transform units of HEVC syntax
|
*
|
* @author
|
* ittiam
|
*
|
* @List of Functions
|
* ihevce_cabac_encode_qp_delta()
|
* ihevce_cabac_encode_last_coeff_x_y()
|
* ihevce_encode_transform_tree()
|
* ihevce_cabac_residue_encode()
|
* ihevce_cabac_residue_encode_rdopt()
|
* ihevce_cabac_residue_encode_rdoq()
|
* ihevce_code_all_sig_coeffs_as_0_explicitly()
|
* ihevce_find_new_last_csb()
|
* ihevce_copy_backup_ctxt()
|
* ihevce_estimate_num_bits_till_next_non_zero_coeff()
|
*
|
******************************************************************************
|
*/
|
|
/*****************************************************************************/
|
/* 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 "ihevc_trans_macros.h"
|
#include "ihevc_trans_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_bs_compute_ctb.h"
|
#include "ihevce_global_tables.h"
|
#include "ihevce_common_utils.h"
|
#include "ihevce_trace.h"
|
|
/*****************************************************************************/
|
/* Globals */
|
/*****************************************************************************/
|
extern UWORD16 gau2_ihevce_cabac_bin_to_bits[64 * 2];
|
|
/**
|
******************************************************************************
|
* @brief LUT for deriving of last significant coeff prefix.
|
*
|
* @input : last_significant_coeff
|
*
|
* @output : last_significant_prefix (does not include the
|
*
|
* @remarks Look up tables taken frm HM-8.0-dev
|
******************************************************************************
|
*/
|
const UWORD8 gu1_hevce_last_coeff_prefix[32] = { 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,
|
8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9 };
|
|
/**
|
*****************************************************************************
|
* @brief LUT for deriving of last significant coeff suffix
|
*
|
* @input : last significant prefix
|
*
|
* @output : prefix code that needs to be subtracted from last_pos to get
|
* suffix as per equation 7-55 in section 7.4.12.
|
*
|
* It returns the following code for last_significant_prefix > 3
|
* ((1 << ((last_significant_coeff_x_prefix >> 1) - 1)) *
|
* (2 + (last_significant_coeff_x_prefix & 1))
|
*
|
*
|
* @remarks Look up tables taken frm HM-8.0-dev
|
*****************************************************************************
|
*/
|
const UWORD8 gu1_hevce_last_coeff_prefix_code[10] = { 0, 1, 2, 3, 4, 6, 8, 12, 16, 24 };
|
|
/**
|
*****************************************************************************
|
* @brief returns raster index of 4x4 block for diag up-right/horz/vert scans
|
*
|
* @input : scan type and scan idx
|
*
|
* @output : packed y pos(msb 4bit) and x pos(lsb 2bit)
|
*
|
*****************************************************************************
|
*/
|
const UWORD8 gu1_hevce_scan4x4[3][16] = {
|
/* diag up right */
|
{ 0, 4, 1, 8, 5, 2, 12, 9, 6, 3, 13, 10, 7, 14, 11, 15 },
|
|
/* horz */
|
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
|
|
/* vert */
|
{ 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15 }
|
};
|
|
/**
|
*****************************************************************************
|
* @brief returns context increment for sig coeff based on csbf neigbour
|
* flags (bottom and right) and current coeff postion in 4x4 block
|
* See section 9.3.3.1.4 for details on this context increment
|
*
|
* @input : neigbour csbf flags(bit0:rightcsbf, bit1:bottom csbf)
|
* coeff idx in raster order (0-15)
|
*
|
* @output : context increment for sig coeff flag
|
*
|
*****************************************************************************
|
*/
|
const UWORD8 gu1_hevce_sigcoeff_ctxtinc[4][16] = {
|
/* nbr csbf = 0: sigCtx = (xP+yP == 0) ? 2 : (xP+yP < 3) ? 1: 0 */
|
{ 2, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
|
|
/* nbr csbf = 1: sigCtx = (yP == 0) ? 2 : (yP == 1) ? 1: 0 */
|
{ 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
|
|
/* nbr csbf = 2: sigCtx = (xP == 0) ? 2 : (xP == 1) ? 1: 0 */
|
{ 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0, 2, 1, 0, 0 },
|
|
/* nbr csbf = 3: sigCtx = 2 */
|
{ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }
|
};
|
|
const UWORD8 gu1_hevce_sigcoeff_ctxtinc_00[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
|
|
/**
|
*****************************************************************************
|
* @brief returns context increment for sig coeff for 4x4 tranform size as
|
* per Table 9-39 in section 9.3.3.1.4
|
*
|
* @input : coeff idx in raster order (0-15)
|
*
|
* @output : context increment for sig coeff flag
|
*
|
*****************************************************************************
|
*/
|
const UWORD8 gu1_hevce_sigcoeff_ctxtinc_tr4[16] = { 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 0 };
|
|
#define DISABLE_ZCSBF 0
|
|
#define TEST_CABAC_BITESTIMATE 0
|
|
/*****************************************************************************/
|
/* Function Definitions */
|
/*****************************************************************************/
|
/**
|
******************************************************************************
|
*
|
* @brief Entropy encoding of qp_delta in a tu as per sec 9.3.2 Table 9-32
|
*
|
* @par Description
|
* trunacted unary binarization is done based upto abs_delta of 5 and the rest
|
* is coded as 0th order Exponential Golomb code
|
*
|
* @param[inout] ps_cabac
|
* pointer to cabac encoding context (handle)
|
*
|
* @param[in] qp_delta
|
* delta qp that needs to be encoded
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_encode_qp_delta(cab_ctxt_t *ps_cabac, WORD32 qp_delta)
|
{
|
WORD32 qp_delta_abs = ABS(qp_delta);
|
WORD32 c_max = TU_MAX_QP_DELTA_ABS;
|
WORD32 ctxt_inc = IHEVC_CAB_QP_DELTA_ABS;
|
WORD32 ctxt_inc_max = CTXT_MAX_QP_DELTA_ABS;
|
WORD32 ret = IHEVCE_SUCCESS;
|
|
/* qp_delta_abs is coded as combination of tunary and eg0 code */
|
/* See Table 9-32 and Table 9-37 for details on cu_qp_delta_abs */
|
ret |= ihevce_cabac_encode_tunary(
|
ps_cabac, MIN(qp_delta_abs, c_max), c_max, ctxt_inc, 0, ctxt_inc_max);
|
if(qp_delta_abs >= c_max)
|
{
|
ret |= ihevce_cabac_encode_egk(ps_cabac, qp_delta_abs - c_max, 0);
|
}
|
AEV_TRACE("cu_qp_delta_abs", qp_delta_abs, ps_cabac->u4_range);
|
|
/* code the qp delta sign flag */
|
if(qp_delta_abs)
|
{
|
WORD32 sign = (qp_delta < 0) ? 1 : 0;
|
ret |= ihevce_cabac_encode_bypass_bin(ps_cabac, sign);
|
AEV_TRACE("cu_qp_delta_sign", sign, ps_cabac->u4_range);
|
}
|
|
return (ret);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Encodes position of the last coded coeff (in scan order) of TU
|
*
|
* @par Description
|
* Entropy encode of last coded coeff of a TU as per section:7.3.13
|
*
|
* @param[inout] ps_cabac
|
* pointer to cabac context (handle)
|
*
|
* @param[in] last_coeff_x
|
* x co-ordinate of the last coded coeff of TU(in scan order)
|
*
|
* @param[in] last_coeff_y
|
* x co-ordinate of the last coded coeff of TU (in scan order
|
*
|
* @param[in] log2_tr_size
|
* transform block size corresponding to this node in quad tree
|
*
|
* @param[in] is_luma
|
* indicates if residual block corresponds to luma or chroma block
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_encode_last_coeff_x_y(
|
cab_ctxt_t *ps_cabac,
|
WORD32 last_coeff_x,
|
WORD32 last_coeff_y,
|
WORD32 log2_tr_size,
|
WORD32 is_luma)
|
{
|
WORD32 ret = IHEVCE_SUCCESS;
|
|
WORD32 last_coeff_x_prefix;
|
WORD32 last_coeff_y_prefix;
|
WORD32 suffix, suf_length;
|
WORD32 c_max;
|
WORD32 ctxt_idx_x, ctxt_idx_y, ctx_shift;
|
|
/* derive the prefix code */
|
last_coeff_x_prefix = gu1_hevce_last_coeff_prefix[last_coeff_x];
|
last_coeff_y_prefix = gu1_hevce_last_coeff_prefix[last_coeff_y];
|
|
c_max = gu1_hevce_last_coeff_prefix[(1 << log2_tr_size) - 1];
|
|
/* context increment as per section 9.3.3.1.2 */
|
if(is_luma)
|
{
|
WORD32 ctx_offset = (3 * (log2_tr_size - 2)) + ((log2_tr_size - 1) >> 2);
|
|
ctxt_idx_x = IHEVC_CAB_COEFFX_PREFIX + ctx_offset;
|
ctxt_idx_y = IHEVC_CAB_COEFFY_PREFIX + ctx_offset;
|
ctx_shift = (log2_tr_size + 1) >> 2;
|
}
|
else
|
{
|
ctxt_idx_x = IHEVC_CAB_COEFFX_PREFIX + 15;
|
ctxt_idx_y = IHEVC_CAB_COEFFY_PREFIX + 15;
|
ctx_shift = log2_tr_size - 2;
|
}
|
|
/* code the last_coeff_x_prefix as tunary binarized code */
|
ret |= ihevce_cabac_encode_tunary(
|
ps_cabac, last_coeff_x_prefix, c_max, ctxt_idx_x, ctx_shift, c_max);
|
|
AEV_TRACE("last_coeff_x_prefix", last_coeff_x_prefix, ps_cabac->u4_range);
|
|
/* code the last_coeff_y_prefix as tunary binarized code */
|
ret |= ihevce_cabac_encode_tunary(
|
ps_cabac, last_coeff_y_prefix, c_max, ctxt_idx_y, ctx_shift, c_max);
|
|
AEV_TRACE("last_coeff_y_prefix", last_coeff_y_prefix, ps_cabac->u4_range);
|
|
if(last_coeff_x_prefix > 3)
|
{
|
/* code the last_coeff_x_suffix as FLC bypass code */
|
suffix = last_coeff_x - gu1_hevce_last_coeff_prefix_code[last_coeff_x_prefix];
|
|
suf_length = ((last_coeff_x_prefix - 2) >> 1);
|
|
ret |= ihevce_cabac_encode_bypass_bins(ps_cabac, suffix, suf_length);
|
|
AEV_TRACE("last_coeff_x_suffix", suffix, ps_cabac->u4_range);
|
}
|
|
if(last_coeff_y_prefix > 3)
|
{
|
/* code the last_coeff_y_suffix as FLC bypass code */
|
suffix = last_coeff_y - gu1_hevce_last_coeff_prefix_code[last_coeff_y_prefix];
|
|
suf_length = ((last_coeff_y_prefix - 2) >> 1);
|
|
ret |= ihevce_cabac_encode_bypass_bins(ps_cabac, suffix, suf_length);
|
|
AEV_TRACE("last_coeff_y_suffix", suffix, ps_cabac->u4_range);
|
}
|
|
return (ret);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Encodes a transform tree as per section 7.3.11
|
*
|
* @par Description
|
* Uses recursion till a leaf node is reached where a transform unit
|
* is coded. While recursing split_transform_flag and parent chroma cbf flags
|
* are coded before recursing to leaf node
|
*
|
* @param[inout] ps_entropy_ctxt
|
* pointer to entropy context (handle)
|
*
|
* @param[in] x0_ctb
|
* x co-ordinate w.r.t ctb start of current tu node of coding tree
|
*
|
* @param[in] y0_ctb
|
* y co-ordinate w.r.t ctb start of current cu node of coding tree
|
*
|
* @param[in] log2_tr_size
|
* transform block size corresponding to this node in quad tree
|
*
|
* @param[in] tr_depth
|
* current depth of the tree
|
*
|
* @param[in] tr_depth
|
* current depth of the tree
|
*
|
* @param[in] blk_num
|
* current block number in the quad tree (required for chorma 4x4 coding)
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_encode_transform_tree(
|
entropy_context_t *ps_entropy_ctxt,
|
WORD32 x0_ctb,
|
WORD32 y0_ctb,
|
WORD32 log2_tr_size,
|
WORD32 tr_depth,
|
WORD32 blk_num,
|
cu_enc_loop_out_t *ps_enc_cu)
|
{
|
WORD32 ret = IHEVCE_SUCCESS;
|
sps_t *ps_sps = ps_entropy_ctxt->ps_sps;
|
WORD32 split_tr_flag;
|
|
WORD32 tu_idx = ps_entropy_ctxt->i4_tu_idx;
|
tu_enc_loop_out_t *ps_enc_tu = ps_enc_cu->ps_enc_tu + tu_idx;
|
|
/* TU size in pels */
|
WORD32 tu_size = 4 << ps_enc_tu->s_tu.b3_size;
|
|
cab_ctxt_t *ps_cabac = &ps_entropy_ctxt->s_cabac_ctxt;
|
|
WORD32 max_tr_depth;
|
WORD32 is_intra = (ps_enc_cu->b1_pred_mode_flag == PRED_MODE_INTRA);
|
WORD32 log2_min_trafo_size, log2_max_trafo_size;
|
UWORD32 u4_bits_estimated_prev;
|
|
WORD32 intra_nxn_pu = 0;
|
WORD32 ctxt_inc;
|
WORD32 cbf_luma = 0;
|
WORD32 ai4_cbf_cb[2] = { 0, 0 };
|
WORD32 ai4_cbf_cr[2] = { 0, 0 };
|
UWORD32 tu_split_bits = 0;
|
UWORD8 u1_is_422 = (ps_sps->i1_chroma_format_idc == 2);
|
|
tu_split_bits = ps_cabac->u4_bits_estimated_q12;
|
/* intialize min / max transform sizes based on sps */
|
log2_min_trafo_size = ps_sps->i1_log2_min_transform_block_size;
|
|
log2_max_trafo_size = log2_min_trafo_size + ps_sps->i1_log2_diff_max_min_transform_block_size;
|
|
/* intialize max transform depth for intra / inter signalled in sps */
|
if(is_intra)
|
{
|
max_tr_depth = ps_sps->i1_max_transform_hierarchy_depth_intra;
|
intra_nxn_pu = ps_enc_cu->b3_part_mode == PART_NxN;
|
}
|
else
|
{
|
max_tr_depth = ps_sps->i1_max_transform_hierarchy_depth_inter;
|
}
|
|
/* Sanity checks */
|
ASSERT(tr_depth <= 4);
|
ASSERT(log2_min_trafo_size >= 2);
|
ASSERT(log2_max_trafo_size <= 5);
|
ASSERT((tu_idx >= 0) && (tu_idx < ps_enc_cu->u2_num_tus_in_cu));
|
ASSERT((tu_size >= 4) && (tu_size <= (1 << log2_tr_size)));
|
|
/* Encode split transform flag based on following conditions; sec 7.3.11 */
|
if((log2_tr_size <= log2_max_trafo_size) && (log2_tr_size > log2_min_trafo_size) &&
|
(tr_depth < max_tr_depth) && (!(intra_nxn_pu && (tr_depth == 0))))
|
{
|
/* encode the split transform flag, context derived as per Table9-37 */
|
ctxt_inc = IHEVC_CAB_SPLIT_TFM + (5 - log2_tr_size);
|
|
/* split if actual tu size is smaller than target tu size */
|
split_tr_flag = tu_size < (1 << log2_tr_size);
|
u4_bits_estimated_prev = ps_cabac->u4_bits_estimated_q12;
|
ret |= ihevce_cabac_encode_bin(ps_cabac, split_tr_flag, ctxt_inc);
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{ // clang-format off
|
/*PIC INFO : populate cu split flag*/
|
ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_split_tu_flag +=
|
(ps_cabac->u4_bits_estimated_q12 - u4_bits_estimated_prev);
|
} // clang-format on
|
|
AEV_TRACE("split_transform_flag", split_tr_flag, ps_cabac->u4_range);
|
}
|
else
|
{
|
WORD32 inter_split;
|
/*********************************************************************/
|
/* */
|
/* split tr is implicitly derived as 1 if (see section 7.4.10) */
|
/* a. log2_tr_size > log2_max_trafo_size */
|
/* b. intra cu has NXN pu */
|
/* c. inter cu is not 2Nx2N && max_transform_hierarchy_depth_inter=0*/
|
/* */
|
/* split tu is implicitly derived as 0 otherwise */
|
/*********************************************************************/
|
inter_split = (!is_intra) && (max_tr_depth == 0) && (tr_depth == 0) &&
|
(ps_enc_cu->b3_part_mode != PART_2Nx2N);
|
|
if((log2_tr_size > log2_max_trafo_size) || (intra_nxn_pu && (tr_depth == 0)) ||
|
(inter_split))
|
{
|
split_tr_flag = 1;
|
}
|
else
|
{
|
split_tr_flag = 0;
|
}
|
}
|
/*accumulate only tu tree bits*/
|
ps_cabac->u4_true_tu_split_flag_q12 += ps_cabac->u4_bits_estimated_q12 - tu_split_bits;
|
|
/* Encode the cbf flags for chroma before the split as per sec 7.3.11 */
|
if(log2_tr_size > 2)
|
{
|
/* encode the cbf cb, context derived as per Table 9-37 */
|
ctxt_inc = IHEVC_CAB_CBCR_IDX + tr_depth;
|
|
/* Note chroma cbf is coded for depth=0 or if parent cbf was coded */
|
if((tr_depth == 0) || (ps_entropy_ctxt->apu1_cbf_cb[0][tr_depth - 1]) ||
|
(ps_entropy_ctxt->apu1_cbf_cb[1][tr_depth - 1]))
|
{
|
#if CABAC_BIT_EFFICIENT_CHROMA_PARENT_CBF
|
/*************************************************************/
|
/* Bit-Efficient chroma cbf signalling */
|
/* if children nodes have 0 cbf parent cbf can be coded as 0 */
|
/* peeking through all the child nodes for cb to check if */
|
/* parent can be coded as 0 */
|
/*************************************************************/
|
WORD32 tu_cnt = 0;
|
while(1)
|
{
|
WORD32 trans_size = 1 << (ps_enc_tu[tu_cnt].s_tu.b3_size + 2);
|
WORD32 tu_x = (ps_enc_tu[tu_cnt].s_tu.b4_pos_x << 2);
|
WORD32 tu_y = (ps_enc_tu[tu_cnt].s_tu.b4_pos_y << 2);
|
|
ASSERT(tu_cnt < ps_enc_cu->u2_num_tus_in_cu);
|
|
if((ps_enc_tu[tu_cnt].s_tu.b1_cb_cbf) || (ps_enc_tu[tu_cnt].s_tu.b1_cb_cbf_subtu1))
|
{
|
ai4_cbf_cb[0] = ps_enc_tu[tu_cnt].s_tu.b1_cb_cbf;
|
ai4_cbf_cb[1] = ps_enc_tu[tu_cnt].s_tu.b1_cb_cbf_subtu1;
|
break;
|
}
|
|
/* 8x8 parent has only one 4x4 valid chroma block for 420 */
|
if(3 == log2_tr_size)
|
break;
|
|
if((tu_x + trans_size == (x0_ctb + (1 << log2_tr_size))) &&
|
(tu_y + trans_size == (y0_ctb + (1 << log2_tr_size))))
|
{
|
ai4_cbf_cb[0] = ps_enc_tu[tu_cnt].s_tu.b1_cb_cbf;
|
ai4_cbf_cb[1] = ps_enc_tu[tu_cnt].s_tu.b1_cb_cbf_subtu1;
|
ASSERT(
|
(0 == ps_enc_tu[tu_cnt].s_tu.b1_cb_cbf) &&
|
(0 == ps_enc_tu[tu_cnt].s_tu.b1_cb_cbf_subtu1));
|
break;
|
}
|
|
tu_cnt++;
|
}
|
#else
|
/* read cbf only when split is 0 (child node) else force cbf=1 */
|
ai4_cbf_cb[0] = (split_tr_flag && (log2_tr_size > 3)) ? 1 : ps_enc_tu->s_tu.b1_cb_cbf;
|
ai4_cbf_cb[1] =
|
(split_tr_flag && (log2_tr_size > 3)) ? 1 : ps_enc_tu->s_tu.b1_cb_cbf_subtu1;
|
|
#endif
|
if((u1_is_422) && ((!split_tr_flag) || (3 == log2_tr_size)))
|
{
|
u4_bits_estimated_prev = ps_cabac->u4_bits_estimated_q12;
|
ret |= ihevce_cabac_encode_bin(ps_cabac, ai4_cbf_cb[0], ctxt_inc);
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{ // clang-format off
|
/*PIC INFO : Populate CBF cr bits*/
|
ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_cbf_chroma_bits +=
|
(ps_cabac->u4_bits_estimated_q12 -
|
u4_bits_estimated_prev);
|
} // clang-format on
|
|
AEV_TRACE("cbf_cb", ai4_cbf_cb[0], ps_cabac->u4_range);
|
|
u4_bits_estimated_prev = ps_cabac->u4_bits_estimated_q12;
|
ret |= ihevce_cabac_encode_bin(ps_cabac, ai4_cbf_cb[1], ctxt_inc);
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{ // clang-format off
|
/*PIC INFO : Populate CBF cr bits*/
|
ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_cbf_chroma_bits +=
|
(ps_cabac->u4_bits_estimated_q12 -
|
u4_bits_estimated_prev);
|
} // clang-format on
|
|
AEV_TRACE("cbf_cb", ai4_cbf_cb[1], ps_cabac->u4_range);
|
}
|
else
|
{
|
u4_bits_estimated_prev = ps_cabac->u4_bits_estimated_q12;
|
ret |= ihevce_cabac_encode_bin(ps_cabac, ai4_cbf_cb[0] || ai4_cbf_cb[1], ctxt_inc);
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{ // clang-format off
|
/*PIC INFO : Populate CBF cr bits*/
|
ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_cbf_chroma_bits +=
|
(ps_cabac->u4_bits_estimated_q12 -
|
u4_bits_estimated_prev);
|
} // clang-format on
|
|
AEV_TRACE("cbf_cb", ai4_cbf_cb[0] || ai4_cbf_cb[1], ps_cabac->u4_range);
|
}
|
}
|
else
|
{
|
ai4_cbf_cb[0] = ps_entropy_ctxt->apu1_cbf_cb[0][tr_depth - 1];
|
ai4_cbf_cb[1] = ps_entropy_ctxt->apu1_cbf_cb[1][tr_depth - 1];
|
}
|
|
if((tr_depth == 0) || (ps_entropy_ctxt->apu1_cbf_cr[0][tr_depth - 1]) ||
|
(ps_entropy_ctxt->apu1_cbf_cr[1][tr_depth - 1]))
|
{
|
#if CABAC_BIT_EFFICIENT_CHROMA_PARENT_CBF
|
/*************************************************************/
|
/* Bit-Efficient chroma cbf signalling */
|
/* if children nodes have 0 cbf parent cbf can be coded as 0 */
|
/* peeking through all the child nodes for cr to check if */
|
/* parent can be coded as 0 */
|
/*************************************************************/
|
WORD32 tu_cnt = 0;
|
while(1)
|
{
|
WORD32 trans_size = 1 << (ps_enc_tu[tu_cnt].s_tu.b3_size + 2);
|
WORD32 tu_x = (ps_enc_tu[tu_cnt].s_tu.b4_pos_x << 2);
|
WORD32 tu_y = (ps_enc_tu[tu_cnt].s_tu.b4_pos_y << 2);
|
|
ASSERT(tu_cnt < ps_enc_cu->u2_num_tus_in_cu);
|
|
if((ps_enc_tu[tu_cnt].s_tu.b1_cr_cbf) || (ps_enc_tu[tu_cnt].s_tu.b1_cr_cbf_subtu1))
|
{
|
ai4_cbf_cr[0] = ps_enc_tu[tu_cnt].s_tu.b1_cr_cbf;
|
ai4_cbf_cr[1] = ps_enc_tu[tu_cnt].s_tu.b1_cr_cbf_subtu1;
|
break;
|
}
|
|
/* 8x8 parent has only one 4x4 valid chroma block for 420 */
|
if(3 == log2_tr_size)
|
break;
|
|
if((tu_x + trans_size == (x0_ctb + (1 << log2_tr_size))) &&
|
(tu_y + trans_size == (y0_ctb + (1 << log2_tr_size))))
|
{
|
ai4_cbf_cr[0] = ps_enc_tu[tu_cnt].s_tu.b1_cr_cbf;
|
ai4_cbf_cr[1] = ps_enc_tu[tu_cnt].s_tu.b1_cr_cbf_subtu1;
|
ASSERT(
|
(0 == ps_enc_tu[tu_cnt].s_tu.b1_cr_cbf) &&
|
(0 == ps_enc_tu[tu_cnt].s_tu.b1_cr_cbf_subtu1));
|
break;
|
}
|
|
tu_cnt++;
|
}
|
#else
|
/* read cbf only when split is 0 (child node) else force cbf=1 */
|
ai4_cbf_cr[0] = (split_tr_flag && (log2_tr_size > 3)) ? 1 : ps_enc_tu->s_tu.b1_cr_cbf;
|
ai4_cbf_cr[1] =
|
(split_tr_flag && (log2_tr_size > 3)) ? 1 : ps_enc_tu->s_tu.b1_cr_cbf_subtu1;
|
#endif
|
|
if((u1_is_422) && ((!split_tr_flag) || (3 == log2_tr_size)))
|
{
|
u4_bits_estimated_prev = ps_cabac->u4_bits_estimated_q12;
|
ret |= ihevce_cabac_encode_bin(ps_cabac, ai4_cbf_cr[0], ctxt_inc);
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{ // clang-format off
|
/*PIC INFO : Populate CBF cr bits*/
|
ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_cbf_chroma_bits +=
|
(ps_cabac->u4_bits_estimated_q12 -
|
u4_bits_estimated_prev);
|
} // clang-format on
|
|
AEV_TRACE("cbf_cr", ai4_cbf_cr[0], ps_cabac->u4_range);
|
|
u4_bits_estimated_prev = ps_cabac->u4_bits_estimated_q12;
|
ret |= ihevce_cabac_encode_bin(ps_cabac, ai4_cbf_cr[1], ctxt_inc);
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{ // clang-format off
|
/*PIC INFO : Populate CBF cr bits*/
|
ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_cbf_chroma_bits +=
|
(ps_cabac->u4_bits_estimated_q12 -
|
u4_bits_estimated_prev);
|
} // clang-format on
|
|
AEV_TRACE("cbf_cr", ai4_cbf_cr[1], ps_cabac->u4_range);
|
}
|
else
|
{
|
u4_bits_estimated_prev = ps_cabac->u4_bits_estimated_q12;
|
ret |= ihevce_cabac_encode_bin(ps_cabac, ai4_cbf_cr[0] || ai4_cbf_cr[1], ctxt_inc);
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{ // clang-format off
|
/*PIC INFO : Populate CBF cr bits*/
|
ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_cbf_chroma_bits +=
|
(ps_cabac->u4_bits_estimated_q12 -
|
u4_bits_estimated_prev);
|
} // clang-format on
|
|
AEV_TRACE("cbf_cr", ai4_cbf_cr[0] || ai4_cbf_cr[1], ps_cabac->u4_range);
|
}
|
}
|
else
|
{
|
ai4_cbf_cr[0] = ps_entropy_ctxt->apu1_cbf_cr[0][tr_depth - 1];
|
ai4_cbf_cr[1] = ps_entropy_ctxt->apu1_cbf_cr[1][tr_depth - 1];
|
}
|
|
ps_entropy_ctxt->apu1_cbf_cb[0][tr_depth] = ai4_cbf_cb[0];
|
ps_entropy_ctxt->apu1_cbf_cr[0][tr_depth] = ai4_cbf_cr[0];
|
ps_entropy_ctxt->apu1_cbf_cb[1][tr_depth] = ai4_cbf_cb[1];
|
ps_entropy_ctxt->apu1_cbf_cr[1][tr_depth] = ai4_cbf_cr[1];
|
}
|
else
|
{
|
ai4_cbf_cb[0] = ps_entropy_ctxt->apu1_cbf_cb[0][tr_depth - 1];
|
ai4_cbf_cr[0] = ps_entropy_ctxt->apu1_cbf_cr[0][tr_depth - 1];
|
ai4_cbf_cb[1] = ps_entropy_ctxt->apu1_cbf_cb[1][tr_depth - 1];
|
ai4_cbf_cr[1] = ps_entropy_ctxt->apu1_cbf_cr[1][tr_depth - 1];
|
}
|
|
if(split_tr_flag)
|
{
|
/* recurse into quad child nodes till a leaf node is reached */
|
WORD32 x1_ctb = x0_ctb + ((1 << log2_tr_size) >> 1);
|
WORD32 y1_ctb = y0_ctb + ((1 << log2_tr_size) >> 1);
|
|
/* node0 of quad tree */
|
ret |= ihevce_encode_transform_tree(
|
ps_entropy_ctxt,
|
x0_ctb,
|
y0_ctb,
|
log2_tr_size - 1,
|
tr_depth + 1,
|
0, /* block 0 */
|
ps_enc_cu);
|
|
/* node1 of quad tree */
|
ret |= ihevce_encode_transform_tree(
|
ps_entropy_ctxt,
|
x1_ctb,
|
y0_ctb,
|
log2_tr_size - 1,
|
tr_depth + 1,
|
1, /* block 1 */
|
ps_enc_cu);
|
|
/* node2 of quad tree */
|
ret |= ihevce_encode_transform_tree(
|
ps_entropy_ctxt,
|
x0_ctb,
|
y1_ctb,
|
log2_tr_size - 1,
|
tr_depth + 1,
|
2, /* block 2 */
|
ps_enc_cu);
|
|
/* node3 of quad tree */
|
ret |= ihevce_encode_transform_tree(
|
ps_entropy_ctxt,
|
x1_ctb,
|
y1_ctb,
|
log2_tr_size - 1,
|
tr_depth + 1,
|
3, /* block 3 */
|
ps_enc_cu);
|
}
|
else
|
{
|
/* leaf node is reached! Encode the TU */
|
WORD32 encode_delta_qp;
|
void *pv_coeff;
|
void *pv_cu_coeff = ps_enc_cu->pv_coeff;
|
|
/* condition to encode qp of cu in first coded tu */
|
encode_delta_qp = ps_entropy_ctxt->i1_encode_qp_delta &&
|
(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS);
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{ // clang-format off
|
/*PIC INFO : Tota TUs based on size*/
|
if(32 == tu_size)
|
{
|
ps_entropy_ctxt->ps_pic_level_info->i8_total_tu_based_on_size[3]++;
|
}
|
else
|
{
|
ps_entropy_ctxt->ps_pic_level_info->i8_total_tu_based_on_size[tu_size >> 3]++;
|
}
|
} // clang-format on
|
|
/* sanity checks */
|
ASSERT(ps_entropy_ctxt->i1_ctb_num_pcm_blks == 0);
|
ASSERT((ps_enc_tu->s_tu.b4_pos_x << 2) == x0_ctb);
|
ASSERT((ps_enc_tu->s_tu.b4_pos_y << 2) == y0_ctb);
|
ASSERT(tu_size == (1 << log2_tr_size));
|
|
/********************************************************************/
|
/* encode luma cbf if any of following conditions are true */
|
/* intra cu | transform depth > 0 | any of chroma cbfs are coded */
|
/* */
|
/* Note that these conditions mean that cbf_luma need not be */
|
/* signalled and implicitly derived as 1 for inter cu whose tfr size*/
|
/* is same as cu size and cbf for cb+cr are zero as no_residue_flag */
|
/* at cu level = 1 indicated cbf luma is coded */
|
/********************************************************************/
|
if(is_intra || (tr_depth != 0) || ai4_cbf_cb[0] || ai4_cbf_cr[0] ||
|
((u1_is_422) && (ai4_cbf_cb[1] || ai4_cbf_cr[1])))
|
{
|
/* encode cbf luma, context derived as per Table 9-37 */
|
cbf_luma = ps_enc_tu->s_tu.b1_y_cbf;
|
|
ctxt_inc = IHEVC_CAB_CBF_LUMA_IDX;
|
ctxt_inc += (tr_depth == 0) ? 1 : 0;
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{
|
if(1 == cbf_luma)
|
{
|
// clang-format off
|
/*PIC INFO: Populated coded Intra/Inter TUs in CU*/
|
if(1 == is_intra)
|
ps_entropy_ctxt->ps_pic_level_info->i8_total_intra_coded_tu++;
|
else
|
ps_entropy_ctxt->ps_pic_level_info->i8_total_inter_coded_tu++;
|
// clang-format on
|
}
|
else
|
{ /*PIC INFO: Populated coded non-coded TUs in CU*/
|
ps_entropy_ctxt->ps_pic_level_info->i8_total_non_coded_tu++;
|
}
|
}
|
u4_bits_estimated_prev = ps_cabac->u4_bits_estimated_q12;
|
ret |= ihevce_cabac_encode_bin(ps_cabac, cbf_luma, ctxt_inc);
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{ // clang-format off
|
/*PIC INFO : Populate CBF luma bits*/
|
ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_cbf_luma_bits +=
|
(ps_cabac->u4_bits_estimated_q12 - u4_bits_estimated_prev);
|
} // clang-format on
|
AEV_TRACE("cbf_luma", cbf_luma, ps_cabac->u4_range);
|
}
|
else
|
{
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{
|
/*PIC INFO: Populated coded Inter TUs in CU*/
|
ps_entropy_ctxt->ps_pic_level_info->i8_total_inter_coded_tu++;
|
}
|
|
/* shall be 1 as no_residue_flag was encoded as 1 in inter cu */
|
ASSERT(1 == ps_enc_tu->s_tu.b1_y_cbf);
|
cbf_luma = ps_enc_tu->s_tu.b1_y_cbf;
|
}
|
|
/*******************************************************************/
|
/* code qp delta conditionally if following conditions are true */
|
/* any cbf coded (luma/cb/cr) and qp_delta_coded is 0 for this cu */
|
/* see section 7.3.12 Transform unit Syntax */
|
/*******************************************************************/
|
{
|
WORD32 cbf_chroma = (ai4_cbf_cb[0] || ai4_cbf_cr[0]) ||
|
(u1_is_422 && (ai4_cbf_cb[1] || ai4_cbf_cr[1]));
|
|
if((cbf_luma || cbf_chroma) && encode_delta_qp)
|
{
|
WORD32 tu_qp = ps_enc_tu->s_tu.b7_qp;
|
WORD32 qp_pred, qp_left, qp_top;
|
WORD32 qp_delta = tu_qp - ps_entropy_ctxt->i1_cur_qp;
|
WORD32 x_nbr_indx, y_nbr_indx;
|
|
/* Added code for handling the QP neighbour population depending
|
on the diff_cu_qp_delta_depth: Lokesh */
|
/* minus 2 becoz the pos_x and pos_y are given in the order of
|
* 8x8 blocks rather than pixels */
|
WORD32 log2_min_cu_qp_delta_size =
|
ps_entropy_ctxt->i1_log2_ctb_size -
|
ps_entropy_ctxt->ps_pps->i1_diff_cu_qp_delta_depth;
|
//WORD32 min_cu_qp_delta_size = 1 << log2_min_cu_qp_delta_size;
|
|
//WORD32 curr_pos_x = ps_enc_cu->b3_cu_pos_x << 3;
|
//WORD32 curr_pos_y = ps_enc_cu->b3_cu_pos_y << 3;
|
|
WORD32 block_addr_align = 15 << (log2_min_cu_qp_delta_size - 3);
|
|
ps_entropy_ctxt->i4_qg_pos_x = ps_enc_cu->b3_cu_pos_x & block_addr_align;
|
ps_entropy_ctxt->i4_qg_pos_y = ps_enc_cu->b3_cu_pos_y & block_addr_align;
|
|
x_nbr_indx = ps_entropy_ctxt->i4_qg_pos_x - 1;
|
y_nbr_indx = ps_entropy_ctxt->i4_qg_pos_y - 1;
|
|
if(ps_entropy_ctxt->i4_qg_pos_x > 0)
|
{
|
// clang-format off
|
qp_left =
|
ps_entropy_ctxt->ai4_8x8_cu_qp[x_nbr_indx +
|
(ps_entropy_ctxt->i4_qg_pos_y * 8)];
|
// clang-format on
|
}
|
if(ps_entropy_ctxt->i4_qg_pos_y > 0)
|
{
|
// clang-format off
|
qp_top = ps_entropy_ctxt->ai4_8x8_cu_qp[ps_entropy_ctxt->i4_qg_pos_x +
|
y_nbr_indx * 8];
|
// clang-format on
|
}
|
if(ps_entropy_ctxt->i4_qg_pos_x == 0)
|
{
|
/*previous coded Qp*/
|
qp_left = ps_entropy_ctxt->i1_cur_qp;
|
}
|
if(ps_entropy_ctxt->i4_qg_pos_y == 0)
|
{
|
/*previous coded Qp*/
|
qp_top = ps_entropy_ctxt->i1_cur_qp;
|
}
|
|
qp_pred = (qp_left + qp_top + 1) >> 1;
|
// clang-format off
|
/* start of every frame encode qp delta wrt slice qp when entrop
|
* sync is enabled */
|
if(ps_entropy_ctxt->i4_ctb_x == 0 &&
|
ps_entropy_ctxt->i4_qg_pos_x == 0 &&
|
ps_entropy_ctxt->i4_qg_pos_y == 0 &&
|
ps_entropy_ctxt->s_cabac_ctxt.i1_entropy_coding_sync_enabled_flag)
|
// clang-format on
|
{
|
qp_pred = ps_entropy_ctxt->ps_slice_hdr->i1_slice_qp_delta +
|
ps_entropy_ctxt->ps_pps->i1_pic_init_qp;
|
}
|
qp_delta = tu_qp - qp_pred;
|
|
/*PIC INFO : Populate QP delta bits*/
|
u4_bits_estimated_prev = ps_cabac->u4_bits_estimated_q12;
|
|
/* code the qp delta */
|
ret |= ihevce_cabac_encode_qp_delta(ps_cabac, qp_delta);
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{
|
// clang-format off
|
ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_qp_delta_bits +=
|
(ps_cabac->u4_bits_estimated_q12 -
|
u4_bits_estimated_prev);
|
// clang-format on
|
}
|
|
ps_entropy_ctxt->i1_cur_qp = tu_qp;
|
//ps_entropy_ctxt->i1_cur_qp = Qp_pred;
|
ps_entropy_ctxt->i1_encode_qp_delta = 0;
|
//ps_entropy_ctxt->i4_is_cu_cbf_zero = 0;
|
}
|
|
if(cbf_luma || cbf_chroma)
|
{
|
ps_entropy_ctxt->i4_is_cu_cbf_zero = 0;
|
}
|
|
/* code the residue of for luma and chroma tu based on cbf */
|
if((cbf_luma) && (1 == ps_entropy_ctxt->i4_enable_res_encode))
|
{
|
u4_bits_estimated_prev = ps_entropy_ctxt->s_cabac_ctxt.u4_bits_estimated_q12;
|
/* code the luma residue */
|
pv_coeff = (void *)((UWORD8 *)pv_cu_coeff + ps_enc_tu->i4_luma_coeff_offset);
|
|
ret |= ihevce_cabac_residue_encode(ps_entropy_ctxt, pv_coeff, log2_tr_size, 1);
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{ // clang-format off
|
/*PIC INFO : Populate Residue Luma Bits*/
|
ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_res_luma_bits +=
|
(ps_entropy_ctxt->s_cabac_ctxt.u4_bits_estimated_q12 -
|
u4_bits_estimated_prev);
|
} // clang-format on
|
}
|
|
/* code chroma residue based on tranform size */
|
/* For Inta 4x4 pu chroma is coded after all 4 luma blks coded */
|
/* Note: chroma not encoded in rdopt mode */
|
if(((log2_tr_size > 2) || (3 == blk_num)) /* &&
|
(CABAC_MODE_ENCODE_BITS == ps_cabac->e_cabac_op_mode) */
|
)
|
{
|
WORD32 log2_chroma_tr_size;
|
WORD32 i4_subtu_idx;
|
void *pv_coeff_cb, *pv_coeff_cr;
|
|
WORD32 i4_num_subtus = u1_is_422 + 1;
|
|
if(1 == ps_entropy_ctxt->i4_enable_res_encode)
|
{
|
for(i4_subtu_idx = 0; i4_subtu_idx < i4_num_subtus; i4_subtu_idx++)
|
{
|
if(ai4_cbf_cb[i4_subtu_idx])
|
{
|
/* initailize chroma transform size and coeff based
|
* on luma size */
|
if(2 == log2_tr_size)
|
{
|
/*********************************************************/
|
/* For Intra 4x4, chroma transform size is 4 and chroma */
|
/* coeff offset is present in the first Luma block */
|
/*********************************************************/
|
log2_chroma_tr_size = 2;
|
|
/* -3 is for going to first luma tu of the 4 TUs in min CU */
|
pv_coeff_cb =
|
(void
|
*)((UWORD8 *)pv_cu_coeff + ps_enc_tu[-3].ai4_cb_coeff_offset[i4_subtu_idx]);
|
}
|
else
|
{
|
log2_chroma_tr_size = (log2_tr_size - 1);
|
|
pv_coeff_cb =
|
(void
|
*)((UWORD8 *)pv_cu_coeff + ps_enc_tu->ai4_cb_coeff_offset[i4_subtu_idx]);
|
}
|
// clang-format off
|
u4_bits_estimated_prev =
|
ps_entropy_ctxt->s_cabac_ctxt.u4_bits_estimated_q12;
|
// clang-format on
|
/* code the cb residue */
|
ret |= ihevce_cabac_residue_encode(
|
ps_entropy_ctxt, pv_coeff_cb, log2_chroma_tr_size, 0);
|
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{ // clang-format off
|
/*PIC INFO : Populate Residue Chroma cr Bits*/
|
ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_res_chroma_bits +=
|
(ps_entropy_ctxt->s_cabac_ctxt.u4_bits_estimated_q12 -
|
u4_bits_estimated_prev);
|
} // clang-format on
|
}
|
}
|
}
|
|
if(1 == ps_entropy_ctxt->i4_enable_res_encode)
|
{
|
for(i4_subtu_idx = 0; i4_subtu_idx < i4_num_subtus; i4_subtu_idx++)
|
{
|
if(ai4_cbf_cr[i4_subtu_idx])
|
{
|
/* initailize chroma transform size and coeff based on luma size */
|
if(2 == log2_tr_size)
|
{
|
/*********************************************************/
|
/* For Intra 4x4, chroma transform size is 4 and chroma */
|
/* coeff offset is present in the first Luma block */
|
/*********************************************************/
|
log2_chroma_tr_size = 2;
|
|
pv_coeff_cr =
|
(void
|
*)((UWORD8 *)pv_cu_coeff + ps_enc_tu[-3].ai4_cr_coeff_offset[i4_subtu_idx]);
|
}
|
else
|
{
|
log2_chroma_tr_size = (log2_tr_size - 1);
|
|
pv_coeff_cr =
|
(void
|
*)((UWORD8 *)pv_cu_coeff + ps_enc_tu->ai4_cr_coeff_offset[i4_subtu_idx]);
|
}
|
// clang-format off
|
u4_bits_estimated_prev =
|
ps_entropy_ctxt->s_cabac_ctxt.u4_bits_estimated_q12;
|
// clang-format on
|
/* code the cb residue */
|
ret |= ihevce_cabac_residue_encode(
|
ps_entropy_ctxt, pv_coeff_cr, log2_chroma_tr_size, 0);
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_ENCODE_BITS)
|
{ // clang-format off
|
/*PIC INFO : Populate Residue Chroma cr Bits*/
|
ps_entropy_ctxt->ps_pic_level_info->u8_bits_estimated_res_chroma_bits +=
|
(ps_entropy_ctxt->s_cabac_ctxt.u4_bits_estimated_q12 -
|
u4_bits_estimated_prev);
|
} // clang-format on
|
}
|
}
|
}
|
}
|
}
|
|
/* update tu_idx after encoding current tu */
|
ps_entropy_ctxt->i4_tu_idx++;
|
}
|
|
return ret;
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Encodes a transform residual block as per section 7.3.13
|
*
|
* @par Description
|
* The residual block is read from a compressed coeff buffer populated during
|
* the scanning of the quantized coeffs. The contents of the buffer are
|
* breifly explained in param description of pv_coeff
|
*
|
* @remarks Does not support sign data hiding and transform skip flag currently
|
*
|
* @remarks Need to resolve the differences between JVT-J1003_d7 spec and
|
* HM.8.0-dev for related abs_greater_than_1 context initialization
|
* and rice_max paramtere used for coeff abs level remaining
|
*
|
* @param[inout] ps_entropy_ctxt
|
* pointer to entropy context (handle)
|
*
|
* @param[in] pv_coeff
|
* Compressed residue buffer containing following information:
|
*
|
* HEADER(4 bytes) : last_coeff_x, last_coeff_y, scantype, last_subblock_num
|
*
|
* For each 4x4 subblock starting from last_subblock_num (in scan order)
|
* Read 2 bytes : MSB 12bits (0xBAD marker), bit0 cur_csbf, bit1-2 nbr csbf
|
*
|
* `If cur_csbf
|
* Read 2 bytes : sig_coeff_map (16bits in scan_order 1:coded, 0:not coded)
|
* Read 2 bytes : abs_gt1_flags (max of 8 only)
|
* Read 2 bytes : coeff_sign_flags
|
*
|
* Based on abs_gt1_flags and sig_coeff_map read remaining abs levels
|
* Read 2 bytes : remaining_abs_coeffs_minus1 (this is in a loop)
|
*
|
* @param[in] log2_tr_size
|
* transform size of the current TU
|
*
|
* @param[in] is_luma
|
* boolean indicating if the texture type is luma / chroma
|
*
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_residue_encode(
|
entropy_context_t *ps_entropy_ctxt, void *pv_coeff, WORD32 log2_tr_size, WORD32 is_luma)
|
{
|
WORD32 ret = IHEVCE_SUCCESS;
|
cab_ctxt_t *ps_cabac = &ps_entropy_ctxt->s_cabac_ctxt;
|
WORD32 i4_sign_data_hiding_flag, cu_tq_bypass_flag;
|
|
UWORD8 *pu1_coeff_buf_hdr = (UWORD8 *)pv_coeff;
|
UWORD16 *pu2_sig_coeff_buf = (UWORD16 *)pv_coeff;
|
|
/* last sig coeff indices in scan order */
|
WORD32 last_sig_coeff_x = pu1_coeff_buf_hdr[0];
|
WORD32 last_sig_coeff_y = pu1_coeff_buf_hdr[1];
|
|
/* read the scan type : upright diag / horz / vert */
|
WORD32 scan_type = pu1_coeff_buf_hdr[2];
|
|
/************************************************************************/
|
/* position of the last coded sub block. This sub block contains coeff */
|
/* corresponding to last_sig_coeff_x, last_sig_coeff_y. Althoug this can*/
|
/* be derived here it better to be populated by scanning module */
|
/************************************************************************/
|
WORD32 last_csb = pu1_coeff_buf_hdr[3];
|
|
WORD32 cur_csbf = 0, nbr_csbf;
|
WORD32 sig_coeff_base_ctxt; /* cabac context for sig coeff flag */
|
WORD32 abs_gt1_base_ctxt; /* cabac context for abslevel > 1 flag */
|
|
WORD32 gt1_ctxt = 1; /* required for abs_gt1_ctxt modelling */
|
|
WORD32 i;
|
|
/* sanity checks */
|
/* transform skip not supported */
|
ASSERT(0 == ps_entropy_ctxt->ps_pps->i1_transform_skip_enabled_flag);
|
|
cu_tq_bypass_flag = ps_entropy_ctxt->ps_pps->i1_transform_skip_enabled_flag;
|
|
i4_sign_data_hiding_flag = ps_entropy_ctxt->ps_pps->i1_sign_data_hiding_flag;
|
|
if(SCAN_VERT == scan_type)
|
{
|
/* last coeff x and y are swapped for vertical scan */
|
SWAP(last_sig_coeff_x, last_sig_coeff_y);
|
}
|
|
/* Encode the last_sig_coeff_x and last_sig_coeff_y */
|
ret |= ihevce_cabac_encode_last_coeff_x_y(
|
ps_cabac, last_sig_coeff_x, last_sig_coeff_y, log2_tr_size, is_luma);
|
|
/*************************************************************************/
|
/* derive base context index for sig coeff as per section 9.3.3.1.4 */
|
/* TODO; convert to look up based on luma/chroma, scan type and tfr size */
|
/*************************************************************************/
|
if(is_luma)
|
{
|
sig_coeff_base_ctxt = IHEVC_CAB_COEFF_FLAG;
|
abs_gt1_base_ctxt = IHEVC_CAB_COEFABS_GRTR1_FLAG;
|
|
if(3 == log2_tr_size)
|
{
|
/* 8x8 transform size */
|
sig_coeff_base_ctxt += (scan_type == SCAN_DIAG_UPRIGHT) ? 9 : 15;
|
}
|
else if(3 < log2_tr_size)
|
{
|
/* larger transform sizes */
|
sig_coeff_base_ctxt += 21;
|
}
|
}
|
else
|
{
|
/* chroma context initializations */
|
sig_coeff_base_ctxt = IHEVC_CAB_COEFF_FLAG + 27;
|
abs_gt1_base_ctxt = IHEVC_CAB_COEFABS_GRTR1_FLAG + 16;
|
|
if(3 == log2_tr_size)
|
{
|
/* 8x8 transform size */
|
sig_coeff_base_ctxt += 9;
|
}
|
else if(3 < log2_tr_size)
|
{
|
/* larger transform sizes */
|
sig_coeff_base_ctxt += 12;
|
}
|
}
|
|
/* go to csbf flags */
|
pu2_sig_coeff_buf = (UWORD16 *)(pu1_coeff_buf_hdr + COEFF_BUF_HEADER_LEN);
|
|
/************************************************************************/
|
/* encode the csbf, sig_coeff_map, abs_grt1_flags, abs_grt2_flag, sign */
|
/* and abs_coeff_remaining for each 4x4 starting from last scan to first*/
|
/************************************************************************/
|
for(i = last_csb; i >= 0; i--)
|
{
|
UWORD16 u2_marker_csbf;
|
WORD32 ctxt_idx;
|
|
u2_marker_csbf = *pu2_sig_coeff_buf;
|
pu2_sig_coeff_buf++;
|
|
/* sanity checks for marker present in every csbf flag */
|
ASSERT((u2_marker_csbf >> 4) == 0xBAD);
|
|
/* extract the current and neigbour csbf flags */
|
cur_csbf = u2_marker_csbf & 0x1;
|
nbr_csbf = (u2_marker_csbf >> 1) & 0x3;
|
|
/*********************************************************************/
|
/* code the csbf flags; last and first csb not sent as it is derived */
|
/*********************************************************************/
|
if((i < last_csb) && (i > 0))
|
{
|
ctxt_idx = IHEVC_CAB_CODED_SUBLK_IDX;
|
|
/* ctxt based on right / bottom avail csbf, section 9.3.3.1.3 */
|
ctxt_idx += nbr_csbf ? 1 : 0;
|
ctxt_idx += is_luma ? 0 : 2;
|
|
ret |= ihevce_cabac_encode_bin(ps_cabac, cur_csbf, ctxt_idx);
|
AEV_TRACE("coded_sub_block_flag", cur_csbf, ps_cabac->u4_range);
|
}
|
else
|
{
|
/* sanity check, this csb contains the last_sig_coeff */
|
if(i == last_csb)
|
{
|
ASSERT(cur_csbf == 1);
|
}
|
}
|
|
if(cur_csbf)
|
{
|
/*****************************************************************/
|
/* encode the sig coeff map as per section 7.3.13 */
|
/* significant_coeff_flags: msb=coeff15-lsb=coeff0 in scan order */
|
/*****************************************************************/
|
|
/* Added for Sign bit data hiding*/
|
WORD32 first_scan_pos = 16;
|
WORD32 last_scan_pos = -1;
|
WORD32 sign_hidden = 0;
|
|
UWORD16 u2_gt0_flags = *pu2_sig_coeff_buf;
|
WORD32 gt1_flags = *(pu2_sig_coeff_buf + 1);
|
WORD32 sign_flags = *(pu2_sig_coeff_buf + 2);
|
|
WORD32 sig_coeff_map = u2_gt0_flags;
|
|
WORD32 gt1_bins = 0; /* bins for coeffs with abslevel > 1 */
|
|
WORD32 sign_bins = 0; /* bins for sign flags of coded coeffs */
|
WORD32 num_coded = 0; /* total coeffs coded in 4x4 */
|
|
WORD32 infer_coeff; /* infer when 0,0 is the only coded coeff */
|
WORD32 bit; /* temp boolean */
|
|
/* total count of coeffs to be coded as abs level remaining */
|
WORD32 num_coeffs_remaining = 0;
|
|
/* count of coeffs to be coded as abslevel-1 */
|
WORD32 num_coeffs_base1 = 0;
|
WORD32 scan_pos;
|
WORD32 first_gt1_coeff = 0;
|
|
if((i != 0) || (0 == last_csb))
|
{
|
/* sanity check, atleast one coeff is coded as csbf is set */
|
ASSERT(sig_coeff_map != 0);
|
}
|
|
pu2_sig_coeff_buf += 3;
|
|
scan_pos = 15;
|
if(i == last_csb)
|
{
|
/*************************************************************/
|
/* clear last_scan_pos for last block in scan order as this */
|
/* is communicated throught last_coeff_x and last_coeff_y */
|
/*************************************************************/
|
WORD32 next_sig = CLZ(sig_coeff_map) + 1;
|
|
scan_pos = WORD_SIZE - next_sig;
|
|
/* prepare the bins for gt1 flags */
|
EXTRACT_BIT(bit, gt1_flags, scan_pos);
|
|
/* insert gt1 bin in lsb */
|
gt1_bins |= bit;
|
|
/* prepare the bins for sign flags */
|
EXTRACT_BIT(bit, sign_flags, scan_pos);
|
|
/* insert sign bin in lsb */
|
sign_bins |= bit;
|
|
sig_coeff_map = CLEAR_BIT(sig_coeff_map, scan_pos);
|
|
if(-1 == last_scan_pos)
|
last_scan_pos = scan_pos;
|
|
scan_pos--;
|
num_coded++;
|
}
|
|
/* infer 0,0 coeff for all 4x4 blocks except fitst and last */
|
infer_coeff = (i < last_csb) && (i > 0);
|
|
/* encode the required sigcoeff flags (abslevel > 0) */
|
while(scan_pos >= 0)
|
{
|
WORD32 y_pos_x_pos;
|
WORD32 sig_ctxinc = 0; /* 0 is default inc for DC coeff */
|
|
WORD32 sig_coeff;
|
|
EXTRACT_BIT(sig_coeff, sig_coeff_map, scan_pos);
|
|
/* derive the x,y pos */
|
y_pos_x_pos = gu1_hevce_scan4x4[scan_type][scan_pos];
|
|
/* derive the context inc as per section 9.3.3.1.4 */
|
if(2 == log2_tr_size)
|
{
|
/* 4x4 transform size increment uses lookup */
|
sig_ctxinc = gu1_hevce_sigcoeff_ctxtinc_tr4[y_pos_x_pos];
|
}
|
else if(scan_pos || i)
|
{
|
/* ctxt for AC coeff depends on curpos and neigbour csbf */
|
sig_ctxinc = gu1_hevce_sigcoeff_ctxtinc[nbr_csbf][y_pos_x_pos];
|
|
/* based on luma subblock pos */
|
sig_ctxinc += (i && is_luma) ? 3 : 0;
|
}
|
else
|
{
|
/* DC coeff has fixed context for luma and chroma */
|
sig_coeff_base_ctxt = is_luma ? IHEVC_CAB_COEFF_FLAG
|
: IHEVC_CAB_COEFF_FLAG + 27;
|
}
|
|
/*************************************************************/
|
/* encode sig coeff only if required */
|
/* decoder infers 0,0 coeff when all the other coeffs are 0 */
|
/*************************************************************/
|
if(scan_pos || (!infer_coeff))
|
{
|
ctxt_idx = sig_ctxinc + sig_coeff_base_ctxt;
|
ret |= ihevce_cabac_encode_bin(ps_cabac, sig_coeff, ctxt_idx);
|
AEV_TRACE("significant_coeff_flag", sig_coeff, ps_cabac->u4_range);
|
}
|
|
if(sig_coeff)
|
{
|
/* prepare the bins for gt1 flags */
|
EXTRACT_BIT(bit, gt1_flags, scan_pos);
|
|
/* shift and insert gt1 bin in lsb */
|
gt1_bins <<= 1;
|
gt1_bins |= bit;
|
|
/* prepare the bins for sign flags */
|
EXTRACT_BIT(bit, sign_flags, scan_pos);
|
|
/* shift and insert sign bin in lsb */
|
sign_bins <<= 1;
|
sign_bins |= bit;
|
|
num_coded++;
|
|
/* 0,0 coeff can no more be inferred :( */
|
infer_coeff = 0;
|
|
if(-1 == last_scan_pos)
|
last_scan_pos = scan_pos;
|
|
first_scan_pos = scan_pos;
|
}
|
|
scan_pos--;
|
}
|
|
/* Added for sign bit hiding*/
|
sign_hidden = ((last_scan_pos - first_scan_pos) > 3 && !cu_tq_bypass_flag);
|
|
/****************************************************************/
|
/* encode the abs level greater than 1 bins; Section 7.3.13 */
|
/* These have already been prepared during sig_coeff_map encode */
|
/* Context modelling done as per section 9.3.3.1.5 */
|
/****************************************************************/
|
{
|
WORD32 j;
|
|
/* context set based on luma subblock pos */
|
WORD32 ctxt_set = (i && is_luma) ? 2 : 0;
|
|
/* count of coeffs with abslevel > 1; max of 8 to be coded */
|
WORD32 num_gt1_bins = MIN(8, num_coded);
|
|
if(num_coded > 8)
|
{
|
/* pull back the bins to required number */
|
gt1_bins >>= (num_coded - 8);
|
|
num_coeffs_remaining += (num_coded - 8);
|
num_coeffs_base1 = (num_coded - 8);
|
}
|
|
/* See section 9.3.3.1.5 */
|
ctxt_set += (0 == gt1_ctxt) ? 1 : 0;
|
|
gt1_ctxt = 1;
|
|
for(j = num_gt1_bins - 1; j >= 0; j--)
|
{
|
/* Encodet the abs level gt1 bins */
|
ctxt_idx = (ctxt_set * 4) + abs_gt1_base_ctxt + gt1_ctxt;
|
|
EXTRACT_BIT(bit, gt1_bins, j);
|
|
ret |= ihevce_cabac_encode_bin(ps_cabac, bit, ctxt_idx);
|
|
AEV_TRACE("coeff_abs_level_greater1_flag", bit, ps_cabac->u4_range);
|
|
if(bit)
|
{
|
gt1_ctxt = 0;
|
num_coeffs_remaining++;
|
}
|
else if(gt1_ctxt && (gt1_ctxt < 3))
|
{
|
gt1_ctxt++;
|
}
|
}
|
|
/*************************************************************/
|
/* encode abs level greater than 2 bin; Section 7.3.13 */
|
/*************************************************************/
|
if(gt1_bins)
|
{
|
WORD32 gt2_bin;
|
|
first_gt1_coeff = pu2_sig_coeff_buf[0] + 1;
|
gt2_bin = (first_gt1_coeff > 2);
|
|
/* atleast one level > 2 */
|
ctxt_idx = IHEVC_CAB_COEFABS_GRTR2_FLAG;
|
|
ctxt_idx += (is_luma) ? ctxt_set : (ctxt_set + 4);
|
|
ret |= ihevce_cabac_encode_bin(ps_cabac, gt2_bin, ctxt_idx);
|
|
if(!gt2_bin)
|
{
|
/* sanity check */
|
ASSERT(first_gt1_coeff == 2);
|
|
/* no need to send this coeff as bypass bins */
|
pu2_sig_coeff_buf++;
|
num_coeffs_remaining--;
|
}
|
|
AEV_TRACE("coeff_abs_level_greater2_flag", gt2_bin, ps_cabac->u4_range);
|
}
|
}
|
|
/*************************************************************/
|
/* encode the coeff signs and abs remaing levels */
|
/*************************************************************/
|
if(num_coded)
|
{
|
WORD32 base_level;
|
WORD32 rice_param = 0;
|
WORD32 j;
|
|
/*************************************************************/
|
/* encode the coeff signs populated in sign_bins */
|
/*************************************************************/
|
|
if(sign_hidden && i4_sign_data_hiding_flag)
|
{
|
sign_bins >>= 1;
|
num_coded--;
|
}
|
|
if(num_coded > 0)
|
{
|
ret |= ihevce_cabac_encode_bypass_bins(ps_cabac, sign_bins, num_coded);
|
}
|
|
AEV_TRACE("sign_flags", sign_bins, ps_cabac->u4_range);
|
|
/*************************************************************/
|
/* encode the coeff_abs_level_remaining as TR / EGK bins */
|
/* See section 9.3.2.7 for details */
|
/*************************************************************/
|
|
/* first remaining coeff baselevel */
|
if(first_gt1_coeff > 2)
|
{
|
base_level = 3;
|
}
|
else if(num_coeffs_remaining > num_coeffs_base1)
|
{
|
/* atleast one coeff in first 8 is gt > 1 */
|
base_level = 2;
|
}
|
else
|
{
|
/* all coeffs have base of 1 */
|
base_level = 1;
|
}
|
|
for(j = 0; j < num_coeffs_remaining; j++)
|
{
|
WORD32 abs_coeff = pu2_sig_coeff_buf[0] + 1;
|
WORD32 abs_coeff_rem;
|
WORD32 rice_max = (4 << rice_param);
|
|
pu2_sig_coeff_buf++;
|
|
/* sanity check */
|
ASSERT(abs_coeff >= base_level);
|
|
abs_coeff_rem = (abs_coeff - base_level);
|
|
/* TODO://HM-8.0-dev uses (3 << rice_param) as rice_max */
|
/* TODO://HM-8.0-dev does either TR or EGK but not both */
|
if(abs_coeff_rem >= rice_max)
|
{
|
UWORD32 u4_suffix = (abs_coeff_rem - rice_max);
|
|
/* coeff exceeds max rice limit */
|
/* encode the TR prefix as tunary code */
|
/* prefix = 1111 as (rice_max >> rice_praram) = 4 */
|
ret |= ihevce_cabac_encode_bypass_bins(ps_cabac, 0xF, 4);
|
|
/* encode the exponential golomb code suffix */
|
ret |= ihevce_cabac_encode_egk(ps_cabac, u4_suffix, (rice_param + 1));
|
}
|
else
|
{
|
/* code coeff as truncated rice code */
|
ret |= ihevce_cabac_encode_trunc_rice(
|
ps_cabac, abs_coeff_rem, rice_param, rice_max);
|
}
|
|
AEV_TRACE("coeff_abs_level_remaining", abs_coeff_rem, ps_cabac->u4_range);
|
|
/* update the rice param based on coeff level */
|
if((abs_coeff > (3 << rice_param)) && (rice_param < 4))
|
{
|
rice_param++;
|
}
|
|
/* change base level to 1 if more than 8 coded coeffs */
|
if((j + 1) < (num_coeffs_remaining - num_coeffs_base1))
|
{
|
base_level = 2;
|
}
|
else
|
{
|
base_level = 1;
|
}
|
}
|
}
|
}
|
}
|
/*tap texture bits*/
|
if(ps_cabac->e_cabac_op_mode == CABAC_MODE_COMPUTE_BITS)
|
{ // clang-format off
|
ps_cabac->u4_texture_bits_estimated_q12 +=
|
(ps_cabac->u4_bits_estimated_q12 -
|
ps_cabac->u4_header_bits_estimated_q12); //(ps_cabac->u4_bits_estimated_q12 - temp_tex_bits_q12);
|
} // clang-format on
|
|
return (ret);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Get the bits estimate for a transform residual block as per section
|
* 7.3.13
|
*
|
* @par Description
|
* The residual block is read from a compressed coeff buffer populated during
|
* the scanning of the quantized coeffs. The contents of the buffer are
|
* breifly explained in param description of pv_coeff
|
*
|
* @remarks Does not support sign data hiding and transform skip flag currently
|
*
|
* @remarks Need to resolve the differences between JVT-J1003_d7 spec and
|
* HM.8.0-dev for related abs_greater_than_1 context initialization
|
* and rice_max paramtere used for coeff abs level remaining
|
*
|
* @param[inout] ps_entropy_ctxt
|
* pointer to entropy context (handle)
|
*
|
* @param[in] pv_coeff
|
* Compressed residue buffer containing following information:
|
*
|
* HEADER(4 bytes) : last_coeff_x, last_coeff_y, scantype, last_subblock_num
|
*
|
* For each 4x4 subblock starting from last_subblock_num (in scan order)
|
* Read 2 bytes : MSB 12bits (0xBAD marker), bit0 cur_csbf, bit1-2 nbr csbf
|
*
|
* `If cur_csbf
|
* Read 2 bytes : sig_coeff_map (16bits in scan_order 1:coded, 0:not coded)
|
* Read 2 bytes : abs_gt1_flags (max of 8 only)
|
* Read 2 bytes : coeff_sign_flags
|
*
|
* Based on abs_gt1_flags and sig_coeff_map read remaining abs levels
|
* Read 2 bytes : remaining_abs_coeffs_minus1 (this is in a loop)
|
*
|
* @param[in] log2_tr_size
|
* transform size of the current TU
|
*
|
* @param[in] is_luma
|
* boolean indicating if the texture type is luma / chroma
|
*
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_cabac_residue_encode_rdopt(
|
entropy_context_t *ps_entropy_ctxt,
|
void *pv_coeff,
|
WORD32 log2_tr_size,
|
WORD32 is_luma,
|
WORD32 perform_sbh)
|
{
|
WORD32 ret = IHEVCE_SUCCESS;
|
cab_ctxt_t *ps_cabac = &ps_entropy_ctxt->s_cabac_ctxt;
|
UWORD32 temp_tex_bits_q12;
|
WORD32 i4_sign_data_hiding_flag, cu_tq_bypass_flag;
|
|
UWORD8 *pu1_coeff_buf_hdr = (UWORD8 *)pv_coeff;
|
UWORD16 *pu2_sig_coeff_buf = (UWORD16 *)pv_coeff;
|
|
/* last sig coeff indices in scan order */
|
WORD32 last_sig_coeff_x = pu1_coeff_buf_hdr[0];
|
WORD32 last_sig_coeff_y = pu1_coeff_buf_hdr[1];
|
|
/* read the scan type : upright diag / horz / vert */
|
WORD32 scan_type = pu1_coeff_buf_hdr[2];
|
|
/************************************************************************/
|
/* position of the last coded sub block. This sub block contains coeff */
|
/* corresponding to last_sig_coeff_x, last_sig_coeff_y. Althoug this can*/
|
/* be derived here it better to be populated by scanning module */
|
/************************************************************************/
|
WORD32 last_csb = pu1_coeff_buf_hdr[3];
|
|
WORD32 cur_csbf = 0, nbr_csbf;
|
WORD32 sig_coeff_base_ctxt; /* cabac context for sig coeff flag */
|
WORD32 abs_gt1_base_ctxt; /* cabac context for abslevel > 1 flag */
|
|
WORD32 gt1_ctxt = 1; /* required for abs_gt1_ctxt modelling */
|
|
WORD32 i;
|
|
UWORD8 *pu1_ctxt_model = &ps_cabac->au1_ctxt_models[0];
|
|
/* sanity checks */
|
/* transform skip not supported */
|
ASSERT(0 == ps_entropy_ctxt->ps_pps->i1_transform_skip_enabled_flag);
|
|
cu_tq_bypass_flag = ps_entropy_ctxt->ps_pps->i1_transform_skip_enabled_flag;
|
|
i4_sign_data_hiding_flag = ps_entropy_ctxt->ps_pps->i1_sign_data_hiding_flag;
|
|
{
|
temp_tex_bits_q12 = ps_cabac->u4_bits_estimated_q12;
|
}
|
|
if(SCAN_VERT == scan_type)
|
{
|
/* last coeff x and y are swapped for vertical scan */
|
SWAP(last_sig_coeff_x, last_sig_coeff_y);
|
}
|
|
/* Encode the last_sig_coeff_x and last_sig_coeff_y */
|
ret |= ihevce_cabac_encode_last_coeff_x_y(
|
ps_cabac, last_sig_coeff_x, last_sig_coeff_y, log2_tr_size, is_luma);
|
|
/*************************************************************************/
|
/* derive base context index for sig coeff as per section 9.3.3.1.4 */
|
/* TODO; convert to look up based on luma/chroma, scan type and tfr size */
|
/*************************************************************************/
|
if(is_luma)
|
{
|
sig_coeff_base_ctxt = IHEVC_CAB_COEFF_FLAG;
|
abs_gt1_base_ctxt = IHEVC_CAB_COEFABS_GRTR1_FLAG;
|
|
if(3 == log2_tr_size)
|
{
|
/* 8x8 transform size */
|
sig_coeff_base_ctxt += (scan_type == SCAN_DIAG_UPRIGHT) ? 9 : 15;
|
}
|
else if(3 < log2_tr_size)
|
{
|
/* larger transform sizes */
|
sig_coeff_base_ctxt += 21;
|
}
|
}
|
else
|
{
|
/* chroma context initializations */
|
sig_coeff_base_ctxt = IHEVC_CAB_COEFF_FLAG + 27;
|
abs_gt1_base_ctxt = IHEVC_CAB_COEFABS_GRTR1_FLAG + 16;
|
|
if(3 == log2_tr_size)
|
{
|
/* 8x8 transform size */
|
sig_coeff_base_ctxt += 9;
|
}
|
else if(3 < log2_tr_size)
|
{
|
/* larger transform sizes */
|
sig_coeff_base_ctxt += 12;
|
}
|
}
|
|
/* go to csbf flags */
|
pu2_sig_coeff_buf = (UWORD16 *)(pu1_coeff_buf_hdr + COEFF_BUF_HEADER_LEN);
|
|
/************************************************************************/
|
/* encode the csbf, sig_coeff_map, abs_grt1_flags, abs_grt2_flag, sign */
|
/* and abs_coeff_remaining for each 4x4 starting from last scan to first*/
|
/************************************************************************/
|
for(i = last_csb; i >= 0; i--)
|
{
|
UWORD16 u2_marker_csbf;
|
WORD32 ctxt_idx;
|
|
u2_marker_csbf = *pu2_sig_coeff_buf;
|
pu2_sig_coeff_buf++;
|
|
/* sanity checks for marker present in every csbf flag */
|
ASSERT((u2_marker_csbf >> 4) == 0xBAD);
|
|
/* extract the current and neigbour csbf flags */
|
cur_csbf = u2_marker_csbf & 0x1;
|
nbr_csbf = (u2_marker_csbf >> 1) & 0x3;
|
|
/*********************************************************************/
|
/* code the csbf flags; last and first csb not sent as it is derived */
|
/*********************************************************************/
|
if((i < last_csb) && (i > 0))
|
{
|
ctxt_idx = IHEVC_CAB_CODED_SUBLK_IDX;
|
|
/* ctxt based on right / bottom avail csbf, section 9.3.3.1.3 */
|
ctxt_idx += nbr_csbf ? 1 : 0;
|
ctxt_idx += is_luma ? 0 : 2;
|
|
{
|
WORD32 state_mps = pu1_ctxt_model[ctxt_idx];
|
|
/* increment bits generated based on state and bin encoded */
|
ps_cabac->u4_bits_estimated_q12 +=
|
gau2_ihevce_cabac_bin_to_bits[state_mps ^ cur_csbf];
|
|
/* update the context model from state transition LUT */
|
pu1_ctxt_model[ctxt_idx] = gau1_ihevc_next_state[(state_mps << 1) | cur_csbf];
|
}
|
}
|
else
|
{
|
/* sanity check, this csb contains the last_sig_coeff */
|
if(i == last_csb)
|
{
|
ASSERT(cur_csbf == 1);
|
}
|
}
|
|
if(cur_csbf)
|
{
|
/*****************************************************************/
|
/* encode the sig coeff map as per section 7.3.13 */
|
/* significant_coeff_flags: msb=coeff15-lsb=coeff0 in scan order */
|
/*****************************************************************/
|
|
/* Added for Sign bit data hiding*/
|
WORD32 first_scan_pos = 16;
|
WORD32 last_scan_pos = -1;
|
WORD32 sign_hidden;
|
|
UWORD16 u2_gt0_flags = *pu2_sig_coeff_buf;
|
WORD32 gt1_flags = *(pu2_sig_coeff_buf + 1);
|
WORD32 sign_flags = *(pu2_sig_coeff_buf + 2);
|
|
WORD32 sig_coeff_map = u2_gt0_flags;
|
|
WORD32 gt1_bins = 0; /* bins for coeffs with abslevel > 1 */
|
|
WORD32 sign_bins = 0; /* bins for sign flags of coded coeffs */
|
WORD32 num_coded = 0; /* total coeffs coded in 4x4 */
|
|
WORD32 infer_coeff; /* infer when 0,0 is the only coded coeff */
|
WORD32 bit; /* temp boolean */
|
|
/* total count of coeffs to be coded as abs level remaining */
|
WORD32 num_coeffs_remaining = 0;
|
|
/* count of coeffs to be coded as abslevel-1 */
|
WORD32 num_coeffs_base1 = 0;
|
WORD32 scan_pos;
|
WORD32 first_gt1_coeff = 0;
|
|
if((i != 0) || (0 == last_csb))
|
{
|
/* sanity check, atleast one coeff is coded as csbf is set */
|
ASSERT(sig_coeff_map != 0);
|
}
|
|
pu2_sig_coeff_buf += 3;
|
|
scan_pos = 15;
|
if(i == last_csb)
|
{
|
/*************************************************************/
|
/* clear last_scan_pos for last block in scan order as this */
|
/* is communicated throught last_coeff_x and last_coeff_y */
|
/*************************************************************/
|
WORD32 next_sig = CLZ(sig_coeff_map) + 1;
|
|
scan_pos = WORD_SIZE - next_sig;
|
|
/* prepare the bins for gt1 flags */
|
EXTRACT_BIT(bit, gt1_flags, scan_pos);
|
|
/* insert gt1 bin in lsb */
|
gt1_bins |= bit;
|
|
/* prepare the bins for sign flags */
|
EXTRACT_BIT(bit, sign_flags, scan_pos);
|
|
/* insert sign bin in lsb */
|
sign_bins |= bit;
|
|
sig_coeff_map = CLEAR_BIT(sig_coeff_map, scan_pos);
|
|
if(-1 == last_scan_pos)
|
last_scan_pos = scan_pos;
|
|
scan_pos--;
|
num_coded++;
|
}
|
|
/* infer 0,0 coeff for all 4x4 blocks except fitst and last */
|
infer_coeff = (i < last_csb) && (i > 0);
|
|
/* encode the required sigcoeff flags (abslevel > 0) */
|
while(scan_pos >= 0)
|
{
|
WORD32 y_pos_x_pos;
|
WORD32 sig_ctxinc = 0; /* 0 is default inc for DC coeff */
|
|
WORD32 sig_coeff;
|
|
EXTRACT_BIT(sig_coeff, sig_coeff_map, scan_pos);
|
|
/* derive the x,y pos */
|
y_pos_x_pos = gu1_hevce_scan4x4[scan_type][scan_pos];
|
|
/* derive the context inc as per section 9.3.3.1.4 */
|
if(2 == log2_tr_size)
|
{
|
/* 4x4 transform size increment uses lookup */
|
sig_ctxinc = gu1_hevce_sigcoeff_ctxtinc_tr4[y_pos_x_pos];
|
}
|
else if(scan_pos || i)
|
{
|
/* ctxt for AC coeff depends on curpos and neigbour csbf */
|
sig_ctxinc = gu1_hevce_sigcoeff_ctxtinc[nbr_csbf][y_pos_x_pos];
|
|
/* based on luma subblock pos */
|
sig_ctxinc += (i && is_luma) ? 3 : 0;
|
}
|
else
|
{
|
/* DC coeff has fixed context for luma and chroma */
|
sig_coeff_base_ctxt = is_luma ? IHEVC_CAB_COEFF_FLAG
|
: IHEVC_CAB_COEFF_FLAG + 27;
|
}
|
|
/*************************************************************/
|
/* encode sig coeff only if required */
|
/* decoder infers 0,0 coeff when all the other coeffs are 0 */
|
/*************************************************************/
|
if(scan_pos || (!infer_coeff))
|
{
|
ctxt_idx = sig_ctxinc + sig_coeff_base_ctxt;
|
|
//ret |= ihevce_cabac_encode_bin(ps_cabac, sig_coeff, ctxt_idx);
|
{
|
WORD32 state_mps = pu1_ctxt_model[ctxt_idx];
|
|
/* increment bits generated based on state and bin encoded */
|
ps_cabac->u4_bits_estimated_q12 +=
|
gau2_ihevce_cabac_bin_to_bits[state_mps ^ sig_coeff];
|
|
/* update the context model from state transition LUT */
|
pu1_ctxt_model[ctxt_idx] =
|
gau1_ihevc_next_state[(state_mps << 1) | sig_coeff];
|
}
|
}
|
|
if(sig_coeff)
|
{
|
/* prepare the bins for gt1 flags */
|
EXTRACT_BIT(bit, gt1_flags, scan_pos);
|
|
/* shift and insert gt1 bin in lsb */
|
gt1_bins <<= 1;
|
gt1_bins |= bit;
|
|
/* prepare the bins for sign flags */
|
EXTRACT_BIT(bit, sign_flags, scan_pos);
|
|
/* shift and insert sign bin in lsb */
|
sign_bins <<= 1;
|
sign_bins |= bit;
|
|
num_coded++;
|
|
/* 0,0 coeff can no more be inferred :( */
|
infer_coeff = 0;
|
|
if(-1 == last_scan_pos)
|
last_scan_pos = scan_pos;
|
|
first_scan_pos = scan_pos;
|
}
|
|
scan_pos--;
|
}
|
|
/* Added for sign bit hiding*/
|
sign_hidden =
|
(((last_scan_pos - first_scan_pos) > 3 && !cu_tq_bypass_flag) && (perform_sbh));
|
|
/****************************************************************/
|
/* encode the abs level greater than 1 bins; Section 7.3.13 */
|
/* These have already been prepared during sig_coeff_map encode */
|
/* Context modelling done as per section 9.3.3.1.5 */
|
/****************************************************************/
|
{
|
WORD32 j;
|
|
/* context set based on luma subblock pos */
|
WORD32 ctxt_set = (i && is_luma) ? 2 : 0;
|
|
/* count of coeffs with abslevel > 1; max of 8 to be coded */
|
WORD32 num_gt1_bins = MIN(8, num_coded);
|
|
if(num_coded > 8)
|
{
|
/* pull back the bins to required number */
|
gt1_bins >>= (num_coded - 8);
|
|
num_coeffs_remaining += (num_coded - 8);
|
num_coeffs_base1 = (num_coded - 8);
|
}
|
|
/* See section 9.3.3.1.5 */
|
ctxt_set += (0 == gt1_ctxt) ? 1 : 0;
|
|
gt1_ctxt = 1;
|
|
for(j = num_gt1_bins - 1; j >= 0; j--)
|
{
|
/* Encodet the abs level gt1 bins */
|
ctxt_idx = (ctxt_set * 4) + abs_gt1_base_ctxt + gt1_ctxt;
|
|
EXTRACT_BIT(bit, gt1_bins, j);
|
|
//ret |= ihevce_cabac_encode_bin(ps_cabac, bit, ctxt_idx);
|
{
|
WORD32 state_mps = pu1_ctxt_model[ctxt_idx];
|
|
/* increment bits generated based on state and bin encoded */
|
ps_cabac->u4_bits_estimated_q12 +=
|
gau2_ihevce_cabac_bin_to_bits[state_mps ^ bit];
|
|
/* update the context model from state transition LUT */
|
pu1_ctxt_model[ctxt_idx] = gau1_ihevc_next_state[(state_mps << 1) | bit];
|
}
|
|
if(bit)
|
{
|
gt1_ctxt = 0;
|
num_coeffs_remaining++;
|
}
|
else if(gt1_ctxt && (gt1_ctxt < 3))
|
{
|
gt1_ctxt++;
|
}
|
}
|
|
/*************************************************************/
|
/* encode abs level greater than 2 bin; Section 7.3.13 */
|
/*************************************************************/
|
if(gt1_bins)
|
{
|
WORD32 gt2_bin;
|
|
first_gt1_coeff = pu2_sig_coeff_buf[0] + 1;
|
gt2_bin = (first_gt1_coeff > 2);
|
|
/* atleast one level > 2 */
|
ctxt_idx = IHEVC_CAB_COEFABS_GRTR2_FLAG;
|
|
ctxt_idx += (is_luma) ? ctxt_set : (ctxt_set + 4);
|
|
//ret |= ihevce_cabac_encode_bin(ps_cabac, gt2_bin, ctxt_idx);
|
{
|
WORD32 state_mps = pu1_ctxt_model[ctxt_idx];
|
|
/* increment bits generated based on state and bin encoded */
|
ps_cabac->u4_bits_estimated_q12 +=
|
gau2_ihevce_cabac_bin_to_bits[state_mps ^ gt2_bin];
|
|
/* update the context model from state transition LUT */
|
pu1_ctxt_model[ctxt_idx] =
|
gau1_ihevc_next_state[(state_mps << 1) | gt2_bin];
|
}
|
|
if(!gt2_bin)
|
{
|
/* sanity check */
|
ASSERT(first_gt1_coeff == 2);
|
|
/* no need to send this coeff as bypass bins */
|
pu2_sig_coeff_buf++;
|
num_coeffs_remaining--;
|
}
|
}
|
}
|
|
/*************************************************************/
|
/* encode the coeff signs and abs remaing levels */
|
/*************************************************************/
|
if(num_coded)
|
{
|
WORD32 base_level;
|
WORD32 rice_param = 0;
|
WORD32 j;
|
|
/*************************************************************/
|
/* encode the coeff signs populated in sign_bins */
|
/*************************************************************/
|
if(sign_hidden && i4_sign_data_hiding_flag)
|
{
|
sign_bins >>= 1;
|
num_coded--;
|
}
|
|
if(num_coded > 0)
|
{
|
/* ret |= ihevce_cabac_encode_bypass_bins(ps_cabac,
|
sign_bins,
|
num_coded);
|
*/
|
|
/* increment bits generated based on num bypass bins */
|
ps_cabac->u4_bits_estimated_q12 += (num_coded << CABAC_FRAC_BITS_Q);
|
}
|
|
/*************************************************************/
|
/* encode the coeff_abs_level_remaining as TR / EGK bins */
|
/* See section 9.3.2.7 for details */
|
/*************************************************************/
|
|
/* first remaining coeff baselevel */
|
if(first_gt1_coeff > 2)
|
{
|
base_level = 3;
|
}
|
else if(num_coeffs_remaining > num_coeffs_base1)
|
{
|
/* atleast one coeff in first 8 is gt > 1 */
|
base_level = 2;
|
}
|
else
|
{
|
/* all coeffs have base of 1 */
|
base_level = 1;
|
}
|
|
for(j = 0; j < num_coeffs_remaining; j++)
|
{
|
WORD32 abs_coeff = pu2_sig_coeff_buf[0] + 1;
|
WORD32 abs_coeff_rem;
|
WORD32 rice_max = (4 << rice_param);
|
WORD32 num_bins, unary_length;
|
UWORD32 u4_sym_shiftk_plus1;
|
|
pu2_sig_coeff_buf++;
|
|
/* sanity check */
|
ASSERT(abs_coeff >= base_level);
|
|
abs_coeff_rem = (abs_coeff - base_level);
|
|
/* TODO://HM-8.0-dev uses (3 << rice_param) as rice_max */
|
/* TODO://HM-8.0-dev does either TR or EGK but not both */
|
if(abs_coeff_rem >= rice_max)
|
{
|
UWORD32 u4_suffix = (abs_coeff_rem - rice_max);
|
|
/* coeff exceeds max rice limit */
|
/* encode the TR prefix as tunary code */
|
/* prefix = 1111 as (rice_max >> rice_praram) = 4 */
|
/* ret |= ihevce_cabac_encode_bypass_bins(ps_cabac, 0xF, 4); */
|
|
/* increment bits generated based on num bypass bins */
|
ps_cabac->u4_bits_estimated_q12 += (4 << CABAC_FRAC_BITS_Q);
|
|
/* encode the exponential golomb code suffix */
|
/*ret |= ihevce_cabac_encode_egk(ps_cabac,
|
u4_suffix,
|
(rice_param+1)
|
); */
|
|
/* k = rice_param+1 */
|
/************************************************************************/
|
/* shift symbol by k bits to find unary code prefix (111110) */
|
/* Use GETRANGE to elminate the while loop in sec 9.3.2.4 of HEVC spec */
|
/************************************************************************/
|
u4_sym_shiftk_plus1 = (u4_suffix >> (rice_param + 1)) + 1;
|
|
/* GETRANGE(unary_length, (u4_sym_shiftk_plus1 + 1)); */
|
GETRANGE(unary_length, u4_sym_shiftk_plus1);
|
|
/* length of the code = 2 *(unary_length - 1) + 1 + k */
|
num_bins = (2 * unary_length) + rice_param;
|
|
/* increment bits generated based on num bypass bins */
|
ps_cabac->u4_bits_estimated_q12 += (num_bins << CABAC_FRAC_BITS_Q);
|
}
|
else
|
{
|
/* code coeff as truncated rice code */
|
/* ret |= ihevce_cabac_encode_trunc_rice(ps_cabac,
|
abs_coeff_rem,
|
rice_param,
|
rice_max);
|
*/
|
|
/************************************************************************/
|
/* shift symbol by c_rice_param bits to find unary code prefix (111.10) */
|
/************************************************************************/
|
unary_length = (abs_coeff_rem >> rice_param) + 1;
|
|
/* length of the code */
|
num_bins = unary_length + rice_param;
|
|
/* increment bits generated based on num bypass bins */
|
ps_cabac->u4_bits_estimated_q12 += (num_bins << CABAC_FRAC_BITS_Q);
|
}
|
|
/* update the rice param based on coeff level */
|
if((abs_coeff > (3 << rice_param)) && (rice_param < 4))
|
{
|
rice_param++;
|
}
|
|
/* change base level to 1 if more than 8 coded coeffs */
|
if((j + 1) < (num_coeffs_remaining - num_coeffs_base1))
|
{
|
base_level = 2;
|
}
|
else
|
{
|
base_level = 1;
|
}
|
}
|
}
|
}
|
}
|
/*tap texture bits*/
|
{
|
ps_cabac->u4_texture_bits_estimated_q12 +=
|
(ps_cabac->u4_bits_estimated_q12 - temp_tex_bits_q12);
|
}
|
|
return (ret);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Encodes a transform residual block as per section 7.3.13
|
*
|
* @par Description
|
* RDOQ optimization is carried out here. When sub-blk RDOQ is turned on, we calculate
|
* the distortion(D) and bits(R) for when the sub blk is coded and when not coded. We
|
* then use the D+lambdaR metric to decide whether the sub-blk should be coded or not, and
|
* aprropriately signal it. When coeff RDOQ is turned on, we traverse through the TU to
|
* find all non-zero coeffs. If the non zero coeff is a 1, then we make a decision(based on D+lambdaR)
|
* metric as to whether to code it as a 0 or 1. In case the coeff is > 1(say L where L>1) we choose betweem
|
* L and L+1
|
*
|
* @remarks Does not support sign data hiding and transform skip flag currently
|
*
|
* @remarks Need to resolve the differences between JVT-J1003_d7 spec and
|
* HM.8.0-dev for related abs_greater_than_1 context initialization
|
* and rice_max paramtere used for coeff abs level remaining
|
*
|
* @param[inout] ps_entropy_ctxt
|
* pointer to entropy context (handle)
|
*
|
* @param[in] pv_coeff
|
* Compressed residue buffer containing following information:
|
*
|
*
|
* HEADER(4 bytes) : last_coeff_x, last_coeff_y, scantype, last_subblock_num
|
*
|
* For each 4x4 subblock starting from last_subblock_num (in scan order)
|
* Read 2 bytes : MSB 12bits (0xBAD marker), bit0 cur_csbf, bit1-2 nbr csbf
|
*
|
* `If cur_csbf
|
* Read 2 bytes : sig_coeff_map (16bits in scan_order 1:coded, 0:not coded)
|
* Read 2 bytes : abs_gt1_flags (max of 8 only)
|
* Read 2 bytes : coeff_sign_flags
|
*
|
* Based on abs_gt1_flags and sig_coeff_map read remaining abs levels
|
* Read 2 bytes : remaining_abs_coeffs_minus1 (this is in a loop)
|
*
|
* @param[in] log2_tr_size
|
* transform size of the current TU
|
*
|
* @param[in] is_luma
|
* boolean indicating if the texture type is luma / chroma
|
*
|
* @param[out] pi4_tu_coded_dist
|
* The distortion when the TU is coded(not all coeffs are set to 0) is stored here
|
*
|
* @param[out] pi4_tu_not_coded_dist
|
* The distortion when the entire TU is not coded(all coeffs are set to 0) is stored here
|
*
|
*
|
* @return success or failure error code
|
*
|
******************************************************************************
|
*/
|
|
WORD32 ihevce_cabac_residue_encode_rdoq(
|
entropy_context_t *ps_entropy_ctxt,
|
void *pv_coeff,
|
WORD32 log2_tr_size,
|
WORD32 is_luma,
|
void *pv_rdoq_ctxt,
|
LWORD64 *pi8_tu_coded_dist,
|
LWORD64 *pi8_tu_not_coded_dist,
|
WORD32 perform_sbh)
|
{
|
WORD32 *pi4_subBlock2csbfId_map;
|
|
WORD32 ret = IHEVCE_SUCCESS;
|
|
cab_ctxt_t *ps_cabac = &ps_entropy_ctxt->s_cabac_ctxt;
|
cab_ctxt_t s_sub_blk_not_coded_cabac_ctxt;
|
backup_ctxt_t s_backup_ctxt;
|
backup_ctxt_t s_backup_ctxt_sub_blk_not_coded;
|
|
UWORD32 temp_tex_bits_q12;
|
|
UWORD8 *pu1_coeff_buf_hdr = (UWORD8 *)pv_coeff;
|
UWORD16 *pu2_sig_coeff_buf = (UWORD16 *)pv_coeff;
|
|
LWORD64 i8_sub_blk_not_coded_dist = 0, i8_sub_blk_coded_dist = 0;
|
WORD32 i4_sub_blk_not_coded_bits = 0, i4_sub_blk_coded_bits = 0;
|
LWORD64 i8_sub_blk_not_coded_metric, i8_sub_blk_coded_metric;
|
LWORD64 i8_tu_not_coded_dist = 0, i8_tu_coded_dist = 0;
|
WORD32 i4_tu_coded_bits = 0;
|
WORD32 temp_zero_col = 0, temp_zero_row = 0;
|
|
UWORD8 *pu1_last_sig_coeff_x;
|
UWORD8 *pu1_last_sig_coeff_y;
|
WORD32 scan_type;
|
WORD32 last_csb;
|
|
WORD32 cur_csbf = 0, nbr_csbf;
|
// WORD32 i4_temp_bits;
|
|
WORD32 sig_coeff_base_ctxt; /* cabac context for sig coeff flag */
|
WORD32 abs_gt1_base_ctxt; /* cabac context for abslevel > 1 flag */
|
|
UWORD8 *pu1_ctxt_model = &ps_cabac->au1_ctxt_models[0];
|
|
rdoq_sbh_ctxt_t *ps_rdoq_ctxt = (rdoq_sbh_ctxt_t *)pv_rdoq_ctxt;
|
WORD16 *pi2_coeffs = ps_rdoq_ctxt->pi2_quant_coeffs;
|
WORD16 *pi2_tr_coeffs = ps_rdoq_ctxt->pi2_trans_values;
|
WORD32 trans_size = ps_rdoq_ctxt->i4_trans_size;
|
WORD32 i4_round_val = ps_rdoq_ctxt->i4_round_val_ssd_in_td;
|
WORD32 i4_shift_val = ps_rdoq_ctxt->i4_shift_val_ssd_in_td;
|
WORD32 scan_idx = ps_rdoq_ctxt->i4_scan_idx;
|
|
UWORD8 *pu1_csb_table, *pu1_trans_table;
|
WORD32 shift_value, mask_value;
|
|
WORD32 gt1_ctxt = 1; /* required for abs_gt1_ctxt modelling */
|
WORD32 temp_gt1_ctxt = gt1_ctxt;
|
|
WORD32 i;
|
#if DISABLE_ZCSBF
|
WORD32 i4_skip_zero_cbf = 0;
|
WORD32 i4_skip_zero_csbf = 0;
|
WORD32 i4_num_abs_1_coeffs = 0;
|
#endif
|
(void)perform_sbh;
|
pi4_subBlock2csbfId_map = ps_rdoq_ctxt->pi4_subBlock2csbfId_map;
|
|
/* scan order inside a csb */
|
pu1_csb_table = (UWORD8 *)&(g_u1_scan_table_4x4[scan_idx][0]);
|
/*Initializing the backup_ctxt structures*/
|
s_backup_ctxt.i4_num_bits = 0;
|
s_backup_ctxt_sub_blk_not_coded.i4_num_bits = 0;
|
|
memset(&s_backup_ctxt.au1_ctxt_to_backup, 0, MAX_NUM_CONTEXT_ELEMENTS);
|
memset(&s_backup_ctxt_sub_blk_not_coded.au1_ctxt_to_backup, 0, MAX_NUM_CONTEXT_ELEMENTS);
|
|
pu1_coeff_buf_hdr = (UWORD8 *)pv_coeff;
|
pu2_sig_coeff_buf = (UWORD16 *)pv_coeff;
|
|
/* last sig coeff indices in scan order */
|
pu1_last_sig_coeff_x = &pu1_coeff_buf_hdr[0];
|
pu1_last_sig_coeff_y = &pu1_coeff_buf_hdr[1];
|
|
/* read the scan type : upright diag / horz / vert */
|
scan_type = pu1_coeff_buf_hdr[2];
|
|
/************************************************************************/
|
/* position of the last coded sub block. This sub block contains coeff */
|
/* corresponding to last_sig_coeff_x, last_sig_coeff_y. Althoug this can*/
|
/* be derived here it better to be populated by scanning module */
|
/************************************************************************/
|
last_csb = pu1_coeff_buf_hdr[3];
|
|
shift_value = ps_rdoq_ctxt->i4_log2_trans_size + 1;
|
/* for finding. row no. from scan index */
|
shift_value = shift_value - 3;
|
/*for finding the col. no. from scan index*/
|
mask_value = (ps_rdoq_ctxt->i4_trans_size / 4) - 1;
|
|
switch(ps_rdoq_ctxt->i4_trans_size)
|
{
|
case 32:
|
pu1_trans_table = (UWORD8 *)&(g_u1_scan_table_8x8[scan_idx][0]);
|
break;
|
case 16:
|
pu1_trans_table = (UWORD8 *)&(g_u1_scan_table_4x4[scan_idx][0]);
|
break;
|
case 8:
|
pu1_trans_table = (UWORD8 *)&(g_u1_scan_table_2x2[scan_idx][0]);
|
break;
|
case 4:
|
pu1_trans_table = (UWORD8 *)&(g_u1_scan_table_1x1[0]);
|
break;
|
default:
|
DBG_PRINTF("Invalid Trans Size\n");
|
return -1;
|
break;
|
}
|
|
/* sanity checks */
|
/* transform skip not supported */
|
ASSERT(0 == ps_entropy_ctxt->ps_pps->i1_transform_skip_enabled_flag);
|
{
|
temp_tex_bits_q12 = ps_cabac->u4_bits_estimated_q12;
|
}
|
/*************************************************************************/
|
/* derive base context index for sig coeff as per section 9.3.3.1.4 */
|
/* TODO; convert to look up based on luma/chroma, scan type and tfr size */
|
/*************************************************************************/
|
if(is_luma)
|
{
|
sig_coeff_base_ctxt = IHEVC_CAB_COEFF_FLAG;
|
abs_gt1_base_ctxt = IHEVC_CAB_COEFABS_GRTR1_FLAG;
|
|
if(3 == log2_tr_size)
|
{
|
/* 8x8 transform size */
|
sig_coeff_base_ctxt += (scan_type == SCAN_DIAG_UPRIGHT) ? 9 : 15;
|
}
|
else if(3 < log2_tr_size)
|
{
|
/* larger transform sizes */
|
sig_coeff_base_ctxt += 21;
|
}
|
}
|
else
|
{
|
/* chroma context initializations */
|
sig_coeff_base_ctxt = IHEVC_CAB_COEFF_FLAG + 27;
|
abs_gt1_base_ctxt = IHEVC_CAB_COEFABS_GRTR1_FLAG + 16;
|
|
if(3 == log2_tr_size)
|
{
|
/* 8x8 transform size */
|
sig_coeff_base_ctxt += 9;
|
}
|
else if(3 < log2_tr_size)
|
{
|
/* larger transform sizes */
|
sig_coeff_base_ctxt += 12;
|
}
|
}
|
|
/* go to csbf flags */
|
pu2_sig_coeff_buf = (UWORD16 *)(pu1_coeff_buf_hdr + COEFF_BUF_HEADER_LEN);
|
|
/*Calculating the distortion produced by all the zero coeffs in the TU*/
|
for(i = (trans_size * trans_size) - 1; i >= 0; i--)
|
{
|
WORD32 i4_dist;
|
WORD16 *pi2_orig_coeff = ps_rdoq_ctxt->pi2_trans_values;
|
|
if(pi2_coeffs[i] == 0)
|
{
|
i4_dist = CALC_SSD_IN_TRANS_DOMAIN(pi2_orig_coeff[i], 0, 0, 0);
|
i8_tu_not_coded_dist += i4_dist;
|
i8_tu_coded_dist += i4_dist;
|
}
|
}
|
|
/*Backup of the various cabac ctxts*/
|
memcpy(&s_sub_blk_not_coded_cabac_ctxt, ps_cabac, sizeof(cab_ctxt_t));
|
/************************************************************************/
|
/* encode the csbf, sig_coeff_map, abs_grt1_flags, abs_grt2_flag, sign */
|
/* and abs_coeff_remaining for each 4x4 starting from last scan to first*/
|
/************************************************************************/
|
|
for(i = last_csb; i >= 0; i--)
|
{
|
UWORD16 u2_marker_csbf;
|
WORD32 ctxt_idx;
|
WORD32 i4_sub_blk_is_coded = 0;
|
WORD32 blk_row, blk_col;
|
WORD32 scaled_blk_row;
|
WORD32 scaled_blk_col;
|
WORD32 infer_coeff;
|
|
gt1_ctxt = temp_gt1_ctxt;
|
#if DISABLE_ZCSBF
|
/*Initialize skip zero cbf flag to 0*/
|
i4_skip_zero_csbf = 0;
|
i4_num_abs_1_coeffs = 0;
|
#endif
|
|
#if OPT_MEMCPY
|
ihevce_copy_backup_ctxt(
|
(void *)&s_sub_blk_not_coded_cabac_ctxt,
|
(void *)ps_cabac,
|
(void *)&s_backup_ctxt_sub_blk_not_coded,
|
(void *)&s_backup_ctxt);
|
memset(s_backup_ctxt_sub_blk_not_coded.au1_ctxt_to_backup, 0, 5);
|
memset(s_backup_ctxt.au1_ctxt_to_backup, 0, 5);
|
#else
|
memcpy(&s_sub_blk_not_coded_cabac_ctxt, ps_cabac, sizeof(cab_ctxt_t));
|
#endif
|
// i4_temp_bits = s_sub_blk_not_coded_cabac_ctxt.u4_bits_estimated_q12;
|
|
blk_row = pu1_trans_table[i] >> shift_value; /*row of csb*/
|
blk_col = pu1_trans_table[i] & mask_value; /*col of csb*/
|
|
scaled_blk_row = blk_row << 2;
|
scaled_blk_col = blk_col << 2;
|
|
infer_coeff = (i < last_csb) && (i > 0);
|
u2_marker_csbf = *pu2_sig_coeff_buf;
|
|
if((blk_col + 1 < trans_size / 4)) /* checking right boundary */
|
{
|
if(!ps_rdoq_ctxt
|
->pu1_csbf_buf[pi4_subBlock2csbfId_map[blk_row * trans_size / 4 + blk_col + 1]])
|
{
|
/* clear the 2nd bit if the right csb is 0 */
|
u2_marker_csbf = u2_marker_csbf & (~(1 << 1));
|
}
|
}
|
if((blk_row + 1 < trans_size / 4)) /* checking bottom boundary */
|
{
|
if(!ps_rdoq_ctxt
|
->pu1_csbf_buf[pi4_subBlock2csbfId_map[(blk_row + 1) * trans_size / 4 + blk_col]])
|
{
|
/* clear the 3rd bit if the bottom csb is 0*/
|
u2_marker_csbf = u2_marker_csbf & (~(1 << 2));
|
}
|
}
|
pu2_sig_coeff_buf++;
|
|
/* sanity checks for marker present in every csbf flag */
|
ASSERT((u2_marker_csbf >> 4) == 0xBAD);
|
|
/* extract the current and neigbour csbf flags */
|
cur_csbf = u2_marker_csbf & 0x1;
|
nbr_csbf = (u2_marker_csbf >> 1) & 0x3;
|
|
if((i < last_csb) && (i > 0))
|
{
|
ctxt_idx = IHEVC_CAB_CODED_SUBLK_IDX;
|
|
/* ctxt based on right / bottom avail csbf, section 9.3.3.1.3 */
|
ctxt_idx += nbr_csbf ? 1 : 0;
|
ctxt_idx += is_luma ? 0 : 2;
|
|
ret |= ihevce_cabac_encode_bin(ps_cabac, cur_csbf, ctxt_idx);
|
|
s_backup_ctxt.au1_ctxt_to_backup[SUB_BLK_CODED_FLAG] = 1;
|
|
if(cur_csbf)
|
{
|
ret |= ihevce_cabac_encode_bin(&s_sub_blk_not_coded_cabac_ctxt, 0, ctxt_idx);
|
// clang-format off
|
i4_sub_blk_not_coded_bits =
|
s_sub_blk_not_coded_cabac_ctxt.u4_bits_estimated_q12; // - i4_temp_bits;
|
s_backup_ctxt_sub_blk_not_coded.au1_ctxt_to_backup[SUB_BLK_CODED_FLAG] = 1;
|
// clang-format on
|
}
|
}
|
else
|
{
|
/* sanity check, this csb contains the last_sig_coeff */
|
if(i == last_csb)
|
{
|
ASSERT(cur_csbf == 1);
|
}
|
}
|
/*If any block in the TU is coded and the 0th block is not coded, the 0th
|
block is still signalled as csbf = 1, and with all sig_coeffs sent as
|
0(HEVC requirement)*/
|
if((ps_rdoq_ctxt->i1_tu_is_coded == 1) && (i == 0))
|
{
|
i4_sub_blk_not_coded_bits = ihevce_code_all_sig_coeffs_as_0_explicitly(
|
(void *)ps_rdoq_ctxt,
|
i,
|
pu1_trans_table,
|
is_luma,
|
scan_type,
|
infer_coeff,
|
nbr_csbf,
|
&s_sub_blk_not_coded_cabac_ctxt);
|
}
|
|
if(i == last_csb)
|
{
|
WORD32 i4_last_x = *pu1_last_sig_coeff_x;
|
WORD32 i4_last_y = *pu1_last_sig_coeff_y;
|
if(SCAN_VERT == scan_type)
|
{
|
/* last coeff x and y are swapped for vertical scan */
|
SWAP(i4_last_x, i4_last_y);
|
}
|
/* Encode the last_sig_coeff_x and last_sig_coeff_y */
|
ret |= ihevce_cabac_encode_last_coeff_x_y(
|
ps_cabac, i4_last_x, i4_last_y, log2_tr_size, is_luma);
|
s_backup_ctxt.au1_ctxt_to_backup[LASTXY] = 1;
|
}
|
|
if(cur_csbf)
|
{
|
/*****************************************************************/
|
/* encode the sig coeff map as per section 7.3.13 */
|
/* significant_coeff_flags: msb=coeff15-lsb=coeff0 in scan order */
|
/*****************************************************************/
|
|
WORD32 i4_bit_depth;
|
WORD32 i4_shift_iq;
|
WORD32 i4_dequant_val;
|
WORD32 bit; /* temp boolean */
|
|
UWORD16 u2_gt0_flags = *pu2_sig_coeff_buf;
|
WORD32 sig_coeff_map = u2_gt0_flags;
|
WORD32 gt1_flags = *(pu2_sig_coeff_buf + 1);
|
WORD32 sign_flags = *(pu2_sig_coeff_buf + 2);
|
|
WORD32 gt1_bins = 0; /* bins for coeffs with abslevel > 1 */
|
|
WORD16 *pi2_dequant_coeff = ps_rdoq_ctxt->pi2_dequant_coeff;
|
WORD16 i2_qp_rem = ps_rdoq_ctxt->i2_qp_rem;
|
WORD32 i4_qp_div = ps_rdoq_ctxt->i4_qp_div;
|
|
WORD32 sign_bins = 0; /* bins for sign flags of coded coeffs */
|
WORD32 num_coded = 0; /* total coeffs coded in 4x4 */
|
|
/* total count of coeffs to be coded as abs level remaining */
|
WORD32 num_coeffs_remaining = 0;
|
|
/* count of coeffs to be coded as abslevel-1 */
|
WORD32 num_coeffs_base1 = 0;
|
WORD32 scan_pos;
|
WORD32 first_gt1_coeff = 0;
|
|
i4_bit_depth = ps_entropy_ctxt->ps_sps->i1_bit_depth_luma_minus8 + 8;
|
i4_shift_iq = i4_bit_depth + ps_rdoq_ctxt->i4_log2_trans_size - 5;
|
|
i4_sub_blk_is_coded = 1;
|
|
if((i != 0) || (0 == last_csb))
|
{
|
/* sanity check, atleast one coeff is coded as csbf is set */
|
ASSERT(sig_coeff_map != 0);
|
}
|
/*Calculating the distortions produced*/
|
{
|
WORD32 k, j;
|
WORD16 *pi2_temp_coeff =
|
&pi2_coeffs[scaled_blk_col + (scaled_blk_row * trans_size)];
|
WORD16 *pi2_temp_tr_coeff =
|
&pi2_tr_coeffs[scaled_blk_col + (scaled_blk_row * trans_size)];
|
WORD16 *pi2_temp_dequant_coeff =
|
&pi2_dequant_coeff[scaled_blk_col + (scaled_blk_row * trans_size)];
|
|
for(k = 0; k < 4; k++)
|
{
|
for(j = 0; j < 4; j++)
|
{
|
if(*pi2_temp_coeff)
|
{
|
/*Inverse quantizing for distortion calculation*/
|
if(ps_rdoq_ctxt->i4_trans_size != 4)
|
{
|
IQUANT(
|
i4_dequant_val,
|
*pi2_temp_coeff,
|
*pi2_temp_dequant_coeff * g_ihevc_iquant_scales[i2_qp_rem],
|
i4_shift_iq,
|
i4_qp_div);
|
}
|
else
|
{
|
IQUANT_4x4(
|
i4_dequant_val,
|
*pi2_temp_coeff,
|
*pi2_temp_dequant_coeff * g_ihevc_iquant_scales[i2_qp_rem],
|
i4_shift_iq,
|
i4_qp_div);
|
}
|
|
i8_sub_blk_coded_dist +=
|
CALC_SSD_IN_TRANS_DOMAIN(*pi2_temp_tr_coeff, i4_dequant_val, 0, 0);
|
|
i8_sub_blk_not_coded_dist +=
|
CALC_SSD_IN_TRANS_DOMAIN(*pi2_temp_tr_coeff, 0, 0, 0);
|
}
|
#if DISABLE_ZCSBF
|
if(abs(*pi2_temp_coeff) > 1)
|
{
|
i4_skip_zero_csbf = 1;
|
}
|
else if(abs(*pi2_temp_coeff) == 1)
|
{
|
i4_num_abs_1_coeffs++;
|
}
|
#endif
|
pi2_temp_coeff++;
|
pi2_temp_tr_coeff++;
|
pi2_temp_dequant_coeff++;
|
}
|
pi2_temp_tr_coeff += ps_rdoq_ctxt->i4_trans_size - 4;
|
pi2_temp_coeff += ps_rdoq_ctxt->i4_q_data_strd - 4;
|
pi2_dequant_coeff += ps_rdoq_ctxt->i4_trans_size - 4;
|
}
|
}
|
|
#if DISABLE_ZCSBF
|
i4_skip_zero_csbf = i4_skip_zero_csbf || (i4_num_abs_1_coeffs > 3);
|
#endif
|
pu2_sig_coeff_buf += 3;
|
|
scan_pos = 15;
|
if(i == last_csb)
|
{
|
/*************************************************************/
|
/* clear last_scan_pos for last block in scan order as this */
|
/* is communicated throught last_coeff_x and last_coeff_y */
|
/*************************************************************/
|
WORD32 next_sig = CLZ(sig_coeff_map) + 1;
|
|
scan_pos = WORD_SIZE - next_sig;
|
|
/* prepare the bins for gt1 flags */
|
EXTRACT_BIT(bit, gt1_flags, scan_pos);
|
|
/* insert gt1 bin in lsb */
|
gt1_bins |= bit;
|
|
/* prepare the bins for sign flags */
|
EXTRACT_BIT(bit, sign_flags, scan_pos);
|
|
/* insert sign bin in lsb */
|
sign_bins |= bit;
|
|
sig_coeff_map = CLEAR_BIT(sig_coeff_map, scan_pos);
|
|
scan_pos--;
|
num_coded++;
|
}
|
|
/* encode the required sigcoeff flags (abslevel > 0) */
|
while(scan_pos >= 0)
|
{
|
WORD32 y_pos_x_pos;
|
WORD32 sig_ctxinc = 0; /* 0 is default inc for DC coeff */
|
|
WORD32 sig_coeff;
|
|
EXTRACT_BIT(sig_coeff, sig_coeff_map, scan_pos);
|
|
/* derive the x,y pos */
|
y_pos_x_pos = gu1_hevce_scan4x4[scan_type][scan_pos];
|
|
/* derive the context inc as per section 9.3.3.1.4 */
|
if(2 == log2_tr_size)
|
{
|
/* 4x4 transform size increment uses lookup */
|
sig_ctxinc = gu1_hevce_sigcoeff_ctxtinc_tr4[y_pos_x_pos];
|
}
|
else if(scan_pos || i)
|
{
|
/* ctxt for AC coeff depends on curpos and neigbour csbf */
|
sig_ctxinc = gu1_hevce_sigcoeff_ctxtinc[nbr_csbf][y_pos_x_pos];
|
|
/* based on luma subblock pos */
|
sig_ctxinc += (i && is_luma) ? 3 : 0;
|
}
|
else
|
{
|
/* DC coeff has fixed context for luma and chroma */
|
sig_coeff_base_ctxt = is_luma ? IHEVC_CAB_COEFF_FLAG
|
: IHEVC_CAB_COEFF_FLAG + 27;
|
}
|
|
/*************************************************************/
|
/* encode sig coeff only if required */
|
/* decoder infers 0,0 coeff when all the other coeffs are 0 */
|
/*************************************************************/
|
if(scan_pos || (!infer_coeff))
|
{
|
ctxt_idx = sig_ctxinc + sig_coeff_base_ctxt;
|
//ret |= ihevce_cabac_encode_bin(ps_cabac, sig_coeff, ctxt_idx);
|
{
|
WORD32 state_mps = pu1_ctxt_model[ctxt_idx];
|
|
/* increment bits generated based on state and bin encoded */
|
ps_cabac->u4_bits_estimated_q12 +=
|
gau2_ihevce_cabac_bin_to_bits[state_mps ^ sig_coeff];
|
|
/* update the context model from state transition LUT */
|
pu1_ctxt_model[ctxt_idx] =
|
gau1_ihevc_next_state[(state_mps << 1) | sig_coeff];
|
}
|
}
|
|
if(sig_coeff)
|
{
|
/* prepare the bins for gt1 flags */
|
EXTRACT_BIT(bit, gt1_flags, scan_pos);
|
|
/* shift and insert gt1 bin in lsb */
|
gt1_bins <<= 1;
|
gt1_bins |= bit;
|
|
/* prepare the bins for sign flags */
|
EXTRACT_BIT(bit, sign_flags, scan_pos);
|
|
/* shift and insert sign bin in lsb */
|
sign_bins <<= 1;
|
sign_bins |= bit;
|
|
num_coded++;
|
|
/* 0,0 coeff can no more be inferred :( */
|
infer_coeff = 0;
|
}
|
|
scan_pos--;
|
}
|
|
s_backup_ctxt.au1_ctxt_to_backup[SIG_COEFF] = 1;
|
|
/****************************************************************/
|
/* encode the abs level greater than 1 bins; Section 7.3.13 */
|
/* These have already been prepared during sig_coeff_map encode */
|
/* Context modelling done as per section 9.3.3.1.5 */
|
/****************************************************************/
|
{
|
WORD32 j;
|
|
/* context set based on luma subblock pos */
|
WORD32 ctxt_set = (i && is_luma) ? 2 : 0;
|
|
/* count of coeffs with abslevel > 1; max of 8 to be coded */
|
WORD32 num_gt1_bins = MIN(8, num_coded);
|
|
if(num_coded > 8)
|
{
|
/* pull back the bins to required number */
|
gt1_bins >>= (num_coded - 8);
|
|
num_coeffs_remaining += (num_coded - 8);
|
num_coeffs_base1 = (num_coded - 8);
|
}
|
|
/* See section 9.3.3.1.5 */
|
ctxt_set += (0 == gt1_ctxt) ? 1 : 0;
|
|
gt1_ctxt = 1;
|
|
for(j = num_gt1_bins - 1; j >= 0; j--)
|
{
|
/* Encodet the abs level gt1 bins */
|
ctxt_idx = (ctxt_set * 4) + abs_gt1_base_ctxt + gt1_ctxt;
|
|
EXTRACT_BIT(bit, gt1_bins, j);
|
|
//ret |= ihevce_cabac_encode_bin(ps_cabac, bit, ctxt_idx);
|
{
|
WORD32 state_mps = pu1_ctxt_model[ctxt_idx];
|
|
/* increment bits generated based on state and bin encoded */
|
ps_cabac->u4_bits_estimated_q12 +=
|
gau2_ihevce_cabac_bin_to_bits[state_mps ^ bit];
|
|
/* update the context model from state transition LUT */
|
pu1_ctxt_model[ctxt_idx] = gau1_ihevc_next_state[(state_mps << 1) | bit];
|
}
|
|
if(bit)
|
{
|
gt1_ctxt = 0;
|
num_coeffs_remaining++;
|
}
|
else if(gt1_ctxt && (gt1_ctxt < 3))
|
{
|
gt1_ctxt++;
|
}
|
}
|
s_backup_ctxt.au1_ctxt_to_backup[GRTR_THAN_1] = 1;
|
/*************************************************************/
|
/* encode abs level greater than 2 bin; Section 7.3.13 */
|
/*************************************************************/
|
if(gt1_bins)
|
{
|
WORD32 gt2_bin;
|
|
first_gt1_coeff = pu2_sig_coeff_buf[0] + 1;
|
gt2_bin = (first_gt1_coeff > 2);
|
|
/* atleast one level > 2 */
|
ctxt_idx = IHEVC_CAB_COEFABS_GRTR2_FLAG;
|
|
ctxt_idx += (is_luma) ? ctxt_set : (ctxt_set + 4);
|
|
//ret |= ihevce_cabac_encode_bin(ps_cabac, gt2_bin, ctxt_idx);
|
{
|
WORD32 state_mps = pu1_ctxt_model[ctxt_idx];
|
|
/* increment bits generated based on state and bin encoded */
|
ps_cabac->u4_bits_estimated_q12 +=
|
gau2_ihevce_cabac_bin_to_bits[state_mps ^ gt2_bin];
|
|
/* update the context model from state transition LUT */
|
pu1_ctxt_model[ctxt_idx] =
|
gau1_ihevc_next_state[(state_mps << 1) | gt2_bin];
|
}
|
|
if(!gt2_bin)
|
{
|
/* sanity check */
|
ASSERT(first_gt1_coeff == 2);
|
|
/* no need to send this coeff as bypass bins */
|
pu2_sig_coeff_buf++;
|
num_coeffs_remaining--;
|
}
|
s_backup_ctxt.au1_ctxt_to_backup[GRTR_THAN_2] = 1;
|
}
|
}
|
|
/*************************************************************/
|
/* encode the coeff signs and abs remaing levels */
|
/*************************************************************/
|
if(num_coded)
|
{
|
WORD32 base_level;
|
WORD32 rice_param = 0;
|
WORD32 j;
|
|
/*************************************************************/
|
/* encode the coeff signs populated in sign_bins */
|
/*************************************************************/
|
if(num_coded > 0)
|
{
|
ret |= ihevce_cabac_encode_bypass_bins(ps_cabac, sign_bins, num_coded);
|
}
|
/*************************************************************/
|
/* encode the coeff_abs_level_remaining as TR / EGK bins */
|
/* See section 9.3.2.7 for details */
|
/*************************************************************/
|
|
/* first remaining coeff baselevel */
|
if(first_gt1_coeff > 2)
|
{
|
base_level = 3;
|
}
|
else if(num_coeffs_remaining > num_coeffs_base1)
|
{
|
/* atleast one coeff in first 8 is gt > 1 */
|
base_level = 2;
|
}
|
else
|
{
|
/* all coeffs have base of 1 */
|
base_level = 1;
|
}
|
|
for(j = 0; j < num_coeffs_remaining; j++)
|
{
|
WORD32 abs_coeff = pu2_sig_coeff_buf[0] + 1;
|
WORD32 abs_coeff_rem;
|
WORD32 rice_max = (4 << rice_param);
|
|
pu2_sig_coeff_buf++;
|
|
/* sanity check */
|
ASSERT(abs_coeff >= base_level);
|
|
abs_coeff_rem = (abs_coeff - base_level);
|
|
/* TODO://HM-8.0-dev uses (3 << rice_param) as rice_max */
|
/* TODO://HM-8.0-dev does either TR or EGK but not both */
|
if(abs_coeff_rem >= rice_max)
|
{
|
UWORD32 u4_suffix = (abs_coeff_rem - rice_max);
|
|
/* coeff exceeds max rice limit */
|
/* encode the TR prefix as tunary code */
|
/* prefix = 1111 as (rice_max >> rice_praram) = 4 */
|
ret |= ihevce_cabac_encode_bypass_bins(ps_cabac, 0xF, 4);
|
|
/* encode the exponential golomb code suffix */
|
ret |= ihevce_cabac_encode_egk(ps_cabac, u4_suffix, (rice_param + 1));
|
}
|
else
|
{
|
/* code coeff as truncated rice code */
|
ret |= ihevce_cabac_encode_trunc_rice(
|
ps_cabac, abs_coeff_rem, rice_param, rice_max);
|
}
|
|
/* update the rice param based on coeff level */
|
if((abs_coeff > (3 << rice_param)) && (rice_param < 4))
|
{
|
rice_param++;
|
}
|
|
/* change base level to 1 if more than 8 coded coeffs */
|
if((j + 1) < (num_coeffs_remaining - num_coeffs_base1))
|
{
|
base_level = 2;
|
}
|
else
|
{
|
base_level = 1;
|
}
|
}
|
}
|
|
i4_sub_blk_coded_bits = ps_cabac->u4_bits_estimated_q12;
|
/**********************************************************/
|
/**********************************************************/
|
/**********************************************************/
|
/*Decide whether sub block should be coded or not*/
|
/**********************************************************/
|
/**********************************************************/
|
/**********************************************************/
|
i8_sub_blk_coded_metric = CALC_CUMMUL_SSD_IN_TRANS_DOMAIN(
|
i8_sub_blk_coded_dist, 0, i4_round_val, i4_shift_val) +
|
COMPUTE_RATE_COST_CLIP30_RDOQ(
|
i4_sub_blk_coded_bits,
|
ps_rdoq_ctxt->i8_cl_ssd_lambda_qf,
|
(LAMBDA_Q_SHIFT + CABAC_FRAC_BITS_Q));
|
i8_sub_blk_not_coded_metric =
|
CALC_CUMMUL_SSD_IN_TRANS_DOMAIN(
|
i8_sub_blk_not_coded_dist, 0, i4_round_val, i4_shift_val) +
|
COMPUTE_RATE_COST_CLIP30_RDOQ(
|
i4_sub_blk_not_coded_bits,
|
ps_rdoq_ctxt->i8_cl_ssd_lambda_qf,
|
(LAMBDA_Q_SHIFT + CABAC_FRAC_BITS_Q));
|
|
#if DISABLE_ZCSBF
|
if(((i8_sub_blk_not_coded_metric < i8_sub_blk_coded_metric) ||
|
(i4_sub_blk_is_coded == 0)) &&
|
(i4_skip_zero_csbf == 0))
|
#else
|
if((i8_sub_blk_not_coded_metric < i8_sub_blk_coded_metric) ||
|
(i4_sub_blk_is_coded == 0))
|
#endif
|
{
|
#if OPT_MEMCPY
|
ihevce_copy_backup_ctxt(
|
(void *)ps_cabac,
|
(void *)&s_sub_blk_not_coded_cabac_ctxt,
|
(void *)&s_backup_ctxt,
|
(void *)&s_backup_ctxt_sub_blk_not_coded);
|
#else
|
memcpy(ps_cabac, &s_sub_blk_not_coded_cabac_ctxt, sizeof(cab_ctxt_t));
|
#endif
|
scan_pos = 15;
|
i4_sub_blk_is_coded = 0;
|
|
{
|
WORD32 k, j;
|
WORD16 *pi2_temp_coeff =
|
&pi2_coeffs[scaled_blk_col + (scaled_blk_row * ps_rdoq_ctxt->i4_q_data_strd)];
|
WORD16 *pi2_temp_iquant_coeff =
|
&ps_rdoq_ctxt->pi2_iquant_coeffs
|
[scaled_blk_col + (scaled_blk_row * ps_rdoq_ctxt->i4_iq_data_strd)];
|
for(k = 0; k < 4; k++)
|
{
|
for(j = 0; j < 4; j++)
|
{
|
*pi2_temp_coeff = 0;
|
*pi2_temp_iquant_coeff = 0;
|
|
pi2_temp_coeff++;
|
pi2_temp_iquant_coeff++;
|
}
|
pi2_temp_coeff += ps_rdoq_ctxt->i4_q_data_strd - 4;
|
pi2_temp_iquant_coeff += ps_rdoq_ctxt->i4_iq_data_strd - 4;
|
}
|
}
|
|
/* If the csb to be masked is the last csb, then we should
|
* signal last x and last y from the next coded sub_blk */
|
if(i == last_csb)
|
{
|
pu1_coeff_buf_hdr = (UWORD8 *)pu2_sig_coeff_buf;
|
|
ps_rdoq_ctxt->pu1_csbf_buf[pi4_subBlock2csbfId_map[pu1_trans_table[i]]] = 0;
|
last_csb = ihevce_find_new_last_csb(
|
pi4_subBlock2csbfId_map,
|
i,
|
(void *)ps_rdoq_ctxt,
|
pu1_trans_table,
|
pu1_csb_table,
|
pi2_coeffs,
|
shift_value,
|
mask_value,
|
&pu1_coeff_buf_hdr);
|
/*We are in a for loop. This means that the decrement to i happens immediately right
|
at the end of the for loop. This would decrement the value of i to (last_csb - 1).
|
Hence we increment i by 1, so that after the decrement i becomes last_csb.*/
|
i = last_csb + 1;
|
pu1_last_sig_coeff_x = &pu1_coeff_buf_hdr[0];
|
pu1_last_sig_coeff_y = &pu1_coeff_buf_hdr[1];
|
scan_type = pu1_coeff_buf_hdr[2];
|
pu2_sig_coeff_buf = (UWORD16 *)(pu1_coeff_buf_hdr + 4);
|
}
|
i8_tu_coded_dist += i8_sub_blk_not_coded_dist;
|
i4_tu_coded_bits += i4_sub_blk_not_coded_bits;
|
}
|
else
|
{
|
ps_rdoq_ctxt->i1_tu_is_coded = 1;
|
temp_gt1_ctxt = gt1_ctxt;
|
|
i8_tu_coded_dist += i8_sub_blk_coded_dist;
|
i4_tu_coded_bits += i4_sub_blk_coded_bits;
|
}
|
#if DISABLE_ZCSBF
|
i4_skip_zero_cbf = i4_skip_zero_cbf || i4_skip_zero_csbf;
|
#endif
|
/*Cumulating the distortion for the entire TU*/
|
i8_tu_not_coded_dist += i8_sub_blk_not_coded_dist;
|
//i4_tu_coded_dist += i4_sub_blk_coded_dist;
|
//i4_tu_coded_bits += i4_sub_blk_coded_bits;
|
i8_sub_blk_not_coded_dist = 0;
|
i4_sub_blk_not_coded_bits = 0;
|
i8_sub_blk_coded_dist = 0;
|
i4_sub_blk_coded_bits = 0;
|
|
if(i4_sub_blk_is_coded)
|
{
|
ps_rdoq_ctxt->pu1_csbf_buf[pi4_subBlock2csbfId_map[pu1_trans_table[i]]] = 1;
|
temp_zero_col = (temp_zero_col) | (0xF << scaled_blk_col);
|
temp_zero_row = (temp_zero_row) | (0xF << scaled_blk_row);
|
}
|
else
|
{
|
if(!((ps_rdoq_ctxt->i1_tu_is_coded == 1) && (i == 0)))
|
{
|
ps_rdoq_ctxt->pu1_csbf_buf[pi4_subBlock2csbfId_map[pu1_trans_table[i]]] = 0;
|
}
|
}
|
}
|
}
|
|
/*tap texture bits*/
|
{
|
ps_cabac->u4_texture_bits_estimated_q12 +=
|
(ps_cabac->u4_bits_estimated_q12 - temp_tex_bits_q12);
|
}
|
|
i8_tu_not_coded_dist =
|
CALC_CUMMUL_SSD_IN_TRANS_DOMAIN(i8_tu_not_coded_dist, 0, i4_round_val, i4_shift_val);
|
|
/* i4_tu_coded_dist = CALC_CUMMUL_SSD_IN_TRANS_DOMAIN(
|
i4_tu_coded_dist, 0, i4_round_val, i4_shift_val); */
|
*pi8_tu_coded_dist = i8_tu_coded_dist;
|
*pi8_tu_not_coded_dist = i8_tu_not_coded_dist;
|
#if DISABLE_ZCSBF
|
if(i4_skip_zero_cbf == 1)
|
{
|
*pi8_tu_not_coded_dist = 0x7FFFFFFF;
|
}
|
#endif
|
|
*ps_rdoq_ctxt->pi4_zero_col = ~temp_zero_col;
|
*ps_rdoq_ctxt->pi4_zero_row = ~temp_zero_row;
|
|
return (ret);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Codes all the sig coeffs as 0
|
*
|
* @param[in] i
|
* Index of the current csb
|
*
|
* @param[in] pu1_trans_table
|
* Pointer to the trans table
|
*
|
* @param[in] scan_type
|
* Determines the scan order
|
*
|
* @param[in] infer_coeff
|
* Indicates whether the 0,0 coeff can be inferred or not
|
*
|
* @param[in] nbr_csbf
|
* Talks about if the neighboour csbs(right and bottom) are coded or not
|
*
|
* @param[in] ps_cabac
|
* Cabac state
|
*
|
* @param[out] pi4_tu_not_coded_dist
|
* The distortion when the entire TU is not coded(all coeffs are set to 0) is stored here
|
*
|
* @return The number of bits generated when the 0th sub blk is coded as all 0s
|
* This is the cumulate bits(i.e. for all blocks in the TU), and not only
|
* the bits generated for this block
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_code_all_sig_coeffs_as_0_explicitly(
|
void *pv_rdoq_ctxt,
|
WORD32 i,
|
UWORD8 *pu1_trans_table,
|
WORD32 is_luma,
|
WORD32 scan_type,
|
WORD32 infer_coeff,
|
WORD32 nbr_csbf,
|
cab_ctxt_t *ps_cabac)
|
{
|
WORD32 sig_coeff_base_ctxt;
|
WORD32 scan_pos = 15;
|
WORD32 ctxt_idx;
|
WORD32 ret = 0;
|
|
rdoq_sbh_ctxt_t *ps_rdoq_ctxt = (rdoq_sbh_ctxt_t *)pv_rdoq_ctxt;
|
|
WORD32 log2_tr_size = ps_rdoq_ctxt->i4_log2_trans_size;
|
|
(void)pu1_trans_table;
|
if(is_luma)
|
{
|
sig_coeff_base_ctxt = IHEVC_CAB_COEFF_FLAG;
|
if(3 == log2_tr_size)
|
{
|
/* 8x8 transform size */
|
sig_coeff_base_ctxt += (scan_type == SCAN_DIAG_UPRIGHT) ? 9 : 15;
|
}
|
else if(3 < log2_tr_size)
|
{
|
/* larger transform sizes */
|
sig_coeff_base_ctxt += 21;
|
}
|
}
|
else
|
{
|
/* chroma context initializations */
|
sig_coeff_base_ctxt = IHEVC_CAB_COEFF_FLAG + 27;
|
|
if(3 == log2_tr_size)
|
{
|
/* 8x8 transform size */
|
sig_coeff_base_ctxt += 9;
|
}
|
else if(3 < log2_tr_size)
|
{
|
/* larger transform sizes */
|
sig_coeff_base_ctxt += 12;
|
}
|
}
|
while(scan_pos >= 0)
|
{
|
WORD32 sig_ctxinc = 0; /* 0 is default inc for DC coeff */
|
WORD32 sig_coeff = 0;
|
/* derive the x,y pos */
|
WORD32 y_pos_x_pos = gu1_hevce_scan4x4[scan_type][scan_pos];
|
|
/* derive the context inc as per section 9.3.3.1.4 */
|
if(2 == log2_tr_size)
|
{
|
/* 4x4 transform size increment uses lookup */
|
sig_ctxinc = gu1_hevce_sigcoeff_ctxtinc_tr4[y_pos_x_pos];
|
}
|
else if(scan_pos || i)
|
{
|
/* ctxt for AC coeff depends on curpos and neigbour csbf */
|
sig_ctxinc = gu1_hevce_sigcoeff_ctxtinc[nbr_csbf][y_pos_x_pos];
|
|
/* based on luma subblock pos */
|
sig_ctxinc += (i && is_luma) ? 3 : 0;
|
}
|
else
|
{
|
/* DC coeff has fixed context for luma and chroma */
|
sig_coeff_base_ctxt = is_luma ? IHEVC_CAB_COEFF_FLAG : IHEVC_CAB_COEFF_FLAG + 27;
|
}
|
|
if(scan_pos || (!infer_coeff))
|
{
|
ctxt_idx = sig_ctxinc + sig_coeff_base_ctxt;
|
ret |= ihevce_cabac_encode_bin(ps_cabac, sig_coeff, ctxt_idx);
|
AEV_TRACE("significant_coeff_flag", sig_coeff, ps_cabac->u4_range);
|
}
|
scan_pos--;
|
}
|
return (ps_cabac->u4_bits_estimated_q12); // - i4_temp_bits);
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Finds the next csb with a non-zero coeff
|
*
|
* @paramp[in] cur_last_csb_pos
|
* The index of the current csb with a non-zero coeff
|
*
|
* @param[inout] pv_rdoq_ctxt
|
* RODQ context structure
|
*
|
* @param[in] pu1_trans_table
|
* Pointer to the trans table
|
*
|
* @param[in] pi2_coeffs
|
* Pointer to all the quantized coefficients
|
*
|
* @param[in] shift_value
|
* Determines the shifting value for determining appropriate position of coeff
|
*
|
* @param[in] mask_value
|
* Determines the masking value for determining appropriate position of coeff
|
*
|
* @param[in] nbr_csbf
|
* Talks about if the neighboour csbs(right and bottom) are coded or not
|
*
|
* @param[in] ps_cabac
|
* Cabac state
|
*
|
* @param[inout] ppu1_addr
|
* Pointer to the header(i.e. pointer used for traversing the ecd data generated
|
* in ihevce_scan_coeffs)
|
*
|
* @return The index of the csb with the next non-zero coeff
|
*
|
******************************************************************************
|
*/
|
WORD32 ihevce_find_new_last_csb(
|
WORD32 *pi4_subBlock2csbfId_map,
|
WORD32 cur_last_csb_pos,
|
void *pv_rdoq_ctxt,
|
UWORD8 *pu1_trans_table,
|
UWORD8 *pu1_csb_table,
|
WORD16 *pi2_coeffs,
|
WORD32 shift_value,
|
WORD32 mask_value,
|
UWORD8 **ppu1_addr)
|
{
|
WORD32 blk_row;
|
WORD32 blk_col;
|
WORD32 x_pos;
|
WORD32 y_pos;
|
WORD32 i;
|
WORD32 j;
|
UWORD16 *pu2_out_data_coeff;
|
rdoq_sbh_ctxt_t *ps_rdoq_ctxt = (rdoq_sbh_ctxt_t *)pv_rdoq_ctxt;
|
WORD32 trans_size = ps_rdoq_ctxt->i4_trans_size;
|
UWORD8 *pu1_out_data_header = *ppu1_addr;
|
|
for(i = cur_last_csb_pos - 1; i >= 0; i--)
|
{
|
/* check for the first csb flag in our scan order */
|
if(ps_rdoq_ctxt->pu1_csbf_buf[pi4_subBlock2csbfId_map[pu1_trans_table[i]]])
|
{
|
UWORD8 u1_last_x, u1_last_y;
|
WORD32 quant_coeff;
|
|
pu1_out_data_header -= 4; //To move the pointer back to the appropriate position
|
/* row of csb */
|
blk_row = pu1_trans_table[i] >> shift_value;
|
/* col of csb */
|
blk_col = pu1_trans_table[i] & mask_value;
|
|
/*check for the 1st non-0 values inside the csb in our scan order*/
|
for(j = 15; j >= 0; j--)
|
{
|
x_pos = (pu1_csb_table[j] & 0x3) + blk_col * 4;
|
y_pos = (pu1_csb_table[j] >> 2) + blk_row * 4;
|
|
quant_coeff = pi2_coeffs[x_pos + (y_pos * trans_size)];
|
|
if(quant_coeff != 0)
|
break;
|
}
|
|
ASSERT(j >= 0);
|
|
u1_last_x = x_pos;
|
u1_last_y = y_pos;
|
|
/* storing last_x and last_y */
|
*(pu1_out_data_header) = u1_last_x;
|
*(pu1_out_data_header + 1) = u1_last_y;
|
|
/* storing the scan order */
|
*(pu1_out_data_header + 2) = ps_rdoq_ctxt->i4_scan_idx;
|
|
/* storing last_sub_block pos. in scan order count */
|
*(pu1_out_data_header + 3) = i;
|
|
/*stored the first 4 bytes, now all are word16. So word16 pointer*/
|
pu2_out_data_coeff = (UWORD16 *)(pu1_out_data_header + 4);
|
|
*pu2_out_data_coeff = 0xBAD0 | 1; /*since right&bottom csbf is 0*/
|
*ppu1_addr = pu1_out_data_header;
|
|
break; /*We just need this loop for finding 1st non-zero csb only*/
|
}
|
else
|
pu1_out_data_header += 2;
|
}
|
return i;
|
}
|
|
/**
|
******************************************************************************
|
*
|
* @brief Used to optimize the memcpy of cabac states. It copies only those
|
* states in the cabac context which have been altered.
|
*
|
* @paramp[inout] pv_dest
|
* Pointer to desitination cabac state.
|
*
|
* @param[inout] pv_backup_ctxt_dest
|
* Pointer to destination backup context
|
*
|
* @param[inout] pv_backup_ctxt_src
|
* Pointer to source backup context
|
*
|
* @Desc:
|
* We go through each element in the backup_ctxt structure which will tell us
|
* if the states corresponding to lastxlasty, sigcoeffs, grtr_than_1_bins,
|
* grtr_than_2_bins and sub_blk_coded_flag(i.e. 0xBAD0) context elements
|
* have been altered. If they have been altered, we will memcpy the states
|
* corresponding to these context elements alone
|
*
|
* @return Nothing
|
*
|
******************************************************************************
|
*/
|
void ihevce_copy_backup_ctxt(
|
void *pv_dest, void *pv_src, void *pv_backup_ctxt_dest, void *pv_backup_ctxt_src)
|
{
|
UWORD8 *pu1_dest = (UWORD8 *)(((cab_ctxt_t *)pv_dest)->au1_ctxt_models);
|
UWORD8 *pu1_src = (UWORD8 *)(((cab_ctxt_t *)pv_src)->au1_ctxt_models);
|
backup_ctxt_t *ps_backup_dest_ctxt = ((backup_ctxt_t *)pv_backup_ctxt_dest);
|
backup_ctxt_t *ps_backup_src_ctxt = ((backup_ctxt_t *)pv_backup_ctxt_src);
|
WORD32 i4_i;
|
|
/*
|
0 IHEVC_CAB_COEFFX_PREFIX lastx last y has been coded
|
1 IHEVC_CAB_CODED_SUBLK_IDX sub-blk coded or not flag has been coded
|
2 IHEVC_CAB_COEFF_FLAG sigcoeff has been coded
|
3 IHEVC_CAB_COEFABS_GRTR1_FLAG greater than 1 bin has been coded
|
4 IHEVC_CAB_COEFABS_GRTR2_FLAG greater than 2 bin has been coded*/
|
assert(MAX_NUM_CONTEXT_ELEMENTS == 5);
|
for(i4_i = 0; i4_i < MAX_NUM_CONTEXT_ELEMENTS; i4_i++)
|
{
|
if((ps_backup_src_ctxt->au1_ctxt_to_backup[SIG_COEFF]) ||
|
(ps_backup_dest_ctxt->au1_ctxt_to_backup[SIG_COEFF]))
|
{
|
memcpy(&pu1_dest[IHEVC_CAB_COEFF_FLAG], &pu1_src[IHEVC_CAB_COEFF_FLAG], 42);
|
ps_backup_dest_ctxt->au1_ctxt_to_backup[SIG_COEFF] = 0;
|
ps_backup_src_ctxt->au1_ctxt_to_backup[SIG_COEFF] = 0;
|
}
|
if((ps_backup_src_ctxt->au1_ctxt_to_backup[GRTR_THAN_1]) ||
|
(ps_backup_dest_ctxt->au1_ctxt_to_backup[GRTR_THAN_1]))
|
{
|
memcpy(
|
&pu1_dest[IHEVC_CAB_COEFABS_GRTR1_FLAG],
|
&pu1_src[IHEVC_CAB_COEFABS_GRTR1_FLAG],
|
24);
|
ps_backup_dest_ctxt->au1_ctxt_to_backup[GRTR_THAN_1] = 0;
|
ps_backup_src_ctxt->au1_ctxt_to_backup[GRTR_THAN_1] = 0;
|
}
|
if((ps_backup_src_ctxt->au1_ctxt_to_backup[GRTR_THAN_2]) ||
|
(ps_backup_dest_ctxt->au1_ctxt_to_backup[GRTR_THAN_2]))
|
{
|
memcpy(
|
&pu1_dest[IHEVC_CAB_COEFABS_GRTR2_FLAG], &pu1_src[IHEVC_CAB_COEFABS_GRTR2_FLAG], 6);
|
ps_backup_dest_ctxt->au1_ctxt_to_backup[GRTR_THAN_2] = 0;
|
ps_backup_src_ctxt->au1_ctxt_to_backup[GRTR_THAN_2] = 0;
|
}
|
if((ps_backup_src_ctxt->au1_ctxt_to_backup[SUB_BLK_CODED_FLAG]) ||
|
(ps_backup_dest_ctxt->au1_ctxt_to_backup[SUB_BLK_CODED_FLAG]))
|
{
|
memcpy(&pu1_dest[IHEVC_CAB_CODED_SUBLK_IDX], &pu1_src[IHEVC_CAB_CODED_SUBLK_IDX], 4);
|
ps_backup_dest_ctxt->au1_ctxt_to_backup[SUB_BLK_CODED_FLAG] = 0;
|
ps_backup_src_ctxt->au1_ctxt_to_backup[SUB_BLK_CODED_FLAG] = 0;
|
}
|
if((ps_backup_src_ctxt->au1_ctxt_to_backup[LASTXY]) ||
|
(ps_backup_dest_ctxt->au1_ctxt_to_backup[LASTXY]))
|
{
|
memcpy(&pu1_dest[IHEVC_CAB_COEFFX_PREFIX], &pu1_src[IHEVC_CAB_COEFFX_PREFIX], 36);
|
ps_backup_dest_ctxt->au1_ctxt_to_backup[LASTXY] = 0;
|
ps_backup_src_ctxt->au1_ctxt_to_backup[LASTXY] = 0;
|
}
|
}
|
((cab_ctxt_t *)pv_dest)->u4_bits_estimated_q12 = ((cab_ctxt_t *)pv_src)->u4_bits_estimated_q12;
|
}
|
