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

 *

 * Copyright (C) 2015 The Android Open Source Project

 *

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

 *

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

 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore

*/

/*!

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

 * \file ih264d_parse_mb_header.c

 *

 * \brief

 *    This file contains context identifier encoding routines.

 *

 * \date

 *    04/02/2003

 *

 * \author  NS

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

 */

#include <string.h>

#include "ih264d_structs.h"

#include "ih264d_bitstrm.h"

#include "ih264d_cabac.h"

#include "ih264_typedefs.h"

#include "ih264_macros.h"

#include "ih264_platform_macros.h"

#include "ih264d_defs.h"

#include "ih264d_error_handler.h"

#include "ih264d_tables.h"

#include "ih264d_debug.h"

#include "ih264d_defs.h"

#include "ih264d_defs.h"

#include "ih264d_mb_utils.h"

#include "ih264d_parse_mb_header.h"

#include "ih264d_defs.h"

/*! < CtxtInc index 0 - CtxMbTypeI, CtxMbTypeSISuffix

 index 1 - CtxMbTypePSuffix, CtxMbTypeBSuffix

 */

/*!

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

 * \if Function name : ih264d_parse_mb_type_intra_cabac \endif

 *

 * \brief

 *    This function decodes MB type using CABAC entropy coding mode.

 *

 * \return

 *    MBType.

 *

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

 */

UWORD8 ih264d_parse_mb_type_intra_cabac(UWORD8 u1_inter,

                                        struct _DecStruct * ps_dec)

{

    decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;

    dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;

    ctxt_inc_mb_info_t * ps_left_ctxt = ps_dec->p_left_ctxt_mb_info;

    ctxt_inc_mb_info_t * ps_top_ctxt = ps_dec->p_top_ctxt_mb_info;

    bin_ctxt_model_t *ps_mb_bin_ctxt = ps_dec->p_mb_type_t;

    WORD8 u1_mb_type, u1_bin;

    UWORD32 u4_cxt_inc;

    u4_cxt_inc = 0;

    if(!u1_inter)

    {

        if(ps_left_ctxt != ps_dec->ps_def_ctxt_mb_info)

            u4_cxt_inc += ((ps_left_ctxt->u1_mb_type != CAB_I4x4) ? 1 : 0);

        if(ps_top_ctxt != ps_dec->ps_def_ctxt_mb_info)

            u4_cxt_inc += ((ps_top_ctxt->u1_mb_type != CAB_I4x4) ? 1 : 0);

    }

    else

    {

        ps_mb_bin_ctxt = ps_mb_bin_ctxt + 3 + (ps_dec->u1_B << 1);

    }

    /* b0 */

    u1_mb_type = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt, ps_bitstrm,

                                          ps_cab_env);

    if(u1_mb_type)

    {

        /* I16x16 or I_PCM mode */

        /* b1 */

        u1_bin = ih264d_decode_terminate(ps_cab_env, ps_bitstrm);

        if(u1_bin == 0)

        {

            /* I16x16 mode */

            /* Read b2 and b3 */

            u4_cxt_inc = (u1_inter) ? 0x021 : 0x043;

            u1_bin = ih264d_decode_bins(2, u4_cxt_inc, ps_mb_bin_ctxt, ps_bitstrm,

                                        ps_cab_env);

            if(u1_bin & 0x01)

                u1_mb_type += 4;

            if(u1_bin & 0x02)

                u1_mb_type += 12;

            if(u1_bin & 0x01)

            {

                /* since b3=1, Read three bins */

                u4_cxt_inc = (u1_inter) ? 0x0332 : 0x0765;

                u1_bin = (UWORD8)ih264d_decode_bins(3, u4_cxt_inc, ps_mb_bin_ctxt,

                                                    ps_bitstrm, ps_cab_env);

            }

            else

            {

                /* Read two bins */

                u4_cxt_inc = (u1_inter) ? 0x033 : 0x076;

                u1_bin = (UWORD8)ih264d_decode_bins(2, u4_cxt_inc, ps_mb_bin_ctxt,

                                                    ps_bitstrm, ps_cab_env);

            }

            u1_mb_type += u1_bin;

        }

        else

        {

            /* I_PCM mode */

            /* b1=1 */

            u1_mb_type = 25;

        }

    }

    return (u1_mb_type);

}

/*!

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

 * \if Function name : ih264d_parse_mb_type_cabac \endif

 *

 * \brief

 *    This function decodes MB type using CABAC entropy coding mode.

 *

 * \return

 *    MBType.

 *

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

 */

UWORD32 ih264d_parse_mb_type_cabac(struct _DecStruct * ps_dec)

{

    const UWORD8 uc_slice_type = ps_dec->ps_cur_slice->u1_slice_type;

    decoding_envirnoment_t *ps_cab_env = &ps_dec->s_cab_dec_env;

    dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;

    ctxt_inc_mb_info_t *ps_left_ctxt = ps_dec->p_left_ctxt_mb_info;

    ctxt_inc_mb_info_t *ps_top_ctxt = ps_dec->p_top_ctxt_mb_info;

    WORD8 c_ctxt_inc;

    bin_ctxt_model_t *ps_mb_bin_ctxt = ps_dec->p_mb_type_t;

    WORD8 u1_mb_type = 0, u1_bin;

    UWORD32 u4_cxt_inc;

    INC_SYM_COUNT(ps_cab_env);

    c_ctxt_inc = 0;

    if(uc_slice_type == SI_SLICE)

    {

        /* b0 */

        if(ps_left_ctxt != ps_dec->ps_def_ctxt_mb_info)

            c_ctxt_inc += ((ps_left_ctxt->u1_mb_type != CAB_SI4x4) ? 1 : 0);

        if(ps_top_ctxt != ps_dec->ps_def_ctxt_mb_info)

            c_ctxt_inc += ((ps_top_ctxt->u1_mb_type != CAB_SI4x4) ? 1 : 0);

        u4_cxt_inc = c_ctxt_inc;

        u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt, ps_bitstrm,

                                           ps_cab_env);

        if(u1_bin == 0)

        {

            /* SI MB */

            u1_mb_type = 0;

        }

        else

        {

            u1_mb_type = 1 + ih264d_parse_mb_type_intra_cabac(0, ps_dec);

        }

    }

    else if(uc_slice_type == P_SLICE)

    {

        /* P Slice */

        /* b0 */

        u4_cxt_inc = 0;

        u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt, ps_bitstrm,

                                           ps_cab_env);

        if(!u1_bin)

        {

            /* Inter MB types */

            /* b1 */

            u4_cxt_inc = 0x01;

            u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt,

                                               ps_bitstrm, ps_cab_env);

            /* b2 */

            u4_cxt_inc = u1_bin + 2;

            u1_mb_type = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt,

                                                  ps_bitstrm, ps_cab_env);

            u1_mb_type = (u1_bin << 1) + u1_mb_type;

            if(u1_mb_type)

                u1_mb_type = 4 - u1_mb_type;

        }

        else

        {

            /* Intra Prefix 1 found */

            /* Intra MB type */

            u1_mb_type = 5 + ih264d_parse_mb_type_intra_cabac(1, ps_dec);

        }

    }

    else if(uc_slice_type == B_SLICE)

    {

        WORD8 a, b;

        /* B Slice */

        /* b0 */

        /* a = b = 0, if B slice and MB is a SKIP or B_DIRECT16x16 */

        a = 0;

        b = 0;

        u1_mb_type = 0;

        if(ps_left_ctxt != ps_dec->ps_def_ctxt_mb_info)

            a = ((ps_left_ctxt->u1_mb_type & CAB_BD16x16_MASK) != CAB_BD16x16);

        if(ps_top_ctxt != ps_dec->ps_def_ctxt_mb_info)

            b = ((ps_top_ctxt->u1_mb_type & CAB_BD16x16_MASK) != CAB_BD16x16);

        u4_cxt_inc = a + b;

        u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt, ps_bitstrm,

                                           ps_cab_env);

        if(u1_bin)

        {

            /* b1 */

            u4_cxt_inc = 0x03;

            u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt,

                                               ps_bitstrm, ps_cab_env);

            if(!u1_bin)

            {

                /* b2 */

                u4_cxt_inc = 0x05;

                u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt,

                                                   ps_bitstrm, ps_cab_env);

                u1_mb_type = u1_bin + 1;

            }

            else

            {

                u1_mb_type = 3;

                /* b2 */

                u4_cxt_inc = 0x04;

                u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt,

                                                   ps_bitstrm, ps_cab_env);

                if(u1_bin)

                {

                    u1_mb_type += 8;

                    /* b3 */

                    u4_cxt_inc = 0x05;

                    u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt,

                                                       ps_bitstrm, ps_cab_env);

                    if(!u1_bin)

                    {

                        u1_mb_type++;

                        /* b4, b5, b6 */

                        u4_cxt_inc = 0x0555;

                        u1_bin = (UWORD8)ih264d_decode_bins(3, u4_cxt_inc,

                                                            ps_mb_bin_ctxt,

                                                            ps_bitstrm,

                                                            ps_cab_env);

                        u1_mb_type += u1_bin;

                    }

                    else

                    {

                        /* b4 */

                        u4_cxt_inc = 0x05;

                        u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc,

                                                           ps_mb_bin_ctxt,

                                                           ps_bitstrm,

                                                           ps_cab_env);

                        if(u1_bin)

                        {

                            /* b5 */

                            u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc,

                                                               ps_mb_bin_ctxt,

                                                               ps_bitstrm,

                                                               ps_cab_env);

                            u1_mb_type += (u1_bin ? 11 : 0);

                        }

                        else

                        {

                            u1_mb_type = 20;

                            /* b5 */

                            u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc,

                                                               ps_mb_bin_ctxt,

                                                               ps_bitstrm,

                                                               ps_cab_env);

                            if(!u1_bin)

                            {

                                /* b6 */

                                u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc,

                                                                   ps_mb_bin_ctxt,

                                                                   ps_bitstrm,

                                                                   ps_cab_env);

                                u1_mb_type += u1_bin;

                            }

                            else

                            {

                                /* Intra Prefix 111101 found */

                                /* Intra MB type */

                                u1_mb_type =

                                                23

                                                                + ih264d_parse_mb_type_intra_cabac(

                                                                                1,

                                                                                ps_dec);

                            }

                        }

                    }

                }

                else

                {

                    /* b3, b4, b5 */

                    u4_cxt_inc = 0x0555;

                    u1_bin = (UWORD8)ih264d_decode_bins(3, u4_cxt_inc,

                                                        ps_mb_bin_ctxt, ps_bitstrm,

                                                        ps_cab_env);

                    u1_mb_type += u1_bin;

                }

            }

        }

    }

    return ((UWORD32)u1_mb_type);

}

/*!

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

 * \if Function name : DecSubMBType \endif

 *

 * \brief

 *    This function decodes MB type using CABAC entropy coding mode.

 *

 * \return

 *    MBType.

 *

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

 */

UWORD32 ih264d_parse_submb_type_cabac(const UWORD8 u1_slc_type_b,

                                      decoding_envirnoment_t * ps_cab_env,

                                      dec_bit_stream_t * ps_bitstrm,

                                      bin_ctxt_model_t * ps_sub_mb_cxt)

{

    WORD8 u1_sub_mb_type, u1_bin;

    INC_SYM_COUNT(ps_cab_env);

    u1_sub_mb_type = 0;

    u1_bin = (UWORD8)ih264d_decode_bin(0, ps_sub_mb_cxt, ps_bitstrm,

                                       ps_cab_env);

    if(u1_slc_type_b ^ u1_bin)

        return 0;

    if(!u1_slc_type_b)

    {

        /* P Slice */

        u1_sub_mb_type = 1;

        u1_bin = (UWORD8)ih264d_decode_bin(1, ps_sub_mb_cxt, ps_bitstrm,

                                           ps_cab_env);

        if(u1_bin == 1)

        {

            u1_bin = (UWORD8)ih264d_decode_bin(2, ps_sub_mb_cxt, ps_bitstrm,

                                               ps_cab_env);

            u1_sub_mb_type = (2 + (!u1_bin));

        }

        return u1_sub_mb_type;

    }

    else

    {

        /* B Slice */

        /* b1 */

        u1_bin = (UWORD8)ih264d_decode_bin(1, ps_sub_mb_cxt, ps_bitstrm,

                                           ps_cab_env);

        if(u1_bin)

        {

            /* b2 */

            u1_bin = (UWORD8)ih264d_decode_bin(2, ps_sub_mb_cxt, ps_bitstrm,

                                               ps_cab_env);

            if(u1_bin)

            {

                /* b3 */

                u1_sub_mb_type = 7;

                u1_bin = (UWORD8)ih264d_decode_bin(3, ps_sub_mb_cxt, ps_bitstrm,

                                                   ps_cab_env);

                u1_sub_mb_type += u1_bin << 2;

                u1_bin = !u1_bin;

                /* b4 */

                if(u1_bin == 0)

                {

                    u1_bin = ih264d_decode_bin(3, ps_sub_mb_cxt, ps_bitstrm,

                                               ps_cab_env);

                }

                else

                {

                    u1_bin = (UWORD8)ih264d_decode_bins(2, 0x33, ps_sub_mb_cxt,

                                                        ps_bitstrm, ps_cab_env);

                }

                return (u1_sub_mb_type + u1_bin);

            }

            else

            {

                /* b3 */

                u1_bin = (UWORD8)ih264d_decode_bins(2, 0x33, ps_sub_mb_cxt,

                                                    ps_bitstrm, ps_cab_env);

                return (3 + u1_bin);

            }

        }

        else

        {

            /* b2 */

            u1_bin = (UWORD8)ih264d_decode_bin(3, ps_sub_mb_cxt, ps_bitstrm,

                                               ps_cab_env);

            return (1 + u1_bin);

        }

    }

}

/*!

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

 * \if Function name : ih264d_parse_ref_idx_cabac \endif

 *

 * \brief

 *    This function decodes Reference Index using CABAC entropy coding mode.

 *

 * \return

 *    None

 *

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

 */

WORD32 ih264d_parse_ref_idx_cabac(const UWORD8 u1_num_part,

                                const UWORD8 u1_b2,

                                const UWORD8 u1_max_ref_minus1,

                                const UWORD8 u1_mb_mode,

                                WORD8 * pi1_ref_idx,

                                WORD8 * const pi1_lft_cxt,

                                WORD8 * const pi1_top_cxt,

                                decoding_envirnoment_t * const ps_cab_env,

                                dec_bit_stream_t * const ps_bitstrm,

                                bin_ctxt_model_t * const ps_ref_cxt)

{

    UWORD8 u1_a, u1_b;

    UWORD32 u4_cxt_inc;

    UWORD8 u1_blk_no, u1_i, u1_idx_lft, u1_idx_top;

    WORD8 i1_ref_idx;

    for(u1_blk_no = 0, u1_i = 0; u1_i < u1_num_part; u1_i++, pi1_ref_idx++)

    {

        u1_idx_lft = ((u1_blk_no & 0x02) >> 1) + u1_b2;

        u1_idx_top = (u1_blk_no & 0x01) + u1_b2;

        i1_ref_idx = *pi1_ref_idx;

        if(i1_ref_idx > 0)

        {

            u1_a = pi1_lft_cxt[u1_idx_lft] > 0;

            u1_b = pi1_top_cxt[u1_idx_top] > 0;

            u4_cxt_inc = u1_a + (u1_b << 1);

            u4_cxt_inc = (u4_cxt_inc | 0x55540);

            i1_ref_idx = (WORD8)ih264d_decode_bins_unary(32, u4_cxt_inc,

                                                         ps_ref_cxt, ps_bitstrm,

                                                         ps_cab_env);

            if((i1_ref_idx > u1_max_ref_minus1) || (i1_ref_idx < 0))

            {

                return ERROR_REF_IDX;

            }

            *pi1_ref_idx = i1_ref_idx;

            INC_SYM_COUNT(ps_cab_env);

        }

        /* Storing Reference Idx Information */

        pi1_lft_cxt[u1_idx_lft] = i1_ref_idx;

        pi1_top_cxt[u1_idx_top] = i1_ref_idx;

        u1_blk_no = u1_blk_no + 1 + (u1_mb_mode & 0x01);

    }

    /* if(!u1_sub_mb) */

    if(u1_num_part != 4)

    {

        pi1_lft_cxt[(!(u1_mb_mode & 0x1)) + u1_b2] = pi1_lft_cxt[u1_b2];

        pi1_top_cxt[(!(u1_mb_mode & 0x2)) + u1_b2] = pi1_top_cxt[u1_b2];

    }

    return OK;

}

/*!

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

 * \if Function name : ih264d_parse_mb_qp_delta_cabac \endif

 *

 * \brief

 *    This function decodes MB Qp delta using CABAC entropy coding mode.

 *

 * \return

 *    None

 *

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

 */

WORD32 ih264d_parse_mb_qp_delta_cabac(struct _DecStruct * ps_dec,

                                      WORD8 *pi1_mb_qp_delta)

{

    decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;

    dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;

    UWORD8 u1_code_num;

    bin_ctxt_model_t *ps_mb_qp_delta_ctxt = ps_dec->p_mb_qp_delta_t;

    UWORD32 u4_cxt_inc;

    INC_SYM_COUNT(ps_cab_env);

    u4_cxt_inc = (!(!(ps_dec->i1_prev_mb_qp_delta)));

    u1_code_num = 0;

    u4_cxt_inc = (u4_cxt_inc | 0x33320);

    /* max number of bins = 53,

     since Range for MbQpDelta= -26 to +25 inclusive, UNARY code */

    u1_code_num = ih264d_decode_bins_unary(32, u4_cxt_inc, ps_mb_qp_delta_ctxt,

                                          ps_bitstrm, ps_cab_env);

    if(u1_code_num == 32)

    {

        /* Read remaining 21 bins */

        UWORD8 uc_codeNumX;

        u4_cxt_inc = 0x33333;

        uc_codeNumX = ih264d_decode_bins_unary(21, u4_cxt_inc, ps_mb_qp_delta_ctxt,

                                               ps_bitstrm, ps_cab_env);

        u1_code_num = u1_code_num + uc_codeNumX;

    }

    *pi1_mb_qp_delta = (u1_code_num + 1) >> 1;

    /* Table 9.3: If code_num is even Syntax Element has -ve value */

    if(!(u1_code_num & 0x01))

        *pi1_mb_qp_delta = -(*pi1_mb_qp_delta);

    /* Range of MbQpDelta= -26 to +25 inclusive */

    if((*pi1_mb_qp_delta < -26) || (*pi1_mb_qp_delta > 25))

        return ERROR_INV_RANGE_QP_T;

    ps_dec->i1_prev_mb_qp_delta = *pi1_mb_qp_delta;

    return OK;

}

/*!

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

 * \if Function name : ih264d_parse_chroma_pred_mode_cabac \endif

 *

 * \brief

 *    This function decodes Chroma Pred mode using CABAC entropy coding mode.

 *

 * \return

 *    None

 *

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

 */

WORD8 ih264d_parse_chroma_pred_mode_cabac(struct _DecStruct * ps_dec)

{

    decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;

    dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;

    ctxt_inc_mb_info_t * ps_left_ctxt = ps_dec->p_left_ctxt_mb_info;

    ctxt_inc_mb_info_t * ps_top_ctxt = ps_dec->p_top_ctxt_mb_info;

    WORD8 i1_chroma_pred_mode, a, b;

    UWORD32 u4_cxt_inc;

    INC_SYM_COUNT(ps_cab_env);

    /* Binarization is TU and Cmax=3 */

    i1_chroma_pred_mode = 0;

    a = 0;

    b = 0;

    a = ((ps_left_ctxt->u1_intra_chroma_pred_mode != 0) ? 1 : 0);

    b = ((ps_top_ctxt->u1_intra_chroma_pred_mode != 0) ? 1 : 0);

    u4_cxt_inc = a + b;

    u4_cxt_inc = (u4_cxt_inc | 0x330);

    i1_chroma_pred_mode = ih264d_decode_bins_tunary(

                    3, u4_cxt_inc, ps_dec->p_intra_chroma_pred_mode_t,

                    ps_bitstrm, ps_cab_env);

    return (i1_chroma_pred_mode);

}

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

/*                                                                           */

/*  Function Name : ih264d_parse_transform8x8flag_cabac                                     */

/*                                                                           */

/*  Description   :                                                          */

/*  Inputs        :                                                          */

/*                                                                           */

/*                                                                           */

/*  Returns       :                                                          */

/*                                                                           */

/*  Revision History:                                                        */

/*                                                                           */

/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */

/*                      Rajasekhar      Creation                             */

/*                                                                           */

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

UWORD8 ih264d_parse_transform8x8flag_cabac(struct _DecStruct * ps_dec,

                                           dec_mb_info_t * ps_cur_mb_info)

{

    decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;

    dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;

    ctxt_inc_mb_info_t * ps_left_ctxt = ps_dec->p_left_ctxt_mb_info;

    ctxt_inc_mb_info_t * ps_top_ctxt = ps_dec->p_top_ctxt_mb_info;

    UWORD8 u1_transform_8x8flag;

    UWORD8 u1_mb_ngbr_avail = ps_cur_mb_info->u1_mb_ngbr_availablity;

    WORD8 a, b;

    UWORD32 u4_cxt_inc;

    /* for calculating the context increment for transform8x8 u4_flag */

    /* it reads transform8x8 u4_flag of the neighbors through */

    /* Binarization is FLC */

    a = 0;

    b = 0;

    if(u1_mb_ngbr_avail & LEFT_MB_AVAILABLE_MASK)

    {

        a = ps_left_ctxt->u1_transform8x8_ctxt;

    }

    if(u1_mb_ngbr_avail & TOP_MB_AVAILABLE_MASK)

    {

        b = ps_top_ctxt->u1_transform8x8_ctxt;

    }

    u4_cxt_inc = a + b;

    u1_transform_8x8flag = ih264d_decode_bin(

                    u4_cxt_inc, ps_dec->s_high_profile.ps_transform8x8_flag,

                    ps_bitstrm, ps_cab_env);

    return (u1_transform_8x8flag);

}

/*!

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

 * \if Function name : ih264d_read_intra_pred_modes_cabac \endif

 *

 * \brief

 *    Reads the intra pred mode related values of I4x4 MB from bitstream.

 *

 *    This function will read the prev intra pred mode flags and

 *    stores it in pu1_prev_intra4x4_pred_mode_flag. If the u4_flag

 *    indicates that most probable mode is not intra pred mode, then

 *    the rem_intra4x4_pred_mode is read and stored in

 *    pu1_rem_intra4x4_pred_mode array.

 *

 *

 * \return

 *    0 on success and Error code otherwise

 *

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

 */

WORD32 ih264d_read_intra_pred_modes_cabac(dec_struct_t * ps_dec,

                                          UWORD8 * pu1_prev_intra4x4_pred_mode_flag,

                                          UWORD8 * pu1_rem_intra4x4_pred_mode,

                                          UWORD8 u1_tran_form8x8)

{

    WORD32 i4x4_luma_blk_idx = 0;

    dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;

    decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;

    bin_ctxt_model_t *ps_ctxt_ipred_luma_mpm, *ps_ctx_ipred_luma_rm;

    WORD32 i4_rem_intra4x4_pred_mode;

    UWORD32 u4_prev_intra4x4_pred_mode_flag;

    UWORD32 u4_code_int_range, u4_code_int_val_ofst;

    const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table;

    ps_ctxt_ipred_luma_mpm = ps_dec->p_prev_intra4x4_pred_mode_flag_t;

    ps_ctx_ipred_luma_rm = ps_dec->p_rem_intra4x4_pred_mode_t;

    SWITCHOFFTRACE;

    i4x4_luma_blk_idx = (0 == u1_tran_form8x8) ? 16 : 4;

    u4_code_int_range = ps_cab_env->u4_code_int_range;

    u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;

    do

    {

        DECODE_ONE_BIN_MACRO(ps_ctxt_ipred_luma_mpm, u4_code_int_range,

                             u4_code_int_val_ofst, pu4_table, ps_bitstrm,

                             u4_prev_intra4x4_pred_mode_flag)

        *pu1_prev_intra4x4_pred_mode_flag = u4_prev_intra4x4_pred_mode_flag;

        i4_rem_intra4x4_pred_mode = -1;

        if(!u4_prev_intra4x4_pred_mode_flag)

        {

            /*inlining DecodeDecisionBins_FLC*/

            {

                UWORD8 u1_max_bins = 3;

                UWORD32 u4_value;

                UWORD32 u4_symbol, i;

                i = 0;

                u4_value = 0;

                do

                {

                    DECODE_ONE_BIN_MACRO(ps_ctx_ipred_luma_rm, u4_code_int_range,

                                         u4_code_int_val_ofst, pu4_table,

                                         ps_bitstrm, u4_symbol)

                    INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env);

                    u4_value = u4_value | (u4_symbol << i);

                    i++;

                }

                while(i < u1_max_bins);

                i4_rem_intra4x4_pred_mode = (u4_value);

            }

        }

        (*pu1_rem_intra4x4_pred_mode) = i4_rem_intra4x4_pred_mode;

        COPYTHECONTEXT("intra4x4_pred_mode", i4_rem_intra4x4_pred_mode);

        pu1_prev_intra4x4_pred_mode_flag++;

        pu1_rem_intra4x4_pred_mode++;

        i4x4_luma_blk_idx--;

    }

    while(i4x4_luma_blk_idx);

    ps_cab_env->u4_code_int_range = u4_code_int_range;

    ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;

    return (0);

}

/*!

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

 * \if Function name : ih264d_parse_ctx_cbp_cabac \endif

 *

 * \brief

 *    This function decodes CtxCbpLuma and CtxCbpChroma (CBP of a Macroblock).

 *    using CABAC entropy coding mode.

 *

 * \return

 *    CBP of a MB.

 *

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

 */

UWORD32 ih264d_parse_ctx_cbp_cabac(struct _DecStruct * ps_dec)

{

    UWORD32 u4_cxt_inc;

    decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;

    dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;

    ctxt_inc_mb_info_t * ps_left_ctxt = ps_dec->p_left_ctxt_mb_info;

    ctxt_inc_mb_info_t * ps_top_ctxt = ps_dec->p_top_ctxt_mb_info;

    bin_ctxt_model_t *ps_ctxt_cbp_luma = ps_dec->p_cbp_luma_t, *ps_bin_ctxt;

    WORD8 c_Cbp; //,i,j;

    UWORD32 u4_code_int_range, u4_code_int_val_ofst;

    UWORD32 u4_offset, *pu4_buffer;

    const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table;

    INC_SYM_COUNT(ps_cab_env);

    /* CBP Luma, FL, Cmax = 15, L = 4 */

    u4_cxt_inc = (!((ps_top_ctxt->u1_cbp >> 2) & 0x01)) << 1;

    u4_cxt_inc += !((ps_left_ctxt->u1_cbp >> 1) & 0x01);

    u4_offset = ps_bitstrm->u4_ofst;

    pu4_buffer = ps_bitstrm->pu4_buffer;

    u4_code_int_range = ps_cab_env->u4_code_int_range;

    u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;

    /*renormalize to ensure there 23 bits more in the u4_code_int_val_ofst*/

    {

        UWORD32 u4_clz, read_bits;

        u4_clz = CLZ(u4_code_int_range);

        FLUSHBITS(u4_offset, u4_clz)

        NEXTBITS(read_bits, u4_offset, pu4_buffer, 23)

        u4_code_int_range = u4_code_int_range << u4_clz;

        u4_code_int_val_ofst = (u4_code_int_val_ofst << u4_clz) | read_bits;

    }

    ps_bin_ctxt = ps_ctxt_cbp_luma + u4_cxt_inc;

    /*inlining DecodeDecision_onebin without renorm*/

    {

        UWORD32 u4_qnt_int_range, u4_int_range_lps;

        UWORD32 u4_symbol, u1_mps_state;

        UWORD32 table_lookup;

        UWORD32 u4_clz;

        u1_mps_state = (ps_bin_ctxt->u1_mps_state);

        u4_clz = CLZ(u4_code_int_range);

        u4_qnt_int_range = u4_code_int_range << u4_clz;

        u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3;

        table_lookup = pu4_table[(u1_mps_state << 2) + u4_qnt_int_range];

        u4_int_range_lps = table_lookup & 0xff;

        u4_int_range_lps = u4_int_range_lps << (23 - u4_clz);

        u4_code_int_range = u4_code_int_range - u4_int_range_lps;

        u4_symbol = ((u1_mps_state >> 6) & 0x1);

        /*if mps*/

        u1_mps_state = (table_lookup >> 8) & 0x7F;

        CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, u4_symbol,

                     u4_int_range_lps, u1_mps_state, table_lookup)

        INC_BIN_COUNT(ps_cab_env);

        ps_bin_ctxt->u1_mps_state = u1_mps_state;

        c_Cbp = u4_symbol;

    }

    u4_cxt_inc = (!((ps_top_ctxt->u1_cbp >> 3) & 0x01)) << 1;

    u4_cxt_inc += !(c_Cbp & 0x01);

    ps_bin_ctxt = ps_ctxt_cbp_luma + u4_cxt_inc;

    /*inlining DecodeDecision_onebin without renorm*/

    {

        UWORD32 u4_qnt_int_range, u4_int_range_lps;

        UWORD32 u4_symbol, u1_mps_state;

        UWORD32 table_lookup;

        UWORD32 u4_clz;

        u1_mps_state = (ps_bin_ctxt->u1_mps_state);

        u4_clz = CLZ(u4_code_int_range);

        u4_qnt_int_range = u4_code_int_range << u4_clz;

        u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3;

        table_lookup = pu4_table[(u1_mps_state << 2) + u4_qnt_int_range];

        u4_int_range_lps = table_lookup & 0xff;

        u4_int_range_lps = u4_int_range_lps << (23 - u4_clz);

        u4_code_int_range = u4_code_int_range - u4_int_range_lps;

        u4_symbol = ((u1_mps_state >> 6) & 0x1);

        /*if mps*/

        u1_mps_state = (table_lookup >> 8) & 0x7F;

        CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, u4_symbol,

                     u4_int_range_lps, u1_mps_state, table_lookup)

        INC_BIN_COUNT(ps_cab_env);

        ps_bin_ctxt->u1_mps_state = u1_mps_state;

        c_Cbp |= u4_symbol << 1;

    }

    u4_cxt_inc = (!(c_Cbp & 0x01)) << 1;

    u4_cxt_inc += !((ps_left_ctxt->u1_cbp >> 3) & 0x01);

    ps_bin_ctxt = ps_ctxt_cbp_luma + u4_cxt_inc;

    /*inlining DecodeDecision_onebin without renorm*/

    {

        UWORD32 u4_qnt_int_range, u4_int_range_lps;

        UWORD32 u4_symbol, u1_mps_state;

        UWORD32 table_lookup;

        UWORD32 u4_clz;

        u1_mps_state = (ps_bin_ctxt->u1_mps_state);

        u4_clz = CLZ(u4_code_int_range);

        u4_qnt_int_range = u4_code_int_range << u4_clz;

        u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3;

        table_lookup = pu4_table[(u1_mps_state << 2) + u4_qnt_int_range];

        u4_int_range_lps = table_lookup & 0xff;

        u4_int_range_lps = u4_int_range_lps << (23 - u4_clz);

        u4_code_int_range = u4_code_int_range - u4_int_range_lps;

        u4_symbol = ((u1_mps_state >> 6) & 0x1);

        /*if mps*/

        u1_mps_state = (table_lookup >> 8) & 0x7F;

        CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, u4_symbol,

                     u4_int_range_lps, u1_mps_state, table_lookup)

        INC_BIN_COUNT(ps_cab_env);

        ps_bin_ctxt->u1_mps_state = u1_mps_state;

        c_Cbp |= u4_symbol << 2;

    }

    u4_cxt_inc = (!((c_Cbp >> 1) & 0x01)) << 1;

    u4_cxt_inc += !((c_Cbp >> 2) & 0x01);

    ps_bin_ctxt = ps_ctxt_cbp_luma + u4_cxt_inc;

    /*inlining DecodeDecision_onebin without renorm*/

    {

        UWORD32 u4_qnt_int_range, u4_int_range_lps;

        UWORD32 u4_symbol, u1_mps_state;

        UWORD32 table_lookup;

        UWORD32 u4_clz;

        u1_mps_state = (ps_bin_ctxt->u1_mps_state);

        u4_clz = CLZ(u4_code_int_range);

        u4_qnt_int_range = u4_code_int_range << u4_clz;

        u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3;

        table_lookup = pu4_table[(u1_mps_state << 2) + u4_qnt_int_range];

        u4_int_range_lps = table_lookup & 0xff;

        u4_int_range_lps = u4_int_range_lps << (23 - u4_clz);

        u4_code_int_range = u4_code_int_range - u4_int_range_lps;

        u4_symbol = ((u1_mps_state >> 6) & 0x1);

        /*if mps*/

        u1_mps_state = (table_lookup >> 8) & 0x7F;

        CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, u4_symbol,

                     u4_int_range_lps, u1_mps_state, table_lookup)

        INC_BIN_COUNT(ps_cab_env);

        ps_bin_ctxt->u1_mps_state = u1_mps_state;

        c_Cbp |= u4_symbol << 3;

    }

    if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_8)

    {

        RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,

                            pu4_buffer)

    }

    {

        UWORD32 u4_cxt_inc;

        WORD8 a, b, c, d;

        bin_ctxt_model_t *p_CtxtCbpChroma = ps_dec->p_cbp_chroma_t;

        /* CBP Chroma, TU, Cmax = 2 */

        a = 0;

        b = 0;

        c = 0;

        d = 0;

        {

            a = (ps_top_ctxt->u1_cbp > 15) ? 2 : 0;

            c = (ps_top_ctxt->u1_cbp > 31) ? 2 : 0;

        }

        {

            b = (ps_left_ctxt->u1_cbp > 15) ? 1 : 0;

            d = (ps_left_ctxt->u1_cbp > 31) ? 1 : 0;

        }

        u4_cxt_inc = a + b;

        u4_cxt_inc = (u4_cxt_inc | ((4 + c + d) << 4));

        /*inlining ih264d_decode_bins_tunary */

        {

            UWORD8 u1_max_bins = 2;

            UWORD32 u4_ctx_inc = u4_cxt_inc;

            UWORD32 u4_value;

            UWORD32 u4_symbol;

            UWORD8 u4_ctx_Inc;

            bin_ctxt_model_t *ps_bin_ctxt;

            u4_value = 0;

            do

            {

                u4_ctx_Inc = u4_ctx_inc & 0xF;

                u4_ctx_inc = u4_ctx_inc >> 4;

                ps_bin_ctxt = p_CtxtCbpChroma + u4_ctx_Inc;

                /*inlining DecodeDecision_onebin*/

                {

                    UWORD32 u4_qnt_int_range, u4_int_range_lps;

                    UWORD32 u1_mps_state;

                    UWORD32 table_lookup;

                    UWORD32 u4_clz;

                    u1_mps_state = (ps_bin_ctxt->u1_mps_state);

                    u4_clz = CLZ(u4_code_int_range);

                    u4_qnt_int_range = u4_code_int_range << u4_clz;