/******************************************************************************

*

* Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore

*

* 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.

*

******************************************************************************/

/**

*******************************************************************************

* @file

*  ihevcd_parse_residual.c

*

* @brief

*  Contains functions for parsing residual data at TU level

*

* @author

*  Harish

*

* @par List of Functions:

*

* @remarks

*  None

*

*******************************************************************************

*/

/*****************************************************************************/

/* File Includes                                                             */

/*****************************************************************************/

#include <stdio.h>

#include <stddef.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include "ihevc_typedefs.h"

#include "iv.h"

#include "ivd.h"

#include "ihevcd_cxa.h"

#include "ihevc_defs.h"

#include "ihevc_debug.h"

#include "ihevc_structs.h"

#include "ihevc_macros.h"

#include "ihevc_platform_macros.h"

#include "ihevc_common_tables.h"

#include "ihevc_error.h"

#include "ihevc_cabac_tables.h"

#include "ihevcd_trace.h"

#include "ihevcd_defs.h"

#include "ihevcd_function_selector.h"

#include "ihevcd_structs.h"

#include "ihevcd_error.h"

#include "ihevcd_nal.h"

#include "ihevcd_bitstream.h"

#include "ihevcd_utils.h"

#include "ihevcd_parse_residual.h"

#include "ihevcd_cabac.h"

/**

  *****************************************************************************

  * @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 gau1_ihevcd_sigcoeff_ctxtinc[3][4][16] =

{

    {

        /* nbr csbf = 0:  sigCtx = (xP+yP == 0) ? 2 : (xP+yP < 3) ? 1: 0 */

        { 2,    1,    1,    1,    1,    1,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0 },

        /* nbr csbf = 1:  sigCtx = (yP == 0) ? 2 : (yP == 1) ? 1: 0      */

        { 2,    1,    2,    0,    1,    2,    0,    0,    1,    2,    0,    0,    1,    0,    0,    0 },

        /* nbr csbf = 2:  sigCtx = (xP == 0) ? 2 : (xP == 1) ? 1: 0      */

        { 2,    2,    1,    2,    1,    0,    2,    1,    0,    0,    1,    0,    0,    0,    0,    0 },

        /* nbr csbf = 3:  sigCtx = 2                                     */

        { 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,    2,    2,    2,    2,    2,    2 },

    },

    {

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

    },

    {

        /* 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,    1,    0,    0,    2,    1,    0,    0,    2,    1,    0,    0,    2,    1,    0,    0 },

        /* nbr csbf = 2:  sigCtx = (xP == 0) ? 2 : (xP == 1) ? 1: 0      */

        { 2,    2,    2,    2,    1,    1,    1,    1,    0,    0,    0,    0,    0,    0,    0,    0 },

        /* nbr csbf = 3:  sigCtx = 2                                     */

        { 2,    2,    2,    2,    2,    2,    2,    2,    2,    2,    2,    2,    2,    2,    2,    2 },

    },

};

/**

  *****************************************************************************

  * @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 gau1_ihevcd_sigcoeff_ctxtinc_tr4[3][16] =

{

    /* Upright diagonal scan */

    {

        0,    2,    1,    6,

        3,    4,    7,    6,

        4,    5,    7,    8,

        5,    8,    8,    8,

    },

    /* Horizontal scan */

    {

        0,    1,    4,    5,

        2,    3,    4,    5,

        6,    6,    8,    8,

        7,    7,    8,    8,

    },

    /* Vertical scan */

    {

        0,    2,    6,    7,

        1,    3,    6,    7,

        4,    4,    8,    8,

        5,    5,    8,    8,

    },

};

/**

*******************************************************************************

*

* @brief

*  Parses Residual coding

*

* @par Description:

*  Parses Residual coding as per  Section:7.3.13

*

* @param[in] ps_codec

*  Pointer to codec context

*

* @returns  error code from IHEVCD_ERROR_T

*

* @remarks

*

*

*******************************************************************************

*/

WORD32 ihevcd_parse_residual_coding(codec_t *ps_codec,

                                    WORD32 x0, WORD32 y0,

                                    WORD32 log2_trafo_size,

                                    WORD32 c_idx,

                                    WORD32 intra_pred_mode)

{

    IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS;

    WORD32 transform_skip_flag;

#ifdef ENABLE_MAIN_REXT_PROFILE

    WORD32 explicit_rdpcm_flag, explicit_rdpcm_dir;

#endif

    WORD32 value;

    sps_t *ps_sps;

    pps_t *ps_pps;

    WORD32 last_scan_pos, last_sub_blk;

    bitstrm_t *ps_bitstrm = &ps_codec->s_parse.s_bitstrm;

    WORD32 last_significant_coeff_x_prefix, last_significant_coeff_y_prefix;

    WORD32 last_significant_coeff_x, last_significant_coeff_y;

    const UWORD8 *pu1_scan_blk = NULL, *pu1_scan_coeff;

    WORD32 scan_idx;

    WORD32 i;

    WORD32 sign_data_hiding_flag;

    cab_ctxt_t *ps_cabac = &ps_codec->s_parse.s_cabac;

    WORD32 gt1_ctxt = 1;

    WORD32 c_max;

    UWORD16 au2_csbf[9];

    tu_sblk_coeff_data_t *ps_tu_sblk_coeff_data;

    WORD8 *pi1_num_coded_subblks;

    WORD32 num_subblks;

    WORD32 sig_coeff_base_ctxt, abs_gt1_base_ctxt;

    UNUSED(x0);

    UNUSED(y0);

    ps_sps = ps_codec->s_parse.ps_sps;

    ps_pps = ps_codec->s_parse.ps_pps;

    sign_data_hiding_flag = ps_pps->i1_sign_data_hiding_flag;

    transform_skip_flag = 0;

#ifdef ENABLE_MAIN_REXT_PROFILE

    explicit_rdpcm_flag = 0;

    explicit_rdpcm_dir = 0;

#endif

    if(ps_pps->i1_transform_skip_enabled_flag &&

       !ps_codec->s_parse.s_cu.i4_cu_transquant_bypass &&

#ifdef ENABLE_MAIN_REXT_PROFILE

       (log2_trafo_size <= ps_pps->i1_log2_max_transform_skip_block_size_minus2 + 2)

#else

       (log2_trafo_size == 2)

#endif

       )

    {

        WORD32 ctxt_idx;

        if(!c_idx)

        {

            ctxt_idx = IHEVC_CAB_TFM_SKIP0;

        }

        else

        {

            ctxt_idx = IHEVC_CAB_TFM_SKIP12;

        }

        TRACE_CABAC_CTXT("transform_skip_flag", ps_cabac->u4_range, ctxt_idx);

        value = ihevcd_cabac_decode_bin(ps_cabac,

                                        ps_bitstrm,

                                        ctxt_idx);

        AEV_TRACE("transform_skip_flag", value, ps_cabac->u4_range);

        transform_skip_flag = value;

    }

#ifdef ENABLE_MAIN_REXT_PROFILE

    if(PRED_MODE_INTER == ps_codec->s_parse.s_cu.i4_pred_mode

                    && ps_sps->i1_explicit_rdpcm_enabled_flag

                    && (transform_skip_flag || ps_codec->s_parse.s_cu.i4_cu_transquant_bypass))

    {

        WORD32 ctxt_idx = IHEVC_CAB_EXPLICIT_RDPCM_FLAG + (c_idx != 0);

        TRACE_CABAC_CTXT("explicit_rdpcm_flag", ps_cabac->u4_range, ctxt_idx);

        value = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

        AEV_TRACE("explicit_rdpcm_flag", value, ps_cabac->u4_range);

        explicit_rdpcm_flag = value;

        if(explicit_rdpcm_flag)

        {

            ctxt_idx = IHEVC_CAB_EXPLICIT_RDPCM_DIR + (c_idx != 0);

            TRACE_CABAC_CTXT("explicit_rdpcm_dir_flag", ps_cabac->u4_range, ctxt_idx);

            value = ihevcd_cabac_decode_bin(ps_cabac, ps_bitstrm, ctxt_idx);

            AEV_TRACE("explicit_rdpcm_dir_flag", value, ps_cabac->u4_range);

            explicit_rdpcm_dir = value;

        }

    }

#endif

    /* code the last_coeff_x_prefix as tunary binarized code */

    {

        WORD32 ctxt_idx_x, ctxt_idx_y, ctx_shift;

        WORD32 ctx_offset;

        c_max = (log2_trafo_size << 1) - 1;

        if(!c_idx)

        {

            ctx_offset = (3 * (log2_trafo_size - 2)) + ((log2_trafo_size - 1) >> 2);

            ctxt_idx_x = IHEVC_CAB_COEFFX_PREFIX + ctx_offset;

            ctxt_idx_y = IHEVC_CAB_COEFFY_PREFIX + ctx_offset;

            ctx_shift  = (log2_trafo_size + 1) >> 2;

        }

        else

        {

            ctxt_idx_x = IHEVC_CAB_COEFFX_PREFIX + 15;

            ctxt_idx_y = IHEVC_CAB_COEFFY_PREFIX + 15;

            ctx_shift  = log2_trafo_size  - 2;

        }

        TRACE_CABAC_CTXT("last_coeff_x_prefix", ps_cabac->u4_range, ctxt_idx_x);

        last_significant_coeff_x_prefix = ihevcd_cabac_decode_bins_tunary(ps_cabac,

                                                                          ps_bitstrm,

                                                                          c_max,

                                                                          ctxt_idx_x,

                                                                          ctx_shift,

                                                                          c_max);

        AEV_TRACE("last_coeff_x_prefix", last_significant_coeff_x_prefix, ps_cabac->u4_range);

        TRACE_CABAC_CTXT("last_coeff_y_prefix", ps_cabac->u4_range, ctxt_idx_y);

        last_significant_coeff_y_prefix = ihevcd_cabac_decode_bins_tunary(ps_cabac,

                                                                          ps_bitstrm,

                                                                          c_max,

                                                                          ctxt_idx_y,

                                                                          ctx_shift,

                                                                          c_max);

        AEV_TRACE("last_coeff_y_prefix", last_significant_coeff_y_prefix, ps_cabac->u4_range);

        last_significant_coeff_x = last_significant_coeff_x_prefix;

        if(last_significant_coeff_x_prefix > 3)

        {

            WORD32 suf_length = ((last_significant_coeff_x_prefix - 2) >> 1);

            value = ihevcd_cabac_decode_bypass_bins(ps_cabac,

                                                    ps_bitstrm,

                                                    suf_length);

            AEV_TRACE("last_coeff_x_suffix", value, ps_cabac->u4_range);

            last_significant_coeff_x =

                            (1 << ((last_significant_coeff_x_prefix >> 1) - 1)) *

                            (2 + (last_significant_coeff_x_prefix & 1)) + value;

        }

        last_significant_coeff_y = last_significant_coeff_y_prefix;

        if(last_significant_coeff_y_prefix > 3)

        {

            WORD32 suf_length = ((last_significant_coeff_y_prefix - 2) >> 1);

            value = ihevcd_cabac_decode_bypass_bins(ps_cabac,

                                                    ps_bitstrm,

                                                    suf_length);

            AEV_TRACE("last_coeff_y_suffix", value, ps_cabac->u4_range);

            last_significant_coeff_y =

                            (1 << ((last_significant_coeff_y_prefix >> 1) - 1)) *

                            (2 + (last_significant_coeff_y_prefix & 1)) + value;

        }

    }

    /* Choose a scan matrix based on intra flag, intra pred mode, transform size

     and luma/chroma */

    scan_idx = SCAN_DIAG_UPRIGHT;

    if(PRED_MODE_INTRA == ps_codec->s_parse.s_cu.i4_pred_mode)

    {

        int is_YUV444 = ps_sps->i1_chroma_format_idc == CHROMA_FMT_IDC_YUV444;

        if((2 == log2_trafo_size) || ((3 == log2_trafo_size) && (0 == c_idx || is_YUV444)))

        {

            if((6 <= intra_pred_mode) &&

               (14 >= intra_pred_mode))

            {

                scan_idx = SCAN_VERT;

            }

            else if((22 <= intra_pred_mode) &&

                    (30 >= intra_pred_mode))

            {

                scan_idx = SCAN_HORZ;

            }

        }

    }

    /* In case the scan is vertical, then swap  X and Y positions */

    if(SCAN_VERT == scan_idx)

    {

        SWAP(last_significant_coeff_x, last_significant_coeff_y);

    }

    {

        WORD8 *pi1_scan_idx;

        WORD8 *pi1_buf = (WORD8 *)ps_codec->s_parse.pv_tu_coeff_data;

        /* First WORD8 gives number of coded subblocks */

        pi1_num_coded_subblks = pi1_buf++;

        /* Set number of coded subblocks in the current TU to zero */

        /* This will be updated later */

        *pi1_num_coded_subblks = 0;

        pi1_scan_idx = pi1_buf++;

#ifdef ENABLE_MAIN_REXT_PROFILE

        /* Second WORD8 gives (explicit_rdpcm_dir << 5) | (explicit_rdpcm_flag << 4) | (scan idx << 1) | trans_skip */

        *pi1_scan_idx = (explicit_rdpcm_dir << 5) | (explicit_rdpcm_flag << 4) | (scan_idx << 1)

                        | transform_skip_flag;

#else

        /* Second WORD8 gives (scan idx << 1) | trans_skip */

        *pi1_scan_idx = (scan_idx << 1) | transform_skip_flag;

#endif

        /* Store the incremented pointer in pv_tu_coeff_data */

        ps_codec->s_parse.pv_tu_coeff_data = pi1_buf;

    }

    /**

     * Given last_significant_coeff_y and last_significant_coeff_x find last sub block

     * This is done by ignoring lower two bits of last_significant_coeff_y and last_significant_coeff_x

     * and using scan matrix for lookup

     */

    /* If transform is 4x4, last_sub_blk is zero */

    last_sub_blk = 0;

    /* If transform is larger than 4x4, then based on scan_idx and transform size, choose a scan table */

    if(log2_trafo_size > 2)

    {

        WORD32 scan_pos;

        WORD32 scan_mat_size;

        pu1_scan_blk = (UWORD8 *)gapv_ihevc_scan[scan_idx * 3 + (log2_trafo_size - 2 - 1)];

        /* Divide the current transform to 4x4 subblocks and count number of 4x4 in the first row */

        /* This will be size of scan matrix to be used for subblock scanning */

        scan_mat_size = 1 << (log2_trafo_size - 2);

        scan_pos = ((last_significant_coeff_y >> 2) * scan_mat_size) +

                        (last_significant_coeff_x >> 2);

        last_sub_blk = pu1_scan_blk[scan_pos];

    }

    pu1_scan_coeff  = &gau1_ihevc_scan4x4[scan_idx][0];

    {

        WORD32 scan_pos;

        scan_pos = ((last_significant_coeff_y & 3) << 2) +

                        (last_significant_coeff_x & 3);

        last_scan_pos = pu1_scan_coeff[scan_pos];

    }

    if(log2_trafo_size > 2)

        pu1_scan_blk = (UWORD8 *)gapv_ihevc_invscan[scan_idx * 3 + (log2_trafo_size - 2 - 1)];

    pu1_scan_coeff  = &gau1_ihevc_invscan4x4[scan_idx][0];

    /* Set CSBF array to zero */

    {

        UWORD32 *pu4_csbf;

        pu4_csbf = (void *)au2_csbf;

        *pu4_csbf++ = 0;

        *pu4_csbf++ = 0;

        *pu4_csbf++ = 0;

        *pu4_csbf = 0;

        /* To avoid a check for y pos, 9th WORD16 in the array is set to zero */

        au2_csbf[8] = 0;

    }

    /*************************************************************************/

    /* 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(!c_idx)

    {

        sig_coeff_base_ctxt = IHEVC_CAB_COEFF_FLAG;

        abs_gt1_base_ctxt = IHEVC_CAB_COEFABS_GRTR1_FLAG;

        if(3 == log2_trafo_size)

        {

            /* 8x8 transform size */

            sig_coeff_base_ctxt += (scan_idx == SCAN_DIAG_UPRIGHT) ? 9 : 15;

        }

        else  if(3 < log2_trafo_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_trafo_size)

        {

            /* 8x8 transform size */

            sig_coeff_base_ctxt += 9;

        }

        else  if(3 < log2_trafo_size)

        {

            /* larger transform sizes */

            sig_coeff_base_ctxt += 12;

        }

    }

    num_subblks = 0;

    /* Parse each 4x4 subblocks */

    for(i = last_sub_blk; i >= 0; i--)

    {

        WORD32 sub_blk_pos;

        WORD32 infer_sig_coeff_flag;

        WORD32 cur_csbf;

        WORD32 n;

        WORD32 num_coeff;

        /* Sig coeff map for 16 entries in raster scan order. Upper 16 bits are used.

         * MSB gives sig coeff flag for 0th coeff and so on

         * UWORD16 would have been enough but kept as UWORD32 for code optimizations

         * In arm unnecessary masking operations are saved

         */

        UWORD32 u4_sig_coeff_map_raster;

        WORD32 sign_hidden;

        /* Sig coeff map in scan order */

        UWORD32 u4_sig_coeff_map;

        WORD32 coeff_abs_level_greater2_flag;

        UWORD32 u4_coeff_abs_level_greater1_map;

        UWORD32 u4_coeff_abs_level_greater2_map;

        UWORD32 u4_coeff_sign_map;

        WORD32 first_sig_scan_pos, last_sig_scan_pos, num_greater1_flag, first_greater1_scan_pos;

        WORD32  num_sig_coeff, sum_abs_level;

        WORD32 nbr_csbf;

        WORD32 ctxt_set;

        WORD32 rice_param;

        WORD32 xs, ys;

#ifdef ENABLE_MAIN_REXT_PROFILE

        WORD8 i1_update_stats = ps_sps->i1_persistent_rice_adaptation_enabled_flag;

#endif

        sub_blk_pos  = 0;

        if(i && (log2_trafo_size > 2))

            sub_blk_pos = pu1_scan_blk[i];

        /* Get xs and ys from scan position */

        /* This is needed for context modelling of significant coeff flag */

        xs = sub_blk_pos & ((1 << (log2_trafo_size - 2)) - 1);

        ys = sub_blk_pos >> (log2_trafo_size - 2);

        /* Check if neighbor subblocks are coded */

        {

            nbr_csbf = 0;

            /* Get Bottom sub blocks CSBF */

            nbr_csbf |= (au2_csbf[ys + 1] >> xs) & 1;

            nbr_csbf <<= 1;

            /* Get Right sub blocks CSBF */

            /* Even if xs is equal to (1 << (log2_trafo_size - 2 )) - 1,

               since au2_csbf is set to zero at the beginning, csbf for

               neighbor will be read as 0 */

            nbr_csbf |= (au2_csbf[ys] >> (xs + 1)) & 1;

        }

        cur_csbf = 0;

        /* DC coeff is inferred, only if coded_sub_block is explicitly parsed as 1 */

        /* i.e. it is not inferred for first and last subblock */

        infer_sig_coeff_flag = 0;

        if((i < last_sub_blk) && (i > 0))

        {

            WORD32 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 based on luma or chroma */

            ctxt_idx += c_idx  ? 2 : 0;

            TRACE_CABAC_CTXT("coded_sub_block_flag", ps_cabac->u4_range, ctxt_idx);

            IHEVCD_CABAC_DECODE_BIN(cur_csbf, ps_cabac, ps_bitstrm, ctxt_idx);

            AEV_TRACE("coded_sub_block_flag", cur_csbf, ps_cabac->u4_range);

            infer_sig_coeff_flag = 1;

        }

        else /* if((i == last_sub_blk) || (sub_blk_pos == 0)) */

        {

            /* CSBF is set to 1 for first and last subblock */

            /* Note for these subblocks sig_coeff_map is not inferred but instead parsed */

            cur_csbf = 1;

        }

        /* Set current sub blocks CSBF */

        {

            UWORD32 u4_mask = 1 << xs;

            if(cur_csbf)

                au2_csbf[ys] |= u4_mask;

            else

                au2_csbf[ys] &= ~u4_mask;

        }

        /* If current subblock is not coded, proceed to the next subblock */

        if(0 == cur_csbf)

            continue;

        n = 15;

        u4_sig_coeff_map_raster = 0;

        u4_sig_coeff_map = 0;

        num_coeff = 0;

        if(i == last_sub_blk)

        {

            WORD32 pos = ((last_significant_coeff_y & 3) << 2) +

                            (last_significant_coeff_x & 3);

            n = (last_scan_pos - 1);

            /* Set Significant coeff map for last significant coeff flag as 1 */

            u4_sig_coeff_map_raster = 1 << pos;

            u4_sig_coeff_map = 1 << last_scan_pos;

            num_coeff = 1;

        }

        for(; n >= 0; n--)

        {

            WORD32 significant_coeff_flag;

            if((n > 0 || !infer_sig_coeff_flag))

            {

                //WORD32 coeff_pos;

                WORD32 sig_ctxinc;

                WORD32 ctxt_idx;

                /* Coefficient position is needed for deriving context index for significant_coeff_flag */

                //coeff_pos = pu1_scan_coeff[n];

                /* derive the context inc as per section 9.3.3.1.4 */

                sig_ctxinc = 0;

#ifdef ENABLE_MAIN_REXT_PROFILE

                if(ps_sps->i1_transform_skip_context_enabled_flag

                                && (ps_codec->s_parse.s_cu.i4_cu_transquant_bypass

                                                || transform_skip_flag))

                {

                    sig_coeff_base_ctxt = IHEVC_CAB_COEFF_FLAG;

                    sig_coeff_base_ctxt += (0 == c_idx) ? 42 : 43;

                }

                else if(2 == log2_trafo_size)

#else

                if(2 == log2_trafo_size)

#endif

                {

                    /* 4x4 transform size increment uses lookup */

                    sig_ctxinc = gau1_ihevcd_sigcoeff_ctxtinc_tr4[scan_idx][n];

                }

                else if(n || i)

                {

                    /* ctxt for AC coeff depends on curpos and neigbour csbf */

                    sig_ctxinc = gau1_ihevcd_sigcoeff_ctxtinc[scan_idx][nbr_csbf][n];

                    /* based on luma subblock pos */

                    sig_ctxinc += (i && (!c_idx)) ? 3 : 0;

                }

                else

                {

                    /* DC coeff has fixed context for luma and chroma */

                    sig_coeff_base_ctxt = (0 == c_idx) ? IHEVC_CAB_COEFF_FLAG :

                                                         (IHEVC_CAB_COEFF_FLAG + 27);

                }

                ctxt_idx = sig_ctxinc + sig_coeff_base_ctxt;

                TRACE_CABAC_CTXT("significant_coeff_flag", ps_cabac->u4_range, ctxt_idx);

                IHEVCD_CABAC_DECODE_BIN(significant_coeff_flag, ps_cabac,

                                        ps_bitstrm,

                                        ctxt_idx);

                AEV_TRACE("significant_coeff_flag", significant_coeff_flag, ps_cabac->u4_range);

                /* If at least one non-zero coeff is signalled then do not infer sig coeff map */

                /* for (0,0) coeff in the current sub block */

                if(significant_coeff_flag)

                    infer_sig_coeff_flag = 0;

//                u4_sig_coeff_map_raster |= significant_coeff_flag

//                              << coeff_pos;

                u4_sig_coeff_map |= significant_coeff_flag << n;

                num_coeff += significant_coeff_flag;

            }

        }

        /*********************************************************************/

        /* If infer_sig_coeff_flag is 1 then treat the 0th coeff as non zero */

        /* If infer_sig_coeff_flag is zero, then last significant_coeff_flag */

        /* is parsed in the above loop                                       */

        /*********************************************************************/

        if(infer_sig_coeff_flag)

        {

            u4_sig_coeff_map_raster |= 1;

            u4_sig_coeff_map |= 1;

            num_coeff++;

        }

        /*********************************************************************/

        /* First subblock does not get an explicit csbf. It is assumed to    */

        /* be 1. For this subblock there is chance of getting all            */

        /* sig_coeff_flags to be zero. In such a case proceed to the next    */

        /* subblock(which is end of parsing for the current transform block) */

        /*********************************************************************/

        if(0 == num_coeff)

            continue;

        /* Increment number of coded subblocks for the current TU */

        num_subblks++;

        /* Set sig coeff map and subblock position */

        ps_tu_sblk_coeff_data = (tu_sblk_coeff_data_t *)ps_codec->s_parse.pv_tu_coeff_data;

        ps_tu_sblk_coeff_data->u2_sig_coeff_map = u4_sig_coeff_map;

        ps_tu_sblk_coeff_data->u2_subblk_pos = (ys << 8) | xs;

        first_sig_scan_pos = 16;

        last_sig_scan_pos = -1;

        num_greater1_flag = 0;

        first_greater1_scan_pos = -1;

        u4_coeff_abs_level_greater1_map = 0;

        /* context set based on luma subblock pos */

        ctxt_set = (i && (!c_idx)) ? 2 : 0;

        /* See section 9.3.3.1.5           */

        ctxt_set += (0 == gt1_ctxt) ? 1 : 0;

        gt1_ctxt = 1;

        /* Instead of initializing n to 15, set it to 31-CLZ(sig coeff map) */

        {

            UWORD32 u4_sig_coeff_map_shift;

            UWORD32 clz;

            clz = CLZ(u4_sig_coeff_map);

            n = 31 - clz;

            u4_sig_coeff_map_shift = u4_sig_coeff_map << clz;

            /* For loop for n changed to do while to break early if sig_coeff_map_shift becomes zero */

            do

            {

                //WORD32 coeff_pos;

                WORD32 ctxt_idx;

                //TODO: Scan lookup will be removed later and instead u4_sig_coeff_map will be used

                //coeff_pos = pu1_scan_coeff[n];

                if((u4_sig_coeff_map_shift >> 31) & 1)

                {

                    /* abs_level_greater1_flag is sent for only first 8 non-zero levels in a subblock */

                    if(num_greater1_flag < 8)

                    {

                        WORD32 coeff_abs_level_greater1_flag;

                        ctxt_idx = (ctxt_set * 4) + abs_gt1_base_ctxt + gt1_ctxt;

                        TRACE_CABAC_CTXT("coeff_abs_level_greater1_flag", ps_cabac->u4_range, ctxt_idx);

                        IHEVCD_CABAC_DECODE_BIN(coeff_abs_level_greater1_flag, ps_cabac, ps_bitstrm, ctxt_idx);

                        AEV_TRACE("coeff_abs_level_greater1_flag", coeff_abs_level_greater1_flag, ps_cabac->u4_range);

                        u4_coeff_abs_level_greater1_map |= coeff_abs_level_greater1_flag << n;

                        num_greater1_flag++;

                        /* first_greater1_scan_pos is obtained using CLZ on u4_coeff_abs_level_greater1_map*/

                        /*  outside the loop instead of the following check inside the loop                */

                        /* if( coeff_abs_level_greater1_flag && first_greater1_scan_pos == -1) */

                        /*    first_greater1_scan_pos = n;                                     */

                        if(coeff_abs_level_greater1_flag)

                        {

                            gt1_ctxt = 0;

                        }

                        else if(gt1_ctxt && (gt1_ctxt < 3))

                        {

                            gt1_ctxt++;

                        }

                    }

                    else

                        break;

                    /* instead of computing last and first significan scan position using checks below */

                    /* They are computed outside the loop using CLZ and CTZ on sig_coeff_map */

                    /* if(last_sig_scan_pos == -1)                          */

                    /*    last_sig_scan_pos = n;                            */

                    /*  first_sig_scan_pos = n;                             */

                }

                u4_sig_coeff_map_shift <<= 1;

                n--;

                /* If there are zero coeffs, then shift by as many zero coeffs and decrement n */

                clz = CLZ(u4_sig_coeff_map_shift);

                u4_sig_coeff_map_shift <<= clz;

                n -= (WORD32)clz;

            }while(u4_sig_coeff_map_shift);

        }

        /* At this level u4_sig_coeff_map is non-zero i.e. has atleast one non-zero coeff */

        last_sig_scan_pos = (31 - CLZ(u4_sig_coeff_map));

        first_sig_scan_pos = CTZ(u4_sig_coeff_map);

        if(ps_codec->s_parse.s_cu.i4_cu_transquant_bypass

#ifdef ENABLE_MAIN_REXT_PROFILE

                        || explicit_rdpcm_flag

#endif

                        || (PRED_MODE_INTRA == ps_codec->s_parse.s_cu.i4_pred_mode

#ifdef ENABLE_MAIN_REXT_PROFILE

                                        && ps_sps->i1_implicit_rdpcm_enabled_flag

#else

                                        && 0

#endif

                                        && transform_skip_flag

                                        && (intra_pred_mode == 10 || intra_pred_mode == 26)))

        {

            sign_hidden = 0;

        }

        else

        {

            sign_hidden = ((last_sig_scan_pos - first_sig_scan_pos) > 3);

        }

        u4_coeff_abs_level_greater2_map = 0;

        if(u4_coeff_abs_level_greater1_map)

        {

            /* Check if the first level > 1 is greater than 2 */

            WORD32 ctxt_idx;

            first_greater1_scan_pos = (31 - CLZ(u4_coeff_abs_level_greater1_map));

            ctxt_idx = IHEVC_CAB_COEFABS_GRTR2_FLAG;

            ctxt_idx += (!c_idx) ? ctxt_set : (ctxt_set + 4);

            TRACE_CABAC_CTXT("coeff_abs_level_greater2_flag", ps_cabac->u4_range, ctxt_idx);

            IHEVCD_CABAC_DECODE_BIN(coeff_abs_level_greater2_flag, ps_cabac, ps_bitstrm, ctxt_idx);

            AEV_TRACE("coeff_abs_level_greater2_flag", coeff_abs_level_greater2_flag, ps_cabac->u4_range);

            u4_coeff_abs_level_greater2_map = coeff_abs_level_greater2_flag << first_greater1_scan_pos;

        }

        u4_coeff_sign_map = 0;

        /* Parse sign flags */

        if(!sign_data_hiding_flag || !sign_hidden)

        {

            IHEVCD_CABAC_DECODE_BYPASS_BINS(value, ps_cabac, ps_bitstrm, num_coeff);

            AEV_TRACE("sign_flags", value, ps_cabac->u4_range);

            u4_coeff_sign_map = (UWORD32)value << (32 - num_coeff);

        }

        else

        {

            IHEVCD_CABAC_DECODE_BYPASS_BINS(value, ps_cabac, ps_bitstrm, (num_coeff - 1));

            AEV_TRACE("sign_flags", value, ps_cabac->u4_range);

            u4_coeff_sign_map = (UWORD32)value << (32 - (num_coeff - 1));

        }

        num_sig_coeff = 0;

        sum_abs_level = 0;

#ifdef ENABLE_MAIN_REXT_PROFILE

        WORD32 sb_type = 2 * (c_idx == 0 ? 1 : 0);

        if(ps_sps->i1_persistent_rice_adaptation_enabled_flag)

        {

            if(!(transform_skip_flag == 0 && ps_codec->s_parse.s_cu.i4_cu_transquant_bypass == 0))

            {

                sb_type += 1;

            }

            rice_param = ps_cabac->ai4_rice_stat_coeff[sb_type] / 4;

        }

        else

#endif

        {

            rice_param = 0;

        }

        {

            UWORD32 clz;

            UWORD32 u4_sig_coeff_map_shift;

            clz = CLZ(u4_sig_coeff_map);

            n = 31 - clz;

            u4_sig_coeff_map_shift = u4_sig_coeff_map << clz;

            /* For loop for n changed to do while to break early if sig_coeff_map_shift becomes zero */

            do

            {

                if((u4_sig_coeff_map_shift >> 31) & 1)

                {

                    WORD32 base_lvl;

                    WORD32 coeff_abs_level_remaining;

                    WORD32 level;

                    base_lvl = 1;

                    /* Update base_lvl if it is greater than 1 */

                    if((u4_coeff_abs_level_greater1_map >> n) & 1)

                        base_lvl++;

                    /* Update base_lvl if it is greater than 2 */

                    if((u4_coeff_abs_level_greater2_map >> n) & 1)

                        base_lvl++;

                    /* If level is greater than 3/2/1 based on the greater1 and greater2 maps,

                     * decode remaining level (level - base_lvl) will be signalled as bypass bins

                     */

                    coeff_abs_level_remaining = 0;

                    if(base_lvl == ((num_sig_coeff < 8) ? ((n == first_greater1_scan_pos) ? 3 : 2) : 1))

                    {

                        UWORD32 u4_prefix;

                        WORD32 bin;

                        u4_prefix = 0;

                        do

                        {

                            IHEVCD_CABAC_DECODE_BYPASS_BIN(bin, ps_cabac, ps_bitstrm);

                            u4_prefix++;

                            if((WORD32)u4_prefix == 19 - rice_param)

                            {

                                bin = 1;

                                break;

                            }

                        }while(bin);

                        u4_prefix = u4_prefix - 1;

                        if(u4_prefix < 3)

                        {

                            UWORD32 u4_suffix;

                            coeff_abs_level_remaining = (u4_prefix << rice_param);

                            if(rice_param)

                            {

                                IHEVCD_CABAC_DECODE_BYPASS_BINS(u4_suffix, ps_cabac, ps_bitstrm, rice_param);

                                coeff_abs_level_remaining |= u4_suffix;

                            }

                        }

                        else

                        {

                            UWORD32 u4_suffix;

                            UWORD32 u4_numbins;

                            //u4_prefix = CLIP3(u4_prefix, 0, 19 - rice_param);