/******************************************************************************
*
* 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;
WORD32 value;
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_pps = ps_codec->s_parse.ps_pps;
sign_data_hiding_flag = ps_pps->i1_sign_data_hiding_flag;
transform_skip_flag = 0;
if(ps_pps->i1_transform_skip_enabled_flag &&
!ps_codec->s_parse.s_cu.i4_cu_transquant_bypass &&
(log2_trafo_size == 2))
{
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;
}
/* 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)
{
if((2 == log2_trafo_size) || ((3 == log2_trafo_size) && (0 == c_idx)))
{
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;
/* Second WORD8 gives (scan idx << 1) | trans_skip */
pi1_scan_idx = pi1_buf++;
*pi1_scan_idx = (scan_idx << 1) | transform_skip_flag;
/* 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;
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;
if(2 == log2_trafo_size)
{
/* 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);
sign_hidden = (((last_sig_scan_pos - first_sig_scan_pos) > 3) && !ps_codec->s_parse.s_cu.i4_cu_transquant_bypass);
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 = 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 = value << (32 - (num_coeff - 1));
}
num_sig_coeff = 0;
sum_abs_level = 0;
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;
}
/* update the rice param based on coeff level */
if((base_lvl > (3 << rice_param)) && (rice_param < 4))
{
rice_param++;
}
/* 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;
}