1 /******************************************************************************
2 *
3 * Copyright (C) 2015 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 *****************************************************************************
18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19 */
20
21 /*****************************************************************************/
22 /* File Includes */
23 /*****************************************************************************/
24
25 /* System include files */
26 #include <stdio.h>
27
28 /* User include files */
29 #include "irc_datatypes.h"
30 #include "irc_cntrl_param.h"
31 #include "irc_common.h"
32 #include "irc_mem_req_and_acq.h"
33 #include "irc_fixed_point_error_bits.h"
34 #include "irc_cbr_buffer_control.h"
35 #include "irc_trace_support.h"
36
37 typedef struct cbr_buffer_t
38 {
39 /* Buffer size = Delay * Bitrate*/
40 WORD32 i4_buffer_size;
41
42 /* Constant drain rate */
43 WORD32 i4_drain_bits_per_frame[MAX_NUM_DRAIN_RATES];
44
45 /* Encoder Buffer Fullness */
46 WORD32 i4_ebf;
47
48 /* Upper threshold of the Buffer */
49 WORD32 i4_upr_thr[MAX_PIC_TYPE];
50
51 /* Lower threshold of the Buffer */
52 WORD32 i4_low_thr[MAX_PIC_TYPE];
53
54 /* Stuffing threshold equal to error bits per second in the drain bits
55 * fixed point computation */
56 WORD32 i4_stuffing_threshold;
57
58 /* For error due to bits per frame calculation */
59 error_bits_handle aps_bpf_error_bits[MAX_NUM_DRAIN_RATES];
60
61 /* Whether the buffer model is used for CBR or VBR streaming */
62 WORD32 i4_is_cbr_mode;
63
64 /* Input parameters stored for initialization */
65 WORD32 ai4_bit_rate[MAX_NUM_DRAIN_RATES];
66
67 WORD32 i4_max_delay;
68
69 WORD32 ai4_num_pics_in_delay_period[MAX_PIC_TYPE];
70
71 WORD32 i4_tgt_frm_rate;
72
73 UWORD32 u4_max_vbv_buf_size;
74
75 } cbr_buffer_t;
76
irc_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)77 WORD32 irc_cbr_buffer_num_fill_use_free_memtab(cbr_buffer_t **pps_cbr_buffer,
78 itt_memtab_t *ps_memtab,
79 ITT_FUNC_TYPE_E e_func_type)
80 {
81 WORD32 i4_mem_tab_idx = 0, i;
82 cbr_buffer_t s_cbr_buffer_temp;
83
84 /*
85 * Hack for all alloc, during which we don't have any state memory.
86 * Dereferencing can cause issues
87 */
88 if(e_func_type == GET_NUM_MEMTAB || e_func_type == FILL_MEMTAB)
89 (*pps_cbr_buffer) = &s_cbr_buffer_temp;
90
91 if(e_func_type != GET_NUM_MEMTAB)
92 {
93 fill_memtab(&ps_memtab[i4_mem_tab_idx], sizeof(cbr_buffer_t),
94 ALIGN_128_BYTE, PERSISTENT, DDR);
95 use_or_fill_base(&ps_memtab[0], (void**)pps_cbr_buffer, e_func_type);
96 }
97 i4_mem_tab_idx++;
98
99 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
100 {
101 i4_mem_tab_idx += irc_error_bits_num_fill_use_free_memtab(
102 &pps_cbr_buffer[0]->aps_bpf_error_bits[i],
103 &ps_memtab[i4_mem_tab_idx], e_func_type);
104 }
105 return (i4_mem_tab_idx);
106 }
107
108 /******************************************************************************
109 * @brief Initialize the CBR VBV buffer state.
110 * This could however be used for VBR streaming VBV also
111 *
112 ******************************************************************************/
irc_init_cbr_buffer(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_buffer_delay,WORD32 i4_tgt_frm_rate,WORD32 * i4_bit_rate,UWORD32 * u4_num_pics_in_delay_prd,UWORD32 u4_vbv_buf_size)113 void irc_init_cbr_buffer(cbr_buffer_t *ps_cbr_buffer,
114 WORD32 i4_buffer_delay,
115 WORD32 i4_tgt_frm_rate,
116 WORD32 *i4_bit_rate,
117 UWORD32 *u4_num_pics_in_delay_prd,
118 UWORD32 u4_vbv_buf_size)
119 {
120 WORD32 i4_i, i4_bits_per_frm[MAX_NUM_DRAIN_RATES];
121 int i;
122
123 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
124 {
125 X_PROD_Y_DIV_Z(i4_bit_rate[i], 1000, i4_tgt_frm_rate,
126 i4_bits_per_frm[i]);
127 /* Drain rate = bitrate/(framerate/1000) */
128 ps_cbr_buffer->i4_drain_bits_per_frame[i] = i4_bits_per_frm[i];
129 /* Initialize the bits per frame error bits calculation */
130 irc_init_error_bits(ps_cbr_buffer->aps_bpf_error_bits[i],
131 i4_tgt_frm_rate, i4_bit_rate[i]);
132 }
133
134 /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/
135 /* This would mean CBR mode */
136 if(i4_bit_rate[0] == i4_bit_rate[1])
137 {
138 X_PROD_Y_DIV_Z(i4_bit_rate[0], i4_buffer_delay, 1000,
139 ps_cbr_buffer->i4_buffer_size);
140 ps_cbr_buffer->i4_is_cbr_mode = 1;
141 }
142 else
143 {
144 /* VBR streaming case which has different drain rates for I and P */
145 ps_cbr_buffer->i4_buffer_size = u4_num_pics_in_delay_prd[0]
146 * ps_cbr_buffer->i4_drain_bits_per_frame[0]
147 + u4_num_pics_in_delay_prd[1]
148 * ps_cbr_buffer->i4_drain_bits_per_frame[1];
149
150 ps_cbr_buffer->i4_is_cbr_mode = 0;
151 }
152
153 if(ps_cbr_buffer->i4_buffer_size > (WORD32)u4_vbv_buf_size)
154 {
155 ps_cbr_buffer->i4_buffer_size = u4_vbv_buf_size;
156 }
157
158 /* Initially Encoder buffer fullness is zero */
159 ps_cbr_buffer->i4_ebf = 0;
160
161 /* tgt_frame_rate is divided by 1000 because, an approximate value is fine
162 * as this is just a threshold below which stuffing is done to avoid buffer
163 * underflow due to fixed point error in drain rate
164 */
165 ps_cbr_buffer->i4_stuffing_threshold = (i4_bit_rate[0]
166 - (i4_bits_per_frm[0] * (i4_tgt_frm_rate / 1000)));
167
168 for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++)
169 {
170 /*
171 * Upper threshold for
172 * I frame = 1 * bits per frame
173 * P Frame = 4 * bits per frame.
174 * The threshold for I frame is only 1 * bits per frame as the threshold
175 * should only account for error in estimated bits.
176 * In P frame it should account for difference bets bits consumed by
177 * I(Scene change) and P frame I to P complexity is assumed to be 5.
178 */
179 WORD32 i4_index;
180 i4_index = i4_i > 0 ? 1 : 0;
181 ps_cbr_buffer->i4_upr_thr[i4_i] = ps_cbr_buffer->i4_buffer_size
182 - (ps_cbr_buffer->i4_buffer_size >> 3);
183
184 /*
185 * For both I and P frame Lower threshold is equal to drain rate.Even if
186 * the encoder consumes zero bits it should have enough bits to drain
187 */
188 ps_cbr_buffer->i4_low_thr[i4_i] = i4_bits_per_frm[i4_index];
189 }
190
191 /* Storing the input parameters for using it for change functions */
192 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
193 {
194 ps_cbr_buffer->ai4_bit_rate[i] = i4_bit_rate[i];
195 }
196
197 for(i = 0; i < MAX_PIC_TYPE; i++)
198 {
199 ps_cbr_buffer->ai4_num_pics_in_delay_period[i] =
200 u4_num_pics_in_delay_prd[i];
201 }
202 ps_cbr_buffer->i4_tgt_frm_rate = i4_tgt_frm_rate;
203 ps_cbr_buffer->i4_max_delay = i4_buffer_delay;
204 ps_cbr_buffer->u4_max_vbv_buf_size = u4_vbv_buf_size;
205 }
206
207 /******************************************************************************
208 * @brief Condition check for constraining the number of bits allocated based on
209 * bufer size
210 ******************************************************************************/
irc_cbr_buffer_constraint_check(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tgt_bits,picture_type_e e_pic_type)211 WORD32 irc_cbr_buffer_constraint_check(cbr_buffer_t *ps_cbr_buffer,
212 WORD32 i4_tgt_bits,
213 picture_type_e e_pic_type)
214 {
215 WORD32 i4_max_tgt_bits, i4_min_tgt_bits;
216 WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC) ?
217 ps_cbr_buffer->i4_drain_bits_per_frame[0] :
218 ps_cbr_buffer->i4_drain_bits_per_frame[1];
219
220 /* Max tgt bits = Upper threshold - current encoder buffer fullness */
221 i4_max_tgt_bits = ps_cbr_buffer->i4_upr_thr[e_pic_type]
222 - ps_cbr_buffer->i4_ebf;
223 /* Max tgt bits cannot be negative */
224 if(i4_max_tgt_bits < 0)
225 i4_max_tgt_bits = 0;
226
227 /*
228 * Min tgt bits , least number of bits in the Encoder after
229 * draining such that it is greater than lower threshold
230 */
231 i4_min_tgt_bits = ps_cbr_buffer->i4_low_thr[e_pic_type]
232 - (ps_cbr_buffer->i4_ebf - i4_drain_bits_per_frame);
233 /* Min tgt bits cannot be negative */
234 if(i4_min_tgt_bits < 0)
235 i4_min_tgt_bits = 0;
236
237 /* Current tgt bits should be between max and min tgt bits */
238 CLIP(i4_tgt_bits, i4_max_tgt_bits, i4_min_tgt_bits);
239 return i4_tgt_bits;
240 }
241
242 /* *****************************************************************************
243 * @brief constaints the bit allocation based on buffer size
244 *
245 ******************************************************************************/
irc_vbr_stream_buffer_constraint_check(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tgt_bits,picture_type_e e_pic_type)246 WORD32 irc_vbr_stream_buffer_constraint_check(cbr_buffer_t *ps_cbr_buffer,
247 WORD32 i4_tgt_bits,
248 picture_type_e e_pic_type)
249 {
250 WORD32 i4_max_tgt_bits;
251
252 /* Max tgt bits = Upper threshold - current encoder buffer fullness */
253 i4_max_tgt_bits = ps_cbr_buffer->i4_upr_thr[e_pic_type]
254 - ps_cbr_buffer->i4_ebf;
255
256 /* Max tgt bits cannot be negative */
257 if(i4_max_tgt_bits < 0)
258 i4_max_tgt_bits = 0;
259
260 if(i4_tgt_bits > i4_max_tgt_bits)
261 i4_tgt_bits = i4_max_tgt_bits;
262
263 return i4_tgt_bits;
264 }
265
266 /* *****************************************************************************
267 * @brief Verifies the buffer state and returns whether it is overflowing,
268 * underflowing or normal
269 *
270 ******************************************************************************/
irc_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)271 vbv_buf_status_e irc_get_cbr_buffer_status(cbr_buffer_t *ps_cbr_buffer,
272 WORD32 i4_tot_consumed_bits,
273 WORD32 *pi4_num_bits_to_prevent_overflow,
274 picture_type_e e_pic_type)
275 {
276 vbv_buf_status_e e_buf_status;
277 WORD32 i4_cur_enc_buf;
278 WORD32 i4_error_bits = (e_pic_type == I_PIC) ?
279 irc_get_error_bits(ps_cbr_buffer
280 ->aps_bpf_error_bits[0]) :
281 irc_get_error_bits(ps_cbr_buffer
282 ->aps_bpf_error_bits[1]);
283
284 WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC) ?
285 ps_cbr_buffer->i4_drain_bits_per_frame[0] :
286 ps_cbr_buffer->i4_drain_bits_per_frame[1];
287
288 /* Add the tot consumed bits to the Encoder Buffer*/
289 i4_cur_enc_buf = ps_cbr_buffer->i4_ebf + i4_tot_consumed_bits;
290
291 /* If the Encoder exceeds the Buffer Size signal an Overflow*/
292 if(i4_cur_enc_buf > ps_cbr_buffer->i4_buffer_size)
293 {
294 e_buf_status = VBV_OVERFLOW;
295 i4_cur_enc_buf = ps_cbr_buffer->i4_buffer_size;
296 }
297 else
298 {
299 /*
300 * Subtract the constant drain bits and error bits due to fixed point
301 * implementation
302 */
303 i4_cur_enc_buf -= (i4_drain_bits_per_frame + i4_error_bits);
304
305 /*
306 * If the buffer is less than stuffing threshold an Underflow is
307 * signaled else its NORMAL
308 */
309 if(i4_cur_enc_buf < ps_cbr_buffer->i4_stuffing_threshold)
310 {
311 e_buf_status = VBV_UNDERFLOW;
312 }
313 else
314 {
315 e_buf_status = VBV_NORMAL;
316 }
317
318 if(i4_cur_enc_buf < 0)
319 i4_cur_enc_buf = 0;
320 }
321
322 /*
323 * The RC lib models the encoder buffer, but the VBV buffer characterizes
324 * the decoder buffer
325 */
326 if(e_buf_status == VBV_OVERFLOW)
327 {
328 e_buf_status = VBV_UNDERFLOW;
329 }
330 else if(e_buf_status == VBV_UNDERFLOW)
331 {
332 e_buf_status = VBV_OVERFLOW;
333 }
334
335 pi4_num_bits_to_prevent_overflow[0] = (ps_cbr_buffer->i4_buffer_size
336 - i4_cur_enc_buf);
337
338 return e_buf_status;
339 }
340
341 /*******************************************************************************
342 * @brief Based on the bits consumed the buffer model is updated
343 ******************************************************************************/
irc_update_cbr_buffer(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tot_consumed_bits,picture_type_e e_pic_type)344 void irc_update_cbr_buffer(cbr_buffer_t *ps_cbr_buffer,
345 WORD32 i4_tot_consumed_bits,
346 picture_type_e e_pic_type)
347 {
348 WORD32 i4_error_bits = (e_pic_type == I_PIC) ?
349 irc_get_error_bits(ps_cbr_buffer->
350 aps_bpf_error_bits[0]) :
351 irc_get_error_bits( ps_cbr_buffer->
352 aps_bpf_error_bits[1]);
353
354 WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC) ?
355 ps_cbr_buffer->i4_drain_bits_per_frame[0] :
356 ps_cbr_buffer->i4_drain_bits_per_frame[1];
357
358 /* Update the Encoder buffer with the total consumed bits*/
359 ps_cbr_buffer->i4_ebf += i4_tot_consumed_bits;
360
361 /*
362 * Subtract the drain bits and error bits due to fixed point
363 * implementation
364 */
365 ps_cbr_buffer->i4_ebf -= (i4_drain_bits_per_frame + i4_error_bits);
366
367 if(ps_cbr_buffer->i4_ebf < 0)
368 ps_cbr_buffer->i4_ebf = 0;
369
370 /*SS - Fix for lack of stuffing*/
371 if(ps_cbr_buffer->i4_ebf > ps_cbr_buffer->i4_buffer_size)
372 {
373 TRACE_PRINTF((const WORD8*)"Error: Should not be coming here with stuffing\n");
374 ps_cbr_buffer->i4_ebf = ps_cbr_buffer->i4_buffer_size;
375 }
376 }
377
378 /*******************************************************************************
379 * @brief If the buffer underflows then return the number of bits to prevent
380 * underflow
381 *
382 ******************************************************************************/
irc_get_cbr_bits_to_stuff(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tot_consumed_bits,picture_type_e e_pic_type)383 WORD32 irc_get_cbr_bits_to_stuff(cbr_buffer_t *ps_cbr_buffer,
384 WORD32 i4_tot_consumed_bits,
385 picture_type_e e_pic_type)
386 {
387 WORD32 i4_bits_to_stuff;
388 WORD32 i4_error_bits = (e_pic_type == I_PIC) ?
389 irc_get_error_bits(ps_cbr_buffer
390 ->aps_bpf_error_bits[0]) :
391 irc_get_error_bits(ps_cbr_buffer
392 ->aps_bpf_error_bits[1]);
393
394 WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC) ?
395 ps_cbr_buffer->i4_drain_bits_per_frame[0] :
396 ps_cbr_buffer->i4_drain_bits_per_frame[1];
397
398 /*
399 * Stuffing bits got from the following equation
400 * Stuffing_threshold = ebf + tcb - drain bits - error bits + stuff_bits
401 */
402 i4_bits_to_stuff = i4_drain_bits_per_frame + i4_error_bits
403 + ps_cbr_buffer->i4_stuffing_threshold
404 - (ps_cbr_buffer->i4_ebf + i4_tot_consumed_bits);
405
406 return i4_bits_to_stuff;
407 }
408
409 /*******************************************************************************
410 * @brief Update the state for change in number of pics in the delay period
411 *
412 ******************************************************************************/
irc_change_cbr_vbv_num_pics_in_delay_period(cbr_buffer_t * ps_cbr_buffer,UWORD32 * u4_num_pics_in_delay_prd)413 void irc_change_cbr_vbv_num_pics_in_delay_period(cbr_buffer_t *ps_cbr_buffer,
414 UWORD32 *u4_num_pics_in_delay_prd)
415 {
416 WORD32 i;
417
418 if(!ps_cbr_buffer->i4_is_cbr_mode)
419 {
420 ps_cbr_buffer->i4_buffer_size =
421 u4_num_pics_in_delay_prd[0]
422 * ps_cbr_buffer->i4_drain_bits_per_frame[0]
423 + u4_num_pics_in_delay_prd[1]
424 * ps_cbr_buffer->i4_drain_bits_per_frame[1];
425
426 if(ps_cbr_buffer->i4_buffer_size
427 > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size)
428 {
429 ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size;
430 }
431 for(i = 0; i < MAX_PIC_TYPE; i++)
432 {
433 ps_cbr_buffer->i4_upr_thr[i] = ps_cbr_buffer->i4_buffer_size
434 - (ps_cbr_buffer->i4_buffer_size >> 3);
435 }
436
437 /* Re-initialize the number of pics in delay period */
438 for(i = 0; i < MAX_PIC_TYPE; i++)
439 {
440 ps_cbr_buffer->ai4_num_pics_in_delay_period[i] =
441 u4_num_pics_in_delay_prd[i];
442 }
443 }
444 }
445
446 /******************************************************************************
447 * @brief update the state for change in target frame rate
448 *
449 ******************************************************************************/
irc_change_cbr_vbv_tgt_frame_rate(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tgt_frm_rate)450 void irc_change_cbr_vbv_tgt_frame_rate(cbr_buffer_t *ps_cbr_buffer,
451 WORD32 i4_tgt_frm_rate)
452 {
453 WORD32 i4_i, i4_bits_per_frm[MAX_NUM_DRAIN_RATES];
454 int i;
455
456 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
457 {
458 X_PROD_Y_DIV_Z(ps_cbr_buffer->ai4_bit_rate[i], 1000, i4_tgt_frm_rate,
459 i4_bits_per_frm[i]);
460 /* Drain rate = bitrate/(framerate/1000) */
461 ps_cbr_buffer->i4_drain_bits_per_frame[i] = i4_bits_per_frm[i];
462 /* Initialize the bits per frame error bits calculation */
463 irc_change_frm_rate_in_error_bits(ps_cbr_buffer->aps_bpf_error_bits[i],
464 i4_tgt_frm_rate);
465 }
466
467 /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/
468 if(!ps_cbr_buffer->i4_is_cbr_mode)
469 {
470 /* VBR streaming case which has different drain rates for I and P */
471 ps_cbr_buffer->i4_buffer_size =
472 ps_cbr_buffer->ai4_num_pics_in_delay_period[0]
473 * ps_cbr_buffer->i4_drain_bits_per_frame[0]
474 + ps_cbr_buffer->ai4_num_pics_in_delay_period[1]
475 * ps_cbr_buffer->i4_drain_bits_per_frame[1];
476 }
477
478 if(ps_cbr_buffer->i4_buffer_size
479 > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size)
480 {
481 ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size;
482 }
483
484 /*
485 * Tgt_frame_rate is divided by 1000 because an approximate value is fine as
486 * this is just a threshold below which stuffing is done to avoid buffer
487 * underflow due to fixed point error in drain rate
488 */
489 ps_cbr_buffer->i4_stuffing_threshold = (ps_cbr_buffer->ai4_bit_rate[0]
490 - (i4_bits_per_frm[0] * (i4_tgt_frm_rate / 1000)));
491
492 for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++)
493 {
494 /*
495 * Upper threshold for
496 * I frame = 1 * bits per frame
497 * P Frame = 4 * bits per frame.
498 * The threshold for I frame is only 1 * bits per frame as the threshold should
499 * only account for error in estimated bits.
500 * In P frame it should account for difference bets bits consumed by I(Scene change)
501 * and P frame I to P complexity is assumed to be 5.
502 */
503 WORD32 i4_index;
504 i4_index = i4_i > 0 ? 1 : 0;
505 ps_cbr_buffer->i4_upr_thr[i4_i] = ps_cbr_buffer->i4_buffer_size
506 - (ps_cbr_buffer->i4_buffer_size >> 3);
507
508 /*
509 * For both I and P frame Lower threshold is equal to drain rate.
510 * Even if the encoder consumes zero bits it should have enough bits to
511 * drain
512 */
513 ps_cbr_buffer->i4_low_thr[i4_i] = i4_bits_per_frm[i4_index];
514 }
515
516 /* Storing the input parameters for using it for change functions */
517 ps_cbr_buffer->i4_tgt_frm_rate = i4_tgt_frm_rate;
518 }
519
520 /*******************************************************************************
521 * @brief Change the state for change in bit rate
522 *
523 ******************************************************************************/
irc_change_cbr_vbv_bit_rate(cbr_buffer_t * ps_cbr_buffer,WORD32 * i4_bit_rate)524 void irc_change_cbr_vbv_bit_rate(cbr_buffer_t *ps_cbr_buffer,
525 WORD32 *i4_bit_rate)
526 {
527 WORD32 i4_i, i4_bits_per_frm[MAX_NUM_DRAIN_RATES];
528 int i;
529
530 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
531 {
532 X_PROD_Y_DIV_Z(i4_bit_rate[i], 1000, ps_cbr_buffer->i4_tgt_frm_rate,
533 i4_bits_per_frm[i]);
534 /* Drain rate = bitrate/(framerate/1000) */
535 ps_cbr_buffer->i4_drain_bits_per_frame[i] = i4_bits_per_frm[i];
536 /* Initialize the bits per frame error bits calculation */
537 irc_change_bitrate_in_error_bits(ps_cbr_buffer->aps_bpf_error_bits[i],
538 i4_bit_rate[i]);
539 }
540
541 /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/
542 if(i4_bit_rate[0] == i4_bit_rate[1]) /* This would mean CBR mode */
543 {
544 X_PROD_Y_DIV_Z(i4_bit_rate[0], ps_cbr_buffer->i4_max_delay, 1000,
545 ps_cbr_buffer->i4_buffer_size);
546 ps_cbr_buffer->i4_is_cbr_mode = 1;
547 }
548 else
549 {
550 /* VBR streaming case which has different drain rates for I and P */
551 ps_cbr_buffer->i4_buffer_size =
552 ps_cbr_buffer->ai4_num_pics_in_delay_period[0]
553 * ps_cbr_buffer->i4_drain_bits_per_frame[0]
554 + ps_cbr_buffer->ai4_num_pics_in_delay_period[1]
555 * ps_cbr_buffer->i4_drain_bits_per_frame[1];
556
557 ps_cbr_buffer->i4_is_cbr_mode = 0;
558 }
559
560 if(ps_cbr_buffer->i4_buffer_size
561 > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size)
562 {
563 ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size;
564 }
565
566 /*
567 * tgt_frame_rate is divided by 1000 because
568 * an approximate value is fine as this is just a threshold below which
569 * stuffing is done to avoid buffer underflow due to fixed point
570 * error in drain rate
571 */
572 ps_cbr_buffer->i4_stuffing_threshold = (i4_bit_rate[0]
573 - (i4_bits_per_frm[0]
574 * (ps_cbr_buffer->i4_tgt_frm_rate / 1000)));
575
576 for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++)
577 {
578 /*
579 * Upper threshold for
580 * I frame = 1 * bits per frame
581 * P Frame = 4 * bits per frame.
582 * The threshold for I frame is only 1 * bits per frame as the threshold
583 * should only account for error in estimated bits.
584 * In P frame it should account for difference bets bits consumed by
585 * I(Scene change) and P frame I to P complexity is assumed to be 5.
586 */
587
588 WORD32 i4_index;
589 i4_index = i4_i > 0 ? 1 : 0;
590 ps_cbr_buffer->i4_upr_thr[i4_i] = ps_cbr_buffer->i4_buffer_size
591 - (ps_cbr_buffer->i4_buffer_size >> 3);
592
593 /* For both I and P frame Lower threshold is equal to drain rate.
594 * Even if the encoder consumes zero bits it should have enough bits to
595 * drain
596 */
597 ps_cbr_buffer->i4_low_thr[i4_i] = i4_bits_per_frm[i4_index];
598 }
599
600 /* Storing the input parameters for using it for change functions */
601 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
602 {
603 ps_cbr_buffer->ai4_bit_rate[i] = i4_bit_rate[i];
604 }
605 }
606
irc_change_cbr_buffer_delay(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_buffer_delay)607 void irc_change_cbr_buffer_delay(cbr_buffer_t *ps_cbr_buffer,
608 WORD32 i4_buffer_delay)
609 {
610 WORD32 i4_i;
611
612 /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/
613 if(ps_cbr_buffer->i4_is_cbr_mode)
614 {
615 X_PROD_Y_DIV_Z(ps_cbr_buffer->ai4_bit_rate[0], i4_buffer_delay, 1000,
616 ps_cbr_buffer->i4_buffer_size);
617 }
618
619 if(ps_cbr_buffer->i4_buffer_size
620 > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size)
621 {
622 ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size;
623 }
624
625 for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++)
626 {
627 /*
628 * Upper threshold for
629 * I frame = 1 * bits per frame
630 * P Frame = 4 * bits per frame.
631 * The threshold for I frame is only 1 * bits per frame as the threshold
632 * should only account for error in estimated bits.
633 * In P frame it should account for difference bets bits consumed by I
634 * (Scene change) and P frame I to P complexity is assumed to be 5.
635 */
636 ps_cbr_buffer->i4_upr_thr[i4_i] = ps_cbr_buffer->i4_buffer_size
637 - (ps_cbr_buffer->i4_buffer_size >> 3);
638 }
639
640 /* Storing the input parameters for using it for change functions */
641 ps_cbr_buffer->i4_max_delay = i4_buffer_delay;
642 }
643
irc_get_cbr_buffer_delay(cbr_buffer_t * ps_cbr_buffer)644 WORD32 irc_get_cbr_buffer_delay(cbr_buffer_t *ps_cbr_buffer)
645 {
646 return (ps_cbr_buffer->i4_max_delay);
647 }
648
irc_get_cbr_buffer_size(cbr_buffer_t * ps_cbr_buffer)649 WORD32 irc_get_cbr_buffer_size(cbr_buffer_t *ps_cbr_buffer)
650 {
651 return (ps_cbr_buffer->i4_buffer_size);
652 }
653