/src/libhevc/decoder/ihevcd_parse_residual.c

Source
/******************************************************************************
*
* 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);

                            u4_numbins = (u4_prefix - 3 + rice_param);
                            coeff_abs_level_remaining = (((1 << (u4_prefix - 3)) + 3 - 1) << rice_param);
                            if(u4_numbins)
                            {
                                IHEVCD_CABAC_DECODE_BYPASS_BINS(u4_suffix, ps_cabac, ps_bitstrm, u4_numbins);
                                coeff_abs_level_remaining += u4_suffix;
                            }
                        }


                        AEV_TRACE("coeff_abs_level_remaining", coeff_abs_level_remaining, ps_cabac->u4_range);
                        base_lvl += coeff_abs_level_remaining;

#ifdef ENABLE_MAIN_REXT_PROFILE
                        if(i1_update_stats)
                        {
                            if(coeff_abs_level_remaining
                                            >= (3 << (ps_cabac->ai4_rice_stat_coeff[sb_type] / 4)))
                            {
                                ps_cabac->ai4_rice_stat_coeff[sb_type]++;
                            }
                            else if((2 * coeff_abs_level_remaining
                                            < (1 << (ps_cabac->ai4_rice_stat_coeff[sb_type] / 4)))
                                            && ps_cabac->ai4_rice_stat_coeff[sb_type] > 0)
                            {
                                ps_cabac->ai4_rice_stat_coeff[sb_type]--;
                            }
                            i1_update_stats = 0;
                        }
#endif
                    }

                    /* update the rice param based on coeff level */
                    if(base_lvl > (3 << rice_param))
                    {
#ifdef ENABLE_MAIN_REXT_PROFILE
                        if(ps_sps->i1_persistent_rice_adaptation_enabled_flag)
                        {
                            rice_param += 1;
                        }
                        else
#endif
                        {
                            rice_param = MIN((rice_param + 1), 4);
                        }
                    }

                    /* Compute absolute level */
                    level = base_lvl;

                    /* Update level with the sign */
                    if((u4_coeff_sign_map >> 31) & 1)
                        level = -level;

                    u4_coeff_sign_map <<= 1;
                    /* Update sign in case sign is hidden */
                    if(sign_data_hiding_flag && sign_hidden)
                    {
                        sum_abs_level += base_lvl;

                        if(n == first_sig_scan_pos && ((sum_abs_level % 2) == 1))
                            level = -level;
                    }

                    /* Store the resulting level in non-zero level array */
                    ps_tu_sblk_coeff_data->ai2_level[num_sig_coeff++] = level;
                    //AEV_TRACE("level", level, 0);
                }
                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);
        }

        /* Increment the pv_tu_sblk_coeff_data */
        {
            UWORD8 *pu1_buf = (UWORD8 *)ps_codec->s_parse.pv_tu_coeff_data;
            pu1_buf += sizeof(tu_sblk_coeff_data_t) - SUBBLK_COEFF_CNT * sizeof(WORD16);
            pu1_buf += num_coeff * sizeof(WORD16);
            ps_codec->s_parse.pv_tu_coeff_data = pu1_buf;

        }

    }
    /* Set number of coded sub blocks in the current TU */
    *pi1_num_coded_subblks = num_subblks;

    return ret;
}

Coverage Report

Created: 2026-10-28 06:26