/src/libavc/decoder/ih264d_cabac.c

Source (jump to first uncovered line)
/******************************************************************************
 *
 * 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_cabac.c
 *
 * \brief
 *    This file contains Binary decoding routines.
 *
 * \date
 *    04/02/2003
 *
 * \author  NS
 ***************************************************************************
 */
#include <string.h>
#include "ih264_typedefs.h"
#include "ih264_macros.h"
#include "ih264_platform_macros.h"
#include "ih264d_structs.h"
#include "ih264d_cabac.h"
#include "ih264d_bitstrm.h"
#include "ih264d_error_handler.h"
#include "ih264d_defs.h"
#include "ih264d_debug.h"
#include "ih264d_tables.h"
#include "ih264d_parse_cabac.h"
#include "ih264d_tables.h"



/*!
 **************************************************************************
 * \if Function name : ih264d_init_cabac_dec_envirnoment \endif
 *
 * \brief
 *    This function initializes CABAC decoding envirnoment. This function
 *    implements 9.3.3.2.3.1 of ISO/IEC14496-10.
 *
 * \return
 *    None
 *
 **************************************************************************
 */
WORD32 ih264d_init_cabac_dec_envirnoment(decoding_envirnoment_t * ps_cab_env,
                                       dec_bit_stream_t *ps_bitstrm)
{
    UWORD32 u4_code_int_val_ofst;

    ps_cab_env->u4_code_int_range = (HALF - 2) << 23;
    NEXTBITS(u4_code_int_val_ofst, ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer,
             32);
    FLUSHBITS(ps_bitstrm->u4_ofst, 9)

    if(EXCEED_OFFSET(ps_bitstrm))
        return ERROR_EOB_FLUSHBITS_T;

    ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;

    /*brief description of the design adopted for CABAC*/
    /*according to the standard the u4_code_int_range needs to be initialized 0x 1FE(10 bits) and
     9 bits from the bit stream need to be read and into the u4_code_int_val_ofst.As and when the
     u4_code_int_range becomes less than 10 bits we need to renormalize and read from the bitstream*

     In the implemented design
     initially

     range_new = range <<23
     valOffset_new = valOffset << 23 + 23 bits(read from the bit stream)

     Thus we have read 23 more bits ahead of time.

     It can be mathematical proved that even with the modified range and u4_ofst the operations
     like comparison and subtraction needed for a bin decode are still valid(both in the regular case and the bypass case)

     As bins are decoded..we consume the bits that we have already read into the valOffset.The clz of Range
     gives us the number of bits we consumed of the 23 bits that we have read ahead of time.

     when the number bits we have consumed exceeds 23 ,we renormalize..and  we read from the bitstream again*/

RESET_BIN_COUNTS(ps_cab_env)

    return OK;
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_init_cabac_contexts                                      */
/*                                                                           */
/*  Description   : This function initializes the cabac contexts             */
/*                  depending upon slice type and Init_Idc value.            */
/*  Inputs        : ps_dec, slice type                                       */
/*  Globals       : <Does it use any global variables?>                      */
/*  Outputs       :                                                          */
/*  Returns       : void                                                     */
/*                                                                           */
/*  Issues        : none                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         03 05 2005   100153)         Draft                                */
/*                                                                           */
/*****************************************************************************/

void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec)
{

    bin_ctxt_model_t *p_cabac_ctxt_table_t = ps_dec->p_cabac_ctxt_table_t;
    UWORD8 u1_qp_y = ps_dec->ps_cur_slice->u1_slice_qp;
    UWORD8 u1_cabac_init_Idc = 0;

    if(I_SLICE != u1_slice_type)
    {
        u1_cabac_init_Idc = ps_dec->ps_cur_slice->u1_cabac_init_idc;
    }

    {
        /* MAKING ps_dec->p_ctxt_inc_mb_map a scratch buffer */
        /* 0th entry of CtxtIncMbMap will be always be containing default values
         for CABAC context representing MB not available */
        ctxt_inc_mb_info_t *p_DefCtxt = ps_dec->p_ctxt_inc_mb_map - 1;
        UWORD8 *pu1_temp;
        WORD8 i;
        p_DefCtxt->u1_mb_type = CAB_SKIP;

        p_DefCtxt->u1_cbp = 0x0f;
        p_DefCtxt->u1_intra_chroma_pred_mode = 0;

        p_DefCtxt->u1_yuv_dc_csbp = 0x7;

        p_DefCtxt->u1_transform8x8_ctxt = 0;

        pu1_temp = (UWORD8*)p_DefCtxt->i1_ref_idx;
        for(i = 0; i < 4; i++, pu1_temp++)
            (*pu1_temp) = 0;
        pu1_temp = (UWORD8*)p_DefCtxt->u1_mv;
        for(i = 0; i < 16; i++, pu1_temp++)
            (*pu1_temp) = 0;
        ps_dec->ps_def_ctxt_mb_info = p_DefCtxt;
    }

    if(u1_slice_type == I_SLICE)
    {
        u1_cabac_init_Idc = 3;
        ps_dec->p_mb_type_t = p_cabac_ctxt_table_t + MB_TYPE_I_SLICE;
    }
    else if(u1_slice_type == P_SLICE)
    {
        ps_dec->p_mb_type_t = p_cabac_ctxt_table_t + MB_TYPE_P_SLICE;
        ps_dec->p_mb_skip_flag_t = p_cabac_ctxt_table_t + MB_SKIP_FLAG_P_SLICE;
        ps_dec->p_sub_mb_type_t = p_cabac_ctxt_table_t + SUB_MB_TYPE_P_SLICE;
    }
    else if(u1_slice_type == B_SLICE)
    {
        ps_dec->p_mb_type_t = p_cabac_ctxt_table_t + MB_TYPE_B_SLICE;
        ps_dec->p_mb_skip_flag_t = p_cabac_ctxt_table_t + MB_SKIP_FLAG_B_SLICE;
        ps_dec->p_sub_mb_type_t = p_cabac_ctxt_table_t + SUB_MB_TYPE_B_SLICE;
    }
    {
        bin_ctxt_model_t *p_cabac_ctxt_table_t_tmp = p_cabac_ctxt_table_t;
        if(ps_dec->ps_cur_slice->u1_field_pic_flag)
        {
            p_cabac_ctxt_table_t_tmp += SIGNIFICANT_COEFF_FLAG_FLD;

        }
        else
        {
            p_cabac_ctxt_table_t_tmp += SIGNIFICANT_COEFF_FLAG_FRAME;
        }
        {
            bin_ctxt_model_t * * p_significant_coeff_flag_t =
                            ps_dec->p_significant_coeff_flag_t;
            p_significant_coeff_flag_t[0] = p_cabac_ctxt_table_t_tmp
                            + SIG_COEFF_CTXT_CAT_0_OFFSET;
            p_significant_coeff_flag_t[1] = p_cabac_ctxt_table_t_tmp
                            + SIG_COEFF_CTXT_CAT_1_OFFSET;
            p_significant_coeff_flag_t[2] = p_cabac_ctxt_table_t_tmp
                            + SIG_COEFF_CTXT_CAT_2_OFFSET;
            p_significant_coeff_flag_t[3] = p_cabac_ctxt_table_t_tmp
                            + SIG_COEFF_CTXT_CAT_3_OFFSET;
            p_significant_coeff_flag_t[4] = p_cabac_ctxt_table_t_tmp
                            + SIG_COEFF_CTXT_CAT_4_OFFSET;

            p_significant_coeff_flag_t[5] = p_cabac_ctxt_table_t_tmp
                            + SIG_COEFF_CTXT_CAT_5_OFFSET;

        }
    }

    memcpy(p_cabac_ctxt_table_t,
           gau1_ih264d_cabac_ctxt_init_table[u1_cabac_init_Idc][u1_qp_y],
           NUM_CABAC_CTXTS * sizeof(bin_ctxt_model_t));
}
/*!
 **************************************************************************
 * \if Function name : ih264d_decode_bin \endif
 *
 * \brief
 *    This function implements decoding process of a decision as defined
 *    in 9.3.3.2.2.
 *
 * \return
 *    Returns symbol decoded.
 *
 * \note
 *    It is specified in 9.3.3.2.3.2 that, one of the input to this function
 *    is CtxIdx. CtxIdx is used to identify state and MPS of that context
 *    (Refer Fig 9.11 - Flowchart for encoding a decision). To suffice that
 *    here we pass a pointer bin_ctxt_model_t which contains these values.
 *
 **************************************************************************
 */

UWORD32 ih264d_decode_bin(UWORD32 u4_ctx_inc,
                          bin_ctxt_model_t *ps_src_bin_ctxt,
                          dec_bit_stream_t *ps_bitstrm,
                          decoding_envirnoment_t *ps_cab_env)

{

    UWORD32 u4_qnt_int_range, u4_code_int_range, u4_code_int_val_ofst,
                    u4_int_range_lps;

    UWORD32 u4_symbol, u4_mps_state;

    bin_ctxt_model_t *ps_bin_ctxt;

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

    ps_bin_ctxt = ps_src_bin_ctxt + u4_ctx_inc;

    u4_code_int_range = ps_cab_env->u4_code_int_range;
    u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;

    u4_mps_state = (ps_bin_ctxt->u1_mps_state);
    u4_clz = CLZ(u4_code_int_range);

    u4_qnt_int_range = u4_code_int_range << u4_clz;
    u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3;

    table_lookup = pu4_table[(u4_mps_state << 2) + u4_qnt_int_range];
    u4_int_range_lps = table_lookup & 0xff;

    u4_int_range_lps = u4_int_range_lps << (23 - u4_clz);
    u4_code_int_range = u4_code_int_range - u4_int_range_lps;

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

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

    CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, u4_symbol,
                 u4_int_range_lps, u4_mps_state, table_lookup)

    if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_8)
    {
        UWORD32 *pu4_buffer, u4_offset;

        pu4_buffer = ps_bitstrm->pu4_buffer;
        u4_offset = ps_bitstrm->u4_ofst;

        RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
                            pu4_buffer)

        ps_bitstrm->u4_ofst = u4_offset;
    }

    INC_BIN_COUNT(ps_cab_env)

    ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
    ps_cab_env->u4_code_int_range = u4_code_int_range;
    ps_bin_ctxt->u1_mps_state = u4_mps_state;

    return (u4_symbol);
}

/*!
 **************************************************************************
 * \if Function name : ih264d_decode_terminate \endif
 *
 * \brief
 *    This function implements decoding process of a termination as defined
 *    9.3.3.2.2.3 of ISO/IEC14496-10.
 *
 * \return
 *    Returns symbol decoded.
 *
 * \note
 *    This routine is called while decoding "end_of_skice_flag" and of the
 *    bin indicating PCM mode in MBType.
 *
 **************************************************************************
 */
UWORD8 ih264d_decode_terminate(decoding_envirnoment_t * ps_cab_env,
                               dec_bit_stream_t * ps_stream)
{
    UWORD32 u4_symbol;
    UWORD32 u4_code_int_val_ofst, u4_code_int_range;
    UWORD32 u4_clz;

    u4_code_int_range = ps_cab_env->u4_code_int_range;
    u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;

    u4_clz = CLZ(u4_code_int_range);
    u4_code_int_range -= (2 << (23 - u4_clz));

    if(u4_code_int_val_ofst >= u4_code_int_range)
    {
        /* S=1 */
        u4_symbol = 1;

        {

            /*the u4_ofst needs to be updated before termination*/
            ps_stream->u4_ofst += u4_clz;

        }

    }
    else
    {
        /* S=0 */
        u4_symbol = 0;

        if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_8)
        {
            UWORD32 *pu4_buffer, u4_offset;

            pu4_buffer = ps_stream->pu4_buffer;
            u4_offset = ps_stream->u4_ofst;

            RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
                                pu4_buffer)
            ps_stream->u4_ofst = u4_offset;
        }
    }

    ps_cab_env->u4_code_int_range = u4_code_int_range;
    ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;

    INC_BIN_COUNT(ps_cab_env)

    return (u4_symbol);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_decode_bins_tunary                                */
/*                                                                           */
/*  Description   : This function decodes bins in the case of TUNARY         */
/*                  binarization technique.valid_length is assumed  equal to 3 */
/*                  and u1_max_bins <= 4 in this functon.                                              */
/*  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        :                                                          */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         20 11 2008   SH          Draft                                   */
/*                                                                           */
/*****************************************************************************/

UWORD32 ih264d_decode_bins_tunary(UWORD8 u1_max_bins,
                                  UWORD32 u4_ctx_inc,
                                  bin_ctxt_model_t *ps_src_bin_ctxt,
                                  dec_bit_stream_t *ps_bitstrm,
                                  decoding_envirnoment_t *ps_cab_env)

{
    UWORD32 u4_value;
    UWORD32 u4_symbol;
    UWORD8 u4_ctx_Inc;
    bin_ctxt_model_t *ps_bin_ctxt;
    UWORD32 u4_code_int_range, u4_code_int_val_ofst;
    const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table;

    u4_value = 0;

    /*u1_max_bins has to be less than or equal to 4, u1_max_bins <= 4 for  this function*/

    /*here the valid length is assumed to be equal to 3 ,so the calling function is expected
     to duplicate CtxInc if valid lenth is 2 and cmaxbin is greater than2*/
    u4_code_int_range = ps_cab_env->u4_code_int_range;
    u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;

    do
    {
        u4_ctx_Inc = u4_ctx_inc & 0xF;
        u4_ctx_inc = u4_ctx_inc >> 4;

        ps_bin_ctxt = ps_src_bin_ctxt + u4_ctx_Inc;

        DECODE_ONE_BIN_MACRO(ps_bin_ctxt, u4_code_int_range, u4_code_int_val_ofst,
                             pu4_table, ps_bitstrm, u4_symbol)

        INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env);

        u4_value++;
    }
    while((u4_value < u1_max_bins) & (u4_symbol));

    u4_value = u4_value - 1 + u4_symbol;

    ps_cab_env->u4_code_int_range = u4_code_int_range;
    ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;

    return (u4_value);

}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_decode_bins                                */
/*                                                                           */
/*  Description   : This function decodes bins in the case of MSB_FIRST_FLC  */
/*                  binarization technique.valid_length is always equal max_bins */
/*                  for MSB_FIRST_FLC. assumes  u1_max_bins <= 4               */
/*  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)  */
/*         20 11 2008   SH          Draft                                   */
/*                                                                           */
/*****************************************************************************/

UWORD32 ih264d_decode_bins(UWORD8 u1_max_bins,
                           UWORD32 u4_ctx_inc,
                           bin_ctxt_model_t *ps_src_bin_ctxt,
                           dec_bit_stream_t *ps_bitstrm,
                           decoding_envirnoment_t *ps_cab_env)

{
    UWORD32 u4_value;
    UWORD32 u4_symbol, i;
    UWORD32 u4_ctxt_inc;
    bin_ctxt_model_t *ps_bin_ctxt;
    UWORD32 u4_code_int_range, u4_code_int_val_ofst;
    const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table;

    i = 0;

    u4_value = 0;

    /*u1_max_bins has to be less than or equal to 4, u1_max_bins <= 4 for  this fucntion*/
    u4_code_int_range = ps_cab_env->u4_code_int_range;
    u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;

    do
    {
        u4_ctxt_inc = u4_ctx_inc & 0xf;
        u4_ctx_inc = u4_ctx_inc >> 4;

        ps_bin_ctxt = ps_src_bin_ctxt + u4_ctxt_inc;

        DECODE_ONE_BIN_MACRO(ps_bin_ctxt, u4_code_int_range, u4_code_int_val_ofst,
                             pu4_table, ps_bitstrm, u4_symbol)

        INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env);

        u4_value = (u4_value << 1) | (u4_symbol);

        i++;
    }
    while(i < u1_max_bins);

    ps_cab_env->u4_code_int_range = u4_code_int_range;
    ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;

    return (u4_value);

}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_decode_bins_unary                                */
/*                                                                           */
/*  Description   : This function decodes bins in the case of UNARY         */
/*                  binarization technique.here the valid length is taken to 5*/
/*                  and cmax is always greater than 9                       */
/*  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)  */
/*         20 11 2008   SH          Draft                                   */
/*                                                                           */
/*****************************************************************************/
UWORD32 ih264d_decode_bins_unary(UWORD8 u1_max_bins,
                                 UWORD32 u4_ctx_inc,
                                 bin_ctxt_model_t *ps_src_bin_ctxt,
                                 dec_bit_stream_t *ps_bitstrm,
                                 decoding_envirnoment_t *ps_cab_env)
{
    UWORD32 u4_value;
    UWORD32 u4_symbol;
    bin_ctxt_model_t *ps_bin_ctxt;
    UWORD32 u4_ctx_Inc;
    UWORD32 u4_code_int_range, u4_code_int_val_ofst;
    const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table;

    /* in this function the valid length for u4_ctx_inc is always taken to be,so if the
     the valid length is lessthan 5 the caller need to duplicate accordingly*/

    /*u1_max_bins is always greater or equal to 9 we have the check for u1_max_bins only after the 2 loop*/
    u4_value = 0;
    u4_code_int_range = ps_cab_env->u4_code_int_range;
    u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;

    do
    {
        u4_ctx_Inc = u4_ctx_inc & 0xf;
        u4_ctx_inc = u4_ctx_inc >> 4;

        ps_bin_ctxt = ps_src_bin_ctxt + u4_ctx_Inc;

        DECODE_ONE_BIN_MACRO(ps_bin_ctxt, u4_code_int_range, u4_code_int_val_ofst,
                             pu4_table, ps_bitstrm, u4_symbol)

        INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env);

        u4_value++;

    }
    while(u4_symbol && u4_value < 4);

    if(u4_symbol && (u4_value < u1_max_bins))
    {

        u4_ctx_Inc = u4_ctx_inc & 0xf;

        ps_bin_ctxt = ps_src_bin_ctxt + u4_ctx_Inc;

        do
        {

            DECODE_ONE_BIN_MACRO(ps_bin_ctxt, u4_code_int_range, u4_code_int_val_ofst,
                                 pu4_table, ps_bitstrm, u4_symbol)

            INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env);

            u4_value++;

        }
        while(u4_symbol && (u4_value < u1_max_bins));

    }

    ps_cab_env->u4_code_int_range = u4_code_int_range;
    ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;

    u4_value = u4_value - 1 + u4_symbol;

    return (u4_value);

}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_decode_bypass_bins_unary                                     */
/*                                                                           */
/*  Description   : This function is used in the case of UNARY coding       */
/*                                                                           */
/*                                                                           */
/*  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)  */
/*         13 10 2005   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/

UWORD32 ih264d_decode_bypass_bins_unary(decoding_envirnoment_t *ps_cab_env,
                                        dec_bit_stream_t *ps_bitstrm)
{
    UWORD32 u4_value;
    UWORD32 u4_bin;
    UWORD32 u4_code_int_val_ofst, u4_code_int_range;

    UWORD32 u1_max_bins;

    u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
    u4_code_int_range = ps_cab_env->u4_code_int_range;

    if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_9)
    {
        UWORD32 *pu4_buffer, u4_offset;

        pu4_buffer = ps_bitstrm->pu4_buffer;
        u4_offset = ps_bitstrm->u4_ofst;

        RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
                            pu4_buffer)
        ps_bitstrm->u4_ofst = u4_offset;
    }

    /*as it is called only form mvd*/
    u1_max_bins = 32;
    u4_value = 0;

    do
    {
        u4_value++;

        u4_code_int_range = u4_code_int_range >> 1;
        if(u4_code_int_val_ofst >= u4_code_int_range)
        {
            /* S=1 */
            u4_bin = 1;
            u4_code_int_val_ofst -= u4_code_int_range;
        }
        else
        {
            /* S=0 */
            u4_bin = 0;
        }

        INC_BIN_COUNT(ps_cab_env);INC_BYPASS_BINS(ps_cab_env);

        if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_9)
        {
            UWORD32 *pu4_buffer, u4_offset;

            pu4_buffer = ps_bitstrm->pu4_buffer;
            u4_offset = ps_bitstrm->u4_ofst;

            RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
                                pu4_buffer)

            ps_bitstrm->u4_ofst = u4_offset;
        }

    }
    while(u4_bin && (u4_value < u1_max_bins));

    ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
    ps_cab_env->u4_code_int_range = u4_code_int_range;
    u4_value = (u4_value - 1 + u4_bin);

return (u4_value);
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : ih264d_decode_bypass_bins                                     */
/*                                                                           */
/*  Description   : This function is used in the case of FLC coding       */
/*                                                                           */
/*                                                                           */
/*  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)  */
/*         13 10 2005   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/

UWORD32 ih264d_decode_bypass_bins(decoding_envirnoment_t *ps_cab_env,
                                  UWORD8 u1_max_bins,
                                  dec_bit_stream_t *ps_bitstrm)
{
    UWORD32 u4_bins;
    UWORD32 u4_bin;
    UWORD32 u4_code_int_val_ofst, u4_code_int_range;

    u4_bins = 0;
    u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
    u4_code_int_range = ps_cab_env->u4_code_int_range;

    if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_9)
    {
        UWORD32 *pu4_buffer, u4_offset;

        pu4_buffer = ps_bitstrm->pu4_buffer;
        u4_offset = ps_bitstrm->u4_ofst;

        RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
                            pu4_buffer)
        ps_bitstrm->u4_ofst = u4_offset;
    }

    do
    {

        u4_code_int_range = u4_code_int_range >> 1;

        if(u4_code_int_val_ofst >= u4_code_int_range)
        {
            /* S=1 */
            u4_bin = 1;
            u4_code_int_val_ofst -= u4_code_int_range;
        }
        else
        {
            /* S=0 */
            u4_bin = 0;
        }

        INC_BIN_COUNT(ps_cab_env);INC_BYPASS_BINS(ps_cab_env);

        u4_bins = ((u4_bins << 1) | u4_bin);
        u1_max_bins--;

        if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_9)
        {
            UWORD32 *pu4_buffer, u4_offset;

            pu4_buffer = ps_bitstrm->pu4_buffer;
            u4_offset = ps_bitstrm->u4_ofst;

            RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
                                pu4_buffer)
            ps_bitstrm->u4_ofst = u4_offset;
        }

    }
    while(u1_max_bins);

    ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
    ps_cab_env->u4_code_int_range = u4_code_int_range;

    return (u4_bins);
}


Coverage Report

Created: 2025-07-23 06:14