xref: /aosp_15_r20/external/libhevc/encoder/cbr_buffer_control.c (revision c83a76b084498d55f252f48b2e3786804cdf24b7)
1*c83a76b0SSuyog Pawar /******************************************************************************
2*c83a76b0SSuyog Pawar  *
3*c83a76b0SSuyog Pawar  * Copyright (C) 2018 The Android Open Source Project
4*c83a76b0SSuyog Pawar  *
5*c83a76b0SSuyog Pawar  * Licensed under the Apache License, Version 2.0 (the "License");
6*c83a76b0SSuyog Pawar  * you may not use this file except in compliance with the License.
7*c83a76b0SSuyog Pawar  * You may obtain a copy of the License at:
8*c83a76b0SSuyog Pawar  *
9*c83a76b0SSuyog Pawar  * http://www.apache.org/licenses/LICENSE-2.0
10*c83a76b0SSuyog Pawar  *
11*c83a76b0SSuyog Pawar  * Unless required by applicable law or agreed to in writing, software
12*c83a76b0SSuyog Pawar  * distributed under the License is distributed on an "AS IS" BASIS,
13*c83a76b0SSuyog Pawar  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14*c83a76b0SSuyog Pawar  * See the License for the specific language governing permissions and
15*c83a76b0SSuyog Pawar  * limitations under the License.
16*c83a76b0SSuyog Pawar  *
17*c83a76b0SSuyog Pawar  *****************************************************************************
18*c83a76b0SSuyog Pawar  * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19*c83a76b0SSuyog Pawar */
20*c83a76b0SSuyog Pawar /*!
21*c83a76b0SSuyog Pawar ******************************************************************************
22*c83a76b0SSuyog Pawar * \file cbr_buffer_control.c
23*c83a76b0SSuyog Pawar *
24*c83a76b0SSuyog Pawar * \brief
25*c83a76b0SSuyog Pawar *    This file contains all functions needed for cbr buffer control
26*c83a76b0SSuyog Pawar * \date
27*c83a76b0SSuyog Pawar * 06/05/2008
28*c83a76b0SSuyog Pawar *
29*c83a76b0SSuyog Pawar * \author
30*c83a76b0SSuyog Pawar *    ittiam
31*c83a76b0SSuyog Pawar *
32*c83a76b0SSuyog Pawar *  \List of Functions
33*c83a76b0SSuyog Pawar *                      init_cbr_buffer
34*c83a76b0SSuyog Pawar *                      cbr_buffer_constraint_check
35*c83a76b0SSuyog Pawar *                      get_cbr_buffer_status
36*c83a76b0SSuyog Pawar *                      update_cbr_buffer
37*c83a76b0SSuyog Pawar *
38*c83a76b0SSuyog Pawar ******************************************************************************
39*c83a76b0SSuyog Pawar */
40*c83a76b0SSuyog Pawar /*****************************************************************************/
41*c83a76b0SSuyog Pawar /* File Includes                                                             */
42*c83a76b0SSuyog Pawar /*****************************************************************************/
43*c83a76b0SSuyog Pawar 
44*c83a76b0SSuyog Pawar /* System include files */
45*c83a76b0SSuyog Pawar #include <stdio.h>
46*c83a76b0SSuyog Pawar 
47*c83a76b0SSuyog Pawar /* User include files */
48*c83a76b0SSuyog Pawar #include "assert.h"
49*c83a76b0SSuyog Pawar #include "ittiam_datatypes.h"
50*c83a76b0SSuyog Pawar #include "rc_cntrl_param.h"
51*c83a76b0SSuyog Pawar #include "rc_common.h"
52*c83a76b0SSuyog Pawar #include "mem_req_and_acq.h"
53*c83a76b0SSuyog Pawar #include "fixed_point_error_bits.h"
54*c83a76b0SSuyog Pawar #include "cbr_buffer_control.h"
55*c83a76b0SSuyog Pawar #include "trace_support.h"
56*c83a76b0SSuyog Pawar #include "var_q_operator.h"
57*c83a76b0SSuyog Pawar 
58*c83a76b0SSuyog Pawar #define MIN(x, y) ((x) < (y)) ? (x) : (y)
59*c83a76b0SSuyog Pawar /*allow a maximum of 20 percent deviation when input is very large*/
60*c83a76b0SSuyog Pawar #define VBR_MAX_BIT_DEV_SEC 50LL
61*c83a76b0SSuyog Pawar 
62*c83a76b0SSuyog Pawar typedef struct cbr_buffer_t
63*c83a76b0SSuyog Pawar {
64*c83a76b0SSuyog Pawar     WORD32 i4_buffer_size; /* Buffer size = Delay * Bitrate*/
65*c83a76b0SSuyog Pawar     WORD32
66*c83a76b0SSuyog Pawar     i4_drain_bits_per_frame[MAX_NUM_DRAIN_RATES]; /* Constant drain rate */
67*c83a76b0SSuyog Pawar     WORD32 i4_ebf; /* Encoder Buffer Fullness */
68*c83a76b0SSuyog Pawar     LWORD64
69*c83a76b0SSuyog Pawar     i8_ebf_bit_alloc; /* current encoder buffer fulness that accounts precise bit consumption (not truncated to max buffer size at skip)*/
70*c83a76b0SSuyog Pawar     LWORD64 i8_credit_level;
71*c83a76b0SSuyog Pawar     WORD32 i4_upr_thr[MAX_PIC_TYPE]; /* Upper threshold of the Buffer */
72*c83a76b0SSuyog Pawar     WORD32 i4_low_thr[MAX_PIC_TYPE]; /* Lower threshold of the Buffer */
73*c83a76b0SSuyog Pawar     error_bits_handle
74*c83a76b0SSuyog Pawar         aps_bpf_error_bits[MAX_NUM_DRAIN_RATES]; /* For error due to bits per frame calculation */
75*c83a76b0SSuyog Pawar     WORD32
76*c83a76b0SSuyog Pawar     i4_is_cbr_mode; /* Whether the buffer model is used for CBR or VBR streaming */
77*c83a76b0SSuyog Pawar     /* Input parameters stored for initialisation */
78*c83a76b0SSuyog Pawar     WORD32 ai4_bit_rate[MAX_NUM_DRAIN_RATES];
79*c83a76b0SSuyog Pawar     WORD32 i4_max_delay;
80*c83a76b0SSuyog Pawar     WORD32 ai4_num_pics_in_delay_period[MAX_PIC_TYPE];
81*c83a76b0SSuyog Pawar     WORD32 i4_tgt_frm_rate;
82*c83a76b0SSuyog Pawar     UWORD32 u4_max_vbv_buf_size;
83*c83a76b0SSuyog Pawar     WORD32 i4_peak_drain_rate_frame;
84*c83a76b0SSuyog Pawar     WORD32 u4_num_frms_in_delay;
85*c83a76b0SSuyog Pawar     UWORD32 u4_vbr_max_bit_deviation;
86*c83a76b0SSuyog Pawar     rc_type_e e_rc_type;
87*c83a76b0SSuyog Pawar     WORD32 i4_vbr_no_peak_rate_duration_limit;
88*c83a76b0SSuyog Pawar     LWORD64 i8_tot_frm_to_be_encoded;
89*c83a76b0SSuyog Pawar     LWORD64
90*c83a76b0SSuyog Pawar     i8_num_frames_encoded; /*need to track the number of frames encoded to calculate possible deviaiton allowed*/
91*c83a76b0SSuyog Pawar     WORD32 i4_cbr_rc_pass;
92*c83a76b0SSuyog Pawar     WORD32 i4_inter_frame_int;
93*c83a76b0SSuyog Pawar     WORD32 i4_intra_frame_int;
94*c83a76b0SSuyog Pawar     WORD32 i4_capped_vbr_on;
95*c83a76b0SSuyog Pawar     float f_max_dur_peak_rate;
96*c83a76b0SSuyog Pawar     LWORD64 i4_ebf_estimate;
97*c83a76b0SSuyog Pawar } cbr_buffer_t;
98*c83a76b0SSuyog Pawar 
99*c83a76b0SSuyog Pawar #if NON_STEADSTATE_CODE
cbr_buffer_num_fill_use_free_memtab(cbr_buffer_t ** pps_cbr_buffer,itt_memtab_t * ps_memtab,ITT_FUNC_TYPE_E e_func_type)100*c83a76b0SSuyog Pawar WORD32 cbr_buffer_num_fill_use_free_memtab(
101*c83a76b0SSuyog Pawar     cbr_buffer_t **pps_cbr_buffer, itt_memtab_t *ps_memtab, ITT_FUNC_TYPE_E e_func_type)
102*c83a76b0SSuyog Pawar {
103*c83a76b0SSuyog Pawar     WORD32 i4_mem_tab_idx = 0, i;
104*c83a76b0SSuyog Pawar     static cbr_buffer_t s_cbr_buffer_temp;
105*c83a76b0SSuyog Pawar 
106*c83a76b0SSuyog Pawar     /* Hack for al alloc, during which we dont have any state memory.
107*c83a76b0SSuyog Pawar       Dereferencing can cause issues */
108*c83a76b0SSuyog Pawar     if(e_func_type == GET_NUM_MEMTAB || e_func_type == FILL_MEMTAB)
109*c83a76b0SSuyog Pawar         (*pps_cbr_buffer) = &s_cbr_buffer_temp;
110*c83a76b0SSuyog Pawar 
111*c83a76b0SSuyog Pawar     if(e_func_type != GET_NUM_MEMTAB)
112*c83a76b0SSuyog Pawar     {
113*c83a76b0SSuyog Pawar         fill_memtab(
114*c83a76b0SSuyog Pawar             &ps_memtab[i4_mem_tab_idx], sizeof(cbr_buffer_t), MEM_TAB_ALIGNMENT, PERSISTENT, DDR);
115*c83a76b0SSuyog Pawar         use_or_fill_base(&ps_memtab[0], (void **)pps_cbr_buffer, e_func_type);
116*c83a76b0SSuyog Pawar     }
117*c83a76b0SSuyog Pawar     i4_mem_tab_idx++;
118*c83a76b0SSuyog Pawar 
119*c83a76b0SSuyog Pawar     for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
120*c83a76b0SSuyog Pawar     {
121*c83a76b0SSuyog Pawar         i4_mem_tab_idx += error_bits_num_fill_use_free_memtab(
122*c83a76b0SSuyog Pawar             &pps_cbr_buffer[0]->aps_bpf_error_bits[i], &ps_memtab[i4_mem_tab_idx], e_func_type);
123*c83a76b0SSuyog Pawar     }
124*c83a76b0SSuyog Pawar     return (i4_mem_tab_idx);
125*c83a76b0SSuyog Pawar }
set_upper_lower_vbv_threshold(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_bits_per_frm)126*c83a76b0SSuyog Pawar static void set_upper_lower_vbv_threshold(cbr_buffer_t *ps_cbr_buffer, WORD32 i4_bits_per_frm)
127*c83a76b0SSuyog Pawar {
128*c83a76b0SSuyog Pawar     WORD32 i;
129*c83a76b0SSuyog Pawar     for(i = 0; i < MAX_PIC_TYPE; i++)
130*c83a76b0SSuyog Pawar     {
131*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_upr_thr[i] =
132*c83a76b0SSuyog Pawar             (WORD32)(((LWORD64)ps_cbr_buffer->i4_buffer_size >> 4) * UPPER_THRESHOLD_EBF_Q4);
133*c83a76b0SSuyog Pawar         if(ps_cbr_buffer->e_rc_type == VBR_STREAMING)
134*c83a76b0SSuyog Pawar         {
135*c83a76b0SSuyog Pawar             /*lower threshold can be zero as there is no problem of studffing in this mode (VBR STORAGE)*/
136*c83a76b0SSuyog Pawar             if(ps_cbr_buffer->i4_vbr_no_peak_rate_duration_limit)
137*c83a76b0SSuyog Pawar                 ps_cbr_buffer->i4_low_thr[i] = 0;
138*c83a76b0SSuyog Pawar             else
139*c83a76b0SSuyog Pawar                 ps_cbr_buffer->i4_low_thr[i] = ps_cbr_buffer->i4_inter_frame_int * i4_bits_per_frm;
140*c83a76b0SSuyog Pawar         }
141*c83a76b0SSuyog Pawar         else
142*c83a76b0SSuyog Pawar         {
143*c83a76b0SSuyog Pawar             if(ps_cbr_buffer->i4_inter_frame_int == 1)
144*c83a76b0SSuyog Pawar                 ps_cbr_buffer->i4_low_thr[i] = 0;
145*c83a76b0SSuyog Pawar             else
146*c83a76b0SSuyog Pawar             {
147*c83a76b0SSuyog Pawar                 ps_cbr_buffer->i4_low_thr[i] = ps_cbr_buffer->i4_inter_frame_int * i4_bits_per_frm;
148*c83a76b0SSuyog Pawar             }
149*c83a76b0SSuyog Pawar         }
150*c83a76b0SSuyog Pawar         /*For huge buffer low limit can be higher*/
151*c83a76b0SSuyog Pawar 
152*c83a76b0SSuyog Pawar         if(ps_cbr_buffer->i4_low_thr[i] < (ps_cbr_buffer->i4_buffer_size >> 6))
153*c83a76b0SSuyog Pawar             ps_cbr_buffer->i4_low_thr[i] = (ps_cbr_buffer->i4_buffer_size >> 6);
154*c83a76b0SSuyog Pawar 
155*c83a76b0SSuyog Pawar         if(ps_cbr_buffer->i4_low_thr[i] > (ps_cbr_buffer->i4_buffer_size >> 3))  //KISH_DEBUG
156*c83a76b0SSuyog Pawar             ps_cbr_buffer->i4_low_thr[i] = (ps_cbr_buffer->i4_buffer_size >> 3);
157*c83a76b0SSuyog Pawar         ASSERT(ps_cbr_buffer->i4_upr_thr[i] > ps_cbr_buffer->i4_low_thr[i]);
158*c83a76b0SSuyog Pawar     }
159*c83a76b0SSuyog Pawar }
160*c83a76b0SSuyog Pawar /* ******************************************************************************/
161*c83a76b0SSuyog Pawar /**
162*c83a76b0SSuyog Pawar  * @brief Initialise the CBR VBV buffer state.
163*c83a76b0SSuyog Pawar  * This could however be used for VBR streaming VBV also
164*c83a76b0SSuyog Pawar  *
165*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
166*c83a76b0SSuyog Pawar  * @param i4_buffer_delay
167*c83a76b0SSuyog Pawar  * @param i4_tgt_frm_rate
168*c83a76b0SSuyog Pawar  * @param i4_bit_rate
169*c83a76b0SSuyog Pawar  * @param u4_num_pics_in_delay_prd
170*c83a76b0SSuyog Pawar  * @param u4_vbv_buf_size
171*c83a76b0SSuyog Pawar  */
172*c83a76b0SSuyog Pawar /* ******************************************************************************/
init_cbr_buffer(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_buffer_delay,WORD32 i4_tgt_frm_rate,UWORD32 u4_bit_rate,UWORD32 * u4_num_pics_in_delay_prd,UWORD32 u4_vbv_buf_size,UWORD32 u4_intra_frm_int,rc_type_e e_rc_type,UWORD32 u4_peak_bit_rate,UWORD32 u4_num_frames_in_delay,float f_max_dur_peak_rate,LWORD64 i8_num_frames_to_encode,WORD32 i4_inter_frm_int,WORD32 i4_cbr_rc_pass,WORD32 i4_capped_vbr_flag)173*c83a76b0SSuyog Pawar void init_cbr_buffer(
174*c83a76b0SSuyog Pawar     cbr_buffer_t *ps_cbr_buffer,
175*c83a76b0SSuyog Pawar     WORD32 i4_buffer_delay,
176*c83a76b0SSuyog Pawar     WORD32 i4_tgt_frm_rate,
177*c83a76b0SSuyog Pawar     UWORD32 u4_bit_rate,
178*c83a76b0SSuyog Pawar     UWORD32 *u4_num_pics_in_delay_prd,
179*c83a76b0SSuyog Pawar     UWORD32 u4_vbv_buf_size,
180*c83a76b0SSuyog Pawar     UWORD32 u4_intra_frm_int,
181*c83a76b0SSuyog Pawar     rc_type_e e_rc_type,
182*c83a76b0SSuyog Pawar     UWORD32 u4_peak_bit_rate,
183*c83a76b0SSuyog Pawar     UWORD32 u4_num_frames_in_delay,
184*c83a76b0SSuyog Pawar     float f_max_dur_peak_rate,
185*c83a76b0SSuyog Pawar     LWORD64 i8_num_frames_to_encode,
186*c83a76b0SSuyog Pawar     WORD32 i4_inter_frm_int,
187*c83a76b0SSuyog Pawar     WORD32 i4_cbr_rc_pass,
188*c83a76b0SSuyog Pawar     WORD32 i4_capped_vbr_flag)
189*c83a76b0SSuyog Pawar 
190*c83a76b0SSuyog Pawar {
191*c83a76b0SSuyog Pawar     WORD32 i4_bits_per_frm[MAX_NUM_DRAIN_RATES];
192*c83a76b0SSuyog Pawar     int i;
193*c83a76b0SSuyog Pawar 
194*c83a76b0SSuyog Pawar     /* Initially Encoder buffer fullness is zero */
195*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_ebf = 0;
196*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_ebf_estimate = 0;
197*c83a76b0SSuyog Pawar     ps_cbr_buffer->i8_ebf_bit_alloc = 0;
198*c83a76b0SSuyog Pawar     ps_cbr_buffer->i8_credit_level = 0;
199*c83a76b0SSuyog Pawar     ps_cbr_buffer->e_rc_type = e_rc_type;
200*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_capped_vbr_on = i4_capped_vbr_flag;
201*c83a76b0SSuyog Pawar     /*If this is set to 1, it acts similar to storage VBR which allows peak rate to be sustained for infinite duration*/
202*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_vbr_no_peak_rate_duration_limit = 0;
203*c83a76b0SSuyog Pawar     ps_cbr_buffer->i8_num_frames_encoded = 0;
204*c83a76b0SSuyog Pawar     ps_cbr_buffer->i8_tot_frm_to_be_encoded = i8_num_frames_to_encode;
205*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_cbr_rc_pass = i4_cbr_rc_pass;
206*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_inter_frame_int = i4_inter_frm_int;
207*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_intra_frame_int = u4_intra_frm_int;
208*c83a76b0SSuyog Pawar     ps_cbr_buffer->f_max_dur_peak_rate = f_max_dur_peak_rate;
209*c83a76b0SSuyog Pawar 
210*c83a76b0SSuyog Pawar     for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
211*c83a76b0SSuyog Pawar     {
212*c83a76b0SSuyog Pawar         X_PROD_Y_DIV_Z(u4_bit_rate, 1000, i4_tgt_frm_rate, i4_bits_per_frm[i]);
213*c83a76b0SSuyog Pawar         /* Drain rate = bitrate/(framerate/1000) */
214*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_drain_bits_per_frame[i] = i4_bits_per_frm[i];
215*c83a76b0SSuyog Pawar         /* initialise the bits per frame error bits calculation */
216*c83a76b0SSuyog Pawar         init_error_bits(ps_cbr_buffer->aps_bpf_error_bits[i], i4_tgt_frm_rate, u4_bit_rate);
217*c83a76b0SSuyog Pawar     }
218*c83a76b0SSuyog Pawar 
219*c83a76b0SSuyog Pawar     /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/
220*c83a76b0SSuyog Pawar     if(e_rc_type == CBR_NLDRC) /* This would mean CBR mode */
221*c83a76b0SSuyog Pawar     {
222*c83a76b0SSuyog Pawar         //buffer size should be independent of initial delay
223*c83a76b0SSuyog Pawar         //X_PROD_Y_DIV_Z(u4_bit_rate,i4_buffer_delay,1000,ps_cbr_buffer->i4_buffer_size);
224*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_buffer_size = (WORD32)u4_vbv_buf_size;
225*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_is_cbr_mode = 1;
226*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_peak_drain_rate_frame = i4_bits_per_frm[0];
227*c83a76b0SSuyog Pawar         /*In CBR the max file size deviaiton allowed is specified by buffer size*/
228*c83a76b0SSuyog Pawar         ps_cbr_buffer->u4_vbr_max_bit_deviation = ps_cbr_buffer->i4_buffer_size;
229*c83a76b0SSuyog Pawar     }
230*c83a76b0SSuyog Pawar     else if(e_rc_type == VBR_STREAMING)
231*c83a76b0SSuyog Pawar     {
232*c83a76b0SSuyog Pawar         /*this is raw vbv buffer size, also initilize the buffer window to bit alloc (credit limit)*/
233*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_buffer_size = (WORD32)u4_vbv_buf_size;
234*c83a76b0SSuyog Pawar         /*if there is no limit on duration for which peak bitrate can be sustained, bits can be moved from any region to other region
235*c83a76b0SSuyog Pawar           giving better quality*/
236*c83a76b0SSuyog Pawar         if(f_max_dur_peak_rate < 0)
237*c83a76b0SSuyog Pawar             ps_cbr_buffer->i4_vbr_no_peak_rate_duration_limit = 1;
238*c83a76b0SSuyog Pawar         /*To avoid file size deviation in case of VBR mode of rate control, clip the max deviaiton allowed based on number of frames to enode*/
239*c83a76b0SSuyog Pawar         {
240*c83a76b0SSuyog Pawar             ULWORD64 u8_vbr_max_bit_deviation;
241*c83a76b0SSuyog Pawar             ULWORD64 file_size = (ULWORD64)(
242*c83a76b0SSuyog Pawar                 (((LWORD64)u4_bit_rate * 1000) / i4_tgt_frm_rate) * i8_num_frames_to_encode);
243*c83a76b0SSuyog Pawar 
244*c83a76b0SSuyog Pawar             /*When f_max_dur_peak_rate is -ve, it implies user is not worried about duration for which peak is sustained, hence go with max possible value*/
245*c83a76b0SSuyog Pawar             if(f_max_dur_peak_rate > 0)
246*c83a76b0SSuyog Pawar                 u8_vbr_max_bit_deviation = (ULWORD64)(f_max_dur_peak_rate * u4_bit_rate);
247*c83a76b0SSuyog Pawar             else
248*c83a76b0SSuyog Pawar                 u8_vbr_max_bit_deviation = (ULWORD64)(VBR_MAX_BIT_DEV_SEC * u4_bit_rate);
249*c83a76b0SSuyog Pawar 
250*c83a76b0SSuyog Pawar             /*when num frames to encode is negative is -ve it implies total frames data is not available (as in case of live encoding)*/
251*c83a76b0SSuyog Pawar             if(i8_num_frames_to_encode > 0)
252*c83a76b0SSuyog Pawar             {
253*c83a76b0SSuyog Pawar                 /*allow atleast one second deviation or 12% of total file size whichever is higher*/
254*c83a76b0SSuyog Pawar                 if(u8_vbr_max_bit_deviation > (file_size >> 3))
255*c83a76b0SSuyog Pawar                     u8_vbr_max_bit_deviation = (UWORD32)(file_size >> 3);
256*c83a76b0SSuyog Pawar 
257*c83a76b0SSuyog Pawar                 /*allow atleast one second for shorter sequence*/
258*c83a76b0SSuyog Pawar                 if(u8_vbr_max_bit_deviation < u4_bit_rate)
259*c83a76b0SSuyog Pawar                     u8_vbr_max_bit_deviation = u4_bit_rate;
260*c83a76b0SSuyog Pawar             }
261*c83a76b0SSuyog Pawar             else
262*c83a76b0SSuyog Pawar             {
263*c83a76b0SSuyog Pawar                 /*the data of number of frames to be encoded is not available*/
264*c83a76b0SSuyog Pawar                 /*start off with one second delay, this will be later adjusted once large number of frames are encoded*/
265*c83a76b0SSuyog Pawar                 u8_vbr_max_bit_deviation = u4_bit_rate;
266*c83a76b0SSuyog Pawar             }
267*c83a76b0SSuyog Pawar             ps_cbr_buffer->u4_vbr_max_bit_deviation = u8_vbr_max_bit_deviation;
268*c83a76b0SSuyog Pawar         }
269*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_is_cbr_mode = 0;
270*c83a76b0SSuyog Pawar         X_PROD_Y_DIV_Z(
271*c83a76b0SSuyog Pawar             u4_peak_bit_rate, 1000, i4_tgt_frm_rate, ps_cbr_buffer->i4_peak_drain_rate_frame);
272*c83a76b0SSuyog Pawar     }
273*c83a76b0SSuyog Pawar     else
274*c83a76b0SSuyog Pawar     {
275*c83a76b0SSuyog Pawar         /*currently only two modes are supported*/
276*c83a76b0SSuyog Pawar         ASSERT(e_rc_type == CONST_QP);
277*c83a76b0SSuyog Pawar     }
278*c83a76b0SSuyog Pawar 
279*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->i4_buffer_size > (WORD32)u4_vbv_buf_size)
280*c83a76b0SSuyog Pawar     {
281*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_buffer_size = u4_vbv_buf_size;
282*c83a76b0SSuyog Pawar     }
283*c83a76b0SSuyog Pawar 
284*c83a76b0SSuyog Pawar     /* Uppr threshold for
285*c83a76b0SSuyog Pawar         I frame = 1 * bits per frame
286*c83a76b0SSuyog Pawar         P Frame = 4 * bits per frame.
287*c83a76b0SSuyog Pawar         The threshold for I frame is only 1 * bits per frame as the threshold should
288*c83a76b0SSuyog Pawar         only account for error in estimated bits.
289*c83a76b0SSuyog Pawar         In P frame it should account for difference bets bits consumed by I(Scene change)
290*c83a76b0SSuyog Pawar         and P frame I to P complexity is assumed to be 5. */
291*c83a76b0SSuyog Pawar     /*HEVC_hierarchy*/
292*c83a76b0SSuyog Pawar     if(e_rc_type != CONST_QP)
293*c83a76b0SSuyog Pawar         set_upper_lower_vbv_threshold(ps_cbr_buffer, i4_bits_per_frm[0]);
294*c83a76b0SSuyog Pawar     /* Storing the input parameters for using it for change functions */
295*c83a76b0SSuyog Pawar     for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
296*c83a76b0SSuyog Pawar         ps_cbr_buffer->ai4_bit_rate[i] = u4_bit_rate;
297*c83a76b0SSuyog Pawar     for(i = 0; i < MAX_PIC_TYPE; i++)
298*c83a76b0SSuyog Pawar     {
299*c83a76b0SSuyog Pawar         ps_cbr_buffer->ai4_num_pics_in_delay_period[i] = u4_num_pics_in_delay_prd[i];
300*c83a76b0SSuyog Pawar     }
301*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_tgt_frm_rate = i4_tgt_frm_rate;
302*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_max_delay = i4_buffer_delay;
303*c83a76b0SSuyog Pawar     ps_cbr_buffer->u4_max_vbv_buf_size = u4_vbv_buf_size;
304*c83a76b0SSuyog Pawar     ps_cbr_buffer->u4_num_frms_in_delay = u4_num_frames_in_delay;
305*c83a76b0SSuyog Pawar }
306*c83a76b0SSuyog Pawar #endif /* #if NON_STEADSTATE_CODE */
307*c83a76b0SSuyog Pawar 
308*c83a76b0SSuyog Pawar /* ******************************************************************************/
309*c83a76b0SSuyog Pawar /**
310*c83a76b0SSuyog Pawar  * @brief Condition check for constrining the number of bits allocated based on bufer size
311*c83a76b0SSuyog Pawar  *
312*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
313*c83a76b0SSuyog Pawar  * @param i4_tgt_bits
314*c83a76b0SSuyog Pawar  * @param e_pic_type
315*c83a76b0SSuyog Pawar  *
316*c83a76b0SSuyog Pawar  * @return
317*c83a76b0SSuyog Pawar  */
318*c83a76b0SSuyog Pawar /* ******************************************************************************/
cbr_buffer_constraint_check(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tgt_bits,picture_type_e e_pic_type,WORD32 * pi4_max_tgt_bits,WORD32 * pi4_min_tgt_bits)319*c83a76b0SSuyog Pawar WORD32 cbr_buffer_constraint_check(
320*c83a76b0SSuyog Pawar     cbr_buffer_t *ps_cbr_buffer,
321*c83a76b0SSuyog Pawar     WORD32 i4_tgt_bits,
322*c83a76b0SSuyog Pawar     picture_type_e e_pic_type,
323*c83a76b0SSuyog Pawar     WORD32 *pi4_max_tgt_bits,
324*c83a76b0SSuyog Pawar     WORD32 *pi4_min_tgt_bits)
325*c83a76b0SSuyog Pawar {
326*c83a76b0SSuyog Pawar     WORD32 i4_max_tgt_bits, i4_min_tgt_bits;
327*c83a76b0SSuyog Pawar     WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC)
328*c83a76b0SSuyog Pawar                                          ? ps_cbr_buffer->i4_drain_bits_per_frame[0]
329*c83a76b0SSuyog Pawar                                          : ps_cbr_buffer->i4_drain_bits_per_frame[1];
330*c83a76b0SSuyog Pawar     WORD32 i4_error_bits = (e_pic_type == I_PIC)
331*c83a76b0SSuyog Pawar                                ? get_error_bits(ps_cbr_buffer->aps_bpf_error_bits[0])
332*c83a76b0SSuyog Pawar                                : get_error_bits(ps_cbr_buffer->aps_bpf_error_bits[1]);
333*c83a76b0SSuyog Pawar 
334*c83a76b0SSuyog Pawar     /*trace_printf("  ebf = %d  bebf = %d ",ps_cbr_buffer->i4_ebf,ps_cbr_buffer->i8_ebf_bit_alloc);*/
335*c83a76b0SSuyog Pawar     /* Max tgt bits = Upper threshold - current encoder buffer fullness */
336*c83a76b0SSuyog Pawar     i4_max_tgt_bits =
337*c83a76b0SSuyog Pawar         (WORD32)(ps_cbr_buffer->i4_upr_thr[e_pic_type] - ps_cbr_buffer->i4_ebf_estimate);
338*c83a76b0SSuyog Pawar     /* Max tgt bits cannot be negative */
339*c83a76b0SSuyog Pawar     if(i4_max_tgt_bits < 0)
340*c83a76b0SSuyog Pawar         i4_max_tgt_bits = 0;
341*c83a76b0SSuyog Pawar 
342*c83a76b0SSuyog Pawar     /* Min tgt bits , least number of bits in the Encoder after
343*c83a76b0SSuyog Pawar     draining such that it is greater than lower threshold */
344*c83a76b0SSuyog Pawar     i4_min_tgt_bits = (WORD32)(
345*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_low_thr[e_pic_type] -
346*c83a76b0SSuyog Pawar         (ps_cbr_buffer->i4_ebf_estimate - i4_drain_bits_per_frame - i4_error_bits));
347*c83a76b0SSuyog Pawar     /*Min tgt bits cannot be negative*/
348*c83a76b0SSuyog Pawar     if(i4_min_tgt_bits < 0)
349*c83a76b0SSuyog Pawar         i4_min_tgt_bits = 0;
350*c83a76b0SSuyog Pawar 
351*c83a76b0SSuyog Pawar     /* current tgt bits should be between max and min tgt bits*/
352*c83a76b0SSuyog Pawar     CLIP(i4_tgt_bits, i4_max_tgt_bits, i4_min_tgt_bits);
353*c83a76b0SSuyog Pawar     pi4_min_tgt_bits[0] = i4_min_tgt_bits;
354*c83a76b0SSuyog Pawar     pi4_max_tgt_bits[0] = i4_max_tgt_bits;
355*c83a76b0SSuyog Pawar     return i4_tgt_bits;
356*c83a76b0SSuyog Pawar }
357*c83a76b0SSuyog Pawar 
358*c83a76b0SSuyog Pawar /* ******************************************************************************/
359*c83a76b0SSuyog Pawar /**
360*c83a76b0SSuyog Pawar  * @brief constaints the bit allocation based on buffer size
361*c83a76b0SSuyog Pawar  *
362*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
363*c83a76b0SSuyog Pawar  * @param i4_tgt_bits
364*c83a76b0SSuyog Pawar  * @param e_pic_type
365*c83a76b0SSuyog Pawar  *
366*c83a76b0SSuyog Pawar  * @return
367*c83a76b0SSuyog Pawar  */
368*c83a76b0SSuyog Pawar /* ******************************************************************************/
vbr_stream_buffer_constraint_check(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tgt_bits,picture_type_e e_pic_type,WORD32 * pi4_max_bits,WORD32 * pi4_min_bits)369*c83a76b0SSuyog Pawar WORD32 vbr_stream_buffer_constraint_check(
370*c83a76b0SSuyog Pawar     cbr_buffer_t *ps_cbr_buffer,
371*c83a76b0SSuyog Pawar     WORD32 i4_tgt_bits,
372*c83a76b0SSuyog Pawar     picture_type_e e_pic_type,
373*c83a76b0SSuyog Pawar     WORD32 *pi4_max_bits,
374*c83a76b0SSuyog Pawar     WORD32 *pi4_min_bits)
375*c83a76b0SSuyog Pawar {
376*c83a76b0SSuyog Pawar     WORD32 i4_max_tgt_bits, i4_min_tgt_bits = 0;
377*c83a76b0SSuyog Pawar 
378*c83a76b0SSuyog Pawar     /* Max tgt bits = Upper threshold - current encoder buffer fullness */
379*c83a76b0SSuyog Pawar     /*maximum target for a pic is amount of bits that can be transmitted to decoder buffer in delay assuming max drain rate
380*c83a76b0SSuyog Pawar       This above limit has to be constrained wrt a single frame being accomodated in the buffer*/
381*c83a76b0SSuyog Pawar     i4_max_tgt_bits = (WORD32)(
382*c83a76b0SSuyog Pawar         (ps_cbr_buffer->u4_num_frms_in_delay * ps_cbr_buffer->i4_peak_drain_rate_frame) -
383*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_ebf_estimate);
384*c83a76b0SSuyog Pawar     /*the below check is necessary to make sure that a single frame to be accomodated in encoder buffer*/
385*c83a76b0SSuyog Pawar     if(i4_max_tgt_bits > ps_cbr_buffer->i4_upr_thr[e_pic_type] - ps_cbr_buffer->i4_ebf_estimate)
386*c83a76b0SSuyog Pawar     {
387*c83a76b0SSuyog Pawar         i4_max_tgt_bits =
388*c83a76b0SSuyog Pawar             (WORD32)(ps_cbr_buffer->i4_upr_thr[e_pic_type] - ps_cbr_buffer->i4_ebf_estimate);
389*c83a76b0SSuyog Pawar     }
390*c83a76b0SSuyog Pawar 
391*c83a76b0SSuyog Pawar     /*In VBR streaming though encoder buffer underflow is not a problem, at any point of time the bitrate underconsumption
392*c83a76b0SSuyog Pawar       cannot go below specified limit. Hence it is limited based on possible bitrate deviation allowed*/
393*c83a76b0SSuyog Pawar     /*Enabling movement of stuffing bits always*/
394*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->i4_vbr_no_peak_rate_duration_limit)
395*c83a76b0SSuyog Pawar     {
396*c83a76b0SSuyog Pawar         /*If the content has underconsumed force it to consume atleast per frame bits so that end of encoding there wont be too much undersonsumption*/
397*c83a76b0SSuyog Pawar         if(ps_cbr_buffer->i8_ebf_bit_alloc < 0 && ps_cbr_buffer->i4_cbr_rc_pass != 2)
398*c83a76b0SSuyog Pawar             i4_min_tgt_bits = (ps_cbr_buffer->i4_drain_bits_per_frame[0] >> 1);
399*c83a76b0SSuyog Pawar     }
400*c83a76b0SSuyog Pawar     else
401*c83a76b0SSuyog Pawar     {
402*c83a76b0SSuyog Pawar         /*In this case buffer is always guranteed to be positive, to avoid stuffing give decent amount of min bits*/
403*c83a76b0SSuyog Pawar         i4_min_tgt_bits = (WORD32)(ps_cbr_buffer->i4_low_thr[0] - ps_cbr_buffer->i8_ebf_bit_alloc);
404*c83a76b0SSuyog Pawar     }
405*c83a76b0SSuyog Pawar 
406*c83a76b0SSuyog Pawar     /*Clip min target bit*/
407*c83a76b0SSuyog Pawar     if(i4_min_tgt_bits < 0)
408*c83a76b0SSuyog Pawar         i4_min_tgt_bits = 0;
409*c83a76b0SSuyog Pawar     if(i4_tgt_bits < i4_min_tgt_bits)
410*c83a76b0SSuyog Pawar         i4_tgt_bits = i4_min_tgt_bits;
411*c83a76b0SSuyog Pawar     pi4_min_bits[0] = i4_min_tgt_bits;
412*c83a76b0SSuyog Pawar     /* Max tgt bits cannot be negative */
413*c83a76b0SSuyog Pawar     if(i4_max_tgt_bits < 0)
414*c83a76b0SSuyog Pawar         i4_max_tgt_bits = 0;
415*c83a76b0SSuyog Pawar     if(i4_tgt_bits > i4_max_tgt_bits)
416*c83a76b0SSuyog Pawar         i4_tgt_bits = i4_max_tgt_bits;
417*c83a76b0SSuyog Pawar     pi4_max_bits[0] = i4_max_tgt_bits;
418*c83a76b0SSuyog Pawar 
419*c83a76b0SSuyog Pawar     return i4_tgt_bits;
420*c83a76b0SSuyog Pawar }
421*c83a76b0SSuyog Pawar 
422*c83a76b0SSuyog Pawar /* ******************************************************************************/
423*c83a76b0SSuyog Pawar /**
424*c83a76b0SSuyog Pawar  * @brief Verifies the buffer state and returns whether it is overflowing, underflowing or normal
425*c83a76b0SSuyog Pawar  *
426*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
427*c83a76b0SSuyog Pawar  * @param i4_tot_consumed_bits
428*c83a76b0SSuyog Pawar  * @param pi4_num_bits_to_prevent_overflow
429*c83a76b0SSuyog Pawar  * @param e_pic_type
430*c83a76b0SSuyog Pawar  *
431*c83a76b0SSuyog Pawar  * @return
432*c83a76b0SSuyog Pawar  */
433*c83a76b0SSuyog Pawar /* ******************************************************************************/
get_cbr_buffer_status(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tot_consumed_bits,WORD32 * pi4_num_bits_to_prevent_overflow,picture_type_e e_pic_type,rc_type_e e_rc_type)434*c83a76b0SSuyog Pawar vbv_buf_status_e get_cbr_buffer_status(
435*c83a76b0SSuyog Pawar     cbr_buffer_t *ps_cbr_buffer,
436*c83a76b0SSuyog Pawar     WORD32 i4_tot_consumed_bits,
437*c83a76b0SSuyog Pawar     WORD32 *pi4_num_bits_to_prevent_overflow,
438*c83a76b0SSuyog Pawar     picture_type_e e_pic_type,
439*c83a76b0SSuyog Pawar     rc_type_e e_rc_type)
440*c83a76b0SSuyog Pawar {
441*c83a76b0SSuyog Pawar     vbv_buf_status_e e_buf_status;
442*c83a76b0SSuyog Pawar     WORD32 i4_cur_enc_buf;
443*c83a76b0SSuyog Pawar     WORD32 i4_error_bits = (e_pic_type == I_PIC)
444*c83a76b0SSuyog Pawar                                ? get_error_bits(ps_cbr_buffer->aps_bpf_error_bits[0])
445*c83a76b0SSuyog Pawar                                : get_error_bits(ps_cbr_buffer->aps_bpf_error_bits[1]);
446*c83a76b0SSuyog Pawar     WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC)
447*c83a76b0SSuyog Pawar                                          ? ps_cbr_buffer->i4_drain_bits_per_frame[0]
448*c83a76b0SSuyog Pawar                                          : ps_cbr_buffer->i4_drain_bits_per_frame[1];
449*c83a76b0SSuyog Pawar 
450*c83a76b0SSuyog Pawar     /* Add the tot consumed bits to the Encoder Buffer*/
451*c83a76b0SSuyog Pawar     i4_cur_enc_buf = ps_cbr_buffer->i4_ebf + i4_tot_consumed_bits;
452*c83a76b0SSuyog Pawar 
453*c83a76b0SSuyog Pawar     /* If the Encoder exceeds the Buffer Size signal an Overflow*/
454*c83a76b0SSuyog Pawar     if(i4_cur_enc_buf > ps_cbr_buffer->i4_buffer_size)
455*c83a76b0SSuyog Pawar     {
456*c83a76b0SSuyog Pawar         e_buf_status = VBV_OVERFLOW;
457*c83a76b0SSuyog Pawar         i4_cur_enc_buf = ps_cbr_buffer->i4_buffer_size;
458*c83a76b0SSuyog Pawar     }
459*c83a76b0SSuyog Pawar     else
460*c83a76b0SSuyog Pawar     {
461*c83a76b0SSuyog Pawar         /* Subtract the constant drain bits and error bits due to fixed point implementation*/
462*c83a76b0SSuyog Pawar         i4_cur_enc_buf -= (i4_drain_bits_per_frame + i4_error_bits);
463*c83a76b0SSuyog Pawar 
464*c83a76b0SSuyog Pawar         if(e_rc_type == VBR_STREAMING)
465*c83a76b0SSuyog Pawar         {
466*c83a76b0SSuyog Pawar             /*In VBR suffing scenerio will not occur*/
467*c83a76b0SSuyog Pawar             if(i4_cur_enc_buf < 0)
468*c83a76b0SSuyog Pawar                 i4_cur_enc_buf = 0;
469*c83a76b0SSuyog Pawar         }
470*c83a76b0SSuyog Pawar         /* If the buffer is less than stuffing threshold an Underflow is signaled else its NORMAL*/
471*c83a76b0SSuyog Pawar         if(i4_cur_enc_buf < 0)
472*c83a76b0SSuyog Pawar         {
473*c83a76b0SSuyog Pawar             e_buf_status = VBV_UNDERFLOW;
474*c83a76b0SSuyog Pawar         }
475*c83a76b0SSuyog Pawar         else
476*c83a76b0SSuyog Pawar         {
477*c83a76b0SSuyog Pawar             e_buf_status = VBV_NORMAL;
478*c83a76b0SSuyog Pawar         }
479*c83a76b0SSuyog Pawar 
480*c83a76b0SSuyog Pawar         if(i4_cur_enc_buf < 0)
481*c83a76b0SSuyog Pawar             i4_cur_enc_buf = 0;
482*c83a76b0SSuyog Pawar     }
483*c83a76b0SSuyog Pawar 
484*c83a76b0SSuyog Pawar     /* The RC lib models the encoder buffer, but the VBV buffer characterises the decoder buffer */
485*c83a76b0SSuyog Pawar     if(e_buf_status == VBV_OVERFLOW)
486*c83a76b0SSuyog Pawar     {
487*c83a76b0SSuyog Pawar         e_buf_status = VBV_UNDERFLOW;
488*c83a76b0SSuyog Pawar     }
489*c83a76b0SSuyog Pawar     else if(e_buf_status == VBV_UNDERFLOW)
490*c83a76b0SSuyog Pawar     {
491*c83a76b0SSuyog Pawar         e_buf_status = VBV_OVERFLOW;
492*c83a76b0SSuyog Pawar     }
493*c83a76b0SSuyog Pawar 
494*c83a76b0SSuyog Pawar     pi4_num_bits_to_prevent_overflow[0] = (ps_cbr_buffer->i4_buffer_size - i4_cur_enc_buf);
495*c83a76b0SSuyog Pawar 
496*c83a76b0SSuyog Pawar     return e_buf_status;
497*c83a76b0SSuyog Pawar }
498*c83a76b0SSuyog Pawar 
499*c83a76b0SSuyog Pawar /* ******************************************************************************/
500*c83a76b0SSuyog Pawar /**
501*c83a76b0SSuyog Pawar  * @brief Based on the bits consumed the buffer model is updated
502*c83a76b0SSuyog Pawar  *
503*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
504*c83a76b0SSuyog Pawar  * @param i4_tot_consumed_bits
505*c83a76b0SSuyog Pawar  * @param e_pic_type
506*c83a76b0SSuyog Pawar  */
507*c83a76b0SSuyog Pawar /* ******************************************************************************/
update_cbr_buffer(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tot_consumed_bits,picture_type_e e_pic_type)508*c83a76b0SSuyog Pawar void update_cbr_buffer(
509*c83a76b0SSuyog Pawar     cbr_buffer_t *ps_cbr_buffer, WORD32 i4_tot_consumed_bits, picture_type_e e_pic_type)
510*c83a76b0SSuyog Pawar {
511*c83a76b0SSuyog Pawar     WORD32 i;
512*c83a76b0SSuyog Pawar     WORD32 i4_error_bits = (e_pic_type == I_PIC)
513*c83a76b0SSuyog Pawar                                ? get_error_bits(ps_cbr_buffer->aps_bpf_error_bits[0])
514*c83a76b0SSuyog Pawar                                : get_error_bits(ps_cbr_buffer->aps_bpf_error_bits[1]);
515*c83a76b0SSuyog Pawar     WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC)
516*c83a76b0SSuyog Pawar                                          ? ps_cbr_buffer->i4_drain_bits_per_frame[0]
517*c83a76b0SSuyog Pawar                                          : ps_cbr_buffer->i4_drain_bits_per_frame[1];
518*c83a76b0SSuyog Pawar 
519*c83a76b0SSuyog Pawar     ps_cbr_buffer->i8_num_frames_encoded++;
520*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->e_rc_type == VBR_STREAMING && ps_cbr_buffer->i8_tot_frm_to_be_encoded < 0)
521*c83a76b0SSuyog Pawar     {
522*c83a76b0SSuyog Pawar         LWORD64 i8_max_bit_dev_allowed = ps_cbr_buffer->ai4_bit_rate[0];
523*c83a76b0SSuyog Pawar         LWORD64 approx_file_size = ps_cbr_buffer->i8_num_frames_encoded *
524*c83a76b0SSuyog Pawar                                    ps_cbr_buffer->ai4_bit_rate[0] * 1000 /
525*c83a76b0SSuyog Pawar                                    ps_cbr_buffer->i4_tgt_frm_rate;
526*c83a76b0SSuyog Pawar         if(i8_max_bit_dev_allowed < (approx_file_size >> 4))
527*c83a76b0SSuyog Pawar             i8_max_bit_dev_allowed = (approx_file_size >> 4);
528*c83a76b0SSuyog Pawar 
529*c83a76b0SSuyog Pawar         /*have a max limit so that bit dev does not grow for very long sequence like 24 hours of encoding (max can be 20 second)*/
530*c83a76b0SSuyog Pawar         if(i8_max_bit_dev_allowed > (VBR_MAX_BIT_DEV_SEC * ps_cbr_buffer->ai4_bit_rate[0]))
531*c83a76b0SSuyog Pawar             i8_max_bit_dev_allowed = (VBR_MAX_BIT_DEV_SEC * ps_cbr_buffer->ai4_bit_rate[0]);
532*c83a76b0SSuyog Pawar 
533*c83a76b0SSuyog Pawar         ps_cbr_buffer->u4_max_vbv_buf_size = (UWORD32)i8_max_bit_dev_allowed;
534*c83a76b0SSuyog Pawar     }
535*c83a76b0SSuyog Pawar     /* Update the Encoder buffer with the total consumed bits*/
536*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->i4_is_cbr_mode != 0)
537*c83a76b0SSuyog Pawar     {
538*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_ebf += i4_tot_consumed_bits;
539*c83a76b0SSuyog Pawar         ps_cbr_buffer->i8_ebf_bit_alloc += i4_tot_consumed_bits;
540*c83a76b0SSuyog Pawar 
541*c83a76b0SSuyog Pawar         /* Subtract the drain bits and error bits due to fixed point implementation*/
542*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_ebf -= (i4_drain_bits_per_frame + i4_error_bits);
543*c83a76b0SSuyog Pawar         ps_cbr_buffer->i8_ebf_bit_alloc -= (i4_drain_bits_per_frame + i4_error_bits);
544*c83a76b0SSuyog Pawar     }
545*c83a76b0SSuyog Pawar     else
546*c83a76b0SSuyog Pawar     {
547*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_ebf += i4_tot_consumed_bits;
548*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_ebf -=
549*c83a76b0SSuyog Pawar             ((MIN(ps_cbr_buffer->i4_peak_drain_rate_frame, ps_cbr_buffer->i4_ebf)) + i4_error_bits);
550*c83a76b0SSuyog Pawar 
551*c83a76b0SSuyog Pawar         ps_cbr_buffer->i8_ebf_bit_alloc += i4_tot_consumed_bits;
552*c83a76b0SSuyog Pawar         ps_cbr_buffer->i8_ebf_bit_alloc -=
553*c83a76b0SSuyog Pawar             (ps_cbr_buffer->i4_drain_bits_per_frame[0] + i4_error_bits);
554*c83a76b0SSuyog Pawar 
555*c83a76b0SSuyog Pawar         ps_cbr_buffer->i8_credit_level += i4_tot_consumed_bits;
556*c83a76b0SSuyog Pawar         ps_cbr_buffer->i8_credit_level -=
557*c83a76b0SSuyog Pawar             (ps_cbr_buffer->i4_drain_bits_per_frame[0] + i4_error_bits);
558*c83a76b0SSuyog Pawar         /*To keep limit on duration for which peak rate can be sustained limit the accumulation of bits from simpler regions*/
559*c83a76b0SSuyog Pawar         if(!ps_cbr_buffer->i4_vbr_no_peak_rate_duration_limit)
560*c83a76b0SSuyog Pawar         {
561*c83a76b0SSuyog Pawar             if(ps_cbr_buffer->i8_ebf_bit_alloc < 0)
562*c83a76b0SSuyog Pawar                 ps_cbr_buffer->i8_ebf_bit_alloc =
563*c83a76b0SSuyog Pawar                     0; /*This will make VBR buffer believe that the bits are lost*/
564*c83a76b0SSuyog Pawar         }
565*c83a76b0SSuyog Pawar     }
566*c83a76b0SSuyog Pawar 
567*c83a76b0SSuyog Pawar     /*SS - Fix for lack of stuffing*/
568*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->i4_ebf < 0)
569*c83a76b0SSuyog Pawar     {
570*c83a76b0SSuyog Pawar         //trace_printf("Error: Should not be coming here with bit stuffing \n");
571*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_ebf = 0;
572*c83a76b0SSuyog Pawar     }
573*c83a76b0SSuyog Pawar 
574*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->i4_ebf > ps_cbr_buffer->i4_buffer_size)
575*c83a76b0SSuyog Pawar     {
576*c83a76b0SSuyog Pawar         //trace_printf("Error: Frame should be skipped\n");
577*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_ebf = ps_cbr_buffer->i4_buffer_size;
578*c83a76b0SSuyog Pawar     }
579*c83a76b0SSuyog Pawar 
580*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_ebf_estimate = ps_cbr_buffer->i4_ebf;
581*c83a76b0SSuyog Pawar 
582*c83a76b0SSuyog Pawar     trace_printf(
583*c83a76b0SSuyog Pawar         "VBR ebf = %d  bebf = %d  ", ps_cbr_buffer->i4_ebf, ps_cbr_buffer->i8_ebf_bit_alloc);
584*c83a76b0SSuyog Pawar     /* Update the error bits */
585*c83a76b0SSuyog Pawar     for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
586*c83a76b0SSuyog Pawar         update_error_bits(ps_cbr_buffer->aps_bpf_error_bits[i]);
587*c83a76b0SSuyog Pawar }
588*c83a76b0SSuyog Pawar 
589*c83a76b0SSuyog Pawar /* ******************************************************************************/
590*c83a76b0SSuyog Pawar /**
591*c83a76b0SSuyog Pawar  * @brief If the buffer underflows then return the number of bits to prevent underflow
592*c83a76b0SSuyog Pawar  *
593*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
594*c83a76b0SSuyog Pawar  * @param i4_tot_consumed_bits
595*c83a76b0SSuyog Pawar  * @param e_pic_type
596*c83a76b0SSuyog Pawar  *
597*c83a76b0SSuyog Pawar  * @return
598*c83a76b0SSuyog Pawar  */
599*c83a76b0SSuyog Pawar /* ******************************************************************************/
get_cbr_bits_to_stuff(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tot_consumed_bits,picture_type_e e_pic_type)600*c83a76b0SSuyog Pawar WORD32 get_cbr_bits_to_stuff(
601*c83a76b0SSuyog Pawar     cbr_buffer_t *ps_cbr_buffer, WORD32 i4_tot_consumed_bits, picture_type_e e_pic_type)
602*c83a76b0SSuyog Pawar {
603*c83a76b0SSuyog Pawar     WORD32 i4_bits_to_stuff;
604*c83a76b0SSuyog Pawar     WORD32 i4_error_bits = (e_pic_type == I_PIC)
605*c83a76b0SSuyog Pawar                                ? get_error_bits(ps_cbr_buffer->aps_bpf_error_bits[0])
606*c83a76b0SSuyog Pawar                                : get_error_bits(ps_cbr_buffer->aps_bpf_error_bits[1]);
607*c83a76b0SSuyog Pawar     WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC)
608*c83a76b0SSuyog Pawar                                          ? ps_cbr_buffer->i4_drain_bits_per_frame[0]
609*c83a76b0SSuyog Pawar                                          : ps_cbr_buffer->i4_drain_bits_per_frame[1];
610*c83a76b0SSuyog Pawar 
611*c83a76b0SSuyog Pawar     /* Stuffing bits got from the following equation
612*c83a76b0SSuyog Pawar        Stuffing_threshold = ebf + tcb - drain bits - error bits + stuff_bits*/
613*c83a76b0SSuyog Pawar     i4_bits_to_stuff =
614*c83a76b0SSuyog Pawar         i4_drain_bits_per_frame + i4_error_bits - (ps_cbr_buffer->i4_ebf + i4_tot_consumed_bits);
615*c83a76b0SSuyog Pawar 
616*c83a76b0SSuyog Pawar     return i4_bits_to_stuff;
617*c83a76b0SSuyog Pawar }
618*c83a76b0SSuyog Pawar 
619*c83a76b0SSuyog Pawar /* ******************************************************************************/
620*c83a76b0SSuyog Pawar /**
621*c83a76b0SSuyog Pawar  * @brief Change the state for change in bit rate
622*c83a76b0SSuyog Pawar  *
623*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
624*c83a76b0SSuyog Pawar  * @param i4_bit_rate
625*c83a76b0SSuyog Pawar  */
626*c83a76b0SSuyog Pawar /* ******************************************************************************/
change_cbr_vbv_bit_rate(cbr_buffer_t * ps_cbr_buffer,WORD32 * i4_bit_rate,WORD32 i4_peak_bitrate)627*c83a76b0SSuyog Pawar void change_cbr_vbv_bit_rate(
628*c83a76b0SSuyog Pawar     cbr_buffer_t *ps_cbr_buffer, WORD32 *i4_bit_rate, WORD32 i4_peak_bitrate)
629*c83a76b0SSuyog Pawar {
630*c83a76b0SSuyog Pawar     WORD32 i4_bits_per_frm[MAX_NUM_DRAIN_RATES];
631*c83a76b0SSuyog Pawar     int i;
632*c83a76b0SSuyog Pawar 
633*c83a76b0SSuyog Pawar     for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
634*c83a76b0SSuyog Pawar     {
635*c83a76b0SSuyog Pawar         X_PROD_Y_DIV_Z(i4_bit_rate[i], 1000, ps_cbr_buffer->i4_tgt_frm_rate, i4_bits_per_frm[i]);
636*c83a76b0SSuyog Pawar         /* Drain rate = bitrate/(framerate/1000) */
637*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_drain_bits_per_frame[i] = i4_bits_per_frm[i];
638*c83a76b0SSuyog Pawar 
639*c83a76b0SSuyog Pawar         /* initialise the bits per frame error bits calculation */
640*c83a76b0SSuyog Pawar         change_bitrate_in_error_bits(ps_cbr_buffer->aps_bpf_error_bits[i], i4_bit_rate[i]);
641*c83a76b0SSuyog Pawar     }
642*c83a76b0SSuyog Pawar     X_PROD_Y_DIV_Z(
643*c83a76b0SSuyog Pawar         i4_peak_bitrate,
644*c83a76b0SSuyog Pawar         1000,
645*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_tgt_frm_rate,
646*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_peak_drain_rate_frame);
647*c83a76b0SSuyog Pawar     /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/
648*c83a76b0SSuyog Pawar     //if(i4_bit_rate[0] == i4_bit_rate[1]) /* This would mean CBR mode */
649*c83a76b0SSuyog Pawar     {
650*c83a76b0SSuyog Pawar         X_PROD_Y_DIV_Z(
651*c83a76b0SSuyog Pawar             i4_bit_rate[0],
652*c83a76b0SSuyog Pawar             ps_cbr_buffer->i4_max_delay,
653*c83a76b0SSuyog Pawar             1000,
654*c83a76b0SSuyog Pawar             ps_cbr_buffer->i4_buffer_size);  //the delay term is supposed to remain constant
655*c83a76b0SSuyog Pawar         //ps_cbr_buffer->i4_is_cbr_mode = 1;
656*c83a76b0SSuyog Pawar         ps_cbr_buffer->u4_max_vbv_buf_size = ps_cbr_buffer->i4_buffer_size;
657*c83a76b0SSuyog Pawar     }
658*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->i4_buffer_size > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size)
659*c83a76b0SSuyog Pawar     {
660*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size;
661*c83a76b0SSuyog Pawar     }
662*c83a76b0SSuyog Pawar     set_upper_lower_vbv_threshold(ps_cbr_buffer, i4_bits_per_frm[0]);
663*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->e_rc_type == CBR_NLDRC)
664*c83a76b0SSuyog Pawar     {
665*c83a76b0SSuyog Pawar         ps_cbr_buffer->u4_vbr_max_bit_deviation = ps_cbr_buffer->i4_buffer_size;
666*c83a76b0SSuyog Pawar     }
667*c83a76b0SSuyog Pawar     else
668*c83a76b0SSuyog Pawar     {
669*c83a76b0SSuyog Pawar         /*DCB: the deviaiton must be altered for VBR case, when bitrate is lowered quality might be bad because of this*/
670*c83a76b0SSuyog Pawar         {
671*c83a76b0SSuyog Pawar             ULWORD64 u8_vbr_max_bit_deviation =
672*c83a76b0SSuyog Pawar                 (ULWORD64)(ps_cbr_buffer->f_max_dur_peak_rate * i4_bit_rate[0]);
673*c83a76b0SSuyog Pawar             ULWORD64 file_size = (ULWORD64)(
674*c83a76b0SSuyog Pawar                 (((LWORD64)i4_bit_rate[0] * 1000) / ps_cbr_buffer->i4_tgt_frm_rate) *
675*c83a76b0SSuyog Pawar                 (ps_cbr_buffer->i8_tot_frm_to_be_encoded - ps_cbr_buffer->i8_num_frames_encoded));
676*c83a76b0SSuyog Pawar             /*When f_max_dur_peak_rate is -ve, it implies user is not worried about duration for which peak is sustained, hence go with max possible value*/
677*c83a76b0SSuyog Pawar             if(ps_cbr_buffer->f_max_dur_peak_rate > 0)
678*c83a76b0SSuyog Pawar                 u8_vbr_max_bit_deviation =
679*c83a76b0SSuyog Pawar                     (ULWORD64)(ps_cbr_buffer->f_max_dur_peak_rate * i4_bit_rate[0]);
680*c83a76b0SSuyog Pawar             else
681*c83a76b0SSuyog Pawar                 u8_vbr_max_bit_deviation = VBR_MAX_BIT_DEV_SEC * i4_bit_rate[0];
682*c83a76b0SSuyog Pawar 
683*c83a76b0SSuyog Pawar             /*when num frames to encode is negative is -ve it implies total frames data is not available (as in case of live encoding)*/
684*c83a76b0SSuyog Pawar             if(ps_cbr_buffer->i8_tot_frm_to_be_encoded > 0)
685*c83a76b0SSuyog Pawar             {
686*c83a76b0SSuyog Pawar                 /*allow atleast one second deviation or 12% of total file size whichever is higher*/
687*c83a76b0SSuyog Pawar                 if(u8_vbr_max_bit_deviation > (file_size >> 3))
688*c83a76b0SSuyog Pawar                     u8_vbr_max_bit_deviation = (UWORD32)(file_size >> 3);
689*c83a76b0SSuyog Pawar             }
690*c83a76b0SSuyog Pawar             else
691*c83a76b0SSuyog Pawar             {
692*c83a76b0SSuyog Pawar                 u8_vbr_max_bit_deviation = (UWORD32)(file_size >> 3);
693*c83a76b0SSuyog Pawar             }
694*c83a76b0SSuyog Pawar             /*allow atleast one second for shorter sequence*/
695*c83a76b0SSuyog Pawar             if(u8_vbr_max_bit_deviation < (ULWORD64)i4_bit_rate[0])
696*c83a76b0SSuyog Pawar                 u8_vbr_max_bit_deviation = (ULWORD64)i4_bit_rate[0];
697*c83a76b0SSuyog Pawar             ps_cbr_buffer->u4_vbr_max_bit_deviation = u8_vbr_max_bit_deviation;
698*c83a76b0SSuyog Pawar         }
699*c83a76b0SSuyog Pawar     }
700*c83a76b0SSuyog Pawar 
701*c83a76b0SSuyog Pawar     /* Storing the input parameters for using it for change functions */
702*c83a76b0SSuyog Pawar     for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
703*c83a76b0SSuyog Pawar         ps_cbr_buffer->ai4_bit_rate[i] = i4_bit_rate[i];
704*c83a76b0SSuyog Pawar }
705*c83a76b0SSuyog Pawar /* ******************************************************************************/
706*c83a76b0SSuyog Pawar /**
707*c83a76b0SSuyog Pawar  * @brief Update the state for change in number of pics in the delay period
708*c83a76b0SSuyog Pawar  *
709*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
710*c83a76b0SSuyog Pawar  * @param u4_num_pics_in_delay_prd
711*c83a76b0SSuyog Pawar  */
712*c83a76b0SSuyog Pawar /* ******************************************************************************/
change_cbr_vbv_num_pics_in_delay_period(cbr_buffer_t * ps_cbr_buffer,UWORD32 * u4_num_pics_in_delay_prd)713*c83a76b0SSuyog Pawar void change_cbr_vbv_num_pics_in_delay_period(
714*c83a76b0SSuyog Pawar     cbr_buffer_t *ps_cbr_buffer, UWORD32 *u4_num_pics_in_delay_prd)
715*c83a76b0SSuyog Pawar {
716*c83a76b0SSuyog Pawar     WORD32 i;
717*c83a76b0SSuyog Pawar 
718*c83a76b0SSuyog Pawar     if(!ps_cbr_buffer->i4_is_cbr_mode)
719*c83a76b0SSuyog Pawar     {
720*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_buffer_size =
721*c83a76b0SSuyog Pawar             u4_num_pics_in_delay_prd[0] * ps_cbr_buffer->i4_drain_bits_per_frame[0] +
722*c83a76b0SSuyog Pawar             u4_num_pics_in_delay_prd[1] * ps_cbr_buffer->i4_drain_bits_per_frame[1];
723*c83a76b0SSuyog Pawar 
724*c83a76b0SSuyog Pawar         if(ps_cbr_buffer->i4_buffer_size > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size)
725*c83a76b0SSuyog Pawar         {
726*c83a76b0SSuyog Pawar             ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size;
727*c83a76b0SSuyog Pawar         }
728*c83a76b0SSuyog Pawar         for(i = 0; i < MAX_PIC_TYPE; i++)
729*c83a76b0SSuyog Pawar         {
730*c83a76b0SSuyog Pawar             ps_cbr_buffer->i4_upr_thr[i] =
731*c83a76b0SSuyog Pawar                 ps_cbr_buffer->i4_buffer_size - (ps_cbr_buffer->i4_buffer_size >> 3);
732*c83a76b0SSuyog Pawar         }
733*c83a76b0SSuyog Pawar 
734*c83a76b0SSuyog Pawar         /* Re-initilise the number of pics in delay period */
735*c83a76b0SSuyog Pawar         for(i = 0; i < MAX_PIC_TYPE; i++)
736*c83a76b0SSuyog Pawar         {
737*c83a76b0SSuyog Pawar             ps_cbr_buffer->ai4_num_pics_in_delay_period[i] = u4_num_pics_in_delay_prd[i];
738*c83a76b0SSuyog Pawar         }
739*c83a76b0SSuyog Pawar     }
740*c83a76b0SSuyog Pawar }
741*c83a76b0SSuyog Pawar /* ******************************************************************************/
742*c83a76b0SSuyog Pawar /**
743*c83a76b0SSuyog Pawar  * @ modifies the ebf estimated parameter based on error
744*c83a76b0SSuyog Pawar  *
745*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
746*c83a76b0SSuyog Pawar  * @param i4_bit_error
747*c83a76b0SSuyog Pawar  */
748*c83a76b0SSuyog Pawar /* ******************************************************************************/
cbr_modify_ebf_estimate(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_bit_error)749*c83a76b0SSuyog Pawar void cbr_modify_ebf_estimate(cbr_buffer_t *ps_cbr_buffer, WORD32 i4_bit_error)
750*c83a76b0SSuyog Pawar {
751*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_ebf_estimate = ps_cbr_buffer->i4_ebf + i4_bit_error;
752*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->i4_ebf_estimate < 0)
753*c83a76b0SSuyog Pawar     {
754*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_ebf_estimate = 0;
755*c83a76b0SSuyog Pawar     }
756*c83a76b0SSuyog Pawar     else if(ps_cbr_buffer->i4_ebf_estimate > ps_cbr_buffer->i4_buffer_size)
757*c83a76b0SSuyog Pawar     {
758*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_ebf_estimate = ps_cbr_buffer->i4_buffer_size;
759*c83a76b0SSuyog Pawar     }
760*c83a76b0SSuyog Pawar }
761*c83a76b0SSuyog Pawar 
762*c83a76b0SSuyog Pawar /* ******************************************************************************/
763*c83a76b0SSuyog Pawar /**
764*c83a76b0SSuyog Pawar  * @ get the buffer size
765*c83a76b0SSuyog Pawar  *
766*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
767*c83a76b0SSuyog Pawar  */
768*c83a76b0SSuyog Pawar /* ******************************************************************************/
769*c83a76b0SSuyog Pawar 
get_cbr_buffer_size(cbr_buffer_t * ps_cbr_buffer)770*c83a76b0SSuyog Pawar WORD32 get_cbr_buffer_size(cbr_buffer_t *ps_cbr_buffer)
771*c83a76b0SSuyog Pawar {
772*c83a76b0SSuyog Pawar     return (ps_cbr_buffer->i4_buffer_size);
773*c83a76b0SSuyog Pawar }
774*c83a76b0SSuyog Pawar 
775*c83a76b0SSuyog Pawar #if NON_STEADSTATE_CODE
776*c83a76b0SSuyog Pawar /* ******************************************************************************/
777*c83a76b0SSuyog Pawar /**
778*c83a76b0SSuyog Pawar  * @brief update the state for change in target frame rate
779*c83a76b0SSuyog Pawar  *
780*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
781*c83a76b0SSuyog Pawar  * @param i4_tgt_frm_rate
782*c83a76b0SSuyog Pawar  */
783*c83a76b0SSuyog Pawar /* ******************************************************************************/
change_cbr_vbv_tgt_frame_rate(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tgt_frm_rate)784*c83a76b0SSuyog Pawar void change_cbr_vbv_tgt_frame_rate(cbr_buffer_t *ps_cbr_buffer, WORD32 i4_tgt_frm_rate)
785*c83a76b0SSuyog Pawar {
786*c83a76b0SSuyog Pawar     WORD32 i4_i, i4_bits_per_frm[MAX_NUM_DRAIN_RATES];
787*c83a76b0SSuyog Pawar     int i;
788*c83a76b0SSuyog Pawar 
789*c83a76b0SSuyog Pawar     for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
790*c83a76b0SSuyog Pawar     {
791*c83a76b0SSuyog Pawar         X_PROD_Y_DIV_Z(ps_cbr_buffer->ai4_bit_rate[i], 1000, i4_tgt_frm_rate, i4_bits_per_frm[i]);
792*c83a76b0SSuyog Pawar         /* Drain rate = bitrate/(framerate/1000) */
793*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_drain_bits_per_frame[i] = i4_bits_per_frm[i];
794*c83a76b0SSuyog Pawar         /* initialise the bits per frame error bits calculation */
795*c83a76b0SSuyog Pawar         change_frm_rate_in_error_bits(ps_cbr_buffer->aps_bpf_error_bits[i], i4_tgt_frm_rate);
796*c83a76b0SSuyog Pawar     }
797*c83a76b0SSuyog Pawar 
798*c83a76b0SSuyog Pawar     /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/
799*c83a76b0SSuyog Pawar     if(!ps_cbr_buffer->i4_is_cbr_mode)
800*c83a76b0SSuyog Pawar     {
801*c83a76b0SSuyog Pawar         /* VBR streaming case which has different drain rates for I and P */
802*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->ai4_num_pics_in_delay_period[0] *
803*c83a76b0SSuyog Pawar                                             ps_cbr_buffer->i4_drain_bits_per_frame[0] +
804*c83a76b0SSuyog Pawar                                         ps_cbr_buffer->ai4_num_pics_in_delay_period[1] *
805*c83a76b0SSuyog Pawar                                             ps_cbr_buffer->i4_drain_bits_per_frame[1];
806*c83a76b0SSuyog Pawar     }
807*c83a76b0SSuyog Pawar 
808*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->i4_buffer_size > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size)
809*c83a76b0SSuyog Pawar     {
810*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size;
811*c83a76b0SSuyog Pawar     }
812*c83a76b0SSuyog Pawar 
813*c83a76b0SSuyog Pawar     for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++)
814*c83a76b0SSuyog Pawar     {
815*c83a76b0SSuyog Pawar         /* Uppr threshold for
816*c83a76b0SSuyog Pawar            I frame = 1 * bits per frame
817*c83a76b0SSuyog Pawar            P Frame = 4 * bits per frame.
818*c83a76b0SSuyog Pawar            The threshold for I frame is only 1 * bits per frame as the threshold should
819*c83a76b0SSuyog Pawar            only account for error in estimated bits.
820*c83a76b0SSuyog Pawar            In P frame it should account for difference bets bits consumed by I(Scene change)
821*c83a76b0SSuyog Pawar            and P frame I to P complexity is assumed to be 5. */
822*c83a76b0SSuyog Pawar         WORD32 i4_index;
823*c83a76b0SSuyog Pawar         i4_index = i4_i > 0 ? 1 : 0;
824*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_upr_thr[i4_i] =
825*c83a76b0SSuyog Pawar             ps_cbr_buffer->i4_buffer_size - (ps_cbr_buffer->i4_buffer_size >> 3);
826*c83a76b0SSuyog Pawar 
827*c83a76b0SSuyog Pawar         /* For both I and P frame Lower threshold is equal to drain rate.
828*c83a76b0SSuyog Pawar         Even if the encoder consumes zero bits it should have enough bits to drain*/
829*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_low_thr[i4_i] = i4_bits_per_frm[i4_index];
830*c83a76b0SSuyog Pawar     }
831*c83a76b0SSuyog Pawar 
832*c83a76b0SSuyog Pawar     /* Storing the input parameters for using it for change functions */
833*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_tgt_frm_rate = i4_tgt_frm_rate;
834*c83a76b0SSuyog Pawar }
835*c83a76b0SSuyog Pawar /* ******************************************************************************/
836*c83a76b0SSuyog Pawar /**
837*c83a76b0SSuyog Pawar  * @brief update the state for change in buffer delay
838*c83a76b0SSuyog Pawar  *
839*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
840*c83a76b0SSuyog Pawar  * @param i4_buffer_delay
841*c83a76b0SSuyog Pawar  */
842*c83a76b0SSuyog Pawar /* ******************************************************************************/
change_cbr_buffer_delay(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_buffer_delay)843*c83a76b0SSuyog Pawar void change_cbr_buffer_delay(cbr_buffer_t *ps_cbr_buffer, WORD32 i4_buffer_delay)
844*c83a76b0SSuyog Pawar {
845*c83a76b0SSuyog Pawar     WORD32 i4_i;
846*c83a76b0SSuyog Pawar 
847*c83a76b0SSuyog Pawar     /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/
848*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->i4_is_cbr_mode)
849*c83a76b0SSuyog Pawar     {
850*c83a76b0SSuyog Pawar         X_PROD_Y_DIV_Z(
851*c83a76b0SSuyog Pawar             ps_cbr_buffer->ai4_bit_rate[0], i4_buffer_delay, 1000, ps_cbr_buffer->i4_buffer_size);
852*c83a76b0SSuyog Pawar     }
853*c83a76b0SSuyog Pawar 
854*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->i4_buffer_size > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size)
855*c83a76b0SSuyog Pawar     {
856*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size;
857*c83a76b0SSuyog Pawar     }
858*c83a76b0SSuyog Pawar 
859*c83a76b0SSuyog Pawar     for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++)
860*c83a76b0SSuyog Pawar     {
861*c83a76b0SSuyog Pawar         /* Uppr threshold for
862*c83a76b0SSuyog Pawar            I frame = 1 * bits per frame
863*c83a76b0SSuyog Pawar            P Frame = 4 * bits per frame.
864*c83a76b0SSuyog Pawar            The threshold for I frame is only 1 * bits per frame as the threshold should
865*c83a76b0SSuyog Pawar            only account for error in estimated bits.
866*c83a76b0SSuyog Pawar            In P frame it should account for difference bets bits consumed by I(Scene change)
867*c83a76b0SSuyog Pawar            and P frame I to P complexity is assumed to be 5. */
868*c83a76b0SSuyog Pawar         ps_cbr_buffer->i4_upr_thr[i4_i] =
869*c83a76b0SSuyog Pawar             ps_cbr_buffer->i4_buffer_size - (ps_cbr_buffer->i4_buffer_size >> 3);
870*c83a76b0SSuyog Pawar     }
871*c83a76b0SSuyog Pawar 
872*c83a76b0SSuyog Pawar     /* Storing the input parameters for using it for change functions */
873*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_max_delay = i4_buffer_delay;
874*c83a76b0SSuyog Pawar }
875*c83a76b0SSuyog Pawar /* ******************************************************************************/
876*c83a76b0SSuyog Pawar /**
877*c83a76b0SSuyog Pawar  * @brief update the state for change in buffer delay
878*c83a76b0SSuyog Pawar  *
879*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
880*c83a76b0SSuyog Pawar  * @param i4_buffer_delay
881*c83a76b0SSuyog Pawar  */
882*c83a76b0SSuyog Pawar /* ******************************************************************************/
get_cbr_buffer_delay(cbr_buffer_t * ps_cbr_buffer)883*c83a76b0SSuyog Pawar WORD32 get_cbr_buffer_delay(cbr_buffer_t *ps_cbr_buffer)
884*c83a76b0SSuyog Pawar {
885*c83a76b0SSuyog Pawar     return (ps_cbr_buffer->i4_max_delay);
886*c83a76b0SSuyog Pawar }
887*c83a76b0SSuyog Pawar /* ******************************************************************************/
888*c83a76b0SSuyog Pawar /**
889*c83a76b0SSuyog Pawar  * @brief get_cbr_ebf
890*c83a76b0SSuyog Pawar  *
891*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
892*c83a76b0SSuyog Pawar   */
893*c83a76b0SSuyog Pawar /* ******************************************************************************/
get_cbr_ebf(cbr_buffer_t * ps_cbr_buffer)894*c83a76b0SSuyog Pawar WORD32 get_cbr_ebf(cbr_buffer_t *ps_cbr_buffer)
895*c83a76b0SSuyog Pawar {
896*c83a76b0SSuyog Pawar     return (ps_cbr_buffer->i4_ebf);
897*c83a76b0SSuyog Pawar }
898*c83a76b0SSuyog Pawar /* ******************************************************************************/
899*c83a76b0SSuyog Pawar /**
900*c83a76b0SSuyog Pawar  * @brief get_cbr_max_ebf
901*c83a76b0SSuyog Pawar  *
902*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
903*c83a76b0SSuyog Pawar  */
904*c83a76b0SSuyog Pawar /* ******************************************************************************/
get_cbr_max_ebf(cbr_buffer_t * ps_cbr_buffer)905*c83a76b0SSuyog Pawar WORD32 get_cbr_max_ebf(cbr_buffer_t *ps_cbr_buffer)
906*c83a76b0SSuyog Pawar {
907*c83a76b0SSuyog Pawar     return (ps_cbr_buffer->i4_upr_thr[0]);
908*c83a76b0SSuyog Pawar }
909*c83a76b0SSuyog Pawar /* ******************************************************************************/
910*c83a76b0SSuyog Pawar /**
911*c83a76b0SSuyog Pawar  * @brief set_cbr_ebf
912*c83a76b0SSuyog Pawar  *
913*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
914*c83a76b0SSuyog Pawar  * @param i32_init_ebf
915*c83a76b0SSuyog Pawar  */
916*c83a76b0SSuyog Pawar /* ******************************************************************************/
set_cbr_ebf(cbr_buffer_t * ps_cbr_buffer,WORD32 i32_init_ebf)917*c83a76b0SSuyog Pawar void set_cbr_ebf(cbr_buffer_t *ps_cbr_buffer, WORD32 i32_init_ebf)
918*c83a76b0SSuyog Pawar {
919*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_ebf = i32_init_ebf;
920*c83a76b0SSuyog Pawar }
921*c83a76b0SSuyog Pawar /* ******************************************************************************/
922*c83a76b0SSuyog Pawar /**
923*c83a76b0SSuyog Pawar  * @brief update_cbr_buf_mismatch_bit
924*c83a76b0SSuyog Pawar  *
925*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
926*c83a76b0SSuyog Pawar  * @param i4_error_bits
927*c83a76b0SSuyog Pawar  */
928*c83a76b0SSuyog Pawar /* ******************************************************************************/
update_cbr_buf_mismatch_bit(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_error_bits)929*c83a76b0SSuyog Pawar void update_cbr_buf_mismatch_bit(cbr_buffer_t *ps_cbr_buffer, WORD32 i4_error_bits)
930*c83a76b0SSuyog Pawar {
931*c83a76b0SSuyog Pawar     ps_cbr_buffer->i4_ebf -= i4_error_bits;
932*c83a76b0SSuyog Pawar     ps_cbr_buffer->i8_ebf_bit_alloc -= i4_error_bits;
933*c83a76b0SSuyog Pawar     ps_cbr_buffer->i8_credit_level -= i4_error_bits;
934*c83a76b0SSuyog Pawar }
935*c83a76b0SSuyog Pawar /* ******************************************************************************/
936*c83a76b0SSuyog Pawar /**
937*c83a76b0SSuyog Pawar  * @brief get encoded number of frames
938*c83a76b0SSuyog Pawar  *
939*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
940*c83a76b0SSuyog Pawar   */
941*c83a76b0SSuyog Pawar /* ******************************************************************************/
get_num_frms_encoded(cbr_buffer_t * ps_cbr_buffer)942*c83a76b0SSuyog Pawar LWORD64 get_num_frms_encoded(cbr_buffer_t *ps_cbr_buffer)
943*c83a76b0SSuyog Pawar {
944*c83a76b0SSuyog Pawar     return ps_cbr_buffer->i8_num_frames_encoded;
945*c83a76b0SSuyog Pawar }
946*c83a76b0SSuyog Pawar /* ******************************************************************************/
947*c83a76b0SSuyog Pawar /**
948*c83a76b0SSuyog Pawar  * @brief get num frames to encode
949*c83a76b0SSuyog Pawar  *
950*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
951*c83a76b0SSuyog Pawar   */
952*c83a76b0SSuyog Pawar /* ******************************************************************************/
get_num_frms_to_encode(cbr_buffer_t * ps_cbr_buffer)953*c83a76b0SSuyog Pawar LWORD64 get_num_frms_to_encode(cbr_buffer_t *ps_cbr_buffer)
954*c83a76b0SSuyog Pawar {
955*c83a76b0SSuyog Pawar     return ps_cbr_buffer->i8_tot_frm_to_be_encoded;
956*c83a76b0SSuyog Pawar }
957*c83a76b0SSuyog Pawar /* ******************************************************************************/
958*c83a76b0SSuyog Pawar /**
959*c83a76b0SSuyog Pawar  * @brief get peak drain rate
960*c83a76b0SSuyog Pawar  *
961*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
962*c83a76b0SSuyog Pawar  */
963*c83a76b0SSuyog Pawar /* ******************************************************************************/
964*c83a76b0SSuyog Pawar /* The buffer limit in bit allocation should be according to peak bitrate */
get_buf_max_drain_rate(cbr_buffer_t * ps_cbr_buffer)965*c83a76b0SSuyog Pawar WORD32 get_buf_max_drain_rate(cbr_buffer_t *ps_cbr_buffer)
966*c83a76b0SSuyog Pawar {
967*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->e_rc_type == VBR_STREAMING)
968*c83a76b0SSuyog Pawar         return ps_cbr_buffer->i4_peak_drain_rate_frame;
969*c83a76b0SSuyog Pawar     else if(ps_cbr_buffer->e_rc_type != CONST_QP)
970*c83a76b0SSuyog Pawar     {
971*c83a76b0SSuyog Pawar         ASSERT(
972*c83a76b0SSuyog Pawar             ps_cbr_buffer->i4_peak_drain_rate_frame == ps_cbr_buffer->i4_drain_bits_per_frame[0]);
973*c83a76b0SSuyog Pawar         return ps_cbr_buffer->i4_drain_bits_per_frame[0];
974*c83a76b0SSuyog Pawar     }
975*c83a76b0SSuyog Pawar     return ps_cbr_buffer->i4_drain_bits_per_frame[0];
976*c83a76b0SSuyog Pawar }
977*c83a76b0SSuyog Pawar /* ******************************************************************************/
978*c83a76b0SSuyog Pawar /**
979*c83a76b0SSuyog Pawar  * @brief get excess bits by moving in VBV buffer to enable bitrate greater than peak rate for shorter duration in very
980*c83a76b0SSuyog Pawar  *  complex contents
981*c83a76b0SSuyog Pawar  *
982*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
983*c83a76b0SSuyog Pawar  * @param i4_tgt_frm_rate
984*c83a76b0SSuyog Pawar  */
985*c83a76b0SSuyog Pawar /* ******************************************************************************/
get_vbv_buffer_based_excess(cbr_buffer_t * ps_cbr_buffer,float f_complexity_peak_rate,float f_cur_bits_complexity,WORD32 bit_alloc_period,WORD32 i4_num_gops_for_excess)986*c83a76b0SSuyog Pawar WORD32 get_vbv_buffer_based_excess(
987*c83a76b0SSuyog Pawar     cbr_buffer_t *ps_cbr_buffer,
988*c83a76b0SSuyog Pawar     float f_complexity_peak_rate,
989*c83a76b0SSuyog Pawar     float f_cur_bits_complexity,
990*c83a76b0SSuyog Pawar     WORD32 bit_alloc_period,
991*c83a76b0SSuyog Pawar     WORD32 i4_num_gops_for_excess)
992*c83a76b0SSuyog Pawar {
993*c83a76b0SSuyog Pawar     LWORD64 max_buffer_level = (LWORD64)((float)ps_cbr_buffer->i4_buffer_size * 0.8f);
994*c83a76b0SSuyog Pawar     LWORD64 i8_excess_bits;
995*c83a76b0SSuyog Pawar     /*LWORD64target_buf_level;*/
996*c83a76b0SSuyog Pawar     WORD32
997*c83a76b0SSuyog Pawar     num_frm_to_be_distributed;  //Number of frames for which excess bits should be distributed, using number of frames corresponding to buffer size for now
998*c83a76b0SSuyog Pawar 
999*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->i4_upr_thr[0] <
1000*c83a76b0SSuyog Pawar        max_buffer_level) /*choose max allowed level to min(upper_threshold,80% of buffer*/
1001*c83a76b0SSuyog Pawar         max_buffer_level = ps_cbr_buffer->i4_upr_thr[0];
1002*c83a76b0SSuyog Pawar 
1003*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->e_rc_type == VBR_STREAMING)
1004*c83a76b0SSuyog Pawar         max_buffer_level = (LWORD64)(
1005*c83a76b0SSuyog Pawar             ps_cbr_buffer->i4_peak_drain_rate_frame * ps_cbr_buffer->u4_num_frms_in_delay * 0.8f);
1006*c83a76b0SSuyog Pawar 
1007*c83a76b0SSuyog Pawar     if(f_cur_bits_complexity >
1008*c83a76b0SSuyog Pawar        0.9f) /*clip current to max of 80% of buffer size to avoid dangerous buffer level by end of GOP*/
1009*c83a76b0SSuyog Pawar         f_cur_bits_complexity = 0.9f;
1010*c83a76b0SSuyog Pawar 
1011*c83a76b0SSuyog Pawar     if(f_cur_bits_complexity < f_complexity_peak_rate || f_cur_bits_complexity < 0.1f ||
1012*c83a76b0SSuyog Pawar        ps_cbr_buffer->i4_buffer_size <
1013*c83a76b0SSuyog Pawar            ps_cbr_buffer->ai4_bit_rate
1014*c83a76b0SSuyog Pawar                [0])  //For buffer size less than 1 sec disable any contribution from buffer based for extra complex contents
1015*c83a76b0SSuyog Pawar     {
1016*c83a76b0SSuyog Pawar         /*For very low compleity content or Cavg do not allow buffer movement*/
1017*c83a76b0SSuyog Pawar         return 0;
1018*c83a76b0SSuyog Pawar     }
1019*c83a76b0SSuyog Pawar 
1020*c83a76b0SSuyog Pawar     i8_excess_bits = (LWORD64)(
1021*c83a76b0SSuyog Pawar         ((f_cur_bits_complexity - f_complexity_peak_rate) / (0.9f - f_complexity_peak_rate)) *
1022*c83a76b0SSuyog Pawar         (max_buffer_level - ps_cbr_buffer->i4_ebf));
1023*c83a76b0SSuyog Pawar 
1024*c83a76b0SSuyog Pawar     if(i8_excess_bits < 0)
1025*c83a76b0SSuyog Pawar         i8_excess_bits = 0;
1026*c83a76b0SSuyog Pawar 
1027*c83a76b0SSuyog Pawar     num_frm_to_be_distributed = (WORD32)(
1028*c83a76b0SSuyog Pawar         ((float)ps_cbr_buffer->i4_buffer_size / ps_cbr_buffer->ai4_bit_rate[0] *
1029*c83a76b0SSuyog Pawar          ps_cbr_buffer->i4_tgt_frm_rate / 1000) +
1030*c83a76b0SSuyog Pawar         0.5);
1031*c83a76b0SSuyog Pawar     /*Excess bits should be proportional to bit alloc period, shorter intra period should get in small incentives*/
1032*c83a76b0SSuyog Pawar     if(bit_alloc_period < num_frm_to_be_distributed)
1033*c83a76b0SSuyog Pawar         i8_excess_bits =
1034*c83a76b0SSuyog Pawar             (LWORD64)((float)i8_excess_bits * bit_alloc_period / num_frm_to_be_distributed);
1035*c83a76b0SSuyog Pawar 
1036*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->e_rc_type == VBR_STREAMING)
1037*c83a76b0SSuyog Pawar     {
1038*c83a76b0SSuyog Pawar         if(i4_num_gops_for_excess > 1)
1039*c83a76b0SSuyog Pawar             i8_excess_bits = i8_excess_bits * i4_num_gops_for_excess;
1040*c83a76b0SSuyog Pawar 
1041*c83a76b0SSuyog Pawar         if(i8_excess_bits > (LWORD64)(
1042*c83a76b0SSuyog Pawar                                 (float)ps_cbr_buffer->i4_peak_drain_rate_frame *
1043*c83a76b0SSuyog Pawar                                 ps_cbr_buffer->u4_num_frms_in_delay * 0.8f))
1044*c83a76b0SSuyog Pawar             i8_excess_bits = (LWORD64)(
1045*c83a76b0SSuyog Pawar                 (float)ps_cbr_buffer->i4_peak_drain_rate_frame *
1046*c83a76b0SSuyog Pawar                 ps_cbr_buffer->u4_num_frms_in_delay * 0.8f);
1047*c83a76b0SSuyog Pawar     }
1048*c83a76b0SSuyog Pawar     trace_printf(
1049*c83a76b0SSuyog Pawar         "Excess bits %d %f %f num gops %d",
1050*c83a76b0SSuyog Pawar         i8_excess_bits,
1051*c83a76b0SSuyog Pawar         f_cur_bits_complexity,
1052*c83a76b0SSuyog Pawar         f_complexity_peak_rate,
1053*c83a76b0SSuyog Pawar         i4_num_gops_for_excess);
1054*c83a76b0SSuyog Pawar 
1055*c83a76b0SSuyog Pawar     return ((WORD32)i8_excess_bits);
1056*c83a76b0SSuyog Pawar }
1057*c83a76b0SSuyog Pawar /* ******************************************************************************/
1058*c83a76b0SSuyog Pawar /**
1059*c83a76b0SSuyog Pawar  * @brief get gop correction error bits for  the current gop. This will be added to rbip.
1060*c83a76b0SSuyog Pawar   *
1061*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
1062*c83a76b0SSuyog Pawar  * @param i4_lap_complexity_q7
1063*c83a76b0SSuyog Pawar  * @param i4_bit_alloc_period
1064*c83a76b0SSuyog Pawar  */
1065*c83a76b0SSuyog Pawar /* ******************************************************************************/
get_error_bits_for_desired_buf(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_lap_complexity_q7,WORD32 i4_bit_alloc_period)1066*c83a76b0SSuyog Pawar WORD32 get_error_bits_for_desired_buf(
1067*c83a76b0SSuyog Pawar     cbr_buffer_t *ps_cbr_buffer, WORD32 i4_lap_complexity_q7, WORD32 i4_bit_alloc_period)
1068*c83a76b0SSuyog Pawar {
1069*c83a76b0SSuyog Pawar     if(ps_cbr_buffer->e_rc_type == CBR_NLDRC)
1070*c83a76b0SSuyog Pawar     {
1071*c83a76b0SSuyog Pawar         LWORD64 error_bits = 0, complexity_mov_buf_size = 0;
1072*c83a76b0SSuyog Pawar         LWORD64 i8_default_bits_in_period, i8_max_additional_bits_in_period;
1073*c83a76b0SSuyog Pawar         LWORD64 i8_buf_based_limit_red, i8_buf_based_limit_inc, i8_buf_diff_bits;
1074*c83a76b0SSuyog Pawar         float buf_diff, abs_lap_complexity;
1075*c83a76b0SSuyog Pawar 
1076*c83a76b0SSuyog Pawar         /*calculate default allocation*/
1077*c83a76b0SSuyog Pawar         i8_default_bits_in_period = (LWORD64)ps_cbr_buffer->ai4_bit_rate[0] * 1000 *
1078*c83a76b0SSuyog Pawar                                     i4_bit_alloc_period / ps_cbr_buffer->i4_tgt_frm_rate;
1079*c83a76b0SSuyog Pawar 
1080*c83a76b0SSuyog Pawar         /*In case of VBR give additional bits according to peak bitrate*/
1081*c83a76b0SSuyog Pawar         if(ps_cbr_buffer->e_rc_type == VBR_STREAMING)
1082*c83a76b0SSuyog Pawar         {
1083*c83a76b0SSuyog Pawar             i8_max_additional_bits_in_period =
1084*c83a76b0SSuyog Pawar                 ((LWORD64)ps_cbr_buffer->i4_peak_drain_rate_frame * i4_bit_alloc_period) -
1085*c83a76b0SSuyog Pawar                 i8_default_bits_in_period;
1086*c83a76b0SSuyog Pawar             ASSERT(i8_max_additional_bits_in_period >= 0);
1087*c83a76b0SSuyog Pawar             if(i8_max_additional_bits_in_period > (i8_default_bits_in_period))
1088*c83a76b0SSuyog Pawar             {
1089*c83a76b0SSuyog Pawar                 /*clip max bits that can be given to 2x bitrate since its too riskly to give more than that in single pass encoding
1090*c83a76b0SSuyog Pawar                   where long future is not known*/
1091*c83a76b0SSuyog Pawar                 i8_max_additional_bits_in_period = (i8_default_bits_in_period);
1092*c83a76b0SSuyog Pawar             }
1093*c83a76b0SSuyog Pawar         }
1094*c83a76b0SSuyog Pawar         else
1095*c83a76b0SSuyog Pawar         {
1096*c83a76b0SSuyog Pawar             i8_max_additional_bits_in_period = i8_default_bits_in_period;
1097*c83a76b0SSuyog Pawar         }
1098*c83a76b0SSuyog Pawar         {
1099*c83a76b0SSuyog Pawar             float X = ((float)i4_lap_complexity_q7 / 128);
1100*c83a76b0SSuyog Pawar             float desired_buf_level;
1101*c83a76b0SSuyog Pawar             /*For CBR VBV buffer size is "complexity_mov_buf_size" and In case of VBR it is determined by bit deviaiton*/
1102*c83a76b0SSuyog Pawar             if(ps_cbr_buffer->e_rc_type == CBR_NLDRC)
1103*c83a76b0SSuyog Pawar             {
1104*c83a76b0SSuyog Pawar                 complexity_mov_buf_size = (LWORD64)ps_cbr_buffer->i4_upr_thr[0];
1105*c83a76b0SSuyog Pawar             }
1106*c83a76b0SSuyog Pawar             else if(ps_cbr_buffer->e_rc_type == VBR_STREAMING)
1107*c83a76b0SSuyog Pawar             {
1108*c83a76b0SSuyog Pawar                 complexity_mov_buf_size = ps_cbr_buffer->u4_vbr_max_bit_deviation;
1109*c83a76b0SSuyog Pawar             }
1110*c83a76b0SSuyog Pawar             abs_lap_complexity = X;
1111*c83a76b0SSuyog Pawar 
1112*c83a76b0SSuyog Pawar             if(ps_cbr_buffer->i4_cbr_rc_pass == 2)
1113*c83a76b0SSuyog Pawar                 desired_buf_level = COMP_TO_BITS_MAP_2_PASS(X, complexity_mov_buf_size);
1114*c83a76b0SSuyog Pawar             else
1115*c83a76b0SSuyog Pawar                 desired_buf_level = COMP_TO_BITS_MAP(X, complexity_mov_buf_size);
1116*c83a76b0SSuyog Pawar 
1117*c83a76b0SSuyog Pawar             if(desired_buf_level < 0)
1118*c83a76b0SSuyog Pawar                 desired_buf_level = 0;
1119*c83a76b0SSuyog Pawar             /*map complexity to buffer level*/
1120*c83a76b0SSuyog Pawar 
1121*c83a76b0SSuyog Pawar             error_bits = (LWORD64)(desired_buf_level - ps_cbr_buffer->i8_ebf_bit_alloc);
1122*c83a76b0SSuyog Pawar             i8_buf_diff_bits = error_bits;
1123*c83a76b0SSuyog Pawar             /*For VBR its possible that i8_ebf_bit_alloc can go below 0, that the extent of giving should only be desired - cur( = 0 for cur < 0)*/
1124*c83a76b0SSuyog Pawar             buf_diff = (float)error_bits / complexity_mov_buf_size;
1125*c83a76b0SSuyog Pawar 
1126*c83a76b0SSuyog Pawar             /*clipping based on buffer size should depend on gop size. Assuming 7% of gop of gop = 32, calculate for other GOP intervals max 7% while giving from buffer and 10%
1127*c83a76b0SSuyog Pawar               while stealing from buffer(for GOP of 32)*/
1128*c83a76b0SSuyog Pawar             /*try to be conservative when giving extra bits to gop and limit while reducing bits to GOP needs to be higher inorder to be buffer compliant if necessary*/
1129*c83a76b0SSuyog Pawar             i8_buf_based_limit_red =
1130*c83a76b0SSuyog Pawar                 ((LWORD64)complexity_mov_buf_size * i4_bit_alloc_period * 12) >> 12;
1131*c83a76b0SSuyog Pawar             i8_buf_based_limit_inc = ((LWORD64)complexity_mov_buf_size * i4_bit_alloc_period * 8) >>
1132*c83a76b0SSuyog Pawar                                      12;
1133*c83a76b0SSuyog Pawar 
1134*c83a76b0SSuyog Pawar             /*(shd be 7 even if GOP size goes lesser)*/
1135*c83a76b0SSuyog Pawar             if(i8_buf_based_limit_red < (((LWORD64)complexity_mov_buf_size * 10) >> 7))
1136*c83a76b0SSuyog Pawar                 i8_buf_based_limit_red = (((LWORD64)complexity_mov_buf_size * 10) >> 7);
1137*c83a76b0SSuyog Pawar             if(i8_buf_based_limit_inc < (((LWORD64)complexity_mov_buf_size * 10) >> 7))
1138*c83a76b0SSuyog Pawar                 i8_buf_based_limit_inc = (((LWORD64)complexity_mov_buf_size * 10) >> 7);
1139*c83a76b0SSuyog Pawar 
1140*c83a76b0SSuyog Pawar             /*if error bits is too high it is given in stages so that buffer is utilized for entire complex content*/
1141*c83a76b0SSuyog Pawar             /*error bits should not exceed ten 7% of buffer*/
1142*c83a76b0SSuyog Pawar             /*error bits can be max equal to bitrate*/
1143*c83a76b0SSuyog Pawar             if(error_bits > 0)
1144*c83a76b0SSuyog Pawar             {
1145*c83a76b0SSuyog Pawar                 /*if lap compleixty is higher and buffer allows give the bits*/
1146*c83a76b0SSuyog Pawar                 error_bits = (WORD32)(abs_lap_complexity * i8_max_additional_bits_in_period);
1147*c83a76b0SSuyog Pawar                 /*if lap complexity is too simple do not give additional bits to make sure that simple scenes never get additional bits whatsoever*/
1148*c83a76b0SSuyog Pawar                 if(abs_lap_complexity < 0.2f && ps_cbr_buffer->i8_ebf_bit_alloc >= 0)
1149*c83a76b0SSuyog Pawar                 {
1150*c83a76b0SSuyog Pawar                     error_bits = 0;
1151*c83a76b0SSuyog Pawar                 }
1152*c83a76b0SSuyog Pawar                 if(error_bits > i8_buf_diff_bits)
1153*c83a76b0SSuyog Pawar                     error_bits = i8_buf_diff_bits;
1154*c83a76b0SSuyog Pawar 
1155*c83a76b0SSuyog Pawar                 if(error_bits > i8_buf_based_limit_inc)
1156*c83a76b0SSuyog Pawar                 {
1157*c83a76b0SSuyog Pawar                     error_bits = i8_buf_based_limit_inc;
1158*c83a76b0SSuyog Pawar                 }
1159*c83a76b0SSuyog Pawar                 /*If buffer is already half filled be conservative. Allocate 1.5 times bits
1160*c83a76b0SSuyog Pawar                  else allocate twice the bits*/
1161*c83a76b0SSuyog Pawar                 if(ps_cbr_buffer->i8_ebf_bit_alloc >
1162*c83a76b0SSuyog Pawar                    (LWORD64)(ps_cbr_buffer->i4_buffer_size * 0.75))
1163*c83a76b0SSuyog Pawar                 {
1164*c83a76b0SSuyog Pawar                     if(error_bits > (i8_max_additional_bits_in_period >> 1))
1165*c83a76b0SSuyog Pawar                     {
1166*c83a76b0SSuyog Pawar                         error_bits = (i8_max_additional_bits_in_period >> 1);
1167*c83a76b0SSuyog Pawar                     }
1168*c83a76b0SSuyog Pawar                 }
1169*c83a76b0SSuyog Pawar                 else
1170*c83a76b0SSuyog Pawar                 {
1171*c83a76b0SSuyog Pawar                     if(error_bits > i8_max_additional_bits_in_period)
1172*c83a76b0SSuyog Pawar                     {
1173*c83a76b0SSuyog Pawar                         error_bits = i8_max_additional_bits_in_period;
1174*c83a76b0SSuyog Pawar                     }
1175*c83a76b0SSuyog Pawar                 }
1176*c83a76b0SSuyog Pawar             }
1177*c83a76b0SSuyog Pawar             else
1178*c83a76b0SSuyog Pawar             {
1179*c83a76b0SSuyog Pawar                 error_bits = (WORD32)(buf_diff * (i8_default_bits_in_period >> 1));
1180*c83a76b0SSuyog Pawar                 if(error_bits < -i8_buf_based_limit_red)
1181*c83a76b0SSuyog Pawar                 {
1182*c83a76b0SSuyog Pawar                     error_bits = -i8_buf_based_limit_red;
1183*c83a76b0SSuyog Pawar                 }
1184*c83a76b0SSuyog Pawar                 /*when buffer level needs to reduce bits in period*/
1185*c83a76b0SSuyog Pawar                 /*If current level is less than half min bits in period = 70% of constant bit in period else 50%*/
1186*c83a76b0SSuyog Pawar                 if(ps_cbr_buffer->i8_ebf_bit_alloc > (ps_cbr_buffer->i4_buffer_size >> 1))
1187*c83a76b0SSuyog Pawar                 {
1188*c83a76b0SSuyog Pawar                     if(error_bits < -(i8_default_bits_in_period >> 1))
1189*c83a76b0SSuyog Pawar                     {
1190*c83a76b0SSuyog Pawar                         error_bits = -(i8_default_bits_in_period >> 1);
1191*c83a76b0SSuyog Pawar                     }
1192*c83a76b0SSuyog Pawar                 }
1193*c83a76b0SSuyog Pawar                 else
1194*c83a76b0SSuyog Pawar                 {
1195*c83a76b0SSuyog Pawar                     if(error_bits < -((i8_default_bits_in_period * 5) >> 4))
1196*c83a76b0SSuyog Pawar                     {
1197*c83a76b0SSuyog Pawar                         error_bits = -((i8_default_bits_in_period * 5) >> 4);
1198*c83a76b0SSuyog Pawar                     }
1199*c83a76b0SSuyog Pawar                 }
1200*c83a76b0SSuyog Pawar             }
1201*c83a76b0SSuyog Pawar         }
1202*c83a76b0SSuyog Pawar         return (WORD32)error_bits;
1203*c83a76b0SSuyog Pawar     }
1204*c83a76b0SSuyog Pawar     else
1205*c83a76b0SSuyog Pawar     {
1206*c83a76b0SSuyog Pawar         LWORD64 max_excess_bits, default_allocation_for_period, comp_based_excess = 0;
1207*c83a76b0SSuyog Pawar         LWORD64 i8_excess_bits = 0, bit_dev_so_far, credit_limit_level;
1208*c83a76b0SSuyog Pawar         LWORD64 Ravg_dur, num_intra_period_in_Ravg_dur,
1209*c83a76b0SSuyog Pawar             num_intra_in_clip;  //duration for which Ravg has to be met, for shorter slips this can be equal to clip duration
1210*c83a76b0SSuyog Pawar         LWORD64 i8_buf_based_limit_red, i8_buf_based_limit_inc;
1211*c83a76b0SSuyog Pawar         float comp_to_bit_mapped, X;
1212*c83a76b0SSuyog Pawar 
1213*c83a76b0SSuyog Pawar         /*default allocation for period in absence of complexity based bit allocation*/
1214*c83a76b0SSuyog Pawar         default_allocation_for_period =
1215*c83a76b0SSuyog Pawar             ps_cbr_buffer->i4_drain_bits_per_frame[0] * i4_bit_alloc_period;
1216*c83a76b0SSuyog Pawar 
1217*c83a76b0SSuyog Pawar         bit_dev_so_far = ps_cbr_buffer->i8_ebf_bit_alloc;
1218*c83a76b0SSuyog Pawar         credit_limit_level = ps_cbr_buffer->i8_credit_level;
1219*c83a76b0SSuyog Pawar         Ravg_dur =
1220*c83a76b0SSuyog Pawar             ps_cbr_buffer->u4_vbr_max_bit_deviation * 5 / ps_cbr_buffer->i4_drain_bits_per_frame[0];
1221*c83a76b0SSuyog Pawar         if(Ravg_dur > 20 * ps_cbr_buffer->i8_tot_frm_to_be_encoded / 100)
1222*c83a76b0SSuyog Pawar             Ravg_dur = 20 * ps_cbr_buffer->i8_tot_frm_to_be_encoded / 100;
1223*c83a76b0SSuyog Pawar         if(Ravg_dur <= 0)
1224*c83a76b0SSuyog Pawar             Ravg_dur = 1;
1225*c83a76b0SSuyog Pawar         /*map the complexity to bits ratio*/
1226*c83a76b0SSuyog Pawar         X = (float)i4_lap_complexity_q7 / 128;
1227*c83a76b0SSuyog Pawar         if(ps_cbr_buffer->i4_cbr_rc_pass == 2)
1228*c83a76b0SSuyog Pawar             comp_to_bit_mapped = COMP_TO_BITS_MAP_2_PASS(X, 1.0f);
1229*c83a76b0SSuyog Pawar         else
1230*c83a76b0SSuyog Pawar             comp_to_bit_mapped = COMP_TO_BITS_MAP(X, 1.0f);
1231*c83a76b0SSuyog Pawar 
1232*c83a76b0SSuyog Pawar         comp_to_bit_mapped *= 10;  //mapping it to absolute peak bitrate
1233*c83a76b0SSuyog Pawar 
1234*c83a76b0SSuyog Pawar         /*calculate the number of bit alloc periods over which the credit limit needs to build up*/
1235*c83a76b0SSuyog Pawar         num_intra_in_clip = ps_cbr_buffer->i8_tot_frm_to_be_encoded / i4_bit_alloc_period;
1236*c83a76b0SSuyog Pawar         num_intra_period_in_Ravg_dur = Ravg_dur / i4_bit_alloc_period;
1237*c83a76b0SSuyog Pawar         //ASSERT(ps_cbr_buffer->i8_tot_frm_to_be_encoded > i4_bit_alloc_period);
1238*c83a76b0SSuyog Pawar         if(ps_cbr_buffer->i8_tot_frm_to_be_encoded < i4_bit_alloc_period)
1239*c83a76b0SSuyog Pawar         {
1240*c83a76b0SSuyog Pawar             num_intra_period_in_Ravg_dur = 1;
1241*c83a76b0SSuyog Pawar             num_intra_in_clip = 1;
1242*c83a76b0SSuyog Pawar         }
1243*c83a76b0SSuyog Pawar         if(num_intra_period_in_Ravg_dur <= 0)
1244*c83a76b0SSuyog Pawar         {
1245*c83a76b0SSuyog Pawar             num_intra_period_in_Ravg_dur = 1;
1246*c83a76b0SSuyog Pawar         }
1247*c83a76b0SSuyog Pawar         /*max excess bits possible according to given peak bitrate*/
1248*c83a76b0SSuyog Pawar         {
1249*c83a76b0SSuyog Pawar             max_excess_bits = (ps_cbr_buffer->i4_peak_drain_rate_frame -
1250*c83a76b0SSuyog Pawar                                ps_cbr_buffer->i4_drain_bits_per_frame[0]) *
1251*c83a76b0SSuyog Pawar                               i4_bit_alloc_period;
1252*c83a76b0SSuyog Pawar             /*constrain max excess bits allocated to a region if buffer is already at critical level*/
1253*c83a76b0SSuyog Pawar             /*assume room for 20% over-consumption due to mismatch between allocation and consumption*/
1254*c83a76b0SSuyog Pawar             if(ps_cbr_buffer->i4_ebf >
1255*c83a76b0SSuyog Pawar                (ps_cbr_buffer->i4_upr_thr[0] - (WORD32)(max_excess_bits * 0.2)))
1256*c83a76b0SSuyog Pawar             {
1257*c83a76b0SSuyog Pawar                 max_excess_bits = (LWORD64)(max_excess_bits * 0.8);
1258*c83a76b0SSuyog Pawar             }
1259*c83a76b0SSuyog Pawar         }
1260*c83a76b0SSuyog Pawar         /*clipping based on buffer size should depend on gop size. Assuming 7% of gop of gop = 32, calculate for other GOP intervals max 7% while giving from buffer and 10%
1261*c83a76b0SSuyog Pawar             while stealing from buffer(for GOP of 32)*/
1262*c83a76b0SSuyog Pawar         /*try to be conservative when giving extra bits to gop and limit while reducing bits to GOP needs to be higher inorder to be buffer compliant if necessary*/
1263*c83a76b0SSuyog Pawar         i8_buf_based_limit_red =
1264*c83a76b0SSuyog Pawar             ((LWORD64)ps_cbr_buffer->u4_vbr_max_bit_deviation * i4_bit_alloc_period * 12) >> 12;
1265*c83a76b0SSuyog Pawar         i8_buf_based_limit_inc =
1266*c83a76b0SSuyog Pawar             ((LWORD64)ps_cbr_buffer->u4_vbr_max_bit_deviation * i4_bit_alloc_period * 8) >> 12;
1267*c83a76b0SSuyog Pawar 
1268*c83a76b0SSuyog Pawar         /*(shd be 7 even if GOP size goes lesser)*/
1269*c83a76b0SSuyog Pawar         if(i8_buf_based_limit_red < (((LWORD64)ps_cbr_buffer->u4_vbr_max_bit_deviation * 10) >> 7))
1270*c83a76b0SSuyog Pawar             i8_buf_based_limit_red = (((LWORD64)ps_cbr_buffer->u4_vbr_max_bit_deviation * 10) >> 7);
1271*c83a76b0SSuyog Pawar         if(i8_buf_based_limit_inc < (((LWORD64)ps_cbr_buffer->u4_vbr_max_bit_deviation * 10) >> 7))
1272*c83a76b0SSuyog Pawar             i8_buf_based_limit_inc = (((LWORD64)ps_cbr_buffer->u4_vbr_max_bit_deviation * 10) >> 7);
1273*c83a76b0SSuyog Pawar 
1274*c83a76b0SSuyog Pawar         /*The credit limit is not completly built, hence the average  operating bitrate will be lesser than average*/
1275*c83a76b0SSuyog Pawar         //if(ps_cbr_buffer->i8_ebf_bit_alloc >= 0)
1276*c83a76b0SSuyog Pawar         //Disabling this to avoid under-consumption of bits since mostly contents will end with simpler sequence
1277*c83a76b0SSuyog Pawar         if(1 != ps_cbr_buffer->i4_capped_vbr_on)
1278*c83a76b0SSuyog Pawar         {
1279*c83a76b0SSuyog Pawar             /*adjust the excess bits to account for deviation in bitrate
1280*c83a76b0SSuyog Pawar             If bit deviation is positive then overconsumption, hence resuce the default bit allocation*/
1281*c83a76b0SSuyog Pawar 
1282*c83a76b0SSuyog Pawar             /* In capped vbr mode this is not calculated as there is no constraint to meet the configured bitrate */
1283*c83a76b0SSuyog Pawar             i8_excess_bits -= (bit_dev_so_far / num_intra_period_in_Ravg_dur);
1284*c83a76b0SSuyog Pawar         }
1285*c83a76b0SSuyog Pawar         /*allocate bits based on complexity*/
1286*c83a76b0SSuyog Pawar         /*comp_to_bit_mapped less than 1 implies a content that requires less than average bitrate,
1287*c83a76b0SSuyog Pawar           hence due to sign reversal we tend to steal bits*/
1288*c83a76b0SSuyog Pawar         comp_based_excess = (LWORD64)((comp_to_bit_mapped - 1) * default_allocation_for_period);
1289*c83a76b0SSuyog Pawar 
1290*c83a76b0SSuyog Pawar         if(1 != ps_cbr_buffer->i4_capped_vbr_on)
1291*c83a76b0SSuyog Pawar         {
1292*c83a76b0SSuyog Pawar             /*clip the complexity based on intra period and credit limit buffer size so that when credit limit is lower not everything is used for first GOP*/
1293*c83a76b0SSuyog Pawar             if(comp_based_excess > i8_buf_based_limit_inc)
1294*c83a76b0SSuyog Pawar             {
1295*c83a76b0SSuyog Pawar                 comp_based_excess = i8_buf_based_limit_inc;
1296*c83a76b0SSuyog Pawar             }
1297*c83a76b0SSuyog Pawar             else if(comp_based_excess < -i8_buf_based_limit_red)
1298*c83a76b0SSuyog Pawar             {
1299*c83a76b0SSuyog Pawar                 comp_based_excess = -i8_buf_based_limit_red;
1300*c83a76b0SSuyog Pawar             }
1301*c83a76b0SSuyog Pawar 
1302*c83a76b0SSuyog Pawar             /*when the credit limit is fully used, stop giving extra*/
1303*c83a76b0SSuyog Pawar             if(credit_limit_level > ps_cbr_buffer->u4_vbr_max_bit_deviation)
1304*c83a76b0SSuyog Pawar             {
1305*c83a76b0SSuyog Pawar                 if(comp_based_excess < 0)
1306*c83a76b0SSuyog Pawar                     i8_excess_bits += comp_based_excess;
1307*c83a76b0SSuyog Pawar             }
1308*c83a76b0SSuyog Pawar             /*when credit limit is almost full (80 percent full)*/
1309*c83a76b0SSuyog Pawar             else if(credit_limit_level > (LWORD64)(ps_cbr_buffer->u4_vbr_max_bit_deviation * 0.8f))
1310*c83a76b0SSuyog Pawar             {
1311*c83a76b0SSuyog Pawar                 /*follow smooth transition, at 80% utilized the excess should be 100 percent, it should move to zero percent as it approaches 100% utlization*/
1312*c83a76b0SSuyog Pawar                 if(comp_based_excess > 0)
1313*c83a76b0SSuyog Pawar                     i8_excess_bits += (LWORD64)(
1314*c83a76b0SSuyog Pawar                         ((ps_cbr_buffer->u4_vbr_max_bit_deviation - credit_limit_level) /
1315*c83a76b0SSuyog Pawar                          (0.2f * ps_cbr_buffer->u4_vbr_max_bit_deviation)) *
1316*c83a76b0SSuyog Pawar                         comp_based_excess);
1317*c83a76b0SSuyog Pawar                 else
1318*c83a76b0SSuyog Pawar                     i8_excess_bits += comp_based_excess;
1319*c83a76b0SSuyog Pawar             }
1320*c83a76b0SSuyog Pawar             else if(credit_limit_level > (LWORD64)(ps_cbr_buffer->u4_vbr_max_bit_deviation * 0.2f))
1321*c83a76b0SSuyog Pawar             {
1322*c83a76b0SSuyog Pawar                 i8_excess_bits += comp_based_excess;
1323*c83a76b0SSuyog Pawar             }
1324*c83a76b0SSuyog Pawar             /*When credit limit is almost unutilized*/
1325*c83a76b0SSuyog Pawar             else if(
1326*c83a76b0SSuyog Pawar                 credit_limit_level < (WORD32)(ps_cbr_buffer->u4_vbr_max_bit_deviation * 0.2f) &&
1327*c83a76b0SSuyog Pawar                 credit_limit_level > 0)
1328*c83a76b0SSuyog Pawar             {
1329*c83a76b0SSuyog Pawar                 if(comp_based_excess < 0)
1330*c83a76b0SSuyog Pawar                     i8_excess_bits += (LWORD64)(
1331*c83a76b0SSuyog Pawar                         (credit_limit_level / (0.2f * ps_cbr_buffer->u4_vbr_max_bit_deviation)) *
1332*c83a76b0SSuyog Pawar                         comp_based_excess);
1333*c83a76b0SSuyog Pawar                 else
1334*c83a76b0SSuyog Pawar                     i8_excess_bits += comp_based_excess;
1335*c83a76b0SSuyog Pawar             }
1336*c83a76b0SSuyog Pawar             /*If the credit limit still uutilized stop drawing bits from simpler content*/
1337*c83a76b0SSuyog Pawar             else if(credit_limit_level <= 0)
1338*c83a76b0SSuyog Pawar             {
1339*c83a76b0SSuyog Pawar                 if(comp_based_excess > 0)
1340*c83a76b0SSuyog Pawar                     i8_excess_bits += comp_based_excess;
1341*c83a76b0SSuyog Pawar             }
1342*c83a76b0SSuyog Pawar             else
1343*c83a76b0SSuyog Pawar                 ASSERT(0);
1344*c83a76b0SSuyog Pawar         }
1345*c83a76b0SSuyog Pawar         else
1346*c83a76b0SSuyog Pawar         {
1347*c83a76b0SSuyog Pawar             /* In capped vbr mode excess bits will be based on complexity of content alone*/
1348*c83a76b0SSuyog Pawar             i8_excess_bits = comp_based_excess;
1349*c83a76b0SSuyog Pawar         }
1350*c83a76b0SSuyog Pawar 
1351*c83a76b0SSuyog Pawar         /*Clip the excess bits such that it will never violate peak bitrate and also Rmin*/
1352*c83a76b0SSuyog Pawar         if(i8_excess_bits > max_excess_bits)
1353*c83a76b0SSuyog Pawar             i8_excess_bits = max_excess_bits;
1354*c83a76b0SSuyog Pawar         /*assuming atleast 0.4 times average bitrate even for the simplest content*/
1355*c83a76b0SSuyog Pawar         if(i8_excess_bits < -(default_allocation_for_period * 0.6f))
1356*c83a76b0SSuyog Pawar             i8_excess_bits = (LWORD64)(-(default_allocation_for_period * 0.6f));
1357*c83a76b0SSuyog Pawar 
1358*c83a76b0SSuyog Pawar         ASSERT(i8_excess_bits <= 0x7FFFFFFF);
1359*c83a76b0SSuyog Pawar         return (WORD32)i8_excess_bits;
1360*c83a76b0SSuyog Pawar     }
1361*c83a76b0SSuyog Pawar }
1362*c83a76b0SSuyog Pawar /* ******************************************************************************/
1363*c83a76b0SSuyog Pawar /**
1364*c83a76b0SSuyog Pawar  * @brief get_rc_type.
1365*c83a76b0SSuyog Pawar   *
1366*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
1367*c83a76b0SSuyog Pawar  */
1368*c83a76b0SSuyog Pawar /* ******************************************************************************/
get_rc_type(cbr_buffer_t * ps_cbr_buffer)1369*c83a76b0SSuyog Pawar rc_type_e get_rc_type(cbr_buffer_t *ps_cbr_buffer)
1370*c83a76b0SSuyog Pawar {
1371*c83a76b0SSuyog Pawar     return (ps_cbr_buffer->e_rc_type);
1372*c83a76b0SSuyog Pawar }
1373*c83a76b0SSuyog Pawar /* ******************************************************************************/
1374*c83a76b0SSuyog Pawar /**
1375*c83a76b0SSuyog Pawar  * @brief cbr_get_delay_frames
1376*c83a76b0SSuyog Pawar   *
1377*c83a76b0SSuyog Pawar  * @param ps_cbr_buffer
1378*c83a76b0SSuyog Pawar  */
1379*c83a76b0SSuyog Pawar /* ******************************************************************************/
cbr_get_delay_frames(cbr_buffer_t * ps_cbr_buffer)1380*c83a76b0SSuyog Pawar UWORD32 cbr_get_delay_frames(cbr_buffer_t *ps_cbr_buffer)
1381*c83a76b0SSuyog Pawar {
1382*c83a76b0SSuyog Pawar     return (ps_cbr_buffer->u4_num_frms_in_delay);
1383*c83a76b0SSuyog Pawar }
1384*c83a76b0SSuyog Pawar #endif /* #if NON_STEADSTATE_CODE */
1385