/******************************************************************************
*
* 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_cabac.c
*
* @brief
* This file contains function definitions related to CABAC parsing
*
* @author
* Ittiam
*
*
* List of Functions
*
* ihevcd_cabac_init()
* ihevcd_cabac_decode_bin()
* ihevcd_cabac_decode_bypass_bin()
* ihevcd_cabac_decode_bypass_bins_tunary()
* ihevcd_cabac_decode_terminate()
* ihevcd_cabac_decode_bin_tunary()
* ihevcd_cabac_decode_bypass_bins()
* ihevcd_cabac_decode_bypass_bins_egk()
* ihevcd_cabac_decode_trunc_rice()
* ihevcd_cabac_flush()
*
******************************************************************************
*/
/*****************************************************************************/
/* File Includes */
/*****************************************************************************/
#include <stdio.h>
#include <stddef.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include "ihevc_typedefs.h"
#include "iv.h"
#include "ivd.h"
#include "ihevcd_cxa.h"
#include "ihevc_debug.h"
#include "ihevc_macros.h"
#include "ihevc_platform_macros.h"
#include "ihevc_cabac_tables.h"
#include "ihevc_defs.h"
#include "ihevc_structs.h"
#include "ihevc_cabac_tables.h"
#include "ihevcd_defs.h"
#include "ihevcd_function_selector.h"
#include "ihevcd_structs.h"
#include "ihevcd_error.h"
#include "ihevcd_bitstream.h"
#include "ihevcd_cabac.h"
#include "ihevcd_trace.h"
#ifdef TRACE
extern trace_t g_trace;
#endif
#if DEBUG_CABAC_RANGE_OFST
#if FULLRANGE
#define DEBUG_RANGE_OFST(str, m_range, m_ofst ) \
{\
UWORD32 m_clz, m_range_shift, m_ofst_shift; \
m_clz = CLZ(m_range); \
m_clz -= (32 - RANGE_NUMBITS); \
m_range_shift = m_range << m_clz; \
m_range_shift = m_range_shift >> RANGE_SHIFT; \
m_ofst_shift = m_ofst << m_clz; \
m_ofst_shift = m_ofst_shift >> RANGE_SHIFT; \
fprintf( g_trace.fp, "%-40s R: %3d O: %3d\n", str, m_range_shift, m_ofst_shift); \
}
#else
#define DEBUG_RANGE_OFST(str, m_range, m_ofst) \
fprintf( g_trace.fp, "%-40s R: %3d O: %3d\n", str, m_range, m_ofst);
#endif
#else
#define DEBUG_RANGE_OFST(str, m_range, m_ofst )
#endif
/*****************************************************************************/
/* Function Definitions */
/*****************************************************************************/
/**
******************************************************************************
*
* @brief Initializes the decoder cabac engine
*
* @par Description
* This routine needs to be called at start of slice/frame decode
*
* @param[in,out] ps_cabac_ctxt
* pointer to cabac context (handle)
*
* @param[in] ps_bitstrm
* pointer to bitstream context (handle)
*
* @param[in] qp
* current slice Qp
*
* @param[in] cabac_init_idc
* current slice init idc (range [0 - 2])
*
* @param[in] pu1_init_ctxt
* Init cabac context to be used (range [0 - 2])
*
* @return success or failure error code
*
******************************************************************************
*/
IHEVCD_ERROR_T ihevcd_cabac_init(cab_ctxt_t *ps_cabac,
bitstrm_t *ps_bitstrm,
WORD32 qp,
WORD32 cabac_init_idc,
const UWORD8 *pu1_init_ctxt)
{
/* Sanity checks */
ASSERT(ps_cabac != NULL);
ASSERT(ps_bitstrm != NULL);
ASSERT((qp >= 0) && (qp < 52));
ASSERT((cabac_init_idc >= 0) && (cabac_init_idc < 3));
UNUSED(qp);
UNUSED(cabac_init_idc);
/* CABAC engine uses 32 bit range instead of 9 bits as specified by
* the spec. This is done to reduce number of renormalizations
*/
/* cabac engine initialization */
#if FULLRANGE
ps_cabac->u4_range = (UWORD32)510 << RANGE_SHIFT;
BITS_GET(ps_cabac->u4_ofst, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, (9 + RANGE_SHIFT));
#else
ps_cabac->u4_range = (UWORD32)510;
BITS_GET(ps_cabac->u4_ofst, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, 9);
#endif
/* cabac context initialization based on init idc and slice qp */
memcpy(ps_cabac->au1_ctxt_models,
pu1_init_ctxt,
IHEVC_CAB_CTXT_END);
DEBUG_RANGE_OFST("init", ps_cabac->u4_range, ps_cabac->u4_ofst);
/*
* If the offset is greater than or equal to range, return fail.
*/
if(ps_cabac->u4_ofst >= ps_cabac->u4_range)
{
return ((IHEVCD_ERROR_T)IHEVCD_FAIL);
}
return ((IHEVCD_ERROR_T)IHEVCD_SUCCESS);
}
IHEVCD_ERROR_T ihevcd_cabac_reset(cab_ctxt_t *ps_cabac,
bitstrm_t *ps_bitstrm)
{
/* Sanity checks */
ASSERT(ps_cabac != NULL);
ASSERT(ps_bitstrm != NULL);
/* CABAC engine uses 32 bit range instead of 9 bits as specified by
* the spec. This is done to reduce number of renormalizations
*/
/* cabac engine initialization */
#if FULLRANGE
ps_cabac->u4_range = (UWORD32)510 << RANGE_SHIFT;
BITS_GET(ps_cabac->u4_ofst, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, (9 + RANGE_SHIFT));
#else
ps_cabac->u4_range = (UWORD32)510;
BITS_GET(ps_cabac->u4_ofst, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, 9);
#endif
return ((IHEVCD_ERROR_T)IHEVCD_SUCCESS);
}
/**
******************************************************************************
*
* @brief Decodes a bin based on probablilty and mps packed context model
*
* @par Description
* Decodes a bin as per Section : 9.3.3.2.1 and calls renormalization if required
* as per section 9.3.3.2.2
* 1. Apart from decoding bin, context model is updated as per state transition
* 2. Range and Low renormalization is done based on bin and original state
* 3. After renorm bistream is updated (if required)
*
* @param[in,out] ps_cabac
* pointer to cabac context (handle)
*
* @param[in] ctxt_index
* index of cabac context model containing pState[bits6-1] | MPS[bit0]
*
* @param[in] ps_bitstrm
* Bitstream context
*
* @return bin(boolean) to be decoded
*
******************************************************************************
*/
UWORD32 ihevcd_cabac_decode_bin(cab_ctxt_t *ps_cabac,
bitstrm_t *ps_bitstrm,
WORD32 ctxt_index
)
{
UWORD32 u4_range = ps_cabac->u4_range;
UWORD32 u4_ofst = ps_cabac->u4_ofst;
UWORD32 u4_rlps;
UWORD32 u4_bin;
UWORD8 *pu1_ctxt_model = &ps_cabac->au1_ctxt_models[ctxt_index];
WORD32 state_mps = *pu1_ctxt_model;
#if FULLRANGE
WORD32 clz;
#endif
UWORD32 u4_qnt_range;
/* Sanity checks */
ASSERT(u4_range >= 256);
ASSERT((ctxt_index >= 0) && (ctxt_index < IHEVC_CAB_CTXT_END));
ASSERT(state_mps < 128);
#if FULLRANGE
clz = CLZ(u4_range);
clz -= (32 - RANGE_NUMBITS);
u4_qnt_range = u4_range << clz;
u4_qnt_range = (u4_qnt_range >> (RANGE_SHIFT + 6)) & 0x3;
#else
u4_qnt_range = (u4_range >> 6) & 0x3;
#endif
/* Get the lps range from LUT based on quantized range and state */
u4_rlps = gau1_ihevc_cabac_rlps[state_mps >> 1][u4_qnt_range];
#if FULLRANGE
u4_rlps = u4_rlps << (RANGE_SHIFT - clz);
#endif
u4_range -= u4_rlps;
u4_bin = state_mps & 1;
if(u4_ofst >= u4_range)
{
u4_bin = 1 - u4_bin;
u4_ofst -= u4_range;
u4_range = u4_rlps;
}
*pu1_ctxt_model = gau1_ihevc_next_state[(state_mps << 1) | u4_bin];
/*****************************************************************/
/* Re-normalization; calculate bits generated based on range(R) */
/*****************************************************************/
if(u4_range < (1 << 8))
{
UWORD32 u4_bits;
WORD32 numbits;
numbits = CLZ(u4_range);
numbits -= (32 - RANGE_NUMBITS);
#if !FULLRANGE
numbits -= RANGE_SHIFT;
#endif
BITS_GET(u4_bits, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, numbits);
u4_ofst <<= numbits;
u4_ofst |= u4_bits;
u4_range <<= numbits;
}
/* Update the cabac context */
ps_cabac->u4_range = u4_range;
ps_cabac->u4_ofst = u4_ofst;
DEBUG_RANGE_OFST("bin", ps_cabac->u4_range, ps_cabac->u4_ofst);
return (u4_bin);
}
/**
******************************************************************************
*
* @brief Decodes a bypass bin (equi-probable 0 / 1)
*
* @par Description
* Decodes a bypss bin as per Section : 9.3.3.2.3
*
* @param[in,out] ps_cabac
* pointer to cabac context (handle)
*
* @param[in] ps_bitstrm
* Bitstream context
*
* @return Decoded bypass bin
*
******************************************************************************
*/
UWORD32 ihevcd_cabac_decode_bypass_bin(cab_ctxt_t *ps_cabac,
bitstrm_t *ps_bitstrm)
{
UWORD32 u4_bin;
UWORD32 u4_range = ps_cabac->u4_range;
UWORD32 u4_ofst = ps_cabac->u4_ofst;
UWORD32 u4_bits;
/* Sanity checks */
ASSERT(u4_range >= 256);
BIT_GET(u4_bits, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word);
u4_ofst <<= 1;
u4_ofst |= u4_bits;
u4_bin = 0;
if(u4_ofst >= u4_range)
{
u4_bin = 1;
u4_ofst -= u4_range;
}
/* Update the cabac context */
ps_cabac->u4_ofst = u4_ofst;
DEBUG_RANGE_OFST("bypass end", ps_cabac->u4_range, ps_cabac->u4_ofst);
return (u4_bin);
}
/**
******************************************************************************
*
* @brief Decodes a terminate bin (1:terminate 0:do not terminate)
*
* @par Description
* Decodes a terminate bin to be called for end_of_slice_flag and pcm_flag
* as per Section : 9.3.3.2.4
*
* @param[in,out] ps_cabac
* pointer to cabac context (handle)
*
* @param[in] ps_bitstrm
* Bitstream context
*
* @return Decoded Bin to indicate whether to terminate or not
*
******************************************************************************
*/
UWORD32 ihevcd_cabac_decode_terminate(cab_ctxt_t *ps_cabac,
bitstrm_t *ps_bitstrm)
{
UWORD32 u4_range = ps_cabac->u4_range;
UWORD32 u4_ofst = ps_cabac->u4_ofst;
UWORD32 u4_bin;
#if FULLRANGE
WORD32 clz;
#endif
/* Sanity checks */
ASSERT(u4_range >= 256);
#if FULLRANGE
clz = CLZ(u4_range);
clz -= (32 - RANGE_NUMBITS);
u4_range -= 2 << (RANGE_SHIFT - clz);
#else
u4_range -= 2;
#endif
if(u4_ofst >= u4_range)
{
u4_bin = 1;
#if FULLRANGE
/* In case of FULLRANGE extra bits read earlier need to pushed back to the bitstream */
{
WORD32 clz;
WORD32 numbits;
clz = CLZ(ps_cabac->u4_range);
numbits = (32 - clz);
numbits -= 9;
ihevcd_bits_seek(ps_bitstrm, -numbits);
}
#endif
}
else
{
u4_bin = 0;
}
if(0 == u4_bin)
{
UWORD32 u4_bits;
WORD32 numbits;
numbits = CLZ(u4_range);
numbits -= (32 - RANGE_NUMBITS);
#if !FULLRANGE
numbits -= RANGE_SHIFT;
#endif
/* Renormalize if required */
if(numbits)
{
BITS_GET(u4_bits, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, numbits);
u4_ofst <<= numbits;
u4_ofst |= u4_bits;
u4_range <<= numbits;
}
}
/* bits to be inserted in the bitstream */
ps_cabac->u4_range = u4_range;
ps_cabac->u4_ofst = u4_ofst;
DEBUG_RANGE_OFST("term", ps_cabac->u4_range, ps_cabac->u4_ofst);
return (u4_bin);
}
/**
******************************************************************************
*
* @brief Decodes a bypass bin (equi-probable 0 / 1)
*
* @par Description
* Decodes a bypss bin as per Section : 9.3.3.2.3
*
* @param[in,out] ps_cabac
* pointer to cabac context (handle)
*
* @param[in] ps_bitstrm
* Bitstream context
*
* @param[in] numbins
* Number of bins to decoded
*
* @return Decoded bypass bin
*
* @remarks Tested only for numbins less than 17
*
******************************************************************************
*/
UWORD32 ihevcd_cabac_decode_bypass_bins(cab_ctxt_t *ps_cabac,
bitstrm_t *ps_bitstrm,
WORD32 numbins)
{
UWORD32 u4_bins;
UWORD32 u4_range = ps_cabac->u4_range;
UWORD32 u4_ofst = ps_cabac->u4_ofst;
UWORD32 u4_bits;
ASSERT(u4_range >= 256);
ASSERT(numbins > 0);
/* Sanity checks */
ASSERT(numbins < 17);
u4_bins = 0;
BITS_GET(u4_bits, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, numbins);
do
{
UWORD32 u4_bit;
numbins--;
u4_bit = (u4_bits >> numbins) & 1;
u4_ofst <<= 1;
u4_ofst |= u4_bit;
u4_bins <<= 1;
if(u4_ofst >= u4_range)
{
u4_bins += 1;
u4_ofst -= u4_range;
}
}while(numbins);
/* Update the cabac context */
ps_cabac->u4_ofst = u4_ofst;
DEBUG_RANGE_OFST("bypass", ps_cabac->u4_range, ps_cabac->u4_ofst);
return (u4_bins);
}
/**
******************************************************************************
*
* @brief Decodes a truncated unary symbol associated with context model(s)
*
* @par Description
* Decodes symbols coded with TUnary binarization as per sec 9.3.2.2
* This is used for computing symbols like qp_delta,
* last_sig_coeff_prefix_x, last_sig_coeff_prefix_y.
*
* The context models associated with each bin is computed as :
* current bin context = "base context idx" + (bin_idx >> shift)
* where
* 1. "base context idx" is the base index for the syntax element
* 2. "bin_idx" is the current bin index of the unary code
* 3. "shift" is the shift factor associated with this syntax element
*
* @param[in,out] ps_cabac
* pointer to cabac context (handle)
*
* @param[in] ps_bitstrm
* Bitstream context
*
* @param[in] c_max
* maximum value of sym (required for tunary binarization)
*
* @param[in] ctxt_index
* base context model index for this syntax element
*
* @param[in] ctxt_shift
* shift factor for context increments associated with this syntax element
*
* @param[in] ctxt_inc_max
* max value of context increment beyond which all bins will use same ctxt
*
* @return syntax element decoded
*
******************************************************************************
*/
UWORD32 ihevcd_cabac_decode_bins_tunary(cab_ctxt_t *ps_cabac,
bitstrm_t *ps_bitstrm,
WORD32 c_max,
WORD32 ctxt_index,
WORD32 ctxt_shift,
WORD32 ctxt_inc_max)
{
UWORD32 u4_sym;
WORD32 bin;
/* Sanity checks */
ASSERT(c_max > 0);
ASSERT((ctxt_index >= 0) && (ctxt_index < IHEVC_CAB_CTXT_END));
ASSERT((ctxt_index + (c_max >> ctxt_shift)) < IHEVC_CAB_CTXT_END);
u4_sym = 0;
do
{
WORD32 bin_index;
bin_index = ctxt_index + MIN((u4_sym >> ctxt_shift), (UWORD32)ctxt_inc_max);
IHEVCD_CABAC_DECODE_BIN(bin, ps_cabac, ps_bitstrm, bin_index);
u4_sym++;
}while(((WORD32)u4_sym < c_max) && bin);
u4_sym = u4_sym - 1 + bin;
return (u4_sym);
}
/**
******************************************************************************
*
* @brief Decodes a syntax element as truncated unary bypass bins
*
* @par Description
* Decodes symbols coded with TUnary binarization as per sec 9.3.2.2
* These symbols are coded as bypass bins
* This is used for computing symbols like merge_idx,
* mpm_idx etc
*
* @param[in,out]ps_cabac
* pointer to cabac context (handle)
*
* @param[in] ps_bitstrm
* Bitstream context
*
* @param[in] c_max
* maximum value of sym (required for tunary binarization)
*
* @return syntax element decoded
*
******************************************************************************
*/
UWORD32 ihevcd_cabac_decode_bypass_bins_tunary(cab_ctxt_t *ps_cabac,
bitstrm_t *ps_bitstrm,
WORD32 c_max)
{
UWORD32 u4_sym;
WORD32 bin;
UWORD32 u4_ofst = ps_cabac->u4_ofst;
UWORD32 u4_range = ps_cabac->u4_range;
UWORD32 u4_bits;
/* Sanity checks */
ASSERT(c_max > 0);
ASSERT(u4_range >= 256);
u4_sym = 0;
BITS_NXT(u4_bits, ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, (UWORD32)c_max);
u4_bits <<= (32 - c_max);
do
{
u4_ofst <<= 1;
u4_ofst |= (u4_bits >> 31);
u4_bits <<= 1;
bin = 0;
if(u4_ofst >= u4_range)
{
bin = 1;
u4_ofst -= u4_range;
}
u4_sym++;
}while(((WORD32)u4_sym < c_max) && bin);
BITS_FLUSH(ps_bitstrm->pu4_buf, ps_bitstrm->u4_bit_ofst,
ps_bitstrm->u4_cur_word, ps_bitstrm->u4_nxt_word, u4_sym);
u4_sym = u4_sym - 1 + bin;
/* Update the cabac context */
ps_cabac->u4_ofst = u4_ofst;
return (u4_sym);
}
/**
******************************************************************************
*
* @brief Decodes a syntax element as kth order Exp-Golomb code (EGK)
*
* @par Description
* Decodes a syntax element binarized as kth order Exp-Golomb code (EGK)
* Elements are coded as bypass bins
*
* @param[in,out] ps_cabac
* pointer to cabac context (handle)
*
* @param[in] u4_sym
* syntax element to be coded as EGK
*
* @param[in] k
* order of EGk
*
* @return success or failure error code
*
******************************************************************************
*/
UWORD32 ihevcd_cabac_decode_bypass_bins_egk(cab_ctxt_t *ps_cabac,
bitstrm_t *ps_bitstrm,
WORD32 k)
{
UWORD32 u4_sym;
WORD32 numones;
WORD32 bin;
/* Sanity checks */
ASSERT((k >= 0));
numones = k;
bin = 1;
u4_sym = 0;
while(bin && (numones <= 16))
{
IHEVCD_CABAC_DECODE_BYPASS_BIN(bin, ps_cabac, ps_bitstrm);
u4_sym += bin << numones++;
}
numones -= 1;
if(numones)
{
UWORD32 u4_suffix;
IHEVCD_CABAC_DECODE_BYPASS_BINS(u4_suffix, ps_cabac, ps_bitstrm, numones);
u4_sym += u4_suffix;
}
return (u4_sym);
}
/**
******************************************************************************
*
* @brief Decodes a syntax element as truncated rice code (TR)
*
* @par Description
* Decodes a syntax element as truncated rice code (TR)
* Elements are coded as bypass bins
* This function ise used for coeff_abs_level_remaining coding when
* level is less than c_rice_max
*
* @param[in,out] ps_cabac
* pointer to cabac context (handle)
*
* @param[in] u4_sym
* syntax element to be coded as truncated rice code
*
* @param[in] c_rice_param
* shift factor for truncated unary prefix coding of (u4_sym >> c_rice_param)
*
* @param[in] c_rice_max
* max symbol val below which a suffix is coded as (u4_sym%(1<<c_rice_param))
* This is currently (4 << c_rice_param) for coeff_abs_level_remaining
*
* @return success or failure error code
*
******************************************************************************
*/
UWORD32 ihevcd_cabac_decode_bypass_bins_trunc_rice(cab_ctxt_t *ps_cabac,
bitstrm_t *ps_bitstrm,
WORD32 c_rice_param,
WORD32 c_rice_max)
{
UWORD32 u4_sym;
WORD32 bin;
WORD32 c_max;
UWORD32 u4_suffix;
/* Sanity checks */
ASSERT((c_rice_param >= 0));
/* Decode prefix coded as TUnary */
c_max = c_rice_max >> c_rice_param;
u4_sym = 0;
do
{
IHEVCD_CABAC_DECODE_BYPASS_BIN(bin, ps_cabac, ps_bitstrm);
u4_sym++;
}while(((WORD32)u4_sym < c_max) && bin);
u4_sym = u4_sym - 1 + bin;
/* If suffix is present, then decode c_rice_param number of bins */
if(c_rice_param)
{
IHEVCD_CABAC_DECODE_BYPASS_BINS(u4_suffix, ps_cabac, ps_bitstrm, c_rice_param);
u4_sym = (u4_sym << c_rice_param) | u4_suffix;
}
return (u4_sym);
}