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

 *

 * Copyright (C) 2018 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 bit_allocation.c

*

* \brief

*    This file contain bit processing functions

*

* \date

*

* \author

*    ittiam

*

******************************************************************************

*/

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

/* File Includes                                                             */

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

/* System include files */

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include <stdarg.h>

#include <math.h>

/* User include files */

#include "ittiam_datatypes.h"

#include "mem_req_and_acq.h"

#include "rc_common.h"

#include "rc_cntrl_param.h"

#include "var_q_operator.h"

#include "fixed_point_error_bits.h"

#include "cbr_buffer_control.h"

#include "rc_rd_model.h"

#include "est_sad.h"

#include "cbr_buffer_control.h"

#include "picture_type.h"

#include "bit_allocation.h"

#include "trace_support.h"

#include "rc_frame_info_collector.h"

#include "rate_control_api.h"

/** Macros **/

#define MIN(x, y) ((x) < (y)) ? (x) : (y)

#define MAX(x, y) ((x) < (y)) ? (y) : (x)

/* State structure for bit allocation */

typedef struct

{

    WORD32 i4_rem_bits_in_period;

    /* Storing inputs */

    WORD32 i4_tot_frms_in_gop;

    WORD32 i4_num_intra_frm_interval;

    WORD32 i4_bits_per_frm;

} rem_bit_in_prd_t;

typedef struct bit_allocation_t

{

    rem_bit_in_prd_t s_rbip;

    WORD32

        i2_K[MAX_PIC_TYPE]; /* A universal constant giving the relative complexity between pictures */

    WORD32 i4_prev_frm_header_bits[MAX_PIC_TYPE]; /* To get a estimate of the header bits consumed */

    WORD32 ai4_prev_frm_tot_bits[MAX_PIC_TYPE];

    WORD32 ai4_prev_frm_tot_est_bits[MAX_PIC_TYPE];

    WORD32 i4_bits_per_frm;

    WORD32 i4_num_gops_in_period;

    WORD32

    i4_actual_num_gops_in_period; /* Num gops as set by rate control module */

    WORD32 i4_saved_bits;

    WORD32 i4_max_bits_per_frm[MAX_NUM_DRAIN_RATES];

    WORD32 i4_min_bits_per_frm;

    /* Error bits module */

    error_bits_handle ps_error_bits;

    /* Storing frame rate */

    WORD32 i4_frame_rate;

    WORD32 i4_bit_rate;

    WORD32 ai4_peak_bit_rate[MAX_NUM_DRAIN_RATES];

    WORD32 i4_max_tex_bits_for_i;

    WORD32 i4_pels_in_frame;

    /* Errors within GOP and across GOP */

    WORD32 i4_gop_level_bit_error;

    WORD32 i4_frame_level_bit_error;

    WORD32 ai4_cur_frm_est_tex_bits[MAX_NUM_FRAME_PARALLEL];

    WORD32 ai4_cur_frm_est_hdr_bits[MAX_NUM_FRAME_PARALLEL];

    WORD32 i4_buffer_based_bit_error;

    WORD32 i4_bits_from_buffer_in_cur_gop;

    WORD32 i4_excess_bits_from_buffer;

    WORD32 i4_is_hbr;

    WORD32 i4_rem_frame_in_period;

    /*HEVC_RC : this will be updated by rc_interface.c to have number of SCD in lap window.

        Ni will be incremented using this to bring down buffer level and also back to back scd within lap window*/

    WORD32 i4_num_scd_in_lap_window;

    WORD32 i4_num_frm_b4_scd;

    WORD32 i4_num_active_pic_type;

    WORD32 i4_lap_window;

    WORD32 i4_field_pic;

    WORD32 i4_ba_rc_pass;

    void *pv_gop_stat;

    LWORD64 i8_cur_gop_num;

    LWORD64

    i8_frm_num_in_gop; /*TBD: For enc loop parallel this variable needs to maintained outside rate control since qp will not be queried in actual bitstream order*/

    float af_sum_weigh[MAX_PIC_TYPE][3];

    LWORD64 i8_cur_gop_bit_consumption; /*To calculate the deviaiton in 2 pass*/

    //LWORD64 i8_2pass_gop_error_accum;

    LWORD64

    i8_2pass_alloc_per_frm_bits; /*Per frame bits allocated to GOP in 2 pass*/

    //LWORD64 i8_2pass_alloc_per_frm_bits_next_gop;

    float f_min_complexity_cross_peak_rate; /*complexity of gop beyond which it is clipped to peak rate in 2ns pass*/

    WORD32 i4_next_sc_i_in_rc_look_ahead;

    /*The peak factor is multiplied to get the total bits for a gop based on squashing function*/

    float f_cur_peak_factor_2pass;

    LWORD64 i8_total_bits_allocated;

    WORD32 i4_luma_pels;

    WORD32 i4_num_gop;

    /*The bitrate will keep changing in 2 pass due to error*/

    LWORD64 i8_current_bitrate_2_pass;

    /*i4_flag_no_more_set_rbip - once we have reached the end of total number of frames to be encoded in

    2nd pass sliding window bit allocation there is no need to set rbip again*/

    WORD32 i4_flag_no_more_set_rbip;

    /*i8_vbv_based_excess_for_segment will be distributed across the complex segments depending on the

    ratio of current complexity to f_sum_complexity_segment_cross_peak*/

    float f_sum_complexity_segment_cross_peak;

    /*(i8_vbv_based_excess_for_segment)Buffer play excess is calculated for the entire segment of complex

    content which may consist of multiple gop's*/

    //LWORD64 i8_vbv_based_excess_for_segment;

    /*I frame bit allocation during scene cuts is dependent on f_curr_i_to_sum which will signal

    the complexity difference between current i to future i's if present in the same default gop*/

    float f_curr_i_to_sum;

    float f_curr_by_sum_subgop;

    WORD32 ai4_pic_types_in_subgop[MAX_PIC_TYPE];

    WORD32 i4_use_subgop_bit_alloc_flag;

    WORD32 i4_num_frames_since_last_I_frame;

    LWORD64 i8_first_pic_bits_pictype[MAX_PIC_TYPE];

    LWORD64 i8_avg_bits_pictype[MAX_PIC_TYPE];

    WORD32 i4_avg_qscale_gop_first_pass;

    WORD32 i4_fp_bit_alloc_in_sp;

    WORD32 i4_frame_level_error_ctr_update_rc;

    float f_qscale_max_clip_in_second_pass;

    float f_average_qscale_1st_pass;

    float f_max_average_qscale_1st_pass;

    LWORD64 i8_bit_consumption_so_far;

    WORD32 i4_total_2pass_frames;

    LWORD64 i8_2pass_avg_bit_rate;

    WORD32 i4_br_id;

} bit_allocation_t;

static WORD32 get_actual_num_frames_in_gop(pic_handling_handle ps_pic_handling)

{

    WORD32 i4_tot_frms_in_gop = 0, i;

    WORD32 ai4_actual_frms_in_gop[MAX_PIC_TYPE];

    memset(ai4_actual_frms_in_gop, 0, MAX_PIC_TYPE * sizeof(WORD32));

    pic_type_get_actual_frms_in_gop(ps_pic_handling, ai4_actual_frms_in_gop);

    for(i = 0; i < MAX_PIC_TYPE; i++)

    {

        i4_tot_frms_in_gop += ai4_actual_frms_in_gop[i];

    }

    return (i4_tot_frms_in_gop);

}

float get_cur_peak_factor_2pass(bit_allocation_t *ps_bit_allocation)

{

    return (ps_bit_allocation->f_cur_peak_factor_2pass);

}

float get_cur_min_complexity_factor_2pass(bit_allocation_t *ps_bit_allocation)

{

    return (ps_bit_allocation->f_min_complexity_cross_peak_rate);

}

void set_2pass_total_gops(bit_allocation_t *ps_bit_allocation, WORD32 i4_num_gop)

{

    ps_bit_allocation->i4_num_gop = i4_num_gop;

}

#if NON_STEADSTATE_CODE

/* Module for accessing remaining bits in period */

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

  Function Name : init_rbip

  Description   : Initalises the remaining bits in period structure.

  Inputs        : ps_rbip         -remaining bits in period structure

                  ps_pic_handling - Pic handling structure

                  num_intra_frm_interval - num of I frm intervals in this period

                  i4_bits_per_frm - num bits per frm

Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

static void init_rbip(

    rem_bit_in_prd_t *ps_rbip,

    pic_handling_handle ps_pic_handling,

    WORD32 i4_bits_per_frm,

    WORD32 i4_num_intra_frm_interval)

{

    WORD32 i4_tot_frms_in_gop = get_actual_num_frames_in_gop(ps_pic_handling);

    /* WORD32 i4_frm_correction_for_open_gop = 0; */

    /* If the GOP is open, then we need to subtract the num_b_frames for the first gop */

    /*if(!pic_type_is_gop_closed(ps_pic_handling))

    {

        i4_frm_correction_for_open_gop = pic_type_get_inter_frame_interval(ps_pic_handling)-1;

    }*/

    ps_rbip->i4_rem_bits_in_period =

        i4_bits_per_frm *

        (i4_tot_frms_in_gop * i4_num_intra_frm_interval /*- i4_frm_correction_for_open_gop*/);

    /* Store the total number of frames in GOP value which is

     * used from module A */

    ps_rbip->i4_tot_frms_in_gop = i4_tot_frms_in_gop;

    ps_rbip->i4_num_intra_frm_interval = i4_num_intra_frm_interval;

    ps_rbip->i4_bits_per_frm = i4_bits_per_frm;

}

#endif /* #if NON_STEADSTATE_CODE */

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

  Function Name : check_update_rbip

  Description   : Function for updating rbip.

  Inputs        : ps_rbip         -remaining bits in period structure

                  ps_pic_handling - Pic handling structure

Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

static void check_update_rbip(rem_bit_in_prd_t *ps_rbip, pic_handling_handle ps_pic_handling)

{

    /* NOTE: Intra frame interval changes aafter the first I frame that is encoded in a GOP */

    WORD32 i4_new_tot_frms_in_gop = get_actual_num_frames_in_gop(ps_pic_handling);

    if(i4_new_tot_frms_in_gop != ps_rbip->i4_tot_frms_in_gop)

    {

        WORD32 i4_num_frames_in_period = ps_rbip->i4_num_intra_frm_interval *

                                         (i4_new_tot_frms_in_gop - ps_rbip->i4_tot_frms_in_gop);

        overflow_avoided_summation(

            &ps_rbip->i4_rem_bits_in_period, (ps_rbip->i4_bits_per_frm * i4_num_frames_in_period));

    }

    /* Updated the new values */

    ps_rbip->i4_tot_frms_in_gop = i4_new_tot_frms_in_gop;

}

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

  Function Name : ret_rbip_default_preenc

  Description   : Function for calculating bits in period.

  Inputs        : ps_rbip         -remaining bits in period structure

                  ps_pic_handling - Pic handling structure

Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

static WORD32

    ret_rbip_default_preenc(rem_bit_in_prd_t *ps_rbip, pic_handling_handle ps_pic_handling)

{

    WORD32 i4_bits_in_period =

        pic_type_get_intra_frame_interval(ps_pic_handling) * ps_rbip->i4_bits_per_frm;

    return (i4_bits_in_period);

}

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

  Function Name : update_rbip

  Description   : Function for updating rbip.

  Inputs        : ps_rbip         -remaining bits in period structure

                  ps_pic_handling - Pic handling structure

Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

static WORD32 update_rbip(

    rem_bit_in_prd_t *ps_rbip, pic_handling_handle ps_pic_handling, WORD32 i4_num_of_bits)

{

    check_update_rbip(ps_rbip, ps_pic_handling);

    overflow_avoided_summation(&ps_rbip->i4_rem_bits_in_period, i4_num_of_bits);

    return (ps_rbip->i4_rem_bits_in_period);

}

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

  Function Name : get_rbip_and_num_frames

  Description   : Update rbip and get number of frames.

  Inputs        : ps_rbip         -remaining bits in period structure

                  ps_pic_handling - Pic handling structure

                  pi4_num_frames  - pointer to update number of frmes

Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

static LWORD64 get_rbip_and_num_frames(

    rem_bit_in_prd_t *ps_rbip,

    pic_handling_handle ps_pic_handling,

    WORD32 i4_num_of_bits,

    WORD32 *pi4_num_frames)

{

    check_update_rbip(ps_rbip, ps_pic_handling);

    overflow_avoided_summation(&ps_rbip->i4_rem_bits_in_period, i4_num_of_bits);

    *pi4_num_frames = ps_rbip->i4_tot_frms_in_gop;

    return (ps_rbip->i4_rem_bits_in_period);

}

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

  Function Name : set_rbip

  Description   : Set rbip

  Inputs        : ps_rbip         -remaining bits in period structure

                  i4_error_bits   - Error bits

Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

static WORD32 set_rbip(rem_bit_in_prd_t *ps_rbip, WORD32 i4_error_bits)

{

    ps_rbip->i4_rem_bits_in_period = (ps_rbip->i4_bits_per_frm * ps_rbip->i4_tot_frms_in_gop *

                                      ps_rbip->i4_num_intra_frm_interval) +

                                     i4_error_bits;

    return ps_rbip->i4_rem_bits_in_period;

}

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

  Function Name : multi_pass_set_rbip

  Description   : 2 pass set RBIP, since the gop bits shall not depend on bitrate or framerate,

                  GOP bits is directly obtained from first pass data

  Inputs        : ps_rbip         -remaining bits in period structure

                  ps_pic_handling - Pic handling structure

                  i4_cur_gop_bits - bits allocated for the curr gop

                  i4_tot_frm_in_cur_gop - frames in the gop

Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

static void multi_pass_set_rbip(

    rem_bit_in_prd_t *ps_rbip,

    pic_handling_handle ps_pic_handling,

    WORD32 i4_cur_gop_bits,

    WORD32 i4_tot_frm_in_cur_gop)

{

    WORD32 i4_num_frames_in_gop = get_actual_num_frames_in_gop(ps_pic_handling);

    ps_rbip->i4_rem_bits_in_period =

        (WORD32)((LWORD64)i4_cur_gop_bits * i4_num_frames_in_gop / i4_tot_frm_in_cur_gop);

    ps_rbip->i4_tot_frms_in_gop = i4_num_frames_in_gop;

    ps_rbip->i4_bits_per_frm = ps_rbip->i4_rem_bits_in_period / i4_num_frames_in_gop;

}

static void change_rbip(

    rem_bit_in_prd_t *ps_rbip, WORD32 i4_new_bits_per_frm, WORD32 i4_new_num_intra_frm_interval)

{

    if(i4_new_bits_per_frm != ps_rbip->i4_bits_per_frm)

    {

        WORD32 i4_rem_frms_in_period =

            (ps_rbip->i4_num_intra_frm_interval) * ps_rbip->i4_tot_frms_in_gop;

        overflow_avoided_summation(

            &ps_rbip->i4_rem_bits_in_period,

            ((i4_new_bits_per_frm - ps_rbip->i4_bits_per_frm) * i4_rem_frms_in_period));

    }

    if(i4_new_num_intra_frm_interval != ps_rbip->i4_num_intra_frm_interval)

    {

        overflow_avoided_summation(

            &ps_rbip->i4_rem_bits_in_period,

            (i4_new_bits_per_frm * ps_rbip->i4_tot_frms_in_gop *

             (i4_new_num_intra_frm_interval - ps_rbip->i4_num_intra_frm_interval)));

    }

    /* Update the new value */

    ps_rbip->i4_num_intra_frm_interval = i4_new_num_intra_frm_interval;

    ps_rbip->i4_bits_per_frm = i4_new_bits_per_frm;

}

#if NON_STEADSTATE_CODE

WORD32 bit_allocation_num_fill_use_free_memtab(

    bit_allocation_t **pps_bit_allocation, itt_memtab_t *ps_memtab, ITT_FUNC_TYPE_E e_func_type)

{

    WORD32 i4_mem_tab_idx = 0;

    static bit_allocation_t s_bit_allocation_temp;

    /* Hack for al alloc, during which we dont have any state memory.

      Dereferencing can cause issues */

    if(e_func_type == GET_NUM_MEMTAB || e_func_type == FILL_MEMTAB)

        (*pps_bit_allocation) = &s_bit_allocation_temp;

    /*for src rate control state structure*/

    if(e_func_type != GET_NUM_MEMTAB)

    {

        fill_memtab(

            &ps_memtab[i4_mem_tab_idx],

            sizeof(bit_allocation_t),

            MEM_TAB_ALIGNMENT,

            PERSISTENT,

            DDR);

        use_or_fill_base(&ps_memtab[0], (void **)pps_bit_allocation, e_func_type);

    }

    i4_mem_tab_idx++;

    i4_mem_tab_idx += error_bits_num_fill_use_free_memtab(

        &pps_bit_allocation[0]->ps_error_bits, &ps_memtab[i4_mem_tab_idx], e_func_type);

    return (i4_mem_tab_idx);

}

#endif /* #if NON_STEADSTATE_CODE */

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

  Function Name : get_bits_based_on_complexity

  Description   : function calculates the bits to be allocated for the current

                  picture type given the relative complexity between different

                  picture types

  Inputs        : i4_bits_in_period

                  pi4_frms_in_period      - num frames of each pictype in the period

                  pvq_complexity_estimate - complexity for each pictype

                  e_pic_type              - current picture type

                  i4_call_type

  Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

static WORD32 get_bits_based_on_complexity(

    bit_allocation_t *ps_bit_allocation,

    WORD32 i4_bits_in_period,

    WORD32 *pi4_frms_in_period,

    number_t *pvq_complexity_estimate,

    picture_type_e e_pic_type,

    WORD32 i4_call_type)

{

    WORD32 i, i4_estimated_bits;

    number_t vq_bits_in_period, vq_frms_in_period[MAX_PIC_TYPE], vq_comp_coeff,

        vq_est_texture_bits_for_frm;

    WORD32 i4_num_scd_in_LAP_window = ps_bit_allocation->i4_num_scd_in_lap_window;

    WORD32 i4_active_pic_types = ps_bit_allocation->i4_num_active_pic_type,

           i4_field_pic = ps_bit_allocation->i4_field_pic;

    float af_sum_weigh[MAX_PIC_TYPE][3];

    memmove(af_sum_weigh, ps_bit_allocation->af_sum_weigh, ((sizeof(float)) * MAX_PIC_TYPE * 3));

    /** Increment I frame count if there is scene cut in LAP window*/

    i4_num_scd_in_LAP_window = 0;

    pi4_frms_in_period[I_PIC] += i4_num_scd_in_LAP_window;

    /* Converting inputs to var_q format */

    SET_VAR_Q(vq_bits_in_period, i4_bits_in_period, 0);

    for(i = 0; i < MAX_PIC_TYPE; i++)

    {

        SET_VAR_Q(vq_frms_in_period[i], pi4_frms_in_period[i], 0);

    }

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

    Estimated texture bits =

            (remaining bits) * (cur frm complexity)

            ---------------------------------------

    (num_i_frm*i_frm_complexity) + (num_p_frm*pfrm_complexity) + (b_frm * b_frm_cm)

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

    /*Taking the numerator weight into account*/

    if(i4_call_type == 1)

    {

        trace_printf("1 CUrr / avg %f", af_sum_weigh[e_pic_type][0]);

    }

    if(af_sum_weigh[e_pic_type][0] > 4.0f)

        af_sum_weigh[e_pic_type][0] = 4.0f;

    if(af_sum_weigh[e_pic_type][0] < 0.3f)

        af_sum_weigh[e_pic_type][0] = 0.3f;

    if(i4_call_type == 1)

    {

        trace_printf("2 CUrr / avg %f", af_sum_weigh[e_pic_type][0]);

    }

    if((ps_bit_allocation->i4_ba_rc_pass != 2) || (i4_call_type == 0) ||

       (ps_bit_allocation->i4_fp_bit_alloc_in_sp == 0))

    {

        convert_float_to_fix(af_sum_weigh[e_pic_type][0], &vq_comp_coeff);

        mult32_var_q(vq_bits_in_period, vq_comp_coeff, &vq_bits_in_period);

        mult32_var_q(vq_bits_in_period, pvq_complexity_estimate[e_pic_type], &vq_bits_in_period);

    }

    else

    {

        WORD32 i4_frame_num = (WORD32)ps_bit_allocation->i8_frm_num_in_gop, i4_offset;

        gop_level_stat_t *ps_gop;

        LWORD64 i8_firs_pass_tot_bits;

        float f_bits_cur_pic, f_offset;

        ps_gop =

            (gop_level_stat_t *)ps_bit_allocation->pv_gop_stat + ps_bit_allocation->i8_cur_gop_num;

        i8_firs_pass_tot_bits = ps_gop->ai8_tex_bits_consumed[i4_frame_num] +

                                ps_gop->ai8_head_bits_consumed[i4_frame_num];

        i4_offset = (ps_gop->ai4_q6_frame_offsets[i4_frame_num] * 1000) >> QSCALE_Q_FAC;

        f_offset = ((float)i4_offset) / 1000;

        f_bits_cur_pic =

            (float)(i8_firs_pass_tot_bits * ps_gop->ai4_first_pass_qscale[i4_frame_num]) /

            (ps_bit_allocation->i4_avg_qscale_gop_first_pass * f_offset);

        convert_float_to_fix(f_bits_cur_pic, &vq_comp_coeff);

        mult32_var_q(vq_bits_in_period, vq_comp_coeff, &vq_bits_in_period);

        for(i = 0; i < MAX_PIC_TYPE; i++)

        {

            number_t temp;

            convert_float_to_fix((float)ps_bit_allocation->i8_avg_bits_pictype[i], &temp);

            pvq_complexity_estimate[i] = temp;

        }

    }

    for(i = 0; i < MAX_PIC_TYPE; i++)

    {

        /*For 2nd pass we will be reducing the num of pictures as they are coded so we dont want to replace 0's*/

        if(af_sum_weigh[i][1] == 0.0 &&

           !((i4_call_type == 1) && (ps_bit_allocation->i4_ba_rc_pass == 2)))

            af_sum_weigh[i][1] = (float)pi4_frms_in_period[i];

        convert_float_to_fix(af_sum_weigh[i][1], &vq_comp_coeff);

        mult32_var_q(vq_comp_coeff, pvq_complexity_estimate[i], &vq_frms_in_period[i]);

    }

    /* changed the index range from active_pic to max_pic*/

    if(i4_field_pic)

    {

        for(i = 1; i < i4_active_pic_types; i++)

        {

            add32_var_q(vq_frms_in_period[I_PIC], vq_frms_in_period[i], &vq_frms_in_period[I_PIC]);

            add32_var_q(

                vq_frms_in_period[I_PIC],

                vq_frms_in_period[i + FIELD_OFFSET],

                &vq_frms_in_period[I_PIC]);

        }

    }

    else /*field case*/

    {

        for(i = 1; i < i4_active_pic_types; i++)

        {

            add32_var_q(vq_frms_in_period[I_PIC], vq_frms_in_period[i], &vq_frms_in_period[I_PIC]);

        }

    }

    div32_var_q(vq_bits_in_period, vq_frms_in_period[I_PIC], &vq_est_texture_bits_for_frm);

    number_t_to_word32(vq_est_texture_bits_for_frm, &i4_estimated_bits);

    /* If the number of frames are zero then return zero */

    if(!pi4_frms_in_period[e_pic_type])

        i4_estimated_bits = 0;

    return (i4_estimated_bits);

}

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

  Function Name : assign_complexity_coeffs

  Description   :

  Inputs        : af_sum_weigh

  Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

void assign_complexity_coeffs(

    bit_allocation_t *ps_bit_allocation, float af_sum_weigh[MAX_PIC_TYPE][3])

{

    WORD32 i;

    for(i = 0; i < MAX_PIC_TYPE; i++)

    {

        ps_bit_allocation->af_sum_weigh[i][0] = af_sum_weigh[i][0];

        ps_bit_allocation->af_sum_weigh[i][1] = af_sum_weigh[i][1];

        ps_bit_allocation->af_sum_weigh[i][2] = af_sum_weigh[i][2];

    }

}

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

  Function Name : ba_get_rbip_and_num_frames

  Description   :

  Inputs        : pi4_num_frames

  Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

LWORD64 ba_get_rbip_and_num_frames(

    bit_allocation_t *ps_bit_allocation,

    pic_handling_handle ps_pic_handling,

    WORD32 *pi4_num_frames)

{

    return (

        get_rbip_and_num_frames(&ps_bit_allocation->s_rbip, ps_pic_handling, 0, pi4_num_frames));

}

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

  Function Name : init_prev_header_bits

  Description   : Intialise header bits for each pic type

  Inputs        : ps_bit_allocation

                  ps_pic_handling

  Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

void init_prev_header_bits(bit_allocation_t *ps_bit_allocation, pic_handling_handle ps_pic_handling)

{

    WORD32 i4_rem_bits_in_period, /* ai4_rem_frms_in_period[MAX_PIC_TYPE], */

        ai4_frms_in_period[MAX_PIC_TYPE], i, j;

    number_t avq_complexity_estimate[MAX_PIC_TYPE];

    WORD32 i4_field_pic;

    i4_field_pic = pic_type_get_field_pic(ps_pic_handling);

    /* Assigning Percentages of I, P and B frame header bits based on actual bits allocated for I, P and B frames */

    /* Getting the remaining bits in period */

    i4_rem_bits_in_period = update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, 0);

    /* Hardcoding the bit ratios between I, P and B */

    SET_VAR_Q(

        avq_complexity_estimate[I_PIC],

        (I_TO_P_BIT_RATIO * P_TO_B_BIT_RATIO * B_TO_B1_BIT_RATO0 * B1_TO_B2_BIT_RATIO),

        0);

    SET_VAR_Q(

        avq_complexity_estimate[P_PIC],

        (P_TO_B_BIT_RATIO * B_TO_B1_BIT_RATO0 * B1_TO_B2_BIT_RATIO),

        0);

    SET_VAR_Q(

        avq_complexity_estimate[P1_PIC],

        (P_TO_B_BIT_RATIO * B_TO_B1_BIT_RATO0 * B1_TO_B2_BIT_RATIO),

        0);

    SET_VAR_Q(avq_complexity_estimate[B_PIC], (B_TO_B1_BIT_RATO0 * B1_TO_B2_BIT_RATIO), 0);

    SET_VAR_Q(avq_complexity_estimate[BB_PIC], (B_TO_B1_BIT_RATO0 * B1_TO_B2_BIT_RATIO), 0);

    SET_VAR_Q(avq_complexity_estimate[B1_PIC], (B1_TO_B2_BIT_RATIO), 0);

    SET_VAR_Q(

        avq_complexity_estimate[B11_PIC],

        (B1_TO_B2_BIT_RATIO),

        0);  //temporarliy treat ref and non ref as same

    SET_VAR_Q(avq_complexity_estimate[B2_PIC], 1, 0);

    SET_VAR_Q(avq_complexity_estimate[B22_PIC], 1, 0);

    /* Get the rem_frms_in_gop & the frms_in_gop from the pic_type state struct */

    /* pic_type_get_rem_frms_in_gop(ps_pic_handling, ai4_rem_frms_in_period); */

    pic_type_get_frms_in_gop(ps_pic_handling, ai4_frms_in_period);

    /* Depending on the number of gops in a period, find the num_frms_in_prd */

    for(j = 0; j < MAX_PIC_TYPE; j++)

    {

        ai4_frms_in_period[j] = (ai4_frms_in_period[j] * ps_bit_allocation->i4_num_gops_in_period);

    }

    /* Percentage of header bits in teh overall bits allocated to I, P and B frames

    when the data is not known. Since this value is based on bitrate using a equation

    to fit the values. Ran the header bit ratio for [1080@30] carnival, ihits and

    football at 9, 12 and 16 mbps and based on that deriving a equation using bpp.

    Values obtained are:

    (bitrate/bpp)   I              P              B

    9/2.87          0.358617291155 0.549124350786 0.798772545232

    12/3.83         0.288633642796 0.444797334749 0.693933711801

    16/5.11         0.284241839623 0.330152764298 0.557999732549

    Equation for I:

        if bpp > 3.83 hdr = 0.29

        else hdr = -0.073*bpp + 0.569

    Equation for P: hdr = -0.098*bpp + 0.825

    Equation for B: hdr = -0.108*bpp + 1.108

    */

    {

#define FRAME_HEADER_BITS_Q_FACTOR (10)

        WORD32 ai4_header_bits_percentage[MAX_PIC_TYPE];

        WORD32 i4_bpp;

        X_PROD_Y_DIV_Z(

            ps_bit_allocation->i4_bits_per_frm,

            (1 << FRAME_HEADER_BITS_Q_FACTOR),

            ps_bit_allocation->i4_pels_in_frame,

            i4_bpp);

        //ps_bit_allocation->i4_bits_per_frm*(1<<FRAME_HEADER_BITS_Q_FACTOR)/ps_bit_allocation->i4_pels_in_frame;

        if(i4_bpp > 131)

            ai4_header_bits_percentage[I_PIC] = 297;

        else

            ai4_header_bits_percentage[I_PIC] =

                ((-2238 * i4_bpp) >> FRAME_HEADER_BITS_Q_FACTOR) + 583;

        ai4_header_bits_percentage[P_PIC] = ((-2990 * i4_bpp) >> FRAME_HEADER_BITS_Q_FACTOR) + 845;

        ai4_header_bits_percentage[B_PIC] = ((-3308 * i4_bpp) >> FRAME_HEADER_BITS_Q_FACTOR) + 1135;

        /* Changes for 2B subGOP */

        ai4_header_bits_percentage[P_PIC] = (ai4_header_bits_percentage[P_PIC] * 13) >> 4;

        ai4_header_bits_percentage[P1_PIC] = (ai4_header_bits_percentage[P_PIC] * 13) >> 4;

        ai4_header_bits_percentage[B_PIC] = (ai4_header_bits_percentage[B_PIC] * 12) >> 4;

        ai4_header_bits_percentage[BB_PIC] = (ai4_header_bits_percentage[B_PIC] * 12) >> 4;

        /*HEVC_hierarchy: temp change consider same percentage because of insufficient data*/

        ai4_header_bits_percentage[B1_PIC] = ai4_header_bits_percentage[B_PIC];

        ai4_header_bits_percentage[B11_PIC] = ai4_header_bits_percentage[B_PIC];

        ai4_header_bits_percentage[B2_PIC] = ai4_header_bits_percentage[B_PIC];

        ai4_header_bits_percentage[B22_PIC] = ai4_header_bits_percentage[B_PIC];

        for(i = 0; i < MAX_PIC_TYPE; i++)

        {

            ps_bit_allocation->af_sum_weigh[i][0] = 1.0;

            ps_bit_allocation->af_sum_weigh[i][1] = 0.0;

            ps_bit_allocation->af_sum_weigh[i][2] = 0.0;

        }

        for(i = 0; i < MAX_PIC_TYPE; i++)

        {

            /* Getting the total bits allocated for each picture type */

            WORD32 i4_num_bits_allocated = get_bits_based_on_complexity(

                ps_bit_allocation,

                i4_rem_bits_in_period,

                ai4_frms_in_period,

                avq_complexity_estimate,

                (picture_type_e)i,

                0);

            if(ai4_header_bits_percentage[i] < 0)

                ai4_header_bits_percentage[i] = 0;

            ps_bit_allocation->i4_prev_frm_header_bits[i] = (WORD32)(

                ((LWORD64)ai4_header_bits_percentage[i] * i4_num_bits_allocated) >>

                FRAME_HEADER_BITS_Q_FACTOR);

        }

    }

}

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

  Function Name : init_bit_allocation

  Description   : Initalises the bit_allocation structure.

  Inputs        : intra_frm_interval - num frames between two I frames

                  num_intra_frm_interval - num such intervals

                  i4_bit_rate - num bits per second

                  i4_frm_rate - num frms in 1000 seconds

                  i4_num_active_pic_type

  Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

#if NON_STEADSTATE_CODE

void init_bit_allocation(

    bit_allocation_t *ps_bit_allocation,

    pic_handling_handle ps_pic_handling,

    WORD32 i4_num_intra_frm_interval, /* num such intervals */

    WORD32 i4_bit_rate, /* num bits per second */

    WORD32 i4_frm_rate, /* num frms in 1000 seconds */

    WORD32 *i4_peak_bit_rate,

    WORD32 i4_min_bitrate, /* The minimum bit rate that is to be satisfied for a gop */

    WORD32 i4_pels_in_frame,

    WORD32 i4_is_hbr,

    WORD32 i4_num_active_pic_type,

    WORD32 i4_lap_window,

    WORD32 i4_field_pic,

    WORD32 rc_pass,

    WORD32 i4_luma_pels,

    WORD32 i4_fp_bit_alloc_in_sp)

{

    WORD32 i;

    WORD32 i4_bits_per_frm, i4_max_bits_per_frm[MAX_NUM_DRAIN_RATES];

    /* Store the pels in frame value */

    ps_bit_allocation->i4_pels_in_frame = i4_pels_in_frame;

    ps_bit_allocation->i4_num_scd_in_lap_window = 0;

    ps_bit_allocation->i4_num_frm_b4_scd = 0;

    ps_bit_allocation->i4_num_active_pic_type = i4_num_active_pic_type;

    ps_bit_allocation->i4_field_pic = i4_field_pic;

    ps_bit_allocation->i4_ba_rc_pass = rc_pass;

    ps_bit_allocation->i4_br_id = 0; /* 0 - peak, 1 - average*/

    ps_bit_allocation->i8_cur_gop_num =

        0; /*Will be incremented after first frame allocation is done(during init itslef)*/

    ps_bit_allocation->i8_frm_num_in_gop = 0;

    ps_bit_allocation->pv_gop_stat =

        NULL; /*In 2 pass the gop stat pointer is set API parameter call*/

    ps_bit_allocation->f_min_complexity_cross_peak_rate =

        1.0; /*In single pass buffer based additional bits movement is disabled, hence set to max complexity

                                                                Reset to lower value in case of two pass*/

    ps_bit_allocation->f_cur_peak_factor_2pass = -1.0;

    ps_bit_allocation->i8_total_bits_allocated = -1;

    ps_bit_allocation->i4_luma_pels = i4_luma_pels;

    ps_bit_allocation->i4_num_gop = -1;

    ps_bit_allocation->f_sum_complexity_segment_cross_peak = 0.0f;

    //ps_bit_allocation->i8_vbv_based_excess_for_segment = 0;

    ps_bit_allocation->i4_flag_no_more_set_rbip = 0;

    ps_bit_allocation->f_curr_i_to_sum = 1.0f;

    ps_bit_allocation->i4_fp_bit_alloc_in_sp = i4_fp_bit_alloc_in_sp;

    /* Calculate the bits per frame */

    X_PROD_Y_DIV_Z(i4_bit_rate, 1000, i4_frm_rate, i4_bits_per_frm);

    for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)

    {

        X_PROD_Y_DIV_Z(i4_peak_bit_rate[i], 1000, i4_frm_rate, i4_max_bits_per_frm[i]);

    }

    /* Initialize the bits_per_frame */

    ps_bit_allocation->i4_bits_per_frm = i4_bits_per_frm;

    for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)

    {

        ps_bit_allocation->i4_max_bits_per_frm[i] = i4_max_bits_per_frm[i];

    }

    X_PROD_Y_DIV_Z(i4_min_bitrate, 1000, i4_frm_rate, ps_bit_allocation->i4_min_bits_per_frm);

    /* Initialise the rem_bits in period

       The first gop in case of an OPEN GOP may have fewer B_PICs,

       That condition is not taken care of */

    init_rbip(

        &ps_bit_allocation->s_rbip, ps_pic_handling, i4_bits_per_frm, i4_num_intra_frm_interval);

    /* Initialize the num_gops_in_period */

    ps_bit_allocation->i4_num_gops_in_period = i4_num_intra_frm_interval;

    ps_bit_allocation->i4_actual_num_gops_in_period = i4_num_intra_frm_interval;

    /* Relative complexity between I and P frames */

    ps_bit_allocation->i2_K[I_PIC] = (1 << K_Q);

    ps_bit_allocation->i2_K[P_PIC] = I_TO_P_RATIO;

    ps_bit_allocation->i2_K[P1_PIC] = I_TO_P_RATIO;

    ps_bit_allocation->i2_K[B_PIC] = (P_TO_B_RATIO * I_TO_P_RATIO) >> K_Q;

    ps_bit_allocation->i2_K[BB_PIC] = (P_TO_B_RATIO * I_TO_P_RATIO) >> K_Q;

    /*HEVC_hierarchy: force qp offset with one high level of hierarchy*/

    ps_bit_allocation->i2_K[B1_PIC] = (B_TO_B1_RATIO * P_TO_B_RATIO * I_TO_P_RATIO) >> (K_Q + K_Q);

    ps_bit_allocation->i2_K[B11_PIC] = (B_TO_B1_RATIO * P_TO_B_RATIO * I_TO_P_RATIO) >> (K_Q + K_Q);

    ps_bit_allocation->i2_K[B2_PIC] =

        (B1_TO_B2_RATIO * B_TO_B1_RATIO * P_TO_B_RATIO * I_TO_P_RATIO) >> (K_Q + K_Q + K_Q);

    ps_bit_allocation->i2_K[B22_PIC] =

        (B1_TO_B2_RATIO * B_TO_B1_RATIO * P_TO_B_RATIO * I_TO_P_RATIO) >> (K_Q + K_Q + K_Q);

    /* Initialize the saved bits to 0*/

    ps_bit_allocation->i4_saved_bits = 0;

    /* Update the error bits module with average bits */

    init_error_bits(ps_bit_allocation->ps_error_bits, i4_frm_rate, i4_bit_rate);

    /* Store the input for implementing change in values */

    ps_bit_allocation->i4_frame_rate = i4_frm_rate;

    ps_bit_allocation->i4_bit_rate = i4_bit_rate;

    for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)

        ps_bit_allocation->ai4_peak_bit_rate[i] = i4_peak_bit_rate[i];

    ps_bit_allocation->i4_is_hbr = i4_is_hbr;

    /* Initilising the header bits to be used for each picture type */

    init_prev_header_bits(ps_bit_allocation, ps_pic_handling);

    /*HEVC_RC*/

    /*remember prev frames tot bit consumption. This is required to calcualte error after first sub gop where estimate is not known*/

    for(i = 0; i < MAX_PIC_TYPE; i++)

    {

        ps_bit_allocation->ai4_prev_frm_tot_bits[i] =

            -1;  //-1 indicates that pic type has not been encoded

        ps_bit_allocation->ai4_prev_frm_tot_est_bits[i] = -1;

    }

    /* #define STATIC_I_TO_P_RATIO ((STATIC_I_TO_B_RATIO)/(STATIC_P_TO_B_RATIO)) */

    /* Calcualte the max i frame bits */

    {

        WORD32 ai4_frms_in_period[MAX_PIC_TYPE];

        WORD32 ai4_actual_frms_in_period[MAX_PIC_TYPE], i4_actual_frms_in_period = 0;

        WORD32 i4_rem_texture_bits, j, i4_tot_header_bits_est = 0;

        number_t avq_complexity_estimate[MAX_PIC_TYPE];

        WORD32 i4_total_frms;

        /* Get the rem_frms_in_gop & the frms_in_gop from the pic_type state struct */

        pic_type_get_frms_in_gop(ps_pic_handling, ai4_frms_in_period);

        pic_type_get_actual_frms_in_gop(ps_pic_handling, ai4_actual_frms_in_period);

        /* Depending on the number of gops in a period, find the num_frms_in_prd */

        i4_total_frms = 0;

        for(j = 0; j < MAX_PIC_TYPE; j++)

        {

            ai4_frms_in_period[j] *= ps_bit_allocation->i4_num_gops_in_period;

            ai4_actual_frms_in_period[j] *= ps_bit_allocation->i4_num_gops_in_period;

            i4_total_frms += ai4_frms_in_period[j];

            i4_actual_frms_in_period += ai4_actual_frms_in_period[j];

        }

        ps_bit_allocation->i4_rem_frame_in_period = i4_actual_frms_in_period; /*i_only*/

        for(j = 0; j < MAX_PIC_TYPE; j++)

        {

            i4_tot_header_bits_est +=

                ai4_frms_in_period[j] * ps_bit_allocation->i4_prev_frm_header_bits[j];

        }

        /* Remove the header bits from the remaining bits to find how many bits you

        can transfer.*/

        i4_rem_texture_bits =

            ps_bit_allocation->i4_bits_per_frm * i4_actual_frms_in_period - i4_tot_header_bits_est;

        /* Set the complexities for static content */

        SET_VAR_Q(avq_complexity_estimate[I_PIC], STATIC_I_TO_B2_RATIO, 0);

        SET_VAR_Q(avq_complexity_estimate[P_PIC], STATIC_P_TO_B2_RATIO, 0);

        SET_VAR_Q(avq_complexity_estimate[P1_PIC], STATIC_P_TO_B2_RATIO, 0);

        SET_VAR_Q(avq_complexity_estimate[B_PIC], STATIC_B_TO_B2_RATIO, 0);

        SET_VAR_Q(avq_complexity_estimate[BB_PIC], STATIC_B_TO_B2_RATIO, 0);

        SET_VAR_Q(avq_complexity_estimate[B1_PIC], STATIC_B1_TO_B2_RATIO, 0);

        SET_VAR_Q(avq_complexity_estimate[B11_PIC], STATIC_B1_TO_B2_RATIO, 0);

        SET_VAR_Q(avq_complexity_estimate[B2_PIC], 1, 0);

        SET_VAR_Q(avq_complexity_estimate[B22_PIC], 1, 0);

        /* Get the texture bits required for the current frame */

        ps_bit_allocation->i4_max_tex_bits_for_i = get_bits_based_on_complexity(

            ps_bit_allocation,

            i4_rem_texture_bits,

            ai4_frms_in_period,

            avq_complexity_estimate,

            I_PIC,

            0);

    }

    /* initialise the GOP and bit errors to zero */

    ps_bit_allocation->i4_gop_level_bit_error = 0;

    ps_bit_allocation->i4_frame_level_bit_error = 0;

    for(i = 0; i < MAX_NUM_FRAME_PARALLEL; i++)

    {

        ps_bit_allocation->ai4_cur_frm_est_tex_bits[i] = 0;

        ps_bit_allocation->ai4_cur_frm_est_hdr_bits[i] = 0;

    }

    ps_bit_allocation->i4_buffer_based_bit_error = 0;

    ps_bit_allocation->i4_bits_from_buffer_in_cur_gop = 0;

    ps_bit_allocation->i4_excess_bits_from_buffer = 0;

    ps_bit_allocation->i4_lap_window = i4_lap_window;

    ps_bit_allocation->i8_cur_gop_bit_consumption = 0;

    //ps_bit_allocation->i8_2pass_gop_error_accum = 0;

    ps_bit_allocation->f_qscale_max_clip_in_second_pass = (float)0x7FFFFFFF;

    /*Buffer play for single pass*/

    if(rc_pass != 2)

    {

        /*Find ps_bit_allocation->f_min_complexity_cross_peak_rate*/

        /*Find the complexity which maps to peak bit-rate*/

        {

            ps_bit_allocation->f_min_complexity_cross_peak_rate = ba_get_min_complexity_for_peak_br(

                i4_peak_bit_rate[0], i4_bit_rate, 10.0f, 1.0f, 0.0f, rc_pass);

        }

    }

    ps_bit_allocation->i4_total_2pass_frames = 0;

    ps_bit_allocation->i8_2pass_avg_bit_rate = -1;

}

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

  Function Name : ba_init_stat_data

  Description   : The parsing of stat file is done at the end of init (by that time

                  bit allocation init would have already happened,The memory for gop

                  stat data is alocated inside the parse stat file code. Hence the

                  pointer has to be updated again.

  Inputs        : ps_bit_allocation

                  ps_pic_handling

                  pv_gop_stat      - pointer to update

  Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

void ba_init_stat_data(

    bit_allocation_t *ps_bit_allocation,

    pic_handling_handle ps_pic_handling,

    void *pv_gop_stat,

    WORD32 *pi4_pic_dist_in_cur_gop,

    WORD32 i4_total_bits_in_period,

    WORD32 i4_excess_bits)

{

    WORD32 i4_tot_frames_in_gop = 0, i;

    ps_bit_allocation->pv_gop_stat = pv_gop_stat;

    /*Init RBIP*/

    /*Get the complexity*/

    ASSERT(ps_bit_allocation->i8_cur_gop_num == 0);

    ASSERT(ps_bit_allocation->i8_frm_num_in_gop == 0);

    /*INit frames of each type*/

    for(i = 0; i < MAX_PIC_TYPE; i++)

    {

        i4_tot_frames_in_gop += pi4_pic_dist_in_cur_gop[i];

    }

    /*ASSERT(i4_tot_frames_in_gop == i4_intra_period);*/

    /*Also allocate data for first GOP*/

    /*Added for getting actual gop structure*/

    pic_type_update_frms_in_gop(ps_pic_handling, pi4_pic_dist_in_cur_gop);

    multi_pass_set_rbip(

        &ps_bit_allocation->s_rbip, ps_pic_handling, i4_total_bits_in_period, i4_tot_frames_in_gop);

    ps_bit_allocation->i8_2pass_alloc_per_frm_bits =

        (i4_total_bits_in_period + (i4_tot_frames_in_gop >> 1)) / i4_tot_frames_in_gop;

    ps_bit_allocation->i8_bit_consumption_so_far = 0;

    ASSERT(ps_bit_allocation->i4_ba_rc_pass == 2);

}

#endif /* #if NON_STEADSTATE_CODE */

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

  Function Name : bit_alloc_get_intra_bits

  Description   :

  Inputs        : ps_bit_allocation

                  ps_pic_handling

                  pvq_complexity_estimate

                  I_to_avg_rest

  Revision History:

         DD MM YYYY   Author(s)       Changes (Describe the changes made)

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

WORD32 bit_alloc_get_intra_bits(

    bit_allocation_t *ps_bit_allocation,

    pic_handling_handle ps_pic_handling,

    cbr_buffer_handle ps_cbr_buf_handling,

    picture_type_e e_pic_type,

    number_t *pvq_complexity_estimate,

    WORD32 i4_is_scd,

    float I_to_avg_rest,

    WORD32 i4_call_type,

    WORD32 i4_non_I_scd,

    float f_percent_head_bits)

{

    WORD32 ai4_frms_in_period[MAX_PIC_TYPE], ai4_frm_in_gop[MAX_PIC_TYPE], tot_frms_in_period = 0;

    WORD32 i4_field_pic,

        i4_safe_margin = 0,

        i4_lap_window;  //margin in buffer to handle I frames that can come immediately after encoding huge static I frame

    /*obtain buffer size*/

    WORD32 i4_buffer_size =

        ((get_cbr_buffer_size(ps_cbr_buf_handling)) >> 4) * UPPER_THRESHOLD_EBF_Q4;

    WORD32 i4_cur_buf_pos = get_cbr_ebf(ps_cbr_buf_handling), i4_max_buffer_based,

           i4_max_buffer_based_I_pic, i, i4_num_scaled_frms = 1;

    WORD32 i4_bit_alloc_window =

        (ps_bit_allocation->s_rbip.i4_tot_frms_in_gop *

         ps_bit_allocation->s_rbip.i4_num_intra_frm_interval);

    WORD32 i4_num_buf_frms,

        ai4_frms_in_baw[MAX_PIC_TYPE];  //window for which I frame bit allocation is done

    WORD32 i4_bits_in_period, i4_frames_in_buf = 0, i4_default_bits_in_period = 0;

    WORD32 i4_est_bits_for_I, i4_peak_drain_rate, i4_subgop_size;

    rc_type_e rc_type = get_rc_type(ps_cbr_buf_handling);

    pic_type_get_actual_frms_in_gop(ps_pic_handling, ai4_frm_in_gop);

    for(i = 0; i < MAX_PIC_TYPE; i++)

    {

        ai4_frms_in_baw[i] =

            ai4_frm_in_gop[i] * ps_bit_allocation->s_rbip.i4_num_intra_frm_interval;

        ai4_frms_in_period[i] =

            ai4_frm_in_gop[i] * ps_bit_allocation->s_rbip.i4_num_intra_frm_interval;

        tot_frms_in_period += ai4_frm_in_gop[i];

    }

    if(i4_call_type == 1)

    {

        i4_default_bits_in_period = update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, 0);

        if((i4_default_bits_in_period + ps_bit_allocation->i4_frame_level_bit_error) <

           (i4_default_bits_in_period * 0.30))

        {

            ps_bit_allocation->i4_frame_level_bit_error = 0;  //-(i4_default_bits_in_period * 0.70);

        }

        i4_bits_in_period = i4_default_bits_in_period + ps_bit_allocation->i4_frame_level_bit_error;

        if(i4_non_I_scd == 0)

        {

            /*For the first gop unnecessarily the QP is going high in order to prevent this bits corresponding to full gop instead of gop-subgop*/

            WORD32 i4_intra_int = pic_type_get_intra_frame_interval(ps_pic_handling);

            WORD32 i4_inter_int = pic_type_get_inter_frame_interval(ps_pic_handling);

            if((tot_frms_in_period ==

                (i4_intra_int - i4_inter_int + (1 << ps_bit_allocation->i4_field_pic))) &&

               (i4_intra_int != 1))

            {

                i4_bits_in_period =

                    (WORD32)(i4_bits_in_period * ((float)i4_intra_int / tot_frms_in_period));

            }

        }

        trace_printf("\nBits in period %d", i4_bits_in_period);

    }

    else

    {

        i4_bits_in_period = ret_rbip_default_preenc(&ps_bit_allocation->s_rbip, ps_pic_handling);

        if(ps_bit_allocation->i4_ba_rc_pass == 2)

            i4_default_bits_in_period = update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, 0);

    }

    i4_peak_drain_rate = get_buf_max_drain_rate(ps_cbr_buf_handling);

    i4_num_buf_frms =

        (get_cbr_buffer_size(ps_cbr_buf_handling) + (ps_bit_allocation->i4_bits_per_frm >> 1)) /

        ps_bit_allocation->i4_bits_per_frm;

    /*In VBR encoder buffer will be drained faster, i4_num_buf_frms should correspond to maximum number of bits that can be drained

      In CBR both peak and average must be same*/

    i4_num_buf_frms = i4_num_buf_frms * i4_peak_drain_rate / ps_bit_allocation->i4_bits_per_frm;

    i4_field_pic = pic_type_get_field_pic(ps_pic_handling);

    i4_subgop_size = pic_type_get_inter_frame_interval(ps_pic_handling);

    if(pvq_complexity_estimate == NULL)

        i4_cur_buf_pos = 0;

    i4_lap_window = ps_bit_allocation->i4_lap_window;

    /*assume minimum lap visibilty.A static I frame is given only the bits of duration for which we have visibility*/

    if(ps_bit_allocation->i4_lap_window < MINIMUM_VISIBILITY_B4_STATIC_I)

    {

        i4_lap_window = MINIMUM_VISIBILITY_B4_STATIC_I;