xref: /aosp_15_r20/external/libavc/encoder/svc/isvce_rate_control.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_rate_control.c
*
* @brief
*  Contains api function definitions for h264 rate control
*
* @author
*  ittiam
*
* @par List of Functions:
*  - isvce_rc_init()
*  - isvce_rc_get_picture_details()
*  - isvce_rc_pre_enc()
*  - isvce_update_rc_mb_info()
*  - isvce_rc_get_buffer_status()
*  - isvce_rc_post_enc()
*  - isvce_update_rc_bits_info()
*
* @remarks
*  None
*
*******************************************************************************
*/

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

#include "ih264_typedefs.h"
#include "iv2.h"
#include "ive2.h"
#include "isvce.h"
#include "isvc_defs.h"
#include "isvc_macros.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_intra_pred_filters.h"
#include "ih264_deblk_edge_filters.h"
#include "isvc_common_tables.h"
#include "isvc_cabac_tables.h"
#include "isvce_defs.h"
#include "isvce_globals.h"
#include "irc_mem_req_and_acq.h"
#include "irc_cntrl_param.h"
#include "irc_frame_info_collector.h"
#include "irc_rate_control_api.h"
#include "ih264e_time_stamp.h"
#include "ih264e_modify_frm_rate.h"
#include "isvce_rate_control.h"
#include "ih264e_error.h"
#include "ih264e_time_stamp.h"
#include "ih264e_bitstream.h"
#include "ime_distortion_metrics.h"
#include "ime_defs.h"
#include "ime_structs.h"
#include "isvce_cabac_structs.h"
#include "isvce_structs.h"
#include "ih264e_utils.h"
#include "irc_trace_support.h"

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

/**
*******************************************************************************
*
* @brief
*  This function initializes rate control context and variables
*
* @par Description
*  This function initializes rate control type, source and target frame rate,
*  average and peak bitrate, intra-inter frame interval and initial
*  quantization parameter
*
* @param[in] pv_rc_api
*  Handle to rate control api
*
* @param[in] pv_frame_time
*  Handle to frame time context
*
* @param[in] pv_time_stamp
*  Handle to time stamp context
*
* @param[in] pv_pd_frm_rate
*  Handle to pull down frame time context
*
* @param[in] u4_max_frm_rate
*  Maximum frame rate
*
* @param[in] u4_src_frm_rate
*  Source frame rate
*
* @param[in] u4_tgt_frm_rate
*  Target frame rate
*
* @param[in] e_rate_control_type
*  Rate control type
*
* @param[in] u4_avg_bit_rate
*  Average bit rate
*
* @param[in] u4_peak_bit_rate
*  Peak bit rate
*
* @param[in] u4_max_delay
*  Maximum delay between frames
*
* @param[in] u4_intra_frame_interval
*  Intra frame interval
*
* @param[in] pu1_init_qp
*  Initial qp
*
* @param[in] i4_max_inter_frm_int
*  Maximum inter frame interval
*
* @param[in] pu1_min_max_qp
*  Array of min/max qp
*
* @param[in] u1_profile_level
*  Encoder profile level
*
* @returns none
*
* @remarks
*
*******************************************************************************
*/
void isvce_rc_init(void *pv_rc_api, void *pv_frame_time, void *pv_time_stamp, void *pv_pd_frm_rate,
                   UWORD32 u4_max_frm_rate, UWORD32 u4_src_frm_rate, UWORD32 u4_tgt_frm_rate,
                   rc_type_e e_rate_control_type, UWORD32 u4_avg_bit_rate, UWORD32 u4_peak_bit_rate,
                   UWORD32 u4_max_delay, UWORD32 u4_intra_frame_interval, WORD32 i4_inter_frm_int,
                   UWORD8 *pu1_init_qp, WORD32 i4_max_inter_frm_int, UWORD8 *pu1_min_max_qp,
                   UWORD8 u1_profile_level)
{
    UWORD32 au4_peak_bit_rate[2] = {0, 0};
    UWORD32 u4_min_bit_rate = 0;
    WORD32 i4_is_gop_closed = 1;
    UWORD32 u4_src_ticks = 0;
    UWORD32 u4_tgt_ticks = 0;
    UWORD8 u1_level_idx = ih264e_get_lvl_idx(u1_profile_level);
    UWORD32 u4_max_cpb_size = 1200 * gas_isvc_lvl_tbl[u1_level_idx].u4_max_cpb_size;

    /* Fill the params needed for the RC init */
    if(e_rate_control_type == CBR_NLDRC)
    {
        au4_peak_bit_rate[0] = u4_avg_bit_rate;
        au4_peak_bit_rate[1] = u4_avg_bit_rate;
    }
    else
    {
        au4_peak_bit_rate[0] = u4_peak_bit_rate;
        au4_peak_bit_rate[1] = u4_peak_bit_rate;
    }

    /* Initialize frame time computation module*/
    ih264e_init_frame_time(pv_frame_time, u4_src_frm_rate, /* u4_src_frm_rate */
                           u4_tgt_frm_rate);               /* u4_tgt_frm_rate */

    /* Initialize the pull_down frame rate */
    ih264e_init_pd_frm_rate(pv_pd_frm_rate, u4_src_frm_rate); /* u4_input_frm_rate */

    /* Initialize time stamp structure */
    ih264e_init_time_stamp(pv_time_stamp, u4_max_frm_rate, /* u4_max_frm_rate */
                           u4_src_frm_rate);               /* u4_src_frm_rate */

    u4_src_ticks = ih264e_frame_time_get_src_ticks(pv_frame_time);
    u4_tgt_ticks = ih264e_frame_time_get_tgt_ticks(pv_frame_time);

    /* Init max_inter_frame int */
    i4_max_inter_frm_int = (i4_inter_frm_int == 1) ? 2 : (i4_inter_frm_int + 2);

    /* Initialize the rate control */
    irc_initialise_rate_control(
        pv_rc_api,               /* RC handle */
        e_rate_control_type,     /* RC algo type */
        0,                       /* MB activity on/off */
        u4_avg_bit_rate,         /* Avg Bitrate */
        au4_peak_bit_rate,       /* Peak bitrate array[2]:[I][P] */
        u4_min_bit_rate,         /* Min Bitrate */
        u4_src_frm_rate,         /* Src frame_rate */
        u4_max_delay,            /* Max buffer delay */
        u4_intra_frame_interval, /* Intra frm_interval */
        i4_inter_frm_int,        /* Inter frame interval */
        pu1_init_qp,             /* Init QP array[3]:[I][P][B] */
        u4_max_cpb_size,         /* Max VBV/CPB Buffer Size */
        i4_max_inter_frm_int,    /* Max inter frm_interval */
        i4_is_gop_closed,        /* Open/Closed GOP */
        pu1_min_max_qp,          /* Min-max QP
                                    array[6]:[Imax][Imin][Pmax][Pmin][Bmax][Bmin] */
        0,                       /* How to calc the I-frame estimated_sad */
        u4_src_ticks,            /* Src_ticks = LCM(src_frm_rate,tgt_frm_rate)/src_frm_rate
                                  */
        u4_tgt_ticks);           /* Tgt_ticks = LCM(src_frm_rate,tgt_frm_rate)/tgt_frm_rate
                                  */
}

/**
*******************************************************************************
*
* @brief Function to get picture details
*
* @par   Description
*  This function returns the Picture type(I/P/B)
*
* @param[in] pv_rc_api
*  Handle to Rate control api
*
* @returns
*  Picture type
*
* @remarks none
*
*******************************************************************************
*/
picture_type_e isvce_rc_get_picture_details(void *pv_rc_api, WORD32 *pi4_pic_id,
                                            WORD32 *pi4_pic_disp_order_no)
{
    picture_type_e e_rc_pic_type = P_PIC;

    irc_get_picture_details(pv_rc_api, pi4_pic_id, pi4_pic_disp_order_no, &e_rc_pic_type);

    return (e_rc_pic_type);
}

/**
*******************************************************************************
*
* @brief  Function to get rate control output before encoding
*
* @par Description
*  This function is called before queing the current frame. It decides if we
*should skip the current iput buffer due to frame rate mismatch. It also updates
*RC about the acehivble frame rate
*
* @param[in] ps_rate_control_api
*  Handle to rate control api
*
* @param[in] ps_pd_frm_rate
*  Handle to pull down frm rate context
*
* @param[in] ps_time_stamp
*  Handle to time stamp context
*
* @param[in] ps_frame_time
*  Handle to frame time context
*
* @param[in] i4_delta_time_stamp
*  Time stamp difference between frames
*
* @param[in] i4_total_mb_in_frame
*  Total Macro Blocks in frame
*
* @param[in/out] pe_vop_coding_type
*  Picture coding type(I/P/B)
*
* @param[in/out] pu1_frame_qp
*  QP for current frame
*
* @returns
*  Skip or queue the current frame
*
* @remarks
*
*******************************************************************************
*/
WORD32 isvce_update_rc_framerates(void *ps_rate_control_api, void *ps_pd_frm_rate,
                                  void *ps_time_stamp, void *ps_frame_time)
{
    WORD8 i4_skip_src = 0;
    UWORD32 u4_src_not_skipped_for_dts = 0;

    /* Update the time stamp for the current frame */
    ih264e_update_time_stamp(ps_time_stamp);

    /* Check if a src not needs to be skipped */
    i4_skip_src = ih264e_should_src_be_skipped(ps_frame_time, 1, &u4_src_not_skipped_for_dts);

    if(i4_skip_src)
    {
        /***********************************************************************
         *Based on difference in source and target frame rate frames are skipped
         ***********************************************************************/
        /*update the missing frames frm_rate with 0 */
        ih264e_update_pd_frm_rate(ps_pd_frm_rate, 0);
    }
    else
    {
        WORD32 i4_avg_frm_rate, i4_source_frame_rate;

        i4_source_frame_rate = ih264e_frame_time_get_src_frame_rate(ps_frame_time);

        /* Update the frame rate of the frame present with the tgt_frm_rate */
        /* If the frm was not skipped due to delta_time_stamp, update the
         frame_rate with double the tgt_frame_rate value, so that it makes
         up for one of the frames skipped by the application */
        ih264e_update_pd_frm_rate(ps_pd_frm_rate, i4_source_frame_rate);

        /* Based on the update get the average frame rate */
        i4_avg_frm_rate = ih264e_get_pd_avg_frm_rate(ps_pd_frm_rate);

        /* Call the RC library function to change the frame_rate to the
         actually achieved frm_rate */
        irc_change_frm_rate_for_bit_alloc(ps_rate_control_api, i4_avg_frm_rate);
    }

    return (i4_skip_src);
}

/**
*******************************************************************************
*
* @brief Function to update mb info for rate control context
*
* @par   Description
*  After encoding a mb, information such as mb type, qp used, mb distortion
*  resulted in encoding the block and so on needs to be preserved for modeling
*  RC. This is preserved via this function call.
*
* @param[in] ps_frame_info
*  Handle Frame info context
*
* @param[in] ps_proc
*  Process context
*
* @returns
*
* @remarks
*
*******************************************************************************
*/
void isvce_update_rc_mb_info(frame_info_t *ps_frame_info, void *pv_proc)
{
    /* proc ctxt */
    isvce_process_ctxt_t *ps_proc = pv_proc;

    /* is intra or inter */
    WORD32 mb_type = !ps_proc->ps_mb_info->u1_is_intra;

    /* distortion */
    ps_frame_info->tot_mb_sad[mb_type] += ps_proc->i4_mb_distortion;

    /* qp */
    ps_frame_info->qp_sum[mb_type] += gau1_h264_to_mpeg2_qmap[ps_proc->u1_mb_qp];

    /* mb cnt */
    ps_frame_info->num_mbs[mb_type]++;

    /* cost */
    if(ps_proc->ps_mb_info->u1_is_intra)
    {
        ps_frame_info->intra_mb_cost_sum += ps_proc->i4_mb_cost;
    }
}

/**
*******************************************************************************
*
* @brief Function to get rate control buffer status
*
* @par Description
*  This function is used to get buffer status(underflow/overflow) by rate
*  control module
*
* @param[in] pv_rc_api
*  Handle to rate control api context
*
* @param[in] i4_total_frame_bits
*  Total frame bits
*
* @param[in] u1_pic_type
*  Picture type
*
* @param[in] pi4_num_bits_to_prevent_vbv_underflow
*  Number of bits to prevent underflow
*
* @param[out] pu1_is_enc_buf_overflow
*  Buffer overflow indication flag
*
* @param[out] pu1_is_enc_buf_underflow
*  Buffer underflow indication flag
*
* @returns
*
* @remarks
*
*******************************************************************************
*/
void isvce_rc_get_buffer_status(void *pv_rc_api, WORD32 i4_total_frame_bits,
                                picture_type_e e_pic_type,
                                WORD32 *pi4_num_bits_to_prevent_vbv_underflow,
                                UWORD8 *pu1_is_enc_buf_overflow, UWORD8 *pu1_is_enc_buf_underflow)
{
    vbv_buf_status_e e_vbv_buf_status = VBV_NORMAL;

    e_vbv_buf_status = irc_get_buffer_status(pv_rc_api, i4_total_frame_bits, e_pic_type,
                                             pi4_num_bits_to_prevent_vbv_underflow);

    if(e_vbv_buf_status == VBV_OVERFLOW)
    {
        *pu1_is_enc_buf_underflow = 1;
        *pu1_is_enc_buf_overflow = 0;
    }
    else if(e_vbv_buf_status == VBV_UNDERFLOW)
    {
        *pu1_is_enc_buf_underflow = 0;
        *pu1_is_enc_buf_overflow = 1;
    }
    else
    {
        *pu1_is_enc_buf_underflow = 0;
        *pu1_is_enc_buf_overflow = 0;
    }
}

/**
*******************************************************************************
*
* @brief Function to update rate control module after encoding
*
* @par Description
*  This function is used to update the rate control module after the current
*  frame encoding is done with details such as bits consumed, SAD for I/P/B,
*  intra cost ,mb type and other
*
* @param[in] ps_rate_control_api
*  Handle to rate control api context
*
* @param[in] ps_frame_info
*  Handle to frame info context
*
* @param[in] ps_pd_frm_rate
*  Handle to pull down frame rate context
*
* @param[in] ps_time_stamp
*  Handle to time stamp context
*
* @param[in] ps_frame_time
*  Handle to frame time context
*
* @param[in] i4_total_mb_in_frame
*  Total mb in frame
*
* @param[in] pe_vop_coding_type
*  Picture coding type
*
* @param[in] i4_is_first_frame
*  Is first frame
*
* @param[in] pi4_is_post_encode_skip
*  Post encoding skip flag
*
* @param[in] u1_frame_qp
*  Frame qp
*
* @param[in] pi4_num_intra_in_prev_frame
*  Numberf of intra mbs in previous frame
*
* @param[in] pi4_avg_activity
*  Average activity
*
* @returns
*
* @remarks
*
*******************************************************************************
*/
WORD32 isvce_rc_post_enc(void *ps_rate_control_api, frame_info_t *ps_frame_info,
                         void *ps_pd_frm_rate, void *ps_time_stamp, void *ps_frame_time,
                         WORD32 i4_total_mb_in_frame, picture_type_e *pe_vop_coding_type,
                         WORD32 i4_is_first_frame, WORD32 *pi4_is_post_encode_skip,
                         UWORD8 u1_frame_qp, WORD32 *pi4_num_intra_in_prev_frame,
                         WORD32 *pi4_avg_activity
#if ENABLE_RE_ENC_AS_SKIP
                         ,
                         UWORD8 *u1_is_post_enc_skip
#endif
)
{
    /* Variables for the update_frm_level_info */
    WORD32 ai4_tot_mb_in_type[MAX_MB_TYPE];
    WORD32 ai4_tot_mb_type_qp[MAX_MB_TYPE] = {0, 0};
    WORD32 ai4_mb_type_sad[MAX_MB_TYPE] = {0, 0};
    WORD32 ai4_mb_type_tex_bits[MAX_MB_TYPE] = {0, 0};
    WORD32 i4_total_frame_bits = 0;
    WORD32 i4_total_hdr_bits = 0;
    WORD32 i4_total_texturebits;
    WORD32 i4_avg_mb_activity = 0;
    WORD32 i4_intra_frm_cost = 0;
    UWORD8 u1_is_scd = 0;
    WORD32 i4_cbr_bits_to_stuff = 0;
    UWORD32 u4_num_intra_in_prev_frame = *pi4_num_intra_in_prev_frame;

    UNUSED(ps_pd_frm_rate);
    UNUSED(ps_time_stamp);
    UNUSED(ps_frame_time);
    UNUSED(u1_frame_qp);
    UNUSED(i4_is_first_frame);
    /* Accumulate RC stats */
    ai4_tot_mb_in_type[MB_TYPE_INTRA] = irc_fi_get_total_mb(ps_frame_info, MB_TYPE_INTRA);
    ai4_tot_mb_in_type[MB_TYPE_INTER] = irc_fi_get_total_mb(ps_frame_info, MB_TYPE_INTER);
    ai4_tot_mb_type_qp[MB_TYPE_INTRA] = irc_fi_get_total_mb_qp(ps_frame_info, MB_TYPE_INTRA);
    ai4_tot_mb_type_qp[MB_TYPE_INTER] = irc_fi_get_total_mb_qp(ps_frame_info, MB_TYPE_INTER);
    ai4_mb_type_sad[MB_TYPE_INTRA] = irc_fi_get_total_mb_sad(ps_frame_info, MB_TYPE_INTRA);
    ai4_mb_type_sad[MB_TYPE_INTER] = irc_fi_get_total_mb_sad(ps_frame_info, MB_TYPE_INTER);
    i4_intra_frm_cost = irc_fi_get_total_intra_mb_cost(ps_frame_info);
    i4_avg_mb_activity = irc_fi_get_avg_activity(ps_frame_info);
    i4_total_hdr_bits = irc_fi_get_total_header_bits(ps_frame_info);
    i4_total_texturebits = irc_fi_get_total_mb_texture_bits(ps_frame_info, MB_TYPE_INTRA);
    i4_total_texturebits += irc_fi_get_total_mb_texture_bits(ps_frame_info, MB_TYPE_INTER);
    i4_total_frame_bits = i4_total_hdr_bits + i4_total_texturebits;

    *pi4_avg_activity = i4_avg_mb_activity;

    /* Texture bits are not accumulated. Hence subtracting hdr bits from total
     * bits */
    ai4_mb_type_tex_bits[MB_TYPE_INTRA] = 0;
    ai4_mb_type_tex_bits[MB_TYPE_INTER] = i4_total_frame_bits - i4_total_hdr_bits;

    /* Set post encode skip to zero */
    pi4_is_post_encode_skip[0] = 0;

    /* For NLDRC, get the buffer status for stuffing or skipping */
    if(irc_get_rc_type(ps_rate_control_api) == CBR_NLDRC)
    {
        WORD32 i4_get_num_bit_to_prevent_vbv_overflow;
        UWORD8 u1_enc_buf_overflow, u1_enc_buf_underflow;

        /* Getting the buffer status */
        isvce_rc_get_buffer_status(ps_rate_control_api, i4_total_frame_bits, pe_vop_coding_type[0],
                                   &i4_get_num_bit_to_prevent_vbv_overflow, &u1_enc_buf_overflow,
                                   &u1_enc_buf_underflow);

        /* We skip the frame if decoder buffer is underflowing. But we never skip
         * first I frame */
#if !DISABLE_POST_ENC_SKIP
        if((u1_enc_buf_overflow == 1) && (i4_is_first_frame != 1))
        // if ((u1_enc_buf_overflow == 1) && (i4_is_first_frame != 0))
        {
            irc_post_encode_frame_skip(ps_rate_control_api, (picture_type_e) pe_vop_coding_type[0]);
            // i4_total_frame_bits = imp4_write_skip_frame_header(ps_enc);
            i4_total_frame_bits = 0;

            *pi4_is_post_encode_skip = 1;

            /* Adjust the GOP if in case we skipped an I-frame */
            if(*pe_vop_coding_type == I_PIC) irc_force_I_frame(ps_rate_control_api);

            /* Since this frame is skipped by writing 7 bytes header, we say this is a
             * P frame */
            // *pe_vop_coding_type = P;

            /* Getting the buffer status again,to check if it underflows  */
            irc_get_buffer_status(ps_rate_control_api, i4_total_frame_bits,
                                  (picture_type_e) pe_vop_coding_type[0],
                                  &i4_get_num_bit_to_prevent_vbv_overflow);
        }
#endif

#if ENABLE_RE_ENC_AS_SKIP
        /* Check for VBV constraints - post encode skip */
        if(u1_enc_buf_overflow == 1 && (pe_vop_coding_type[0] != I_PIC))
        {
            *u1_is_post_enc_skip = 1;

            ai4_tot_mb_in_type[MB_TYPE_INTER] += ai4_tot_mb_in_type[MB_TYPE_INTRA];
            ai4_tot_mb_in_type[MB_TYPE_INTRA] = 0;
            ai4_tot_mb_type_qp[MB_TYPE_INTER] += ai4_tot_mb_type_qp[MB_TYPE_INTRA];
            ai4_tot_mb_type_qp[MB_TYPE_INTRA] = 0;

            ai4_mb_type_sad[MB_TYPE_INTER] += ai4_mb_type_sad[MB_TYPE_INTRA];
            ai4_mb_type_sad[MB_TYPE_INTRA] = 0;

            i4_intra_frm_cost = 0;

            i4_total_hdr_bits = 0;
            i4_total_texturebits = 0;
            i4_total_frame_bits = i4_total_hdr_bits + i4_total_texturebits;

            ai4_mb_type_tex_bits[MB_TYPE_INTRA] = 0;
            ai4_mb_type_tex_bits[MB_TYPE_INTER] = i4_total_frame_bits - i4_total_hdr_bits;

            /* Getting the buffer status again,to check if it underflows  */
            irc_get_buffer_status(ps_rate_control_api, i4_total_frame_bits,
                                  (picture_type_e) pe_vop_coding_type[0],
                                  &i4_get_num_bit_to_prevent_vbv_overflow);
        }
#endif

        /* In this case we stuff bytes as buffer is overflowing */
        if(u1_enc_buf_underflow == 1)
        {
            /* The stuffing function is directly pulled out from split controller
               workspace. encode_vop_data() function makes sure alignment data is
               dumped at the end of a frame. Split controller was identifying this
               alignment byte, overwriting it with the stuff data and then finally
               aligning the buffer. Here every thing is inside the DSP. So, ideally
               encode_vop_data needn't align, and we can start stuffing directly. But
               in that case, it'll break the logic for a normal frame. Hence for
               simplicity, not changing this part since it is ok to align and then
               overwrite since stuffing is not done for every frame */
            i4_cbr_bits_to_stuff = irc_get_bits_to_stuff(ps_rate_control_api, i4_total_frame_bits,
                                                         pe_vop_coding_type[0]);

            /* Just add extra 32 bits to make sure we don't stuff lesser */
            i4_cbr_bits_to_stuff += 32;

            /* We can not stuff more than the outbuf size. So have a check here */
            /* Add stuffed bits to total bits */
            i4_total_frame_bits += i4_cbr_bits_to_stuff;
        }
    }

    /* If number of intra MBs are more than 2/3rd of total MBs, assume it as a
     * scene change */
    if((ai4_tot_mb_in_type[MB_TYPE_INTRA] > ((2 * i4_total_mb_in_frame) / 3)) &&
       (*pe_vop_coding_type == P_PIC) &&
       (ai4_tot_mb_in_type[MB_TYPE_INTRA] > ((11 * (WORD32) u4_num_intra_in_prev_frame) / 10)))
    {
        u1_is_scd = 1;
    }

    /* Update num intra mbs of this frame */
    if(pi4_is_post_encode_skip[0] == 0)
    {
        *pi4_num_intra_in_prev_frame = ai4_tot_mb_in_type[MB_TYPE_INTRA];
    }

    /* Reset intra count to zero, if u encounter an I frame */
    if(*pe_vop_coding_type == I_PIC)
    {
        *pi4_num_intra_in_prev_frame = 0;
    }

    /* Do an update of rate control after post encode */
    irc_update_frame_level_info(ps_rate_control_api,        /* RC state */
                                pe_vop_coding_type[0],      /* PIC type */
                                ai4_mb_type_sad,            /* SAD for [Intra/Inter] */
                                i4_total_frame_bits,        /* Total frame bits */
                                i4_total_hdr_bits,          /* header bits for */
                                ai4_mb_type_tex_bits,       /* for MB[Intra/Inter] */
                                ai4_tot_mb_type_qp,         /* for MB[Intra/Inter] */
                                ai4_tot_mb_in_type,         /* for MB[Intra/Inter] */
                                i4_avg_mb_activity,         /* Average mb activity in frame */
                                u1_is_scd,                  /* Is a scene change detected */
                                0,                          /* Pre encode skip  */
                                (WORD32) i4_intra_frm_cost, /* Intra cost for frame */
                                0);                         /* Not done outside */

    return (i4_cbr_bits_to_stuff >> 3);
}

/**
*******************************************************************************
*
* @brief Function to update bits consumed info to rate control context
*
* @par Description
*  Function to update bits consume info to rate control context
*
* @param[in] ps_frame_info
*  Frame info context
*
* @param[in] ps_entropy
*  Entropy context
*
* @returns
*  total bits consumed by the frame
*
* @remarks
*
*******************************************************************************
*/
void isvce_update_rc_bits_info(frame_info_t *ps_frame_info, void *pv_entropy)
{
    isvce_entropy_ctxt_t *ps_entropy = pv_entropy;

    ps_frame_info->mb_header_bits[MB_TYPE_INTRA] += ps_entropy->u4_header_bits[MB_TYPE_INTRA];

    ps_frame_info->mb_texture_bits[MB_TYPE_INTRA] += ps_entropy->u4_residue_bits[MB_TYPE_INTRA];

    ps_frame_info->mb_header_bits[MB_TYPE_INTER] += ps_entropy->u4_header_bits[MB_TYPE_INTER];

    ps_frame_info->mb_texture_bits[MB_TYPE_INTER] += ps_entropy->u4_residue_bits[MB_TYPE_INTER];

    return;
}