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(
374 (const WORD8*)"Error: Should not be coming here with stuffing\n");
375 ps_cbr_buffer->i4_ebf = ps_cbr_buffer->i4_buffer_size;
376 }
377 }
378
379 /*******************************************************************************
380 * @brief If the buffer underflows then return the number of bits to prevent
381 * underflow
382 *
383 ******************************************************************************/
irc_get_cbr_bits_to_stuff(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tot_consumed_bits,picture_type_e e_pic_type)384 WORD32 irc_get_cbr_bits_to_stuff(cbr_buffer_t *ps_cbr_buffer,
385 WORD32 i4_tot_consumed_bits,
386 picture_type_e e_pic_type)
387 {
388 WORD32 i4_bits_to_stuff;
389 WORD32 i4_error_bits = (e_pic_type == I_PIC) ?
390 irc_get_error_bits(ps_cbr_buffer
391 ->aps_bpf_error_bits[0]) :
392 irc_get_error_bits(ps_cbr_buffer
393 ->aps_bpf_error_bits[1]);
394
395 WORD32 i4_drain_bits_per_frame = (e_pic_type == I_PIC) ?
396 ps_cbr_buffer->i4_drain_bits_per_frame[0] :
397 ps_cbr_buffer->i4_drain_bits_per_frame[1];
398
399 /*
400 * Stuffing bits got from the following equation
401 * Stuffing_threshold = ebf + tcb - drain bits - error bits + stuff_bits
402 */
403 i4_bits_to_stuff = i4_drain_bits_per_frame + i4_error_bits
404 + ps_cbr_buffer->i4_stuffing_threshold
405 - (ps_cbr_buffer->i4_ebf + i4_tot_consumed_bits);
406
407 return i4_bits_to_stuff;
408 }
409
410 /*******************************************************************************
411 * @brief Update the state for change in number of pics in the delay period
412 *
413 ******************************************************************************/
irc_change_cbr_vbv_num_pics_in_delay_period(cbr_buffer_t * ps_cbr_buffer,UWORD32 * u4_num_pics_in_delay_prd)414 void irc_change_cbr_vbv_num_pics_in_delay_period(cbr_buffer_t *ps_cbr_buffer,
415 UWORD32 *u4_num_pics_in_delay_prd)
416 {
417 WORD32 i;
418
419 if(!ps_cbr_buffer->i4_is_cbr_mode)
420 {
421 ps_cbr_buffer->i4_buffer_size =
422 u4_num_pics_in_delay_prd[0]
423 * ps_cbr_buffer->i4_drain_bits_per_frame[0]
424 + u4_num_pics_in_delay_prd[1]
425 * ps_cbr_buffer->i4_drain_bits_per_frame[1];
426
427 if(ps_cbr_buffer->i4_buffer_size
428 > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size)
429 {
430 ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size;
431 }
432 for(i = 0; i < MAX_PIC_TYPE; i++)
433 {
434 ps_cbr_buffer->i4_upr_thr[i] = ps_cbr_buffer->i4_buffer_size
435 - (ps_cbr_buffer->i4_buffer_size >> 3);
436 }
437
438 /* Re-initialize the number of pics in delay period */
439 for(i = 0; i < MAX_PIC_TYPE; i++)
440 {
441 ps_cbr_buffer->ai4_num_pics_in_delay_period[i] =
442 u4_num_pics_in_delay_prd[i];
443 }
444 }
445 }
446
447 /******************************************************************************
448 * @brief update the state for change in target frame rate
449 *
450 ******************************************************************************/
irc_change_cbr_vbv_tgt_frame_rate(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_tgt_frm_rate)451 void irc_change_cbr_vbv_tgt_frame_rate(cbr_buffer_t *ps_cbr_buffer,
452 WORD32 i4_tgt_frm_rate)
453 {
454 WORD32 i4_i, i4_bits_per_frm[MAX_NUM_DRAIN_RATES];
455 int i;
456
457 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
458 {
459 X_PROD_Y_DIV_Z(ps_cbr_buffer->ai4_bit_rate[i], 1000, i4_tgt_frm_rate,
460 i4_bits_per_frm[i]);
461 /* Drain rate = bitrate/(framerate/1000) */
462 ps_cbr_buffer->i4_drain_bits_per_frame[i] = i4_bits_per_frm[i];
463 /* Initialize the bits per frame error bits calculation */
464 irc_change_frm_rate_in_error_bits(ps_cbr_buffer->aps_bpf_error_bits[i],
465 i4_tgt_frm_rate);
466 }
467
468 /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/
469 if(!ps_cbr_buffer->i4_is_cbr_mode)
470 {
471 /* VBR streaming case which has different drain rates for I and P */
472 ps_cbr_buffer->i4_buffer_size =
473 ps_cbr_buffer->ai4_num_pics_in_delay_period[0]
474 * ps_cbr_buffer->i4_drain_bits_per_frame[0]
475 + ps_cbr_buffer->ai4_num_pics_in_delay_period[1]
476 * ps_cbr_buffer->i4_drain_bits_per_frame[1];
477 }
478
479 if(ps_cbr_buffer->i4_buffer_size
480 > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size)
481 {
482 ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size;
483 }
484
485 /*
486 * Tgt_frame_rate is divided by 1000 because an approximate value is fine as
487 * this is just a threshold below which stuffing is done to avoid buffer
488 * underflow due to fixed point error in drain rate
489 */
490 ps_cbr_buffer->i4_stuffing_threshold = (ps_cbr_buffer->ai4_bit_rate[0]
491 - (i4_bits_per_frm[0] * (i4_tgt_frm_rate / 1000)));
492
493 for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++)
494 {
495 /*
496 * Upper threshold for
497 * I frame = 1 * bits per frame
498 * P Frame = 4 * bits per frame.
499 * The threshold for I frame is only 1 * bits per frame as the threshold should
500 * only account for error in estimated bits.
501 * In P frame it should account for difference bets bits consumed by I(Scene change)
502 * and P frame I to P complexity is assumed to be 5.
503 */
504 WORD32 i4_index;
505 i4_index = i4_i > 0 ? 1 : 0;
506 ps_cbr_buffer->i4_upr_thr[i4_i] = ps_cbr_buffer->i4_buffer_size
507 - (ps_cbr_buffer->i4_buffer_size >> 3);
508
509 /*
510 * For both I and P frame Lower threshold is equal to drain rate.
511 * Even if the encoder consumes zero bits it should have enough bits to
512 * drain
513 */
514 ps_cbr_buffer->i4_low_thr[i4_i] = i4_bits_per_frm[i4_index];
515 }
516
517 /* Storing the input parameters for using it for change functions */
518 ps_cbr_buffer->i4_tgt_frm_rate = i4_tgt_frm_rate;
519 }
520
521 /*******************************************************************************
522 * @brief Change the state for change in bit rate
523 *
524 ******************************************************************************/
irc_change_cbr_vbv_bit_rate(cbr_buffer_t * ps_cbr_buffer,WORD32 * i4_bit_rate)525 void irc_change_cbr_vbv_bit_rate(cbr_buffer_t *ps_cbr_buffer,
526 WORD32 *i4_bit_rate)
527 {
528 WORD32 i4_i, i4_bits_per_frm[MAX_NUM_DRAIN_RATES];
529 int i;
530
531 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
532 {
533 X_PROD_Y_DIV_Z(i4_bit_rate[i], 1000, ps_cbr_buffer->i4_tgt_frm_rate,
534 i4_bits_per_frm[i]);
535 /* Drain rate = bitrate/(framerate/1000) */
536 ps_cbr_buffer->i4_drain_bits_per_frame[i] = i4_bits_per_frm[i];
537 /* Initialize the bits per frame error bits calculation */
538 irc_change_bitrate_in_error_bits(ps_cbr_buffer->aps_bpf_error_bits[i],
539 i4_bit_rate[i]);
540 }
541
542 /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/
543 if(i4_bit_rate[0] == i4_bit_rate[1]) /* This would mean CBR mode */
544 {
545 X_PROD_Y_DIV_Z(i4_bit_rate[0], ps_cbr_buffer->i4_max_delay, 1000,
546 ps_cbr_buffer->i4_buffer_size);
547 ps_cbr_buffer->i4_is_cbr_mode = 1;
548 }
549 else
550 {
551 /* VBR streaming case which has different drain rates for I and P */
552 ps_cbr_buffer->i4_buffer_size =
553 ps_cbr_buffer->ai4_num_pics_in_delay_period[0]
554 * ps_cbr_buffer->i4_drain_bits_per_frame[0]
555 + ps_cbr_buffer->ai4_num_pics_in_delay_period[1]
556 * ps_cbr_buffer->i4_drain_bits_per_frame[1];
557
558 ps_cbr_buffer->i4_is_cbr_mode = 0;
559 }
560
561 if(ps_cbr_buffer->i4_buffer_size
562 > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size)
563 {
564 ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size;
565 }
566
567 /*
568 * tgt_frame_rate is divided by 1000 because
569 * an approximate value is fine as this is just a threshold below which
570 * stuffing is done to avoid buffer underflow due to fixed point
571 * error in drain rate
572 */
573 ps_cbr_buffer->i4_stuffing_threshold = (i4_bit_rate[0]
574 - (i4_bits_per_frm[0]
575 * (ps_cbr_buffer->i4_tgt_frm_rate / 1000)));
576
577 for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++)
578 {
579 /*
580 * Upper threshold for
581 * I frame = 1 * bits per frame
582 * P Frame = 4 * bits per frame.
583 * The threshold for I frame is only 1 * bits per frame as the threshold
584 * should only account for error in estimated bits.
585 * In P frame it should account for difference bets bits consumed by
586 * I(Scene change) and P frame I to P complexity is assumed to be 5.
587 */
588
589 WORD32 i4_index;
590 i4_index = i4_i > 0 ? 1 : 0;
591 ps_cbr_buffer->i4_upr_thr[i4_i] = ps_cbr_buffer->i4_buffer_size
592 - (ps_cbr_buffer->i4_buffer_size >> 3);
593
594 /* For both I and P frame Lower threshold is equal to drain rate.
595 * Even if the encoder consumes zero bits it should have enough bits to
596 * drain
597 */
598 ps_cbr_buffer->i4_low_thr[i4_i] = i4_bits_per_frm[i4_index];
599 }
600
601 /* Storing the input parameters for using it for change functions */
602 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
603 {
604 ps_cbr_buffer->ai4_bit_rate[i] = i4_bit_rate[i];
605 }
606 }
607
irc_change_cbr_buffer_delay(cbr_buffer_t * ps_cbr_buffer,WORD32 i4_buffer_delay)608 void irc_change_cbr_buffer_delay(cbr_buffer_t *ps_cbr_buffer,
609 WORD32 i4_buffer_delay)
610 {
611 WORD32 i4_i;
612
613 /* Bitrate * delay = buffer size, divide by 1000 as delay is in ms*/
614 if(ps_cbr_buffer->i4_is_cbr_mode)
615 {
616 X_PROD_Y_DIV_Z(ps_cbr_buffer->ai4_bit_rate[0], i4_buffer_delay, 1000,
617 ps_cbr_buffer->i4_buffer_size);
618 }
619
620 if(ps_cbr_buffer->i4_buffer_size
621 > (WORD32)ps_cbr_buffer->u4_max_vbv_buf_size)
622 {
623 ps_cbr_buffer->i4_buffer_size = ps_cbr_buffer->u4_max_vbv_buf_size;
624 }
625
626 for(i4_i = 0; i4_i < MAX_PIC_TYPE; i4_i++)
627 {
628 /*
629 * Upper threshold for
630 * I frame = 1 * bits per frame
631 * P Frame = 4 * bits per frame.
632 * The threshold for I frame is only 1 * bits per frame as the threshold
633 * should only account for error in estimated bits.
634 * In P frame it should account for difference bets bits consumed by I
635 * (Scene change) and P frame I to P complexity is assumed to be 5.
636 */
637 ps_cbr_buffer->i4_upr_thr[i4_i] = ps_cbr_buffer->i4_buffer_size
638 - (ps_cbr_buffer->i4_buffer_size >> 3);
639 }
640
641 /* Storing the input parameters for using it for change functions */
642 ps_cbr_buffer->i4_max_delay = i4_buffer_delay;
643 }
644
irc_get_cbr_buffer_delay(cbr_buffer_t * ps_cbr_buffer)645 WORD32 irc_get_cbr_buffer_delay(cbr_buffer_t *ps_cbr_buffer)
646 {
647 return (ps_cbr_buffer->i4_max_delay);
648 }
649
irc_get_cbr_buffer_size(cbr_buffer_t * ps_cbr_buffer)650 WORD32 irc_get_cbr_buffer_size(cbr_buffer_t *ps_cbr_buffer)
651 {
652 return (ps_cbr_buffer->i4_buffer_size);
653 }
654