xref: /aosp_15_r20/external/libhevc/encoder/ihevce_cabac_tu.c (revision c83a76b084498d55f252f48b2e3786804cdf24b7)

/******************************************************************************
 *
 * 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;
}