xref: /aosp_15_r20/external/libavc/decoder/ih264d_parse_cavlc.c (revision 495ae853bb871d1e5a258cb02c2cc13cde8ddb9a)

/******************************************************************************
 *
 * 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_cavlc.c
 *
 * \brief
 *    This file contains UVLC related functions.
 *
 * \date
 *    20/11/2002
 *
 * \author  NS
 ***************************************************************************
 */

#include <string.h>
#include <stdio.h>

#include "ih264d_bitstrm.h"
#include "ih264d_parse_cavlc.h"
#include "ih264d_error_handler.h"
#include "ih264d_defs.h"
#include "ih264d_debug.h"
#include "ih264d_cabac.h"
#include "ih264d_structs.h"
#include "ih264d_tables.h"
#include "ih264d_tables.h"
#include "ih264d_mb_utils.h"

void ih264d_unpack_coeff4x4_dc_4x4blk(tu_sblk4x4_coeff_data_t *ps_tu_4x4,
                                      WORD16 *pi2_out_coeff_data,
                                      UWORD8 *pu1_inv_scan);

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_uev                                                  */
/*                                                                           */
/*  Description   : Reads the unsigned Exp Golomb codec syntax from the      */
/*                  ps_bitstrm as specified in section 9.1 of H264 standard      */
/*                  It also increases bitstream u4_ofst by the number of bits */
/*                  parsed for UEV decode operation                          */
/*                                                                           */
/*  Inputs        : bitstream base pointer and bitsream u4_ofst in bits       */
/*  Globals       : None                                                     */
/*  Processing    :                                                          */
/*  Outputs       : UEV decoded syntax element and incremented ps_bitstrm u4_ofst */
/*  Returns       : UEV decoded syntax element                               */
/*                                                                           */
/*  Issues        : Does not check if ps_bitstrm u4_ofst exceeds max ps_bitstrm i4_size  */
/*                  for performamce. Caller might have to do error resilence */
/*                  check for bitstream overflow                             */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         19 09 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/
UWORD32 ih264d_uev(UWORD32 *pu4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf)
{
    UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
    UWORD32 u4_word, u4_ldz;

    /***************************************************************/
    /* Find leading zeros in next 32 bits                          */
    /***************************************************************/
    NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
    u4_ldz = CLZ(u4_word);
    /* Flush the ps_bitstrm */
    u4_bitstream_offset += (u4_ldz + 1);
    /* Read the suffix from the ps_bitstrm */
    u4_word = 0;
    if(u4_ldz)
        GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
    *pu4_bitstrm_ofst = u4_bitstream_offset;
    return ((1 << u4_ldz) + u4_word - 1);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_sev                                                  */
/*                                                                           */
/*  Description   : Reads the signed Exp Golomb codec syntax from the ps_bitstrm */
/*                  as specified in section 9.1 of H264 standard.            */
/*                  It also increases bitstream u4_ofst by the number of bits */
/*                  parsed for SEV decode operation                          */
/*                                                                           */
/*  Inputs        : bitstream base pointer and bitsream u4_ofst in bits       */
/*  Globals       : None                                                     */
/*  Processing    :                                                          */
/*  Outputs       : SEV decoded syntax element and incremented ps_bitstrm u4_ofst */
/*  Returns       : SEV decoded syntax element                               */
/*                                                                           */
/*  Issues        : Does not check if ps_bitstrm u4_ofst exceeds max ps_bitstrm i4_size  */
/*                  for performamce. Caller might have to do error resilence */
/*                  check for bitstream overflow                             */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         19 09 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/
WORD32 ih264d_sev(UWORD32 *pu4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf)
{
    UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst;
    UWORD32 u4_word, u4_ldz, u4_abs_val;

    /***************************************************************/
    /* Find leading zeros in next 32 bits                          */
    /***************************************************************/
    NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
    u4_ldz = CLZ(u4_word);

    /* Flush the ps_bitstrm */
    u4_bitstream_offset += (u4_ldz + 1);

    /* Read the suffix from the ps_bitstrm */
    u4_word = 0;
    if(u4_ldz)
        GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);

    *pu4_bitstrm_ofst = u4_bitstream_offset;
    u4_abs_val = ((1 << u4_ldz) + u4_word) >> 1;

    if(u4_word & 0x1)
        return (-(WORD32)u4_abs_val);
    else
        return (u4_abs_val);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : get_tev_range_1                                          */
/*                                                                           */
/*  Description   : Reads the TEV Exp Golomb codec syntax from the ps_bitstrm    */
/*                  as specified in section 9.1 of H264 standard. This will  */
/*                  called only when the input range is 1 for TEV decode.    */
/*                  If range is more than 1, then UEV decode is done         */
/*                                                                           */
/*  Inputs        : bitstream base pointer and bitsream u4_ofst in bits       */
/*  Globals       : None                                                     */
/*  Processing    :                                                          */
/*  Outputs       : TEV decoded syntax element and incremented ps_bitstrm u4_ofst */
/*  Returns       : TEV decoded syntax element                               */
/*                                                                           */
/*  Issues        : Does not check if ps_bitstrm u4_ofst exceeds max ps_bitstrm i4_size  */
/*                  for performamce. Caller might have to do error resilence */
/*                  check for bitstream overflow                             */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         19 09 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/
UWORD32 ih264d_tev_range1(UWORD32 *pu4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf)
{
    UWORD32 u4_code;
    GETBIT(u4_code, *pu4_bitstrm_ofst, pu4_bitstrm_buf);
    return (!u4_code);
}

/*!
 **************************************************************************
 * \if Function name : ih264d_uvlc \endif
 *
 * \brief
 *
 *    Reads the unsigned/signed/truncated integer Exp-Golomb-coded syntax element
 *    with the left bit first. The parsing process for this descriptor is specified
 *    in subclause 9.1.
 *
 * \param ps_bitstrm       : Pointer to Bitstream Structure .
 * \param u4_range           : Range value in case of Truncated Exp-Golomb-code
 * \param pi_bitstrm_ofst : Pointer to the local copy of Bitstream u4_ofst
 * \param u1_flag            : Flag indicating the case of UEV,SEV or TEV
 * \param u4_bitstrm_ofst : Local copy of Bitstream u4_ofst
 * \param pu4_bitstrm_buf : Pointer to the Bitstream buffer
 *
 * \return
 *    Returns Code Value.
 *
 **************************************************************************
 */

WORD32 ih264d_uvlc(dec_bit_stream_t *ps_bitstrm,
                   UWORD32 u4_range,
                   UWORD32 *pi_bitstrm_ofst,
                   UWORD8 u1_flag,
                   UWORD32 u4_bitstrm_ofst,
                   UWORD32 *pu4_bitstrm_buf)
{
    UWORD32 word, word2, cur_bit, cur_word, code_val, code_num, clz;

    SWITCHOFFTRACE;
    cur_bit = u4_bitstrm_ofst & 0x1F;
    cur_word = u4_bitstrm_ofst >> 5;
    word = pu4_bitstrm_buf[cur_word];
    word2 = pu4_bitstrm_buf[cur_word + 1];

    if(cur_bit != 0)
    {
        word <<= cur_bit;
        word2 >>= (32 - cur_bit);
        word |= word2;
    }

    if(u1_flag == TEV && u4_range == 1)
    {
        word >>= 31;
        word = 1 - word;
        (*pi_bitstrm_ofst)++;
        ps_bitstrm->u4_ofst = *pi_bitstrm_ofst;
        return (WORD32)word;
    }

    //finding clz
    {
        UWORD32 ui32_code, ui32_mask;

        ui32_code = word;
        ui32_mask = 0x80000000;
        clz = 0;

        /* DSP implements this with LMBD instruction */
        /* so there we don't need to break the loop */
        while(!(ui32_code & ui32_mask))
        {
            clz++;
            ui32_mask >>= 1;
            if(0 == ui32_mask)
                break;
        }
    }

    if(clz == 0)
    {
        *pi_bitstrm_ofst = *pi_bitstrm_ofst + (2 * clz) + 1;
        ps_bitstrm->u4_ofst = *pi_bitstrm_ofst;
        return 0;
    }

    word <<= (clz + 1);
    word >>= (32 - clz);
    code_num = (1 << clz) + word - 1;
    *pi_bitstrm_ofst = *pi_bitstrm_ofst + (2 * clz) + 1;
    ps_bitstrm->u4_ofst = *pi_bitstrm_ofst;

    if(u1_flag == TEV || u1_flag == UEV)
        return (WORD32)code_num;

    code_val = (code_num + 1) >> 1;
    if(!(code_num & 0x01))
        return -((WORD32)code_val);
    return (WORD32)code_val;

}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_cavlc_4x4res_block_totalcoeff_1                          */
/*                                                                           */
/*  Description   : This function does cavlc decoding of 4x4 block residual  */
/*                  coefficient when total coeff is equal to 1. The parsing  */
/*                  is done as defined in section 9.2.2 and 9.2.3 of the     */
/*                  H264 standard.                                           */
/*                                                                           */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : <Does it use any global variables?>                      */
/*  Processing    : <Describe how the function operates - include algorithm  */
/*                  description>                                             */
/*  Outputs       : <What does the function produce?>                        */
/*  Returns       : <What does the function return?>                         */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         25 09 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/
WORD32 ih264d_cavlc_4x4res_block_totalcoeff_1(UWORD32 u4_isdc,
                                           UWORD32 u4_total_coeff_trail_one,
                                           dec_bit_stream_t *ps_bitstrm)
{

    UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
    UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF;
    WORD32 i2_level;
    UWORD32 u4_tot_zero, u4_ldz, u4_scan_pos;

    tu_sblk4x4_coeff_data_t *ps_tu_4x4;
    WORD16 *pi2_coeff_data;
    dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle;

    ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data;
    ps_tu_4x4->u2_sig_coeff_map = 0;
    pi2_coeff_data = &ps_tu_4x4->ai2_level[0];


    if(u4_trailing_ones)
    {
        UWORD32 u4_sign;
        /****************************************************************/
        /* Decode Trailing One as in section 9.2.2                      */
        /****************************************************************/
        GETBIT(u4_sign, u4_bitstream_offset, pu4_bitstrm_buf);
        i2_level = u4_sign ? -1 : 1;
    }
    else
    {
        /****************************************************************/
        /* Decoding Level based on prefix and suffix  as in 9.2.2       */
        /****************************************************************/
        UWORD32 u4_lev_suffix, u4_lev_suffix_size;
        WORD32 u2_lev_code, u2_abs_value;
        UWORD32 u4_lev_prefix;
        /***************************************************************/
        /* Find leading zeros in next 32 bits                          */
        /***************************************************************/
        FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
                              pu4_bitstrm_buf);
        u2_lev_code = (2 + MIN(u4_lev_prefix, 15));

        if(14 == u4_lev_prefix)
            u4_lev_suffix_size = 4;
        else if(15 <= u4_lev_prefix)
        {
            u2_lev_code += 15;
            u4_lev_suffix_size = u4_lev_prefix - 3;
        }
        else
            u4_lev_suffix_size = 0;

        //HP_LEVEL_PREFIX
        if(16 <= u4_lev_prefix)
        {
            u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
        }
        if(u4_lev_suffix_size)
        {
            GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
                    u4_lev_suffix_size);
            u2_lev_code += u4_lev_suffix;
        }

        u2_abs_value = (u2_lev_code + 2) >> 1;
        /*********************************************************/
        /* If Level code is odd, level is negative else positive */
        /*********************************************************/
        i2_level = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;

    }

    /****************************************************************/
    /* Decoding total zeros as in section 9.2.3, table 9.7          */
    /****************************************************************/
    FIND_ONE_IN_STREAM_LEN(u4_ldz, u4_bitstream_offset, pu4_bitstrm_buf, 8);

    if(u4_ldz)
    {
        GETBIT(u4_tot_zero, u4_bitstream_offset, pu4_bitstrm_buf);
        u4_tot_zero = (u4_ldz << 1) - u4_tot_zero;
    }
    else
        u4_tot_zero = 0;

    /***********************************************************************/
    /* Inverse scan and store  residual coeff. Update the bitstream u4_ofst */
    /***********************************************************************/
    u4_scan_pos = u4_tot_zero + u4_isdc;
    if(u4_scan_pos > 15)
        return -1;

    SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
    *pi2_coeff_data++ = i2_level;


    {
        WORD32 offset;
        offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4;
        offset = ALIGN4(offset);
        ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset);
    }

    ps_bitstrm->u4_ofst = u4_bitstream_offset;
    return 0;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_cavlc_4x4res_block_totalcoeff_2to10                      */
/*                                                                           */
/*  Description   : This function does cavlc decoding of 4x4 block residual  */
/*                  coefficient when total coeffs are between two and ten    */
/*                  inclusive. Parsing is done as defined in section 9.2.2   */
/*                  and 9.2.3 the H264 standard.                             */
/*                                                                           */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : <Does it use any global variables?>                      */
/*  Processing    : <Describe how the function operates - include algorithm  */
/*                  description>                                             */
/*  Outputs       : <What does the function produce?>                        */
/*  Returns       : <What does the function return?>                         */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         25 09 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/

WORD32 ih264d_cavlc_4x4res_block_totalcoeff_2to10(UWORD32 u4_isdc,
                                               UWORD32 u4_total_coeff_trail_one, /*!<TotalCoefficients<<16+trailingones*/
                                               dec_bit_stream_t *ps_bitstrm)
{
    UWORD32 u4_total_zeroes;
    WORD32 i;
    UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
    UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF;
    UWORD32 u4_total_coeff = u4_total_coeff_trail_one >> 16;
    // To avoid error check at 4x4 level, allocating for 3 extra levels(16+3)
    // since u4_trailing_ones can at the max be 3. This will be required when
    // u4_total_coeff is less than u4_trailing_ones
    WORD16 ai2_level_arr[19];
    WORD16 *i2_level_arr = &ai2_level_arr[3];

    tu_sblk4x4_coeff_data_t *ps_tu_4x4;
    WORD16 *pi2_coeff_data;
    dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle;

    ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data;
    ps_tu_4x4->u2_sig_coeff_map = 0;
    pi2_coeff_data = &ps_tu_4x4->ai2_level[0];

    i = u4_total_coeff - 1;

    if(u4_trailing_ones)
    {
        /*********************************************************************/
        /* Decode Trailing Ones                                              */
        /* read the sign of T1's and put them in level array                 */
        /*********************************************************************/
        UWORD32 u4_signs, u4_cnt = u4_trailing_ones;
        WORD16 (*ppi2_trlone_lkup)[3] =
                        (WORD16 (*)[3])gai2_ih264d_trailing_one_level;
        WORD16 *pi2_trlone_lkup;

        GETBITS(u4_signs, u4_bitstream_offset, pu4_bitstrm_buf, u4_cnt);

        pi2_trlone_lkup = ppi2_trlone_lkup[(1 << u4_cnt) - 2 + u4_signs];

        while(u4_cnt)
        {
            i2_level_arr[i--] = *pi2_trlone_lkup++;
            u4_cnt--;
        }
    }

    /****************************************************************/
    /* Decoding Levels Begins                                       */
    /****************************************************************/
    if(i >= 0)
    {
        /****************************************************************/
        /* First level is decoded outside the loop as it has lot of     */
        /* special cases.                                               */
        /****************************************************************/
        UWORD32 u4_lev_suffix, u4_suffix_len, u4_lev_suffix_size;
        WORD32 u2_lev_code, u2_abs_value;
        UWORD32 u4_lev_prefix;

        /***************************************************************/
        /* u4_suffix_len = 0,  Find leading zeros in next 32 bits      */
        /***************************************************************/
        FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
                              pu4_bitstrm_buf);

        /*********************************************************/
        /* Special decoding case when trailing ones are 3        */
        /*********************************************************/
        u2_lev_code = MIN(15, u4_lev_prefix);

        u2_lev_code += (3 == u4_trailing_ones) ? 0 : 2;

        if(14 == u4_lev_prefix)
            u4_lev_suffix_size = 4;
        else if(15 <= u4_lev_prefix)
        {
            u2_lev_code += 15;
            u4_lev_suffix_size = u4_lev_prefix - 3;
        }
        else
            u4_lev_suffix_size = 0;

        //HP_LEVEL_PREFIX
        if(16 <= u4_lev_prefix)
        {
            u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
        }
        if(u4_lev_suffix_size)
        {
            GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
                    u4_lev_suffix_size);
            u2_lev_code += u4_lev_suffix;
        }

        u2_abs_value = (u2_lev_code + 2) >> 1;
        /*********************************************************/
        /* If Level code is odd, level is negative else positive */
        /*********************************************************/
        i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;

        u4_suffix_len = (u2_abs_value > 3) ? 2 : 1;

        /*********************************************************/
        /* Now loop over the remaining levels                    */
        /*********************************************************/
        while(i >= 0)
        {

            /***************************************************************/
            /* Find leading zeros in next 32 bits                          */
            /***************************************************************/
            FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
                                  pu4_bitstrm_buf);

            u4_lev_suffix_size =
                            (15 <= u4_lev_prefix) ?
                                            (u4_lev_prefix - 3) : u4_suffix_len;

            /*********************************************************/
            /* Compute level code using prefix and suffix            */
            /*********************************************************/
            GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
                    u4_lev_suffix_size);
            u2_lev_code = (MIN(15,u4_lev_prefix) << u4_suffix_len)
                            + u4_lev_suffix;

            //HP_LEVEL_PREFIX
            if(16 <= u4_lev_prefix)
            {
                u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
            }
            u2_abs_value = (u2_lev_code + 2) >> 1;

            /*********************************************************/
            /* If Level code is odd, level is negative else positive */
            /*********************************************************/
            i2_level_arr[i--] =
                            (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;

            /*********************************************************/
            /* Increment suffix length if required                   */
            /*********************************************************/
            u4_suffix_len +=
                            (u4_suffix_len < 6) ?
                                            (u2_abs_value
                                                            > (3
                                                                            << (u4_suffix_len
                                                                                            - 1))) :
                                            0;
        }

        /****************************************************************/
        /* Decoding Levels Ends                                         */
        /****************************************************************/
    }

    /****************************************************************/
    /* Decoding total zeros as in section 9.2.3, table 9.7          */
    /****************************************************************/
    {
        UWORD32 u4_index;
        const UWORD8 (*ppu1_total_zero_lkup)[64] =
                        (const UWORD8 (*)[64])gau1_ih264d_table_total_zero_2to10;

        NEXTBITS(u4_index, u4_bitstream_offset, pu4_bitstrm_buf, 6);
        u4_total_zeroes = ppu1_total_zero_lkup[u4_total_coeff - 2][u4_index];

        FLUSHBITS(u4_bitstream_offset, (u4_total_zeroes >> 4));
        u4_total_zeroes &= 0xf;
    }

    /**************************************************************/
    /* Decode the runs and form the coefficient buffer            */
    /**************************************************************/
    {
        const UWORD8 *pu1_table_runbefore;
        UWORD32 u4_run;
        WORD32 k;
        WORD32 u4_scan_pos = u4_total_coeff + u4_total_zeroes - 1 + u4_isdc;
        WORD32 u4_zeroes_left = u4_total_zeroes;
        k = u4_total_coeff - 1;

        /**************************************************************/
        /* Decoding Runs Begin for zeros left > 6                     */
        /**************************************************************/
        while((u4_zeroes_left > 6) && k)
        {
            UWORD32 u4_code;

            NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3);

            if(u4_code != 0)
            {
                FLUSHBITS(u4_bitstream_offset, 3);
                u4_run = (7 - u4_code);
            }
            else
            {

                FIND_ONE_IN_STREAM_LEN(u4_code, u4_bitstream_offset,
                                       pu4_bitstrm_buf, 11);
                u4_run = (4 + u4_code);
            }

            SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
            *pi2_coeff_data++ = i2_level_arr[k--];
            u4_zeroes_left -= (WORD32)u4_run;
            u4_scan_pos -= (WORD32)(u4_run + 1);
        }

        if (u4_zeroes_left < 0 || u4_scan_pos < 0)
            return -1;

        /**************************************************************/
        /* Decoding Runs for 0 < zeros left <=6                       */
        /**************************************************************/
        pu1_table_runbefore = (UWORD8 *)gau1_ih264d_table_run_before;
        while((u4_zeroes_left > 0) && k)
        {
            UWORD32 u4_code;
            NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3);

            u4_code = pu1_table_runbefore[u4_code + (u4_zeroes_left << 3)];
            u4_run = u4_code >> 2;

            FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03));

            SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
            *pi2_coeff_data++ = i2_level_arr[k--];
            u4_zeroes_left -= (WORD32)u4_run;
            u4_scan_pos -= (WORD32)(u4_run + 1);
        }
        if (u4_zeroes_left < 0 || u4_scan_pos < 0)
            return -1;
        /**************************************************************/
        /* Decoding Runs End                                          */
        /**************************************************************/

        /**************************************************************/
        /* Copy the remaining coefficients                            */
        /**************************************************************/
        while(k >= 0)
        {

            SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
            *pi2_coeff_data++ = i2_level_arr[k--];
            u4_scan_pos--;
        }
    }

    {
        WORD32 offset;
        offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4;
        offset = ALIGN4(offset);
        ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset);
    }

    ps_bitstrm->u4_ofst = u4_bitstream_offset;
    return 0;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_cavlc_4x4res_block_totalcoeff_11to16                     */
/*                                                                           */
/*  Description   : This function does cavlc decoding of 4x4 block residual  */
/*                  coefficient when total coeffs are greater than ten.      */
/*                  Parsing is done as defined in section 9.2.2 and 9.2.3 of */
/*                  the H264 standard.                                       */
/*                                                                           */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : <Does it use any global variables?>                      */
/*  Processing    : <Describe how the function operates - include algorithm  */
/*                  description>                                             */
/*  Outputs       : <What does the function produce?>                        */
/*  Returns       : <What does the function return?>                         */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         25 09 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/

WORD32 ih264d_cavlc_4x4res_block_totalcoeff_11to16(UWORD32 u4_isdc,
                                                UWORD32 u4_total_coeff_trail_one, /*!<TotalCoefficients<<16+trailingones*/
                                                dec_bit_stream_t *ps_bitstrm )
{
    UWORD32 u4_total_zeroes;
    WORD32 i;
    UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
    UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF;
    UWORD32 u4_total_coeff = u4_total_coeff_trail_one >> 16;
    // To avoid error check at 4x4 level, allocating for 3 extra levels(16+3)
    // since u4_trailing_ones can at the max be 3. This will be required when
    // u4_total_coeff is less than u4_trailing_ones
    WORD16 ai2_level_arr[19];//
    WORD16 *i2_level_arr = &ai2_level_arr[3];

    tu_sblk4x4_coeff_data_t *ps_tu_4x4;
    WORD16 *pi2_coeff_data;
    dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle;

    ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data;
    ps_tu_4x4->u2_sig_coeff_map = 0;
    pi2_coeff_data = &ps_tu_4x4->ai2_level[0];

    i = u4_total_coeff - 1;
    if(u4_trailing_ones)
    {
        /*********************************************************************/
        /* Decode Trailing Ones                                              */
        /* read the sign of T1's and put them in level array                 */
        /*********************************************************************/
        UWORD32 u4_signs, u4_cnt = u4_trailing_ones;
        WORD16 (*ppi2_trlone_lkup)[3] =
                        (WORD16 (*)[3])gai2_ih264d_trailing_one_level;
        WORD16 *pi2_trlone_lkup;

        GETBITS(u4_signs, u4_bitstream_offset, pu4_bitstrm_buf, u4_cnt);

        pi2_trlone_lkup = ppi2_trlone_lkup[(1 << u4_cnt) - 2 + u4_signs];

        while(u4_cnt)
        {
            i2_level_arr[i--] = *pi2_trlone_lkup++;
            u4_cnt--;
        }
    }

    /****************************************************************/
    /* Decoding Levels Begins                                       */
    /****************************************************************/
    if(i >= 0)
    {
        /****************************************************************/
        /* First level is decoded outside the loop as it has lot of     */
        /* special cases.                                               */
        /****************************************************************/
        UWORD32 u4_lev_suffix, u4_suffix_len, u4_lev_suffix_size;
        UWORD16 u2_lev_code, u2_abs_value;
        UWORD32 u4_lev_prefix;

        if(u4_trailing_ones < 3)
        {
            /*********************************************************/
            /* u4_suffix_len = 1                                     */
            /*********************************************************/
            /***************************************************************/
            /* Find leading zeros in next 32 bits                          */
            /***************************************************************/
            FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
                                  pu4_bitstrm_buf);

            u4_lev_suffix_size =
                            (15 <= u4_lev_prefix) ? (u4_lev_prefix - 3) : 1;

            GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
                    u4_lev_suffix_size);
            u2_lev_code = 2 + (MIN(u4_lev_prefix,15) << 1) + u4_lev_suffix;

            //HP_LEVEL_PREFIX
            if(16 <= u4_lev_prefix)
            {
                u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
            }
        }
        else
        {
            /*********************************************************/
            /*u4_suffix_len = 0                                      */
            /*********************************************************/
            /***************************************************************/
            /* Find leading zeros in next 32 bits                          */
            /***************************************************************/
            FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
                                  pu4_bitstrm_buf);

            /*********************************************************/
            /* Special decoding case when trailing ones are 3        */
            /*********************************************************/
            u2_lev_code = MIN(15, u4_lev_prefix);

            u2_lev_code += (3 == u4_trailing_ones) ? 0 : (2);

            if(14 == u4_lev_prefix)
                u4_lev_suffix_size = 4;
            else if(15 <= u4_lev_prefix)
            {
                u2_lev_code += 15;
                u4_lev_suffix_size = (u4_lev_prefix - 3);
            }
            else
                u4_lev_suffix_size = 0;

            //HP_LEVEL_PREFIX
            if(16 <= u4_lev_prefix)
            {
                u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
            }
            if(u4_lev_suffix_size)
            {
                GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
                        u4_lev_suffix_size);
                u2_lev_code += u4_lev_suffix;
            }
        }

        u2_abs_value = (u2_lev_code + 2) >> 1;
        /*********************************************************/
        /* If Level code is odd, level is negative else positive */
        /*********************************************************/
        i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;

        u4_suffix_len = (u2_abs_value > 3) ? 2 : 1;

        /*********************************************************/
        /* Now loop over the remaining levels                    */
        /*********************************************************/
        while(i >= 0)
        {

            /***************************************************************/
            /* Find leading zeros in next 32 bits                          */
            /***************************************************************/
            FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
                                  pu4_bitstrm_buf);

            u4_lev_suffix_size =
                            (15 <= u4_lev_prefix) ?
                                            (u4_lev_prefix - 3) : u4_suffix_len;

            /*********************************************************/
            /* Compute level code using prefix and suffix            */
            /*********************************************************/
            GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
                    u4_lev_suffix_size);
            u2_lev_code = (MIN(15,u4_lev_prefix) << u4_suffix_len)
                            + u4_lev_suffix;

            //HP_LEVEL_PREFIX
            if(16 <= u4_lev_prefix)
            {
                u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
            }
            u2_abs_value = (u2_lev_code + 2) >> 1;

            /*********************************************************/
            /* If Level code is odd, level is negative else positive */
            /*********************************************************/
            i2_level_arr[i--] =
                            (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;

            /*********************************************************/
            /* Increment suffix length if required                   */
            /*********************************************************/
            u4_suffix_len +=
                            (u4_suffix_len < 6) ?
                                            (u2_abs_value
                                                            > (3
                                                                            << (u4_suffix_len
                                                                                            - 1))) :
                                            0;
        }

        /****************************************************************/
        /* Decoding Levels Ends                                         */
        /****************************************************************/
    }

    if(u4_total_coeff < (16 - u4_isdc))
    {
        UWORD32 u4_index;
        const UWORD8 (*ppu1_total_zero_lkup)[16] =
                        (const UWORD8 (*)[16])gau1_ih264d_table_total_zero_11to15;

        NEXTBITS(u4_index, u4_bitstream_offset, pu4_bitstrm_buf, 4);
        u4_total_zeroes = ppu1_total_zero_lkup[u4_total_coeff - 11][u4_index];

        FLUSHBITS(u4_bitstream_offset, (u4_total_zeroes >> 4));
        u4_total_zeroes &= 0xf;
    }
    else
        u4_total_zeroes = 0;

    /**************************************************************/
    /* Decode the runs and form the coefficient buffer            */
    /**************************************************************/
    {
        const UWORD8 *pu1_table_runbefore;
        UWORD32 u4_run;
        WORD32 k;
        WORD32 u4_scan_pos = u4_total_coeff + u4_total_zeroes - 1 + u4_isdc;
        WORD32 u4_zeroes_left = u4_total_zeroes;
        k = u4_total_coeff - 1;

        /**************************************************************/
        /* Decoding Runs for 0 < zeros left <=6                       */
        /**************************************************************/
        pu1_table_runbefore = (UWORD8 *)gau1_ih264d_table_run_before;
        while((u4_zeroes_left > 0) && k)
        {
            UWORD32 u4_code;
            NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3);

            u4_code = pu1_table_runbefore[u4_code + (u4_zeroes_left << 3)];
            u4_run = u4_code >> 2;

            FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03));
            SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
            *pi2_coeff_data++ = i2_level_arr[k--];
            u4_zeroes_left -= (WORD32)u4_run;
            u4_scan_pos -= (WORD32)(u4_run + 1);
        }
        if (u4_zeroes_left < 0 || u4_scan_pos < 0)
          return -1;

        /**************************************************************/
        /* Decoding Runs End                                          */
        /**************************************************************/

        /**************************************************************/
        /* Copy the remaining coefficients                            */
        /**************************************************************/
        while(k >= 0)
        {
            SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
            *pi2_coeff_data++ = i2_level_arr[k--];
            u4_scan_pos--;
        }
    }

    {
        WORD32 offset;
        offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4;
        offset = ALIGN4(offset);
        ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset);
    }

    ps_bitstrm->u4_ofst = u4_bitstream_offset;
    return 0;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_rest_of_residual_cav_chroma_dc_block              */
/*                                                                           */
/*  Description   : This function does the Cavlc parsing of the bitstream    */
/*                  for chroma dc coefficients                               */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : <Does it use any global variables?>                      */
/*  Processing    : <Describe how the function operates - include algorithm  */
/*                  description>                                             */
/*  Outputs       : <What does the function produce?>                        */
/*  Returns       : <What does the function return?>                         */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         15 09 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/
void ih264d_rest_of_residual_cav_chroma_dc_block(UWORD32 u4_total_coeff_trail_one,
                                                 dec_bit_stream_t *ps_bitstrm)
{
    UWORD32 u4_total_zeroes;
    WORD16 i;
    UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
    UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF;
    UWORD32 u4_total_coeff = u4_total_coeff_trail_one >> 16;
    // To avoid error check at 4x4 level, allocating for 3 extra levels(4+3)
    // since u4_trailing_ones can at the max be 3. This will be required when
    // u4_total_coeff is less than u4_trailing_ones
    WORD16 ai2_level_arr[7];//
    WORD16 *i2_level_arr = &ai2_level_arr[3];

    tu_sblk4x4_coeff_data_t *ps_tu_4x4;
    WORD16 *pi2_coeff_data;
    dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle;

    ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data;
    ps_tu_4x4->u2_sig_coeff_map = 0;
    pi2_coeff_data = &ps_tu_4x4->ai2_level[0];

    i = u4_total_coeff - 1;
    if(u4_trailing_ones)
    {
        /*********************************************************************/
        /* Decode Trailing Ones                                              */
        /* read the sign of T1's and put them in level array                 */
        /*********************************************************************/
        UWORD32 u4_signs, u4_cnt = u4_trailing_ones;
        WORD16 (*ppi2_trlone_lkup)[3] =
                        (WORD16 (*)[3])gai2_ih264d_trailing_one_level;
        WORD16 *pi2_trlone_lkup;

        GETBITS(u4_signs, u4_bitstream_offset, pu4_bitstrm_buf, u4_cnt);

        pi2_trlone_lkup = ppi2_trlone_lkup[(1 << u4_cnt) - 2 + u4_signs];

        while(u4_cnt)
        {
            i2_level_arr[i--] = *pi2_trlone_lkup++;
            u4_cnt--;
        }
    }

    /****************************************************************/
    /* Decoding Levels Begins                                       */
    /****************************************************************/
    if(i >= 0)
    {
        /****************************************************************/
        /* First level is decoded outside the loop as it has lot of     */
        /* special cases.                                               */
        /****************************************************************/
        UWORD32 u4_lev_suffix, u4_suffix_len, u4_lev_suffix_size;
        UWORD16 u2_lev_code, u2_abs_value;
        UWORD32 u4_lev_prefix;

        /***************************************************************/
        /* u4_suffix_len = 0,  Find leading zeros in next 32 bits      */
        /***************************************************************/
        FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
                              pu4_bitstrm_buf);

        /*********************************************************/
        /* Special decoding case when trailing ones are 3        */
        /*********************************************************/
        u2_lev_code = MIN(15, u4_lev_prefix);

        u2_lev_code += (3 == u4_trailing_ones) ? 0 : (2);

        if(14 == u4_lev_prefix)
            u4_lev_suffix_size = 4;
        else if(15 <= u4_lev_prefix)
        {
            u2_lev_code += 15;
            u4_lev_suffix_size = u4_lev_prefix - 3;
        }
        else
            u4_lev_suffix_size = 0;

        //HP_LEVEL_PREFIX
        if(16 <= u4_lev_prefix)
        {
            u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
        }
        if(u4_lev_suffix_size)
        {
            GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
                    u4_lev_suffix_size);
            u2_lev_code += u4_lev_suffix;
        }

        u2_abs_value = (u2_lev_code + 2) >> 1;
        /*********************************************************/
        /* If Level code is odd, level is negative else positive */
        /*********************************************************/
        i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;

        u4_suffix_len = (u2_abs_value > 3) ? 2 : 1;

        /*********************************************************/
        /* Now loop over the remaining levels                    */
        /*********************************************************/
        while(i >= 0)
        {

            /***************************************************************/
            /* Find leading zeros in next 32 bits                          */
            /***************************************************************/
            FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset,
                                  pu4_bitstrm_buf);

            u4_lev_suffix_size =
                            (15 <= u4_lev_prefix) ?
                                            (u4_lev_prefix - 3) : u4_suffix_len;

            /*********************************************************/
            /* Compute level code using prefix and suffix            */
            /*********************************************************/
            GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf,
                    u4_lev_suffix_size);
            u2_lev_code = (MIN(u4_lev_prefix,15) << u4_suffix_len)
                            + u4_lev_suffix;

            //HP_LEVEL_PREFIX
            if(16 <= u4_lev_prefix)
            {
                u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096);
            }
            u2_abs_value = (u2_lev_code + 2) >> 1;

            /*********************************************************/
            /* If Level code is odd, level is negative else positive */
            /*********************************************************/
            i2_level_arr[i--] =
                            (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value;

            /*********************************************************/
            /* Increment suffix length if required                   */
            /*********************************************************/
            u4_suffix_len += (u2_abs_value > (3 << (u4_suffix_len - 1)));
        }

        /****************************************************************/
        /* Decoding Levels Ends                                         */
        /****************************************************************/
    }

    if(u4_total_coeff < 4)
    {
        UWORD32 u4_max_ldz = (4 - u4_total_coeff);
        FIND_ONE_IN_STREAM_LEN(u4_total_zeroes, u4_bitstream_offset,
                               pu4_bitstrm_buf, u4_max_ldz);
    }
    else
        u4_total_zeroes = 0;

    /**************************************************************/
    /* Decode the runs and form the coefficient buffer            */
    /**************************************************************/
    {
        const UWORD8 *pu1_table_runbefore;
        UWORD32 u4_run;
        WORD32 u4_scan_pos = (u4_total_coeff + u4_total_zeroes - 1);
        UWORD32 u4_zeroes_left = u4_total_zeroes;
        i = u4_total_coeff - 1;

        /**************************************************************/
        /* Decoding Runs for 0 < zeros left <=6                       */
        /**************************************************************/
        pu1_table_runbefore = (UWORD8 *)gau1_ih264d_table_run_before;
        while(u4_zeroes_left && i)
        {
            UWORD32 u4_code;
            NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3);

            u4_code = pu1_table_runbefore[u4_code + (u4_zeroes_left << 3)];
            u4_run = u4_code >> 2;

            FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03));
            SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
            *pi2_coeff_data++ = i2_level_arr[i--];
            u4_zeroes_left -= (WORD32)u4_run;
            u4_scan_pos -= (WORD32)(u4_run + 1);
        }
        /**************************************************************/
        /* Decoding Runs End                                          */
        /**************************************************************/

        /**************************************************************/
        /* Copy the remaining coefficients                            */
        /**************************************************************/
        while(i >= 0)
        {
            SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos);
            *pi2_coeff_data++ = i2_level_arr[i--];
            u4_scan_pos--;
        }
    }

    {
        WORD32 offset;
        offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4;
        offset = ALIGN4(offset);
        ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset);
    }

    ps_bitstrm->u4_ofst = u4_bitstream_offset;
}

/*!
 **************************************************************************
 * \if Function name : CavlcParsingInvScanInvQuant \endif
 *
 * \brief
 *    This function do cavlc parsing of coefficient tokens for any block
 *    type except chromDc and depending
 *    on whenther any coefficients to be parsed calls module
 *    RestOfResidualBlockCavlc.
 *
 * \return
 *    Returns total number of non-zero coefficients.
 *
 **************************************************************************
 */

WORD32 ih264d_cavlc_parse4x4coeff_n0to7(WORD16 *pi2_coeff_block,
                                        UWORD32 u4_isdc, /* is it a DC block */
                                        WORD32 u4_n,
                                        dec_struct_t *ps_dec,
                                        UWORD32 *pu4_total_coeff)
{
    dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
    UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
    UWORD32 u4_code, u4_index, u4_ldz;
    const UWORD16 *pu2_code = (const UWORD16*)gau2_ih264d_code_gx;
    const UWORD16 *pu2_offset_num_vlc =
                    (const UWORD16 *)gau2_ih264d_offset_num_vlc_tab;
    UWORD32 u4_offset_num_vlc = pu2_offset_num_vlc[u4_n];


    UNUSED(pi2_coeff_block);
    *pu4_total_coeff = 0;
    FIND_ONE_IN_STREAM_32(u4_ldz, u4_bitstream_offset, pu4_bitstrm_buf);
    NEXTBITS(u4_index, u4_bitstream_offset, pu4_bitstrm_buf, 3);
    u4_index += (u4_ldz << 3);
    u4_index += u4_offset_num_vlc;

    u4_index = MIN(u4_index, 303);
    u4_code = pu2_code[u4_index];

    FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03));
    ps_bitstrm->u4_ofst = u4_bitstream_offset;
    *pu4_total_coeff = (u4_code >> 4);

    if(*pu4_total_coeff)
    {
        UWORD32 u4_trailing_ones, u4_offset, u4_total_coeff_tone;
        const UWORD8 *pu1_offset =
                        (UWORD8 *)gau1_ih264d_total_coeff_fn_ptr_offset;
        WORD32 ret;
        u4_trailing_ones = ((u4_code >> 2) & 0x03);
        u4_offset = pu1_offset[*pu4_total_coeff - 1];
        u4_total_coeff_tone = (*pu4_total_coeff << 16) | u4_trailing_ones;

        ret = ps_dec->pf_cavlc_4x4res_block[u4_offset](u4_isdc,
                                                       u4_total_coeff_tone,
                                                       ps_bitstrm);
        if(ret != 0)
            return ERROR_CAVLC_NUM_COEFF_T;
    }

    return OK;
}

WORD32 ih264d_cavlc_parse4x4coeff_n8(WORD16 *pi2_coeff_block,
                                     UWORD32 u4_isdc, /* is it a DC block */
                                     WORD32 u4_n,
                                     dec_struct_t *ps_dec,
                                     UWORD32 *pu4_total_coeff)
{

    dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
    UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
    UWORD32 u4_code;
    UNUSED(u4_n);
    UNUSED(pi2_coeff_block);
    GETBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 6);
    ps_bitstrm->u4_ofst = u4_bitstream_offset;
    *pu4_total_coeff = 0;

    if(u4_code != 3)
    {
        UWORD8 *pu1_offset = (UWORD8 *)gau1_ih264d_total_coeff_fn_ptr_offset;
        UWORD32 u4_trailing_ones, u4_offset, u4_total_coeff_tone;

        *pu4_total_coeff = (u4_code >> 2) + 1;
        u4_trailing_ones = u4_code & 0x03;
        u4_offset = pu1_offset[*pu4_total_coeff - 1];
        u4_total_coeff_tone = (*pu4_total_coeff << 16) | u4_trailing_ones;

        ps_dec->pf_cavlc_4x4res_block[u4_offset](u4_isdc,
                                                 u4_total_coeff_tone,
                                                 ps_bitstrm);
    }

    return OK;
}

/*!
 **************************************************************************
 * \if Function name : ih264d_cavlc_parse_chroma_dc \endif
 *
 * \brief
 *    This function do cavlc parsing of coefficient tokens chromDc block
 *    and depending  on whenther any coefficients to be parsed calls module
 *    ih264d_rest_of_residual_cav_chroma_dc_block.
 *
 * \return
 *    Returns total number of non-zero coefficients.
 *
 **************************************************************************
 */

void ih264d_cavlc_parse_chroma_dc(dec_mb_info_t *ps_cur_mb_info,
                                  WORD16 *pi2_coeff_block,
                                  dec_bit_stream_t *ps_bitstrm,
                                  UWORD32 u4_scale_u,
                                  UWORD32 u4_scale_v,
                                  WORD32 i4_mb_inter_inc)
{
    UWORD32 u4_total_coeff, u4_trailing_ones, u4_total_coeff_tone, u4_code;
    UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst;
    const UWORD8 *pu1_cav_chromdc = (const UWORD8*)gau1_ih264d_cav_chromdc_vld;
    UNUSED(i4_mb_inter_inc);
    /******************************************************************/
    /*  Chroma DC Block for U component                               */
    /******************************************************************/
    NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 8);

    u4_code = pu1_cav_chromdc[u4_code];

    FLUSHBITS(u4_bitstream_offset, ((u4_code & 0x7) + 1));
    ps_bitstrm->u4_ofst = u4_bitstream_offset;

    u4_total_coeff = (u4_code >> 5);

    if(u4_total_coeff)
    {
        WORD32 i_z0, i_z1, i_z2, i_z3;
        tu_sblk4x4_coeff_data_t *ps_tu_4x4;
        dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle;
        WORD16 ai2_dc_coef[4];
        UWORD8 pu1_inv_scan[4] =
                        { 0, 1, 2, 3 };
        WORD16 *pi2_coeff_data =
                                    (WORD16 *)ps_dec->pv_parse_tu_coeff_data;

        ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data;

        u4_trailing_ones = ((u4_code >> 3) & 0x3);
        u4_total_coeff_tone = (u4_total_coeff << 16) | u4_trailing_ones;
        ih264d_rest_of_residual_cav_chroma_dc_block(u4_total_coeff_tone,
                                                    ps_bitstrm);

        ai2_dc_coef[0] = 0;
        ai2_dc_coef[1] = 0;
        ai2_dc_coef[2] = 0;
        ai2_dc_coef[3] = 0;

        ih264d_unpack_coeff4x4_dc_4x4blk(ps_tu_4x4,
                                         ai2_dc_coef,
                                         pu1_inv_scan);
        /*-------------------------------------------------------------------*/
        /* Inverse 2x2 transform and scaling  of chroma DC                   */
        /*-------------------------------------------------------------------*/
        i_z0 = (ai2_dc_coef[0] + ai2_dc_coef[2]);
        i_z1 = (ai2_dc_coef[0] - ai2_dc_coef[2]);
        i_z2 = (ai2_dc_coef[1] - ai2_dc_coef[3]);
        i_z3 = (ai2_dc_coef[1] + ai2_dc_coef[3]);

        /*-----------------------------------------------------------*/
        /* Scaling and storing the values back                       */
        /*-----------------------------------------------------------*/
        *pi2_coeff_data++ = (WORD16)(((i_z0 + i_z3) * (WORD32)u4_scale_u) >> 5);
        *pi2_coeff_data++ = (WORD16)(((i_z0 - i_z3) * (WORD32)u4_scale_u) >> 5);
        *pi2_coeff_data++ = (WORD16)(((i_z1 + i_z2) * (WORD32)u4_scale_u) >> 5);
        *pi2_coeff_data++ = (WORD16)(((i_z1 - i_z2) * (WORD32)u4_scale_u) >> 5);

        ps_dec->pv_parse_tu_coeff_data = (void *)pi2_coeff_data;

        SET_BIT(ps_cur_mb_info->u1_yuv_dc_block_flag,1);
    }

    /******************************************************************/
    /*  Chroma DC Block for V component                               */
    /******************************************************************/
    pi2_coeff_block += 64;
    u4_bitstream_offset = ps_bitstrm->u4_ofst;

    NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 8);

    u4_code = pu1_cav_chromdc[u4_code];

    FLUSHBITS(u4_bitstream_offset, ((u4_code & 0x7) + 1));
    ps_bitstrm->u4_ofst = u4_bitstream_offset;

    u4_total_coeff = (u4_code >> 5);

    if(u4_total_coeff)
    {
        WORD32 i_z0, i_z1, i_z2, i_z3;
        tu_sblk4x4_coeff_data_t *ps_tu_4x4;
        dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle;
        WORD16 ai2_dc_coef[4];
        UWORD8 pu1_inv_scan[4] =
                        { 0, 1, 2, 3 };
        WORD16 *pi2_coeff_data =
                                    (WORD16 *)ps_dec->pv_parse_tu_coeff_data;

        ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data;

        u4_trailing_ones = ((u4_code >> 3) & 0x3);
        u4_total_coeff_tone = (u4_total_coeff << 16) | u4_trailing_ones;
        ih264d_rest_of_residual_cav_chroma_dc_block(u4_total_coeff_tone,
                                                    ps_bitstrm);

        ai2_dc_coef[0] = 0;
        ai2_dc_coef[1] = 0;
        ai2_dc_coef[2] = 0;
        ai2_dc_coef[3] = 0;

        ih264d_unpack_coeff4x4_dc_4x4blk(ps_tu_4x4,
                                         ai2_dc_coef,
                                         pu1_inv_scan);

        /*-------------------------------------------------------------------*/
        /* Inverse 2x2 transform and scaling  of chroma DC                   */
        /*-------------------------------------------------------------------*/
        i_z0 = (ai2_dc_coef[0] + ai2_dc_coef[2]);
        i_z1 = (ai2_dc_coef[0] - ai2_dc_coef[2]);
        i_z2 = (ai2_dc_coef[1] - ai2_dc_coef[3]);
        i_z3 = (ai2_dc_coef[1] + ai2_dc_coef[3]);

        /*-----------------------------------------------------------*/
        /* Scaling and storing the values back                       */
        /*-----------------------------------------------------------*/
        *pi2_coeff_data++ = (WORD16)(((i_z0 + i_z3) * (WORD32)u4_scale_v) >> 5);
        *pi2_coeff_data++ = (WORD16)(((i_z0 - i_z3) * (WORD32)u4_scale_v) >> 5);
        *pi2_coeff_data++ = (WORD16)(((i_z1 + i_z2) * (WORD32)u4_scale_v) >> 5);
        *pi2_coeff_data++ = (WORD16)(((i_z1 - i_z2) * (WORD32)u4_scale_v) >> 5);

        ps_dec->pv_parse_tu_coeff_data = (void *)pi2_coeff_data;

        SET_BIT(ps_cur_mb_info->u1_yuv_dc_block_flag,2);
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_parse_pmb_ref_index_cavlc_range1                         */
/*                                                                           */
/*  Description   : This function does the Cavlc  TEV range =1 parsing of    */
/*                  reference index  for a P MB. Range is 1 when             */
/*                  num_ref_idx_active_minus1 is 0                           */
/*                                                                           */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : <Does it use any global variables?>                      */
/*  Processing    : <Describe how the function operates - include algorithm  */
/*                  description>                                             */
/*  Outputs       : <What does the function produce?>                        */
/*  Returns       : <What does the function return?>                         */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         19 09 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/
void ih264d_parse_pmb_ref_index_cavlc_range1(UWORD32 u4_num_part, /* Number of partitions in MB      */
                                             dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */
                                             WORD8 *pi1_ref_idx, /* pointer to reference index array */
                                             UWORD32 u4_num_ref_idx_active_minus1 /* Not used for range 1    */
                                             )
{
    UWORD32 u4_i;
    UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst;
    UNUSED(u4_num_ref_idx_active_minus1);
    for(u4_i = 0; u4_i < u4_num_part; u4_i++)
    {
        UWORD32 u4_ref_idx;
        u4_ref_idx = ih264d_tev_range1(pu4_bitstream_off, pu4_bitstrm_buf);

        /* Storing Reference Idx Information */
        pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx;
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_parse_pmb_ref_index_cavlc                                */
/*                                                                           */
/*  Description   : This function does the Cavlc  TEV range > 1 parsing of   */
/*                  reference index  for a P MB.                             */
/*                  Range > 1 when num_ref_idx_active_minus1 > 0             */
/*                                                                           */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : <Does it use any global variables?>                      */
/*  Processing    : <Describe how the function operates - include algorithm  */
/*                  description>                                             */
/*  Outputs       : <What does the function produce?>                        */
/*  Returns       : <What does the function return?>                         */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         19 09 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/

WORD32 ih264d_parse_pmb_ref_index_cavlc(UWORD32 u4_num_part, /* Number of partitions in MB      */
                                      dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */
                                      WORD8 *pi1_ref_idx, /* pointer to reference index array */
                                      UWORD32 u4_num_ref_idx_active_minus1 /* Number of active references - 1  */
                                      )
{
    UWORD32 u4_i;
    UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst;

    for(u4_i = 0; u4_i < u4_num_part; u4_i++)
    {
        UWORD32 u4_ref_idx;
//Inlined ih264d_uev
        UWORD32 u4_bitstream_offset = *pu4_bitstream_off;
        UWORD32 u4_word, u4_ldz;

        /***************************************************************/
        /* Find leading zeros in next 32 bits                          */
        /***************************************************************/
        NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
        u4_ldz = CLZ(u4_word);
        /* Flush the ps_bitstrm */
        u4_bitstream_offset += (u4_ldz + 1);
        /* Read the suffix from the ps_bitstrm */
        u4_word = 0;
        if(u4_ldz)
            GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
        *pu4_bitstream_off = u4_bitstream_offset;
        u4_ref_idx = ((1 << u4_ldz) + u4_word - 1);
//Inlined ih264d_uev

        if(u4_ref_idx > u4_num_ref_idx_active_minus1)
            return ERROR_REF_IDX;

        /* Storing Reference Idx Information */
        pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx;
    }
    return OK;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_parse_bmb_ref_index_cavlc_range1                         */
/*                                                                           */
/*  Description   : This function does the Cavlc  TEV range =1 parsing of    */
/*                  reference index  for a B MB. Range is 1 when             */
/*                  num_ref_idx_active_minus1 is 0                           */
/*                                                                           */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : <Does it use any global variables?>                      */
/*  Processing    : <Describe how the function operates - include algorithm  */
/*                  description>                                             */
/*  Outputs       : <What does the function produce?>                        */
/*  Returns       : <What does the function return?>                         */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         19 09 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/
void ih264d_parse_bmb_ref_index_cavlc_range1(UWORD32 u4_num_part, /* Number of partitions in MB      */
                                             dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */
                                             WORD8 *pi1_ref_idx, /* pointer to reference index array */
                                             UWORD32 u4_num_ref_idx_active_minus1 /* Not used for range 1    */
                                             )
{
    UWORD32 u4_i;
    UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst;
    UNUSED(u4_num_ref_idx_active_minus1);
    for(u4_i = 0; u4_i < u4_num_part; u4_i++)
    {
        if(pi1_ref_idx[u4_i] > -1)
        {
            UWORD32 u4_ref_idx;

            u4_ref_idx = ih264d_tev_range1(pu4_bitstream_off, pu4_bitstrm_buf);

            /* Storing Reference Idx Information */
            pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx;
        }
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_parse_bmb_ref_index_cavlc                                */
/*                                                                           */
/*  Description   : This function does the Cavlc  TEV range > 1 parsing of   */
/*                  reference index  for a B MB.                             */
/*                  Range > 1 when num_ref_idx_active_minus1 > 0             */
/*                                                                           */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : <Does it use any global variables?>                      */
/*  Processing    : <Describe how the function operates - include algorithm  */
/*                  description>                                             */
/*  Outputs       : <What does the function produce?>                        */
/*  Returns       : <What does the function return?>                         */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         19 09 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/
WORD32 ih264d_parse_bmb_ref_index_cavlc(UWORD32 u4_num_part, /* Number of partitions in MB      */
                                      dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */
                                      WORD8 *pi1_ref_idx, /* pointer to reference index array */
                                      UWORD32 u4_num_ref_idx_active_minus1 /* Number of active references - 1  */
                                      )
{
    UWORD32 u4_i;
    UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
    UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst;

    for(u4_i = 0; u4_i < u4_num_part; u4_i++)
    {
        if(pi1_ref_idx[u4_i] > -1)
        {
            UWORD32 u4_ref_idx;
//inlining ih264d_uev
            UWORD32 u4_bitstream_offset = *pu4_bitstream_off;
            UWORD32 u4_word, u4_ldz;

            /***************************************************************/
            /* Find leading zeros in next 32 bits                          */
            /***************************************************************/
            NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf);
            u4_ldz = CLZ(u4_word);
            /* Flush the ps_bitstrm */
            u4_bitstream_offset += (u4_ldz + 1);
            /* Read the suffix from the ps_bitstrm */
            u4_word = 0;
            if(u4_ldz)
                GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz);
            *pu4_bitstream_off = u4_bitstream_offset;
            u4_ref_idx = ((1 << u4_ldz) + u4_word - 1);
//inlining ih264d_uev
            if(u4_ref_idx > u4_num_ref_idx_active_minus1)
                return ERROR_REF_IDX;

            /* Storing Reference Idx Information */
            pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx;
        }
    }
    return OK;
}
/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_cavlc_parse_8x8block_both_available                      */
/*                                                                           */
/*  Description   : This function does the residual parsing of 4 subblocks   */
/*                  in a 8x8 block when both top and left are available      */
/*                                                                           */
/*  Inputs        : pi2_coeff_block : pointer to residual block where        */
/*                  decoded and inverse scan coefficients are updated        */
/*                                                                           */
/*                  u4_sub_block_strd : indicates the number of sublocks    */
/*                  in a row. It is 4 for luma and 2 for chroma.             */
/*                                                                           */
/*                  u4_isdc : required to indicate 4x4 parse modules if the  */
/*                  current  Mb is I_16x16/chroma DC coded.                  */
/*                                                                           */
/*                  ps_dec : pointer to Decstruct (decoder context)          */
/*                                                                           */
/*                  pu1_top_nnz : top nnz pointer                            */
/*                                                                           */
/*                  pu1_left_nnz : left nnz pointer                          */
/*                                                                           */
/*  Globals       : No                                                       */
/*  Processing    : Parsing for four subblocks in unrolled, top and left nnz */
/*                  are updated on the fly. csbp is set in accordance to     */
/*                  decoded numcoeff for the subblock index in raster order  */
/*                                                                           */
/*  Outputs       : The updated residue buffer, nnzs and csbp current block  */
/*                                                                           */
/*  Returns       : Returns the coded sub block pattern csbp for the block   */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         09 10 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/
WORD32 ih264d_cavlc_parse_8x8block_both_available(WORD16 *pi2_coeff_block,
                                                  UWORD32 u4_sub_block_strd,
                                                  UWORD32 u4_isdc,
                                                  dec_struct_t * ps_dec,
                                                  UWORD8 *pu1_top_nnz,
                                                  UWORD8 *pu1_left_nnz,
                                                  UWORD8 u1_tran_form8x8,
                                                  UWORD8 u1_mb_field_decodingflag,
                                                  UWORD32 *pu4_csbp)
{
    UWORD32 u4_num_coeff, u4_n, u4_subblock_coded;
    UWORD32 u4_top0, u4_top1;
    UWORD32 *pu4_dummy;
    WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block,
                                      UWORD32 u4_isdc,
                                      WORD32 u4_n,
                                      struct _DecStruct *ps_dec,
                                      UWORD32 *pu4_dummy) =
                                      ps_dec->pf_cavlc_parse4x4coeff;
    UWORD32 u4_idx = 0;
    UWORD8 *puc_temp;
    WORD32 ret;

    *pu4_csbp = 0;
    /* need to change the inverse scan matrices here */
    puc_temp = ps_dec->pu1_inv_scan;

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 0                    */
    /*------------------------------------------------------*/
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0];
        }
    }
    u4_n = (pu1_top_nnz[0] + pu1_left_nnz[0] + 1) >> 1;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    u4_top0 = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 1                    */
    /*------------------------------------------------------*/
    u4_idx++;
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1];
        }
    }
    else
    {
        pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
    }
    u4_n = (pu1_top_nnz[1] + u4_num_coeff + 1) >> 1;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    u4_top1 = pu1_left_nnz[0] = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 2                    */
    /*------------------------------------------------------*/
    u4_idx += (u4_sub_block_strd - 1);
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2];
        }
    }
    else
    {
        pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK);
    }
    u4_n = (u4_top0 + pu1_left_nnz[1] + 1) >> 1;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    pu1_top_nnz[0] = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 3                    */
    /*------------------------------------------------------*/
    u4_idx++;
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3];
        }
    }
    else
    {
        pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
    }
    u4_n = (u4_top1 + u4_num_coeff + 1) >> 1;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    ps_dec->pu1_inv_scan = puc_temp;

    return OK;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_cavlc_parse_8x8block_left_available                      */
/*                                                                           */
/*  Description   : This function does the residual parsing of 4 subblocks   */
/*                  in a 8x8 block when only left is available for block     */
/*                                                                           */
/*  Inputs        : pi2_coeff_block : pointer to residual block where        */
/*                  decoded and inverse scan coefficients are updated        */
/*                                                                           */
/*                  u4_sub_block_strd : indicates the number of sublocks    */
/*                  in a row. It is 4 for luma and 2 for chroma.             */
/*                                                                           */
/*                  u4_isdc : required to indicate 4x4 parse modules if the  */
/*                  current  Mb is I_16x16/chroma DC coded.                  */
/*                                                                           */
/*                  ps_dec : pointer to Decstruct (decoder context)          */
/*                                                                           */
/*                  pu1_top_nnz : top nnz pointer                            */
/*                                                                           */
/*                  pu1_left_nnz : left nnz pointer                          */
/*                                                                           */
/*  Globals       : No                                                       */
/*  Processing    : Parsing for four subblocks in unrolled, top and left nnz */
/*                  are updated on the fly. csbp is set in accordance to     */
/*                  decoded numcoeff for the subblock index in raster order  */
/*                                                                           */
/*  Outputs       : The updated residue buffer, nnzs and csbp current block  */
/*                                                                           */
/*  Returns       : Returns the coded sub block pattern csbp for the block   */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         09 10 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/
WORD32 ih264d_cavlc_parse_8x8block_left_available(WORD16 *pi2_coeff_block,
                                                  UWORD32 u4_sub_block_strd,
                                                  UWORD32 u4_isdc,
                                                  dec_struct_t * ps_dec,
                                                  UWORD8 *pu1_top_nnz,
                                                  UWORD8 *pu1_left_nnz,
                                                  UWORD8 u1_tran_form8x8,
                                                  UWORD8 u1_mb_field_decodingflag,
                                                  UWORD32 *pu4_csbp)
{
    UWORD32 u4_num_coeff, u4_n, u4_subblock_coded;
    UWORD32 u4_top0, u4_top1;
    UWORD32 *pu4_dummy;
    WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block,
                                      UWORD32 u4_isdc,
                                      WORD32 u4_n,
                                      struct _DecStruct *ps_dec,
                                      UWORD32 *pu4_dummy) =
                                      ps_dec->pf_cavlc_parse4x4coeff;
    UWORD32 u4_idx = 0;
    UWORD8 *puc_temp;
    WORD32 ret;

    *pu4_csbp = 0;
    puc_temp = ps_dec->pu1_inv_scan;

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 0                    */
    /*------------------------------------------------------*/
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0];
        }
    }
    u4_n = pu1_left_nnz[0];
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    u4_top0 = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 1                    */
    /*------------------------------------------------------*/
    u4_idx++;
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1];
        }
    }
    else
    {
        pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
    }
    u4_n = u4_num_coeff;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    u4_top1 = pu1_left_nnz[0] = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 2                    */
    /*------------------------------------------------------*/
    u4_idx += (u4_sub_block_strd - 1);
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2];
        }
    }
    else
    {
        pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK);
    }
    u4_n = (u4_top0 + pu1_left_nnz[1] + 1) >> 1;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    pu1_top_nnz[0] = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 3                    */
    /*------------------------------------------------------*/
    u4_idx++;
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3];
        }
    }
    else
    {
        pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
    }
    u4_n = (u4_top1 + u4_num_coeff + 1) >> 1;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    ps_dec->pu1_inv_scan = puc_temp;

    return OK;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_cavlc_parse_8x8block_top_available                       */
/*                                                                           */
/*  Description   : This function does the residual parsing of 4 subblocks   */
/*                  in a 8x8 block when only top is available for block      */
/*                                                                           */
/*  Inputs        : pi2_coeff_block : pointer to residual block where        */
/*                  decoded and inverse scan coefficients are updated        */
/*                                                                           */
/*                  u4_sub_block_strd : indicates the number of sublocks    */
/*                  in a row. It is 4 for luma and 2 for chroma.             */
/*                                                                           */
/*                  u4_isdc : required to indicate 4x4 parse modules if the  */
/*                  current  Mb is I_16x16/chroma DC coded.                  */
/*                                                                           */
/*                  ps_dec : pointer to Decstruct (decoder context)          */
/*                                                                           */
/*                  pu1_top_nnz : top nnz pointer                            */
/*                                                                           */
/*                  pu1_left_nnz : left nnz pointer                          */
/*                                                                           */
/*  Globals       : No                                                       */
/*  Processing    : Parsing for four subblocks in unrolled, top and left nnz */
/*                  are updated on the fly. csbp is set in accordance to     */
/*                  decoded numcoeff for the subblock index in raster order  */
/*                                                                           */
/*  Outputs       : The updated residue buffer, nnzs and csbp current block  */
/*                                                                           */
/*  Returns       : Returns the coded sub block pattern csbp for the block   */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         09 10 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/
WORD32 ih264d_cavlc_parse_8x8block_top_available(WORD16 *pi2_coeff_block,
                                                 UWORD32 u4_sub_block_strd,
                                                 UWORD32 u4_isdc,
                                                 dec_struct_t * ps_dec,
                                                 UWORD8 *pu1_top_nnz,
                                                 UWORD8 *pu1_left_nnz,
                                                 UWORD8 u1_tran_form8x8,
                                                 UWORD8 u1_mb_field_decodingflag,
                                                 UWORD32 *pu4_csbp)
{
    UWORD32 u4_num_coeff, u4_n, u4_subblock_coded;
    UWORD32 u4_top0, u4_top1;
    UWORD32 *pu4_dummy;
    WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block,
                                      UWORD32 u4_isdc,
                                      WORD32 u4_n,
                                      struct _DecStruct *ps_dec,
                                      UWORD32 *pu4_dummy) =
                                      ps_dec->pf_cavlc_parse4x4coeff;
    UWORD32 u4_idx = 0;
    UWORD8 *puc_temp;
    WORD32 ret;

    *pu4_csbp = 0;
    puc_temp = ps_dec->pu1_inv_scan;

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 0                    */
    /*------------------------------------------------------*/
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0];
        }
    }
    u4_n = pu1_top_nnz[0];
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    u4_top0 = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 1                    */
    /*------------------------------------------------------*/
    u4_idx++;
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1];
        }
    }
    else
    {
        pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
    }
    u4_n = (pu1_top_nnz[1] + u4_num_coeff + 1) >> 1;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    u4_top1 = pu1_left_nnz[0] = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 2                    */
    /*------------------------------------------------------*/
    u4_idx += (u4_sub_block_strd - 1);
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2];
        }
    }
    else
    {
        pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK);
    }
    u4_n = u4_top0;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    pu1_top_nnz[0] = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 3                    */
    /*------------------------------------------------------*/
    u4_idx++;
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3];
        }
    }
    else
    {
        pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
    }
    u4_n = (u4_top1 + u4_num_coeff + 1) >> 1;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    ps_dec->pu1_inv_scan = puc_temp;

    return OK;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_cavlc_parse_8x8block_none_available                      */
/*                                                                           */
/*  Description   : This function does the residual parsing of 4 subblocks   */
/*                  in a 8x8 block when none of the neigbours are available  */
/*                                                                           */
/*  Inputs        : pi2_coeff_block : pointer to residual block where        */
/*                  decoded and inverse scan coefficients are updated        */
/*                                                                           */
/*                  u4_sub_block_strd : indicates the number of sublocks    */
/*                  in a row. It is 4 for luma and 2 for chroma.             */
/*                                                                           */
/*                  u4_isdc : required to indicate 4x4 parse modules if the  */
/*                  current  Mb is I_16x16/chroma DC coded.                  */
/*                                                                           */
/*                  ps_dec : pointer to Decstruct (decoder context)          */
/*                                                                           */
/*                  pu1_top_nnz : top nnz pointer                            */
/*                                                                           */
/*                  pu1_left_nnz : left nnz pointer                          */
/*                                                                           */
/*  Globals       : No                                                       */
/*  Processing    : Parsing for four subblocks in unrolled, top and left nnz */
/*                  are updated on the fly. csbp is set in accordance to     */
/*                  decoded numcoeff for the subblock index in raster order  */
/*                                                                           */
/*  Outputs       : The updated residue buffer, nnzs and csbp current block  */
/*                                                                           */
/*  Returns       : Returns the coded sub block pattern csbp for the block   */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         09 10 2008   Jay          Draft                                   */
/*                                                                           */
/*****************************************************************************/
WORD32 ih264d_cavlc_parse_8x8block_none_available(WORD16 *pi2_coeff_block,
                                                  UWORD32 u4_sub_block_strd,
                                                  UWORD32 u4_isdc,
                                                  dec_struct_t * ps_dec,
                                                  UWORD8 *pu1_top_nnz,
                                                  UWORD8 *pu1_left_nnz,
                                                  UWORD8 u1_tran_form8x8,
                                                  UWORD8 u1_mb_field_decodingflag,
                                                  UWORD32 *pu4_csbp)
{
    UWORD32 u4_num_coeff, u4_n, u4_subblock_coded;
    UWORD32 u4_top0, u4_top1;
    UWORD32 *pu4_dummy;
    WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block,
                                      UWORD32 u4_isdc,
                                      WORD32 u4_n,
                                      struct _DecStruct *ps_dec,
                                      UWORD32 *pu4_dummy) =
                                      ps_dec->pf_cavlc_parse4x4coeff;
    UWORD32 u4_idx = 0;
    UWORD8 *puc_temp;
    WORD32 ret;

    *pu4_csbp = 0;
    puc_temp = ps_dec->pu1_inv_scan;

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 0                    */
    /*------------------------------------------------------*/
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0];
        }
    }
    ret = pf_cavlc_parse4x4coeff[0](pi2_coeff_block, u4_isdc, 0,
                                    ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    u4_top0 = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 1                    */
    /*------------------------------------------------------*/
    u4_idx++;
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1];
        }
    }
    else
    {
        pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
    }
    u4_n = u4_num_coeff;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    u4_top1 = pu1_left_nnz[0] = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 2                    */
    /*------------------------------------------------------*/
    u4_idx += (u4_sub_block_strd - 1);
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2];
        }
    }
    else
    {
        pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK);
    }
    u4_n = u4_top0;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    pu1_top_nnz[0] = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    /*------------------------------------------------------*/
    /* Residual 4x4 decoding: SubBlock 3                    */
    /*------------------------------------------------------*/
    u4_idx++;
    if(u1_tran_form8x8)
    {
        if(!u1_mb_field_decodingflag)
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3];
        }
        else
        {
            ps_dec->pu1_inv_scan =
                            (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3];
        }
    }
    else
    {
        pi2_coeff_block += NUM_COEFFS_IN_4x4BLK;
    }
    u4_n = (u4_top1 + u4_num_coeff + 1) >> 1;
    ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc,
                                             u4_n, ps_dec, &u4_num_coeff);
    if(ret != OK)
        return ret;

    pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff;
    u4_subblock_coded = (u4_num_coeff != 0);
    INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded);

    ps_dec->pu1_inv_scan = puc_temp;

    return OK;
}

/*!
 **************************************************************************
 * \if Function name : ih264d_parse_residual4x4_cavlc \endif
 *
 * \brief
 *    This function parses CAVLC syntax of a Luma and Chroma AC Residuals.
 *
 * \return
 *    0 on Success and Error code otherwise
 **************************************************************************
 */

WORD32 ih264d_parse_residual4x4_cavlc(dec_struct_t * ps_dec,
                                      dec_mb_info_t *ps_cur_mb_info,
                                      UWORD8 u1_offset)
{
    UWORD8 u1_cbp = ps_cur_mb_info->u1_cbp;
    UWORD16 ui16_csbp = 0;
    UWORD32 u4_nbr_avl;
    WORD16 *pi2_residual_buf;

    UWORD8 u1_is_top_mb_avail;
    UWORD8 u1_is_left_mb_avail;

    UWORD8 *pu1_top_nnz = ps_cur_mb_info->ps_curmb->pu1_nnz_y;
    UWORD8 *pu1_left_nnz = ps_dec->pu1_left_nnz_y;
    WORD16 *pi2_coeff_block = NULL;
    UWORD32 *pu4_dummy;
    WORD32 ret;

    WORD32 (**pf_cavlc_parse_8x8block)(WORD16 *pi2_coeff_block,
                                       UWORD32 u4_sub_block_strd,
                                       UWORD32 u4_isdc,
                                       struct _DecStruct *ps_dec,
                                       UWORD8 *pu1_top_nnz,
                                       UWORD8 *pu1_left_nnz,
                                       UWORD8 u1_tran_form8x8,
                                       UWORD8 u1_mb_field_decodingflag,
                                       UWORD32 *pu4_dummy) = ps_dec->pf_cavlc_parse_8x8block;


    {
        UWORD8 uc_temp = ps_dec->u1_mb_ngbr_availablity;
        u1_is_top_mb_avail = BOOLEAN(uc_temp & TOP_MB_AVAILABLE_MASK);
        u1_is_left_mb_avail = BOOLEAN(uc_temp & LEFT_MB_AVAILABLE_MASK);
        u4_nbr_avl = (u1_is_top_mb_avail << 1) | u1_is_left_mb_avail;
    }

    ps_cur_mb_info->u1_qp_div6 = ps_dec->u1_qp_y_div6;
    ps_cur_mb_info->u1_qp_rem6 = ps_dec->u1_qp_y_rem6;
    ps_cur_mb_info->u1_qpc_div6 = ps_dec->u1_qp_u_div6;
    ps_cur_mb_info->u1_qpc_rem6 = ps_dec->u1_qp_u_rem6;
    ps_cur_mb_info->u1_qpcr_div6 = ps_dec->u1_qp_v_div6;
    ps_cur_mb_info->u1_qpcr_rem6 = ps_dec->u1_qp_v_rem6;

    if(u1_cbp & 0xf)
    {
        pu1_top_nnz[0] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[0];
        pu1_top_nnz[1] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[1];
        pu1_top_nnz[2] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[2];
        pu1_top_nnz[3] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[3];

        /*******************************************************************/
        /* Block 0 residual decoding, check cbp and proceed (subblock = 0) */
        /*******************************************************************/
        if(!(u1_cbp & 0x1))
        {
            *(UWORD16 *)(pu1_top_nnz) = 0;
            *(UWORD16 *)(pu1_left_nnz) = 0;

        }
        else
        {
            UWORD32 u4_temp;
            ret = pf_cavlc_parse_8x8block[u4_nbr_avl](
                        pi2_coeff_block, 4, u1_offset, ps_dec, pu1_top_nnz,
                        pu1_left_nnz, ps_cur_mb_info->u1_tran_form8x8,
                        ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp);
            if(ret != OK)
                return ret;
            ui16_csbp = u4_temp;
        }

        /*******************************************************************/
        /* Block 1 residual decoding, check cbp and proceed (subblock = 2) */
        /*******************************************************************/
        if(ps_cur_mb_info->u1_tran_form8x8)
        {
            pi2_coeff_block += 64;
        }
        else
        {
            pi2_coeff_block += (2 * NUM_COEFFS_IN_4x4BLK);
        }

        if(!(u1_cbp & 0x2))
        {
            *(UWORD16 *)(pu1_top_nnz + 2) = 0;
            *(UWORD16 *)(pu1_left_nnz) = 0;
        }
        else
        {
            UWORD32 u4_temp = (u4_nbr_avl | 0x1);
            ret = pf_cavlc_parse_8x8block[u4_temp](
                        pi2_coeff_block, 4, u1_offset, ps_dec,
                        (pu1_top_nnz + 2), pu1_left_nnz,
                        ps_cur_mb_info->u1_tran_form8x8,
                        ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp);
            if(ret != OK)
                return ret;
            ui16_csbp |= (u4_temp << 2);
        }

        /*******************************************************************/
        /* Block 2 residual decoding, check cbp and proceed (subblock = 8) */
        /*******************************************************************/
        if(ps_cur_mb_info->u1_tran_form8x8)
        {
            pi2_coeff_block += 64;
        }
        else
        {
            pi2_coeff_block += (6 * NUM_COEFFS_IN_4x4BLK);
        }

        if(!(u1_cbp & 0x4))
        {
            *(UWORD16 *)(pu1_top_nnz) = 0;
            *(UWORD16 *)(pu1_left_nnz + 2) = 0;
        }
        else
        {
            UWORD32 u4_temp = (u4_nbr_avl | 0x2);
            ret = pf_cavlc_parse_8x8block[u4_temp](
                        pi2_coeff_block, 4, u1_offset, ps_dec, pu1_top_nnz,
                        (pu1_left_nnz + 2), ps_cur_mb_info->u1_tran_form8x8,
                        ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp);
            if(ret != OK)
                return ret;
            ui16_csbp |= (u4_temp << 8);
        }

        /*******************************************************************/
        /* Block 3 residual decoding, check cbp and proceed (subblock = 10)*/
        /*******************************************************************/
        if(ps_cur_mb_info->u1_tran_form8x8)
        {
            pi2_coeff_block += 64;
        }
        else
        {
            pi2_coeff_block += (2 * NUM_COEFFS_IN_4x4BLK);
        }

        if(!(u1_cbp & 0x8))
        {
            *(UWORD16 *)(pu1_top_nnz + 2) = 0;
            *(UWORD16 *)(pu1_left_nnz + 2) = 0;
        }
        else
        {
            UWORD32 u4_temp;
            ret = pf_cavlc_parse_8x8block[0x3](
                        pi2_coeff_block, 4, u1_offset, ps_dec,
                        (pu1_top_nnz + 2), (pu1_left_nnz + 2),
                        ps_cur_mb_info->u1_tran_form8x8,
                        ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp);
            if(ret != OK)
                return ret;
            ui16_csbp |= (u4_temp << 10);
        }
    }
    else
    {
        *(UWORD32 *)(pu1_top_nnz) = 0;
        *(UWORD32 *)(pu1_left_nnz) = 0;
    }

    ps_cur_mb_info->u2_luma_csbp = ui16_csbp;
    ps_cur_mb_info->ps_curmb->u2_luma_csbp = ui16_csbp;

    {
        UWORD16 u2_chroma_csbp = 0;
        ps_cur_mb_info->u2_chroma_csbp = 0;
        pu1_top_nnz = ps_cur_mb_info->ps_curmb->pu1_nnz_uv;
        pu1_left_nnz = ps_dec->pu1_left_nnz_uv;

        u1_cbp >>= 4;
        /*--------------------------------------------------------------------*/
        /* if Chroma Component not present OR no ac values present            */
        /* Set the values of N to zero                                        */
        /*--------------------------------------------------------------------*/
        if(u1_cbp == CBPC_ALLZERO || u1_cbp == CBPC_ACZERO)
        {
            *(UWORD32 *)(pu1_top_nnz) = 0;
            *(UWORD32 *)(pu1_left_nnz) = 0;
        }

        if(u1_cbp == CBPC_ALLZERO)
        {
            return (0);
        }
        /*--------------------------------------------------------------------*/
        /* Decode Chroma DC values                                            */
        /*--------------------------------------------------------------------*/
        {
            WORD32 u4_scale_u;
            WORD32 u4_scale_v;
            WORD32 i4_mb_inter_inc;
            u4_scale_u = ps_dec->pu2_quant_scale_u[0] << ps_dec->u1_qp_u_div6;
            u4_scale_v = ps_dec->pu2_quant_scale_v[0] << ps_dec->u1_qp_v_div6;
            i4_mb_inter_inc = (!((ps_cur_mb_info->ps_curmb->u1_mb_type == I_4x4_MB)
                            || (ps_cur_mb_info->ps_curmb->u1_mb_type == I_16x16_MB)))
                            * 3;

            if(ps_dec->s_high_profile.u1_scaling_present)
            {
                u4_scale_u *=
                                ps_dec->s_high_profile.i2_scalinglist4x4[i4_mb_inter_inc
                                                + 1][0];
                u4_scale_v *=
                                ps_dec->s_high_profile.i2_scalinglist4x4[i4_mb_inter_inc
                                                + 2][0];

            }
            else
            {
                u4_scale_u <<= 4;
                u4_scale_v <<= 4;
            }

            ih264d_cavlc_parse_chroma_dc(ps_cur_mb_info,pi2_coeff_block, ps_dec->ps_bitstrm,
                                         u4_scale_u, u4_scale_v,
                                         i4_mb_inter_inc);
        }

        if(u1_cbp == CBPC_ACZERO)
            return (0);

        pu1_top_nnz[0] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[0];
        pu1_top_nnz[1] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[1];
        pu1_top_nnz[2] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[2];
        pu1_top_nnz[3] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[3];
        /*--------------------------------------------------------------------*/
        /* Decode Chroma AC values                                            */
        /*--------------------------------------------------------------------*/
        {
            UWORD32 u4_temp;
            /*****************************************************************/
            /* U Block  residual decoding, check cbp and proceed (subblock=0)*/
            /*****************************************************************/
            ret = pf_cavlc_parse_8x8block[u4_nbr_avl](
                        pi2_coeff_block, 2, 1, ps_dec, pu1_top_nnz,
                        pu1_left_nnz, 0, 0, &u4_temp);
            if(ret != OK)
                return ret;
            u2_chroma_csbp = u4_temp;

            pi2_coeff_block += MB_CHROM_SIZE;
            /*****************************************************************/
            /* V Block  residual decoding, check cbp and proceed (subblock=1)*/
            /*****************************************************************/
            ret = pf_cavlc_parse_8x8block[u4_nbr_avl](pi2_coeff_block, 2, 1,
                                                      ps_dec,
                                                      (pu1_top_nnz + 2),
                                                      (pu1_left_nnz + 2), 0,
                                                      0, &u4_temp);
            if(ret != OK)
                return ret;
            u2_chroma_csbp |= (u4_temp << 4);
        }

        ps_cur_mb_info->u2_chroma_csbp = u2_chroma_csbp;
    }
    return OK;
}