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

*

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

}