xref: /aosp_15_r20/external/libavc/encoder/svc/isvce_cabac.c (revision 495ae853bb871d1e5a258cb02c2cc13cde8ddb9a)

/******************************************************************************
 *
 * Copyright (C) 2022 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
*  isvce_cabac.c
*
* @brief
*  Contains all leaf level functions for CABAC entropy coding.
*
*
* @author
* Doney Alex
*
* @par List of Functions:
*
*
* @remarks
*  None
*
*******************************************************************************
*/

/*****************************************************************************/
/* File Includes                                                             */
/*****************************************************************************/

/* System include files */
#include <stdio.h>
#include <assert.h>
#include <limits.h>
#include <string.h>

/* User include files */
#include "ih264e_config.h"
#include "ih264_typedefs.h"
#include "iv2.h"
#include "ive2.h"
#include "ih264_debug.h"
#include "ih264_macros.h"
#include "isvc_defs.h"
#include "isvce_defs.h"
#include "isvc_macros.h"
#include "ih264e_error.h"
#include "ih264e_bitstream.h"
#include "ime_distortion_metrics.h"
#include "ime_defs.h"
#include "ime_structs.h"
#include "ih264_error.h"
#include "isvc_structs.h"
#include "isvc_trans_quant_itrans_iquant.h"
#include "isvc_inter_pred_filters.h"
#include "isvc_mem_fns.h"
#include "ih264_padding.h"
#include "ih264_platform_macros.h"
#include "ih264_intra_pred_filters.h"
#include "ih264_deblk_edge_filters.h"
#include "isvc_cabac_tables.h"
#include "irc_cntrl_param.h"
#include "irc_frame_info_collector.h"
#include "isvce_rate_control.h"
#include "isvce_cabac_structs.h"
#include "isvce_structs.h"
#include "isvce_cabac.h"
#include "isvce_encode_header.h"
#include "ih264_cavlc_tables.h"
#include "ih264e_statistics.h"
#include "ih264e_trace.h"

/*****************************************************************************/
/* Function Definitions                                                      */
/*****************************************************************************/

/**
 *******************************************************************************
 *
 * @brief
 *  k-th order Exp-Golomb (UEGk) binarization process: Implements concatenated
 *   unary/ k-th order Exp-Golomb  (UEGk) binarization process,
 *   where k = 0 as defined in 9.3.2.3 of  ITU_T_H264-201402
 *
 * @param[in] i2_sufs
 *  Suffix bit string
 *
 * @param[in] pi1_bins_len
 *  Pointer to length of tthe string
 *
 * @returns Binarized value
 *
 * @remarks
 *  None
 *
 *******************************************************************************
 */

UWORD32 isvce_cabac_UEGk0_binarization(WORD16 i2_sufs, WORD8 *pi1_bins_len)
{
    WORD32 unary_length;
    UWORD32 u4_sufs_shiftk_plus1, u4_egk, u4_unary_bins;

    u4_sufs_shiftk_plus1 = i2_sufs + 1;

    unary_length = (32 - CLZ(u4_sufs_shiftk_plus1) + (0 == u4_sufs_shiftk_plus1));

    /* unary code with (unary_length-1) '1's and terminating '0' bin */
    u4_unary_bins = (1 << unary_length) - 2;

    /* insert the symbol prefix of (unary length - 1)  bins */
    u4_egk = (u4_unary_bins << (unary_length - 1)) |
             (u4_sufs_shiftk_plus1 & ((1 << (unary_length - 1)) - 1));

    /* length of the code = 2 *(unary_length - 1) + 1 + k */
    *pi1_bins_len = (2 * unary_length) - 1;

    return (u4_egk);
}

/**
 *******************************************************************************
 *
 * @brief
 *  Get cabac context for the MB :calculates the pointers to Top and   left
 *          cabac neighbor context depending upon neighbor  availability.
 *
 * @param[in] ps_ent_ctxt
 *  Pointer to entropy context structure
 *
 * @param[in] u4_mb_type
 *  Type of MB
 *
 * @returns
 *
 * @remarks
 *  None
 *
 *******************************************************************************
 */
void isvce_get_cabac_context(isvce_entropy_ctxt_t *ps_ent_ctxt, WORD32 u4_mb_type)
{
    /* CABAC context */
    isvce_cabac_ctxt_t *ps_cabac_ctxt = ps_ent_ctxt->ps_cabac;
    isvce_mb_info_ctxt_t *ps_ctx_inc_mb_map;
    cab_csbp_t *ps_lft_csbp;

    WORD32 i4_lft_avail, i4_top_avail, i4_is_intra;
    WORD32 i4_mb_x, i4_mb_y;
    UWORD8 *pu1_slice_idx = ps_ent_ctxt->pu1_slice_idx;

    i4_is_intra = ((u4_mb_type == I16x16) || (u4_mb_type == I8x8) || (u4_mb_type == I4x4));

    /* derive neighbor availability */
    i4_mb_x = ps_ent_ctxt->i4_mb_x;
    i4_mb_y = ps_ent_ctxt->i4_mb_y;
    pu1_slice_idx += (i4_mb_y * ps_ent_ctxt->i4_wd_mbs);
    /* left macroblock availability */
    i4_lft_avail = (i4_mb_x == 0 || (pu1_slice_idx[i4_mb_x - 1] != pu1_slice_idx[i4_mb_x])) ? 0 : 1;
    /* top macroblock availability */
    i4_top_avail = (i4_mb_y == 0 ||
                    (pu1_slice_idx[i4_mb_x - ps_ent_ctxt->i4_wd_mbs] != pu1_slice_idx[i4_mb_x]))
                       ? 0
                       : 1;
    i4_mb_x = ps_ent_ctxt->i4_mb_x;
    ps_ctx_inc_mb_map = ps_cabac_ctxt->ps_mb_map_ctxt_inc;
    ps_cabac_ctxt->ps_curr_ctxt_mb_info = ps_ctx_inc_mb_map + i4_mb_x;
    ps_cabac_ctxt->ps_left_ctxt_mb_info = ps_cabac_ctxt->ps_def_ctxt_mb_info;
    ps_cabac_ctxt->ps_top_ctxt_mb_info = ps_cabac_ctxt->ps_def_ctxt_mb_info;
    ps_lft_csbp = ps_cabac_ctxt->ps_lft_csbp;
    ps_cabac_ctxt->pu1_left_y_ac_csbp = &ps_lft_csbp->u1_y_ac_csbp_top_mb;
    ps_cabac_ctxt->pu1_left_uv_ac_csbp = &ps_lft_csbp->u1_uv_ac_csbp_top_mb;
    ps_cabac_ctxt->pu1_left_yuv_dc_csbp = &ps_lft_csbp->u1_yuv_dc_csbp_top_mb;
    ps_cabac_ctxt->pi1_left_ref_idx_ctxt_inc = &ps_cabac_ctxt->i1_left_ref_idx_ctx_inc_arr[0][0];
    ps_cabac_ctxt->pu1_left_mv_ctxt_inc = ps_cabac_ctxt->u1_left_mv_ctxt_inc_arr[0];

    if(i4_lft_avail) ps_cabac_ctxt->ps_left_ctxt_mb_info = ps_cabac_ctxt->ps_curr_ctxt_mb_info - 1;
    if(i4_top_avail) ps_cabac_ctxt->ps_top_ctxt_mb_info = ps_cabac_ctxt->ps_curr_ctxt_mb_info;

    if(!i4_lft_avail)
    {
        UWORD8 u1_def_csbp = i4_is_intra ? 0xf : 0;
        *(ps_cabac_ctxt->pu1_left_y_ac_csbp) = u1_def_csbp;
        *(ps_cabac_ctxt->pu1_left_uv_ac_csbp) = u1_def_csbp;
        *(ps_cabac_ctxt->pu1_left_yuv_dc_csbp) = u1_def_csbp;
        *((UWORD32 *) ps_cabac_ctxt->pi1_left_ref_idx_ctxt_inc) = 0;
        memset(ps_cabac_ctxt->pu1_left_mv_ctxt_inc, 0, 16);
    }
    if(!i4_top_avail)
    {
        UWORD8 u1_def_csbp = i4_is_intra ? 0xff : 0;
        ps_cabac_ctxt->ps_top_ctxt_mb_info->u1_yuv_ac_csbp = u1_def_csbp;
        ps_cabac_ctxt->ps_top_ctxt_mb_info->u1_yuv_dc_csbp = u1_def_csbp;
        ps_cabac_ctxt->ps_curr_ctxt_mb_info->i1_ref_idx[0] =
            ps_cabac_ctxt->ps_curr_ctxt_mb_info->i1_ref_idx[1] =
                ps_cabac_ctxt->ps_curr_ctxt_mb_info->i1_ref_idx[2] =
                    ps_cabac_ctxt->ps_curr_ctxt_mb_info->i1_ref_idx[3] = 0;
        memset(ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_mv, 0, 16);
    }
}

/**
 *******************************************************************************
 * @brief
 *  flushing at termination: Explained in flowchart 9-12(ITU_T_H264-201402).
 *
 *  @param[in]   ps_cabac_ctxt
 *  pointer to cabac context (handle)
 *
 * @returns  none
 *
 * @remarks
 *  None
 *
 *******************************************************************************
 */
void isvce_cabac_flush(isvce_cabac_ctxt_t *ps_cabac_ctxt)
{
    /* bit stream ptr */
    bitstrm_t *ps_stream = ps_cabac_ctxt->ps_bitstrm;
    encoding_envirnoment_t *ps_cab_enc_env = &(ps_cabac_ctxt->s_cab_enc_env);
    UWORD32 u4_low = ps_cab_enc_env->u4_code_int_low;
    UWORD32 u4_bits_gen = ps_cab_enc_env->u4_bits_gen;
    UWORD8 *pu1_strm_buf = ps_stream->pu1_strm_buffer;
    UWORD32 u4_strm_buf_offset = ps_stream->u4_strm_buf_offset;
    WORD32 zero_run = ps_stream->i4_zero_bytes_run;
    UWORD32 u4_out_standing_bytes = ps_cab_enc_env->u4_out_standing_bytes;

    /************************************************************************/
    /* Insert the carry (propogated in previous byte) along with            */
    /* outstanding bytes (if any) and flush remaining bits                  */
    /************************************************************************/
    {
        /* carry = 1 => putbit(1); carry propogated due to L renorm */
        WORD32 carry = (u4_low >> (u4_bits_gen + CABAC_BITS)) & 0x1;
        WORD32 last_byte;
        WORD32 bits_left;
        WORD32 rem_bits;

        /* carry exists only if pu1_strm_buf has at least 1 byte of data */
        carry = carry && (u4_strm_buf_offset > 0);

        if(carry)
        {
            /* CORNER CASE: if the previous data is 0x000003, then EPB will be
             inserted and the data will become 0x00000303 and if the carry is present,
             it will be added with the last byte and it will become 0x00000304 which
             is not correct as per standard */
            /* so check for previous four bytes and if it is equal to 0x00000303
             then subtract u4_strm_buf_offset by 1 */
            if((u4_strm_buf_offset >= 4) && pu1_strm_buf[u4_strm_buf_offset - 1] == 0x03 &&
               pu1_strm_buf[u4_strm_buf_offset - 2] == 0x03 &&
               pu1_strm_buf[u4_strm_buf_offset - 3] == 0x00 &&
               pu1_strm_buf[u4_strm_buf_offset - 4] == 0x00)
            {
                u4_strm_buf_offset -= 1;
            }
            /* previous byte carry add will not result in overflow to        */
            /* u4_strm_buf_offset - 2 as we track 0xff as outstanding bytes  */
            pu1_strm_buf[u4_strm_buf_offset - 1] += carry;
            zero_run = 0;
        }

        /*        Insert outstanding bytes (if any)         */
        while(u4_out_standing_bytes)
        {
            UWORD8 u1_0_or_ff = carry ? 0 : 0xFF;

            PUTBYTE_EPB(pu1_strm_buf, u4_strm_buf_offset, u1_0_or_ff, zero_run);
            u4_out_standing_bytes--;
        }

        /*  clear the carry in low */
        if(carry)
        {
            u4_low &= ((1 << (u4_bits_gen + CABAC_BITS)) - 1);
        }

        /* extract the remaining bits;                                   */
        /* includes additional msb bit of low as per Figure 9-12      */
        bits_left = u4_bits_gen + 1;
        rem_bits = (u4_low >> (u4_bits_gen + CABAC_BITS - bits_left));

        if(bits_left >= 8)
        {
            last_byte = (rem_bits >> (bits_left - 8)) & 0xFF;
            PUTBYTE_EPB(pu1_strm_buf, u4_strm_buf_offset, last_byte, zero_run);
            bits_left -= 8;
        }

        /* insert last byte along with rbsp stop bit(1) and 0's in the end */
        last_byte =
            (rem_bits << (8 - bits_left)) | (1 << (7 - bits_left) | (1 << (7 - bits_left - 1)));
        last_byte &= 0xFF;
        PUTBYTE_EPB(pu1_strm_buf, u4_strm_buf_offset, last_byte, zero_run);

        /* update the state variables and return success */
        ps_stream->u4_strm_buf_offset = u4_strm_buf_offset;
        ps_stream->i4_zero_bytes_run = 0;
        /* Default init values for scratch variables of bitstream context */
        ps_stream->u4_cur_word = 0;
        ps_stream->i4_bits_left_in_cw = WORD_SIZE;
    }
}

/**
 ******************************************************************************
 *
 *  @brief Puts new byte (and outstanding bytes) into bitstream after cabac
 *         renormalization
 *
 *  @par   Description
 *  1. Extract the leading byte of low(L)
 *  2. If leading byte=0xff increment outstanding bytes and return
 *     (as the actual bits depend on carry propogation later)
 *  3. If leading byte is not 0xff check for any carry propogation
 *  4. Insert the carry (propogated in previous byte) along with outstanding
 *     bytes (if any) and leading byte
 *
 *
 *  @param[in]   ps_cabac_ctxt
 *  pointer to cabac context (handle)
 *
 *  @return
 *
 ******************************************************************************
 */
void isvce_cabac_put_byte(isvce_cabac_ctxt_t *ps_cabac_ctxt)
{
    /* bit stream ptr */
    bitstrm_t *ps_stream = ps_cabac_ctxt->ps_bitstrm;
    encoding_envirnoment_t *ps_cab_enc_env = &(ps_cabac_ctxt->s_cab_enc_env);
    UWORD32 u4_low = ps_cab_enc_env->u4_code_int_low;
    UWORD32 u4_bits_gen = ps_cab_enc_env->u4_bits_gen;
    WORD32 lead_byte = u4_low >> (u4_bits_gen + CABAC_BITS - 8);

    /* Sanity checks */
    ASSERT((ps_cab_enc_env->u4_code_int_range >= 256) && (ps_cab_enc_env->u4_code_int_range < 512));
    ASSERT((u4_bits_gen >= 8));

    /* update bits generated and low after extracting leading byte */
    u4_bits_gen -= 8;
    ps_cab_enc_env->u4_code_int_low &= ((1 << (CABAC_BITS + u4_bits_gen)) - 1);
    ps_cab_enc_env->u4_bits_gen = u4_bits_gen;

    /************************************************************************/
    /* 1. Extract the leading byte of low(L)                                */
    /* 2. If leading byte=0xff increment outstanding bytes and return       */
    /*      (as the actual bits depend on carry propogation later)          */
    /* 3. If leading byte is not 0xff check for any carry propogation       */
    /* 4. Insert the carry (propogated in previous byte) along with         */
    /*    outstanding bytes (if any) and leading byte                       */
    /************************************************************************/
    if(lead_byte == 0xff)
    {
        /* actual bits depend on carry propogration     */
        ps_cab_enc_env->u4_out_standing_bytes++;
        return;
    }
    else
    {
        UWORD8 *pu1_strm_buf = ps_stream->pu1_strm_buffer;
        UWORD32 u4_strm_buf_offset = ps_stream->u4_strm_buf_offset;
        /* carry = 1 => putbit(1); carry propogated due to L renorm */
        WORD32 carry = (lead_byte >> 8) & 0x1;
        WORD32 zero_run = ps_stream->i4_zero_bytes_run;
        UWORD32 u4_out_standing_bytes = ps_cab_enc_env->u4_out_standing_bytes;

        /*********************************************************************/
        /*        Insert the carry propogated in previous byte               */
        /*                                                                   */
        /* Note : Do not worry about corruption into slice header align byte */
        /*        This is because the first bin cannot result in overflow    */
        /*********************************************************************/
        if(carry)
        {
            /* CORNER CASE: if the previous data is 0x000003, then EPB will be
             inserted and the data will become 0x00000303 and if the carry is present,
             it will be added with the last byte and it will become 0x00000304 which
             is not correct as per standard */
            /* so check for previous four bytes and if it is equal to 0x00000303
             then subtract u4_strm_buf_offset by 1 */
            if((u4_strm_buf_offset > 3) && (pu1_strm_buf[u4_strm_buf_offset - 1] == 0x03) &&
               (pu1_strm_buf[u4_strm_buf_offset - 2] == 0x03) &&
               (pu1_strm_buf[u4_strm_buf_offset - 3] == 0x00) &&
               (pu1_strm_buf[u4_strm_buf_offset - 4] == 0x00))
            {
                u4_strm_buf_offset -= 1;
            }

            /* previous byte carry add will not result in overflow to        */
            /* u4_strm_buf_offset - 2 as we track 0xff as outstanding bytes  */
            if(u4_strm_buf_offset > 0)
            {
                pu1_strm_buf[u4_strm_buf_offset - 1] += carry;
                zero_run = 0;
            }
        }

        /*        Insert outstanding bytes (if any)         */
        while(u4_out_standing_bytes)
        {
            UWORD8 u1_0_or_ff = carry ? 0 : 0xFF;

            PUTBYTE_EPB(pu1_strm_buf, u4_strm_buf_offset, u1_0_or_ff, zero_run);

            u4_out_standing_bytes--;
        }
        ps_cab_enc_env->u4_out_standing_bytes = 0;

        /*        Insert the leading byte                   */
        lead_byte &= 0xFF;
        PUTBYTE_EPB(pu1_strm_buf, u4_strm_buf_offset, lead_byte, zero_run);

        /* update the state variables and return success */
        ps_stream->u4_strm_buf_offset = u4_strm_buf_offset;
        ps_stream->i4_zero_bytes_run = zero_run;
    }
}

/**
******************************************************************************
*
*  @brief Codes a bin based on probablilty and mps packed context model
*
*  @par   Description
*  1. Apart from encoding bin, context model is updated as per state transition
*  2. Range and Low renormalization is done based on bin and original state
*  3. After renorm bistream is updated (if required)
*
*  @param[in]   ps_cabac
*  pointer to cabac context (handle)
*
*  @param[in]   bin
*  bin(boolean) to be encoded
*
*  @param[in]  pu1_bin_ctxts
*  index of cabac context model containing pState[bits 5-0] | MPS[bit6]
*
*  @return
*
******************************************************************************
*/
void isvce_cabac_encode_bin(isvce_cabac_ctxt_t *ps_cabac, WORD32 bin, bin_ctxt_model *pu1_bin_ctxts)
{
    encoding_envirnoment_t *ps_cab_enc_env = &(ps_cabac->s_cab_enc_env);
    UWORD32 u4_range = ps_cab_enc_env->u4_code_int_range;
    UWORD32 u4_low = ps_cab_enc_env->u4_code_int_low;
    UWORD32 u4_rlps;
    UWORD8 state_mps = (*pu1_bin_ctxts) & 0x3F;
    UWORD8 u1_mps = !!((*pu1_bin_ctxts) & (0x40));
    WORD32 shift;
    UWORD32 u4_table_val;
    /* Sanity checks */
    ASSERT((bin == 0) || (bin == 1));
    ASSERT((u4_range >= 256) && (u4_range < 512));

    /* Get the lps range from LUT based on quantized range and state */
    u4_table_val = gau4_isvc_cabac_table[state_mps][(u4_range >> 6) & 0x3];
    u4_rlps = u4_table_val & 0xFF;
    u4_range -= u4_rlps;

    /* check if bin is mps or lps */
    if(u1_mps ^ bin)
    {
        /* lps path;  L= L + R; R = RLPS */
        u4_low += u4_range;
        u4_range = u4_rlps;
        if(state_mps == 0)
        {
            /* MPS(CtxIdx) = 1 - MPS(CtxIdx) */
            u1_mps = 1 - u1_mps;
        } /* update the context model from state transition LUT */

        state_mps = (u4_table_val >> 15) & 0x3F;
    }
    else
    { /* update the context model from state transition LUT */
        state_mps = (u4_table_val >> 8) & 0x3F;
    }

    (*pu1_bin_ctxts) = (u1_mps << 6) | state_mps;

    /*****************************************************************/
    /* Renormalization; calculate bits generated based on range(R)   */
    /* Note : 6 <= R < 512; R is 2 only for terminating encode       */
    /*****************************************************************/
    GETRANGE(shift, u4_range);
    shift = 9 - shift;
    u4_low <<= shift;
    u4_range <<= shift;

    /* bits to be inserted in the bitstream */
    ps_cab_enc_env->u4_bits_gen += shift;
    ps_cab_enc_env->u4_code_int_range = u4_range;
    ps_cab_enc_env->u4_code_int_low = u4_low;

    /* generate stream when a byte is ready */
    if(ps_cab_enc_env->u4_bits_gen > CABAC_BITS)
    {
        isvce_cabac_put_byte(ps_cabac);
    }
}

/**
*******************************************************************************
*
* @brief
*  Encoding process for a binary decision :implements encoding process of a
decision
*  as defined in 9.3.4.2 . This function encodes multiple bins, of a symbol.
Implements
*  flowchart Figure 9-7( ITU_T_H264-201402)
*
* @param[in] u4_bins
* array of bin values
*
* @param[in] i1_bins_len
*  Length of bins, maximum 32
*
* @param[in] u4_ctx_inc
*  CtxInc, byte0- bin0, byte1-bin1 ..
*
* @param[in] i1_valid_len
*  valid length of bins, after that CtxInc is constant
*
* @param[in] pu1_bin_ctxt_type
*  Pointer to binary contexts

* @param[in] ps_cabac
*  Pointer to cabac_context_structure
*
* @returns
*
* @remarks
*  None
*
*******************************************************************************
*/
void isvce_encode_decision_bins(UWORD32 u4_bins, WORD8 i1_bins_len, UWORD32 u4_ctx_inc,
                                WORD8 i1_valid_len, bin_ctxt_model *pu1_bin_ctxt_type,
                                isvce_cabac_ctxt_t *ps_cabac)
{
    WORD8 i;
    UWORD8 u1_ctx_inc, u1_bin;

    for(i = 0; i < i1_bins_len; i++)
    {
        u1_bin = (u4_bins & 0x01);
        u4_bins = u4_bins >> 1;
        u1_ctx_inc = u4_ctx_inc & 0x0f;
        if(i < i1_valid_len) u4_ctx_inc = u4_ctx_inc >> 4;
        /* Encode the bin */
        isvce_cabac_encode_bin(ps_cabac, u1_bin, pu1_bin_ctxt_type + u1_ctx_inc);
    }
}

/**
 *******************************************************************************
 * @brief
 *  Encoding process for a binary decision before termination:Encoding process
 *  of a termination(9.3.4.5 :ITU_T_H264-201402) . Explained in flowchart 9-11.
 *
 * @param[in] ps_cabac
 *  Pointer to cabac structure
 *
 * @param[in] term_bin
 *  Symbol value, end of slice or not, term_bin is binary
 *
 * @returns
 *
 * @remarks
 *  None
 *
 *******************************************************************************
 */
void isvce_cabac_encode_terminate(isvce_cabac_ctxt_t *ps_cabac, WORD32 term_bin)
{
    encoding_envirnoment_t *ps_cab_enc_env = &(ps_cabac->s_cab_enc_env);

    UWORD32 u4_range = ps_cab_enc_env->u4_code_int_range;
    UWORD32 u4_low = ps_cab_enc_env->u4_code_int_low;
    UWORD32 u4_rlps;
    WORD32 shift;

    /* Sanity checks */
    ASSERT((u4_range >= 256) && (u4_range < 512));
    ASSERT((term_bin == 0) || (term_bin == 1));

    /*  term_bin = 1 has lps range = 2 */
    u4_rlps = 2;
    u4_range -= u4_rlps;

    /* if terminate L is incremented by curR and R=2 */
    if(term_bin)
    {
        /* lps path;  L= L + R; R = RLPS */
        u4_low += u4_range;
        u4_range = u4_rlps;
    }

    /*****************************************************************/
    /* Renormalization; calculate bits generated based on range(R)   */
    /* Note : 6 <= R < 512; R is 2 only for terminating encode       */
    /*****************************************************************/
    GETRANGE(shift, u4_range);
    shift = 9 - shift;
    u4_low <<= shift;
    u4_range <<= shift;

    /* bits to be inserted in the bitstream */
    ps_cab_enc_env->u4_bits_gen += shift;
    ps_cab_enc_env->u4_code_int_range = u4_range;
    ps_cab_enc_env->u4_code_int_low = u4_low;

    /* generate stream when a byte is ready */
    if(ps_cab_enc_env->u4_bits_gen > CABAC_BITS)
    {
        isvce_cabac_put_byte(ps_cabac);
    }

    if(term_bin)
    {
        isvce_cabac_flush(ps_cabac);
    }
}

/**
 *******************************************************************************
 * @brief
 * Bypass encoding process for binary decisions:  Explained (9.3.4.4
 *:ITU_T_H264-201402) , flowchart 9-10.
 *
 *  @param[ino]  ps_cabac : pointer to cabac context (handle)
 *
 *  @param[in]   bin :  bypass bin(0/1) to be encoded
 *
 *  @returns
 *
 *  @remarks
 *  None
 *
 *******************************************************************************
 */

void isvce_cabac_encode_bypass_bin(isvce_cabac_ctxt_t *ps_cabac, WORD32 bin)
{
    encoding_envirnoment_t *ps_cab_enc_env = &(ps_cabac->s_cab_enc_env);

    UWORD32 u4_range = ps_cab_enc_env->u4_code_int_range;
    UWORD32 u4_low = ps_cab_enc_env->u4_code_int_low;

    /* Sanity checks */
    ASSERT((u4_range >= 256) && (u4_range < 512));
    ASSERT((bin == 0) || (bin == 1));

    u4_low <<= 1;
    /* add range if bin is 1 */
    if(bin)
    {
        u4_low += u4_range;
    }

    /* 1 bit to be inserted in the bitstream */
    ps_cab_enc_env->u4_bits_gen++;
    ps_cab_enc_env->u4_code_int_low = u4_low;

    /* generate stream when a byte is ready */
    if(ps_cab_enc_env->u4_bits_gen > CABAC_BITS)
    {
        isvce_cabac_put_byte(ps_cabac);
    }
}

/**
******************************************************************************
*
*  @brief Encodes a series of bypass bins (FLC bypass bins)
*
*  @par   Description
*  This function is more optimal than calling isvce_cabac_encode_bypass_bin()
*  in a loop as cabac low, renorm and generating the stream (8bins at a time)
*  can be done in one operation
*
*  @param[inout]ps_cabac
*   pointer to cabac context (handle)
*
*  @param[in]   u4_bins
*   syntax element to be coded (as FLC bins)
*
*  @param[in]   num_bins
*   This is the FLC length for u4_sym
*
*  @return
*
******************************************************************************
*/

void isvce_cabac_encode_bypass_bins(isvce_cabac_ctxt_t *ps_cabac, UWORD32 u4_bins, WORD32 num_bins)
{
    encoding_envirnoment_t *ps_cab_enc_env = &(ps_cabac->s_cab_enc_env);

    UWORD32 u4_range = ps_cab_enc_env->u4_code_int_range;
    WORD32 next_byte;

    /* Sanity checks */
    ASSERT((num_bins < 33) && (num_bins > 0));
    ASSERT((u4_range >= 256) && (u4_range < 512));

    /* Compute bit always to populate the trace */
    /* increment bits generated by num_bins */

    /* Encode 8bins at a time and put in the bit-stream */
    while(num_bins > 8)
    {
        num_bins -= 8;

        next_byte = (u4_bins >> (num_bins)) & 0xff;

        /*  L = (L << 8) +  (R * next_byte) */
        ps_cab_enc_env->u4_code_int_low <<= 8;
        ps_cab_enc_env->u4_code_int_low += (next_byte * u4_range);
        ps_cab_enc_env->u4_bits_gen += 8;

        if(ps_cab_enc_env->u4_bits_gen > CABAC_BITS)
        {
            /*  insert the leading byte of low into stream */
            isvce_cabac_put_byte(ps_cabac);
        }
    }

    /* Update low with remaining bins and return */
    next_byte = (u4_bins & ((1 << num_bins) - 1));

    ps_cab_enc_env->u4_code_int_low <<= num_bins;
    ps_cab_enc_env->u4_code_int_low += (next_byte * u4_range);
    ps_cab_enc_env->u4_bits_gen += num_bins;

    if(ps_cab_enc_env->u4_bits_gen > CABAC_BITS)
    {
        /*  insert the leading byte of low into stream */
        isvce_cabac_put_byte(ps_cabac);
    }
}