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

 *

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

}