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 /** Includes */
22 #include <stdio.h>
23 #include <string.h>
24 #include "irc_datatypes.h"
25 #include "irc_mem_req_and_acq.h"
26 #include "irc_common.h"
27 #include "irc_cntrl_param.h"
28 #include "irc_fixed_point_error_bits.h"
29 #include "irc_rd_model.h"
30 #include "irc_est_sad.h"
31 #include "irc_picture_type.h"
32 #include "irc_bit_allocation.h"
33 #include "irc_trace_support.h"
34
35 /** Macros **/
36 #define MIN(x,y) ((x) < (y))? (x) : (y)
37
38 /* State structure for bit allocation */
39 typedef struct
40 {
41 /* using var_q number as it can cross 31 bits for large intra frameinterval */
42 number_t vq_rem_bits_in_period;
43
44 /* Storing inputs */
45 WORD32 i4_tot_frms_in_gop;
46
47 WORD32 i4_num_intra_frm_interval;
48
49 WORD32 i4_bits_per_frm;
50
51 } rem_bit_in_prd_t;
52
53 typedef struct bit_allocation_t
54 {
55 rem_bit_in_prd_t s_rbip;
56
57 /* A universal constant giving the relative complexity between pictures */
58 WORD32 i2_K[MAX_PIC_TYPE];
59
60 /* To get a estimate of the header bits consumed */
61 WORD32 i4_prev_frm_header_bits[MAX_PIC_TYPE];
62
63 WORD32 i4_bits_per_frm;
64
65 WORD32 i4_num_gops_in_period;
66
67 /* Num gops as set by rate control module */
68 WORD32 i4_actual_num_gops_in_period;
69
70 number_t vq_saved_bits;
71
72 WORD32 i4_max_bits_per_frm[MAX_NUM_DRAIN_RATES];
73
74 WORD32 i4_min_bits_per_frm;
75
76 /* Error bits module */
77 error_bits_handle ps_error_bits;
78
79 /* Storing frame rate */
80 WORD32 i4_frame_rate;
81
82 WORD32 i4_bit_rate;
83
84 WORD32 ai4_peak_bit_rate[MAX_NUM_DRAIN_RATES];
85
86 } bit_allocation_t;
87
get_number_of_frms_in_a_gop(pic_handling_handle ps_pic_handling)88 static WORD32 get_number_of_frms_in_a_gop(pic_handling_handle ps_pic_handling)
89 {
90 WORD32 i4_tot_frms_in_gop = 0, i;
91 WORD32 ai4_frms_in_gop[MAX_PIC_TYPE];
92
93 /* Query the pic_handling struct for the rem frames in the period */
94 irc_pic_type_get_frms_in_gop(ps_pic_handling, ai4_frms_in_gop);
95
96 /* Get the total frms in the gop */
97 i4_tot_frms_in_gop = 0;
98 for(i = 0; i < MAX_PIC_TYPE; i++)
99 {
100 i4_tot_frms_in_gop += ai4_frms_in_gop[i];
101 }
102 return (i4_tot_frms_in_gop);
103 }
104
init_rbip(rem_bit_in_prd_t * ps_rbip,pic_handling_handle ps_pic_handling,WORD32 i4_bits_per_frm,WORD32 i4_num_intra_frm_interval)105 static void init_rbip(rem_bit_in_prd_t *ps_rbip,
106 pic_handling_handle ps_pic_handling,
107 WORD32 i4_bits_per_frm,
108 WORD32 i4_num_intra_frm_interval)
109 {
110 WORD32 i4_tot_frms_in_gop = get_number_of_frms_in_a_gop(ps_pic_handling);
111
112 /* rem_bits_in_period = bits_per_frm * tot_frms_in_gop * num_intra_frm_interval */
113 {
114 number_t vq_bits_per_frm, vq_tot_frms_in_gop, vq_num_intra_frm_interval;
115 number_t *pvq_rem_bits_in_period = &ps_rbip->vq_rem_bits_in_period;
116
117 SET_VAR_Q(vq_bits_per_frm, i4_bits_per_frm, 0);
118 SET_VAR_Q(vq_tot_frms_in_gop, i4_tot_frms_in_gop, 0);
119 SET_VAR_Q(vq_num_intra_frm_interval, i4_num_intra_frm_interval, 0);
120
121 /* rem_bits_in_period = bits_per_frm * tot_frms_in_gop */
122 mult32_var_q(vq_bits_per_frm, vq_tot_frms_in_gop,
123 pvq_rem_bits_in_period);
124
125 /* rem_bits_in_period *= num_intra_frm_interval */
126 mult32_var_q(vq_num_intra_frm_interval, pvq_rem_bits_in_period[0],
127 pvq_rem_bits_in_period);
128 }
129
130 /*
131 * Store the total number of frames in GOP value which is
132 * used from module A
133 */
134 ps_rbip->i4_tot_frms_in_gop = i4_tot_frms_in_gop;
135 ps_rbip->i4_num_intra_frm_interval = i4_num_intra_frm_interval;
136 ps_rbip->i4_bits_per_frm = i4_bits_per_frm;
137 }
138
check_update_rbip(rem_bit_in_prd_t * ps_rbip,pic_handling_handle ps_pic_handling)139 static void check_update_rbip(rem_bit_in_prd_t *ps_rbip,
140 pic_handling_handle ps_pic_handling)
141 {
142 /*
143 * NOTE: Intra frame interval changes after the first I frame that is
144 * encoded in a GOP
145 */
146 WORD32 i4_new_tot_frms_in_gop = get_number_of_frms_in_a_gop(
147 ps_pic_handling);
148
149 if(i4_new_tot_frms_in_gop != ps_rbip->i4_tot_frms_in_gop)
150 {
151 WORD32 i4_rem_frames_in_period =
152 ps_rbip->i4_num_intra_frm_interval
153 * (i4_new_tot_frms_in_gop
154 - ps_rbip->i4_tot_frms_in_gop);
155
156 number_t vq_rem_frms_in_period, s_bits_per_frm, vq_delta_bits_in_period;
157
158 SET_VAR_Q(vq_rem_frms_in_period, i4_rem_frames_in_period, 0);
159 SET_VAR_Q(s_bits_per_frm, ps_rbip->i4_bits_per_frm, 0);
160
161 /* delta_bits_in_period = bits_per_frm * rem_frms_in_period */
162 mult32_var_q(s_bits_per_frm, vq_rem_frms_in_period,
163 &vq_delta_bits_in_period);
164
165 /* rem_bits_in_period += delta_bits_in_period */
166 add32_var_q(vq_delta_bits_in_period, ps_rbip->vq_rem_bits_in_period,
167 &ps_rbip->vq_rem_bits_in_period);
168 }
169 /* Updated the new values */
170 ps_rbip->i4_tot_frms_in_gop = i4_new_tot_frms_in_gop;
171 }
172
irc_ba_update_rbip(rem_bit_in_prd_t * ps_rbip,pic_handling_handle ps_pic_handling,number_t vq_num_bits)173 static void irc_ba_update_rbip(rem_bit_in_prd_t *ps_rbip,
174 pic_handling_handle ps_pic_handling,
175 number_t vq_num_bits)
176 {
177 check_update_rbip(ps_rbip, ps_pic_handling);
178
179 /* rem_bits_in_period += num_of_bits */
180 add32_var_q(vq_num_bits, ps_rbip->vq_rem_bits_in_period,
181 &ps_rbip->vq_rem_bits_in_period);
182 }
183
irc_ba_change_rbip(rem_bit_in_prd_t * ps_rbip,pic_handling_handle ps_pic_handling,WORD32 i4_new_bits_per_frm,WORD32 i4_new_num_intra_frm_interval)184 static void irc_ba_change_rbip(rem_bit_in_prd_t *ps_rbip,
185 pic_handling_handle ps_pic_handling,
186 WORD32 i4_new_bits_per_frm,
187 WORD32 i4_new_num_intra_frm_interval)
188 {
189 WORD32 ai4_rem_frms_in_period[MAX_PIC_TYPE], i4_rem_frms_in_gop, i;
190 irc_pic_type_get_rem_frms_in_gop(ps_pic_handling, ai4_rem_frms_in_period);
191
192 i4_rem_frms_in_gop = 0;
193 for(i = 0; i < MAX_PIC_TYPE; i++)
194 i4_rem_frms_in_gop += ai4_rem_frms_in_period[i];
195
196 if(i4_new_bits_per_frm != ps_rbip->i4_bits_per_frm)
197 {
198 WORD32 i4_rem_frms_in_period = (ps_rbip->i4_num_intra_frm_interval - 1)
199 * ps_rbip->i4_tot_frms_in_gop + i4_rem_frms_in_gop;
200
201 number_t vq_rem_frms_in_period, vq_delta_bits_per_frm,
202 vq_delta_bits_in_period;
203
204 /* delta_bits_per_frm = new_bits_per_frm - old_bits_per_frm */
205 SET_VAR_Q(vq_delta_bits_per_frm,
206 (i4_new_bits_per_frm - ps_rbip->i4_bits_per_frm), 0);
207
208 SET_VAR_Q(vq_rem_frms_in_period, i4_rem_frms_in_period, 0);
209
210 /* delta_bits_in_period = delta_bits_per_frm * rem_frms_in_period */
211 mult32_var_q(vq_delta_bits_per_frm, vq_rem_frms_in_period,
212 &vq_delta_bits_in_period);
213
214 /* ps_rbip->rem_bits_in_period += delta_bits_in_period */
215 add32_var_q(vq_delta_bits_in_period, ps_rbip->vq_rem_bits_in_period,
216 &ps_rbip->vq_rem_bits_in_period);
217 }
218
219 if(i4_new_num_intra_frm_interval != ps_rbip->i4_num_intra_frm_interval)
220 {
221 WORD32 i4_rem_frms_in_period = ps_rbip->i4_tot_frms_in_gop
222 * (i4_new_num_intra_frm_interval
223 - ps_rbip->i4_num_intra_frm_interval);
224
225 number_t vq_rem_frms_in_period, vq_new_bits_per_frm,
226 vq_delta_bits_in_period;
227
228 /* new_bits_per_frm = new_new_bits_per_frm - old_new_bits_per_frm */
229 SET_VAR_Q(vq_new_bits_per_frm, i4_new_bits_per_frm, 0);
230
231 SET_VAR_Q(vq_rem_frms_in_period, i4_rem_frms_in_period, 0);
232
233 /* delta_bits_in_period = new_bits_per_frm * rem_frms_in_period */
234 mult32_var_q(vq_new_bits_per_frm, vq_rem_frms_in_period,
235 &vq_delta_bits_in_period);
236
237 /* ps_rbip->rem_bits_in_period += delta_bits_in_period */
238 add32_var_q(vq_delta_bits_in_period, ps_rbip->vq_rem_bits_in_period,
239 &ps_rbip->vq_rem_bits_in_period);
240 }
241 /* Update the new value */
242 ps_rbip->i4_num_intra_frm_interval = i4_new_num_intra_frm_interval;
243 ps_rbip->i4_bits_per_frm = i4_new_bits_per_frm;
244 }
245
irc_ba_num_fill_use_free_memtab(bit_allocation_t ** pps_bit_allocation,itt_memtab_t * ps_memtab,ITT_FUNC_TYPE_E e_func_type)246 WORD32 irc_ba_num_fill_use_free_memtab(bit_allocation_t **pps_bit_allocation,
247 itt_memtab_t *ps_memtab,
248 ITT_FUNC_TYPE_E e_func_type)
249 {
250 WORD32 i4_mem_tab_idx = 0;
251 bit_allocation_t s_bit_allocation_temp;
252
253 /*
254 * Hack for all alloc, during which we don't have any state memory.
255 * Dereferencing can cause issues
256 */
257 if(e_func_type == GET_NUM_MEMTAB || e_func_type == FILL_MEMTAB)
258 (*pps_bit_allocation) = &s_bit_allocation_temp;
259
260 /*for src rate control state structure*/
261 if(e_func_type != GET_NUM_MEMTAB)
262 {
263 fill_memtab(&ps_memtab[i4_mem_tab_idx], sizeof(bit_allocation_t),
264 ALIGN_128_BYTE, PERSISTENT, DDR);
265 use_or_fill_base(&ps_memtab[0], (void**)pps_bit_allocation,
266 e_func_type);
267 }
268 i4_mem_tab_idx++;
269
270 i4_mem_tab_idx += irc_error_bits_num_fill_use_free_memtab(
271 &pps_bit_allocation[0]->ps_error_bits,
272 &ps_memtab[i4_mem_tab_idx], e_func_type);
273
274 return (i4_mem_tab_idx);
275 }
276
277 /*******************************************************************************
278 Function Name : irc_ba_init_bit_allocation
279 Description : Initialize the bit_allocation structure.
280 ******************************************************************************/
irc_ba_init_bit_allocation(bit_allocation_t * ps_bit_allocation,pic_handling_handle ps_pic_handling,WORD32 i4_num_intra_frm_interval,WORD32 i4_bit_rate,WORD32 i4_frm_rate,WORD32 * i4_peak_bit_rate,WORD32 i4_min_bitrate)281 void irc_ba_init_bit_allocation(bit_allocation_t *ps_bit_allocation,
282 pic_handling_handle ps_pic_handling,
283 WORD32 i4_num_intra_frm_interval,
284 WORD32 i4_bit_rate,
285 WORD32 i4_frm_rate,
286 WORD32 *i4_peak_bit_rate,
287 WORD32 i4_min_bitrate)
288 {
289 WORD32 i;
290 WORD32 i4_bits_per_frm, i4_max_bits_per_frm[MAX_NUM_DRAIN_RATES];
291
292 /* Calculate the bits per frame */
293 X_PROD_Y_DIV_Z(i4_bit_rate, 1000, i4_frm_rate, i4_bits_per_frm);
294 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
295 {
296 X_PROD_Y_DIV_Z(i4_peak_bit_rate[i], 1000, i4_frm_rate,
297 i4_max_bits_per_frm[i]);
298 }
299 /* Initialize the bits_per_frame */
300 ps_bit_allocation->i4_bits_per_frm = i4_bits_per_frm;
301 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
302 {
303 ps_bit_allocation->i4_max_bits_per_frm[i] = i4_max_bits_per_frm[i];
304 }
305 X_PROD_Y_DIV_Z(i4_min_bitrate, 1000, i4_frm_rate,
306 ps_bit_allocation->i4_min_bits_per_frm);
307
308 /*
309 * Initialize the rem_bits in period
310 * The first gop in case of an OPEN GOP may have fewer B_PICs,
311 * That condition is not taken care of
312 */
313 init_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, i4_bits_per_frm,
314 i4_num_intra_frm_interval);
315
316 /* Initialize the num_gops_in_period */
317 ps_bit_allocation->i4_num_gops_in_period = i4_num_intra_frm_interval;
318 ps_bit_allocation->i4_actual_num_gops_in_period = i4_num_intra_frm_interval;
319
320 /* Relative complexity between I and P frames */
321 ps_bit_allocation->i2_K[I_PIC] = (1 << K_Q);
322 ps_bit_allocation->i2_K[P_PIC] = I_TO_P_RATIO;
323 ps_bit_allocation->i2_K[B_PIC] = (P_TO_B_RATIO * I_TO_P_RATIO) >> K_Q;
324
325 /* Initialize the saved bits to 0*/
326 SET_VAR_Q(ps_bit_allocation->vq_saved_bits, 0, 0);
327
328 /* Update the error bits module with average bits */
329 irc_init_error_bits(ps_bit_allocation->ps_error_bits, i4_frm_rate,
330 i4_bit_rate);
331 /* Store the input for implementing change in values */
332 ps_bit_allocation->i4_frame_rate = i4_frm_rate;
333 ps_bit_allocation->i4_bit_rate = i4_bit_rate;
334
335 memset(ps_bit_allocation->i4_prev_frm_header_bits, 0, sizeof(ps_bit_allocation->i4_prev_frm_header_bits));
336 for(i=0;i<MAX_NUM_DRAIN_RATES;i++)
337 ps_bit_allocation->ai4_peak_bit_rate[i] = i4_peak_bit_rate[i];
338 }
339
340 /*******************************************************************************
341 Function Name : get_cur_frm_est_bits
342 Description : Based on remaining bits in period and rd_model
343 the number of bits required for the current frame is estimated.
344 ******************************************************************************/
irc_ba_get_cur_frm_est_texture_bits(bit_allocation_t * ps_bit_allocation,rc_rd_model_handle * pps_rd_model,est_sad_handle ps_est_sad,pic_handling_handle ps_pic_handling,picture_type_e e_pic_type)345 WORD32 irc_ba_get_cur_frm_est_texture_bits(bit_allocation_t *ps_bit_allocation,
346 rc_rd_model_handle *pps_rd_model,
347 est_sad_handle ps_est_sad,
348 pic_handling_handle ps_pic_handling,
349 picture_type_e e_pic_type)
350 {
351 WORD32 i, j;
352 WORD32 i4_est_texture_bits_for_frm;
353 number_t vq_rem_texture_bits;
354 number_t vq_complexity_estimate[MAX_PIC_TYPE];
355 WORD32 i4_rem_frms_in_period[MAX_PIC_TYPE], i4_frms_in_period[MAX_PIC_TYPE];
356 number_t vq_max_consumable_bits;
357 number_t vq_rem_frms_in_period[MAX_PIC_TYPE], vq_est_texture_bits_for_frm;
358 number_t vq_prev_hdr_bits[MAX_PIC_TYPE];
359 number_t vq_num_bits;
360 WORD32 complexity_est = 0;
361
362 /* Get the rem_frms_in_gop & the frms_in_gop from the pic_type state struct */
363 irc_pic_type_get_rem_frms_in_gop(ps_pic_handling, i4_rem_frms_in_period);
364 irc_pic_type_get_frms_in_gop(ps_pic_handling, i4_frms_in_period);
365
366 /* Depending on the number of gops in a period, find the num_frms_in_prd */
367 for(j = 0; j < MAX_PIC_TYPE; j++)
368 {
369 i4_rem_frms_in_period[j] += (i4_frms_in_period[j]
370 * (ps_bit_allocation->i4_num_gops_in_period - 1));
371 i4_frms_in_period[j] *= ps_bit_allocation->i4_num_gops_in_period;
372 }
373
374 /* Remove the header bits from the remaining bits to find how many bits you
375 can transfer.*/
376 SET_VAR_Q(vq_num_bits, 0, 0);
377 irc_ba_update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, vq_num_bits);
378 for(i = 0; i < MAX_PIC_TYPE; i++)
379 {
380 SET_VAR_Q(vq_rem_frms_in_period[i], i4_rem_frms_in_period[i], 0);
381 SET_VAR_Q(vq_prev_hdr_bits[i],
382 ps_bit_allocation->i4_prev_frm_header_bits[i], 0);
383 }
384 {
385 /*
386 *rem_texture_bits = rem_bits_in_period -
387 *(rem_frms_in_period[I_PIC] * prev_frm_header_bits[I_PIC]) -
388 *(rem_frms_in_period[P_PIC] * prev_frm_header_bits[P_PIC]) -
389 *(rem_frms_in_period[B_PIC] * prev_frm_header_bits[B_PIC]);
390 */
391 number_t vq_rem_hdr_bits;
392 vq_rem_texture_bits = ps_bit_allocation->s_rbip.vq_rem_bits_in_period;
393
394 mult32_var_q(vq_prev_hdr_bits[I_PIC], vq_rem_frms_in_period[I_PIC],
395 &vq_rem_hdr_bits);
396 sub32_var_q(vq_rem_texture_bits, vq_rem_hdr_bits, &vq_rem_texture_bits);
397
398 mult32_var_q(vq_prev_hdr_bits[P_PIC], vq_rem_frms_in_period[P_PIC],
399 &vq_rem_hdr_bits);
400 sub32_var_q(vq_rem_texture_bits, vq_rem_hdr_bits, &vq_rem_texture_bits);
401
402 mult32_var_q(vq_prev_hdr_bits[B_PIC], vq_rem_frms_in_period[B_PIC],
403 &vq_rem_hdr_bits);
404 sub32_var_q(vq_rem_texture_bits, vq_rem_hdr_bits, &vq_rem_texture_bits);
405 }
406 {
407 /* max_consumable_bits =
408 *(frms_in_period[I_PIC] * max_bits_per_frm[0] ) +
409 *(frms_in_period[P_PIC] + frms_in_period[B_PIC] ) * max_bits_per_frm[1];
410 */
411 number_t vq_max_bits, vq_max_bits_per_frm[2];
412
413 SET_VAR_Q(vq_max_bits_per_frm[0],
414 ps_bit_allocation->i4_max_bits_per_frm[0], 0);
415 SET_VAR_Q(vq_max_bits_per_frm[1],
416 ps_bit_allocation->i4_max_bits_per_frm[1], 0);
417
418 mult32_var_q(vq_rem_frms_in_period[I_PIC], vq_max_bits_per_frm[0],
419 &vq_max_bits);
420 vq_max_consumable_bits = vq_max_bits;
421
422 mult32_var_q(vq_rem_frms_in_period[P_PIC], vq_max_bits_per_frm[1],
423 &vq_max_bits);
424 add32_var_q(vq_max_bits, vq_max_consumable_bits,
425 &vq_max_consumable_bits);
426
427 mult32_var_q(vq_rem_frms_in_period[B_PIC], vq_max_bits_per_frm[1],
428 &vq_max_bits);
429 add32_var_q(vq_max_bits, vq_max_consumable_bits,
430 &vq_max_consumable_bits);
431 }
432
433 /* rem_texture_bits = MIN(rem_texture_bits, max_consumable_bits) */
434 MIN_VARQ(vq_max_consumable_bits, vq_rem_texture_bits, vq_rem_texture_bits);
435
436 /* The bits are then allocated based on the relative complexity of the
437 current frame with respect to that of the rest of the frames in period */
438 for(i = 0; i < MAX_PIC_TYPE; i++)
439 {
440 number_t vq_lin_mod_coeff, vq_est_sad, vq_K;
441
442 /* Getting the linear model coefficient */
443 vq_lin_mod_coeff = irc_get_linear_coefficient(pps_rd_model[i]);
444
445 /* Getting the estimated SAD */
446 SET_VAR_Q(vq_est_sad, irc_get_est_sad(ps_est_sad,i), 0);
447
448 /* Making K factor a var Q format */
449 SET_VAR_Q(vq_K, ps_bit_allocation->i2_K[i], K_Q);
450
451 /* Complexity_estimate = [ (lin_mod_coeff * estimated_sad) / K factor ] */
452 mult32_var_q(vq_lin_mod_coeff, vq_est_sad, &vq_lin_mod_coeff);
453 div32_var_q(vq_lin_mod_coeff, vq_K, &vq_complexity_estimate[i]);
454 }
455
456 /*
457 * For simple cases, one of the complexities go to zero and in those cases
458 * distribute the bits evenly among frames based on I_TO_P_RATIO
459 */
460
461 /* Also check the B-pictures complexity only in case they are present*/
462 if(i4_frms_in_period[B_PIC] == 0)
463 {
464 complexity_est = (vq_complexity_estimate[I_PIC]
465 && vq_complexity_estimate[P_PIC]);
466 }
467 else
468 {
469 complexity_est = (vq_complexity_estimate[I_PIC]
470 && vq_complexity_estimate[P_PIC]
471 && vq_complexity_estimate[B_PIC]);
472 }
473
474 if(complexity_est)
475 {
476 /*
477 * Estimated texture bits =
478 * (remaining bits) * (cur frm complexity)
479 * ---------------------------------------
480 * (num_i_frm*i_frm_complexity) + (num_p_frm*pfrm_complexity)
481 * + (b_frm * b_frm_cm)
482 */
483 mult32_var_q(vq_rem_texture_bits, vq_complexity_estimate[e_pic_type],
484 &vq_rem_texture_bits);
485
486 for(i = 0; i < MAX_PIC_TYPE; i++)
487 {
488 mult32_var_q(vq_rem_frms_in_period[i], vq_complexity_estimate[i],
489 &vq_rem_frms_in_period[i]);
490 }
491
492 add32_var_q(vq_rem_frms_in_period[I_PIC], vq_rem_frms_in_period[P_PIC],
493 &vq_rem_frms_in_period[I_PIC]);
494
495 add32_var_q(vq_rem_frms_in_period[I_PIC], vq_rem_frms_in_period[B_PIC],
496 &vq_rem_frms_in_period[I_PIC]);
497
498 div32_var_q(vq_rem_texture_bits, vq_rem_frms_in_period[I_PIC],
499 &vq_est_texture_bits_for_frm);
500
501 number_t_to_word32(vq_est_texture_bits_for_frm,
502 &i4_est_texture_bits_for_frm);
503 }
504 else
505 {
506 number_t vq_i_to_p_bit_ratio, vq_rem_frms;
507
508 SET_VAR_Q(vq_i_to_p_bit_ratio, I_TO_P_BIT_RATIO, 0);
509
510 /* rem_frms = ((I_TO_P_BIT_RATIO * rem_frms_in_period[I_PIC]) +
511 * rem_frms_in_period[P_PIC] + rem_frms_in_period[B_PIC]);
512 */
513 mult32_var_q(vq_rem_frms_in_period[I_PIC], vq_i_to_p_bit_ratio,
514 &vq_rem_frms);
515 add32_var_q(vq_rem_frms_in_period[P_PIC], vq_rem_frms, &vq_rem_frms);
516 add32_var_q(vq_rem_frms_in_period[B_PIC], vq_rem_frms, &vq_rem_frms);
517
518 /* est_texture_bits_for_frm = rem_texture_bits / rem_frms */
519 div32_var_q(vq_rem_texture_bits, vq_rem_frms,
520 &vq_est_texture_bits_for_frm);
521 number_t_to_word32(vq_est_texture_bits_for_frm,
522 &i4_est_texture_bits_for_frm);
523
524 i4_est_texture_bits_for_frm =
525 (I_PIC == e_pic_type) ?
526 (i4_est_texture_bits_for_frm
527 * I_TO_P_BIT_RATIO) :
528 i4_est_texture_bits_for_frm;
529 }
530
531 /*
532 * If the remaining bits in the period becomes negative then the estimated
533 * texture bits would also become negative. This would send a feedback to
534 * the model which may go for a toss. Thus sending the minimum possible
535 * value = 0
536 */
537 if(i4_est_texture_bits_for_frm < 0)
538 {
539 i4_est_texture_bits_for_frm = 0;
540 }
541
542 return (i4_est_texture_bits_for_frm);
543 }
544
545 /******************************************************************************
546 Function Name : irc_ba_get_cur_frm_est_header_bits
547 Description : Based on remaining bits in period and rd_model
548 the number of bits required for the current frame is estimated.
549 ******************************************************************************/
irc_ba_get_cur_frm_est_header_bits(bit_allocation_t * ps_bit_allocation,picture_type_e e_pic_type)550 WORD32 irc_ba_get_cur_frm_est_header_bits(bit_allocation_t *ps_bit_allocation,
551 picture_type_e e_pic_type)
552 {
553 return (ps_bit_allocation->i4_prev_frm_header_bits[e_pic_type]);
554 }
555
irc_ba_get_rem_bits_in_period(bit_allocation_t * ps_bit_allocation,pic_handling_handle ps_pic_handling)556 WORD32 irc_ba_get_rem_bits_in_period(bit_allocation_t *ps_bit_allocation,
557 pic_handling_handle ps_pic_handling)
558 {
559 WORD32 i4_rem_bits_in_gop = 0;
560
561 number_t vq_num_bits;
562 SET_VAR_Q(vq_num_bits, 0, 0);
563
564 irc_ba_update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, vq_num_bits);
565 number_t_to_word32(ps_bit_allocation->s_rbip.vq_rem_bits_in_period,
566 &i4_rem_bits_in_gop);
567 return (i4_rem_bits_in_gop);
568 }
569
570 /*******************************************************************************
571 Function Name : irc_ba_update_cur_frm_consumed_bits
572 Description : Based on remaining bits in period and rd_model
573 the number of bits required for the current frame is estimated.
574 ******************************************************************************/
irc_ba_update_cur_frm_consumed_bits(bit_allocation_t * ps_bit_allocation,pic_handling_handle ps_pic_handling,WORD32 i4_total_frame_bits,WORD32 i4_model_updation_hdr_bits,picture_type_e e_pic_type,UWORD8 u1_is_scd,WORD32 i4_last_frm_in_gop)575 void irc_ba_update_cur_frm_consumed_bits(bit_allocation_t *ps_bit_allocation,
576 pic_handling_handle ps_pic_handling,
577 WORD32 i4_total_frame_bits,
578 WORD32 i4_model_updation_hdr_bits,
579 picture_type_e e_pic_type,
580 UWORD8 u1_is_scd,
581 WORD32 i4_last_frm_in_gop)
582 {
583 WORD32 i4_error_bits = irc_get_error_bits(ps_bit_allocation->ps_error_bits);
584
585 /* Update the remaining bits in period */
586 number_t vq_num_bits;
587 SET_VAR_Q(vq_num_bits, (-i4_total_frame_bits + i4_error_bits), 0);
588
589 irc_ba_update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, vq_num_bits);
590
591 /*
592 * Update the header bits so that it can be used as an estimate to the next
593 * frame
594 */
595 if(u1_is_scd)
596 {
597 /*
598 * In case of SCD, even though the frame type is P, it is equivalent to
599 * a I frame and so the corresponding header bits is updated
600 */
601 ps_bit_allocation->i4_prev_frm_header_bits[I_PIC] =
602 i4_model_updation_hdr_bits;
603
604 #define MAX_NUM_GOPS_IN_PERIOD (3)
605 if(ps_bit_allocation->i4_num_gops_in_period < MAX_NUM_GOPS_IN_PERIOD)
606 {
607 /*
608 * Whenever there is a scene change increase the number of gops by
609 * 2 so that the number of bits allocated is not very constrained
610 */
611 ps_bit_allocation->i4_num_gops_in_period += 2;
612 /* Add the extra bits in GOP to remaining bits in period */
613 irc_ba_change_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling,
614 ps_bit_allocation->i4_bits_per_frm,
615 ps_bit_allocation->i4_num_gops_in_period);
616 }
617 }
618 else
619 {
620 ps_bit_allocation->i4_prev_frm_header_bits[e_pic_type] =
621 i4_model_updation_hdr_bits;
622 }
623
624 if(i4_last_frm_in_gop)
625 {
626 WORD32 i4_tot_frms_in_gop = get_number_of_frms_in_a_gop(
627 ps_pic_handling);
628 number_t vq_total_frms_in_gop, vq_bits_per_frm, vq_num_bits_in_gop;
629
630 SET_VAR_Q(vq_total_frms_in_gop, i4_tot_frms_in_gop, 0);
631 SET_VAR_Q(vq_bits_per_frm, ps_bit_allocation->i4_bits_per_frm, 0);
632
633 mult32_var_q(vq_bits_per_frm, vq_total_frms_in_gop,
634 &vq_num_bits_in_gop);
635 /*
636 * If the number of gops in period has been increased due to scene
637 * change, slowly bring in down across the gops
638 */
639 if(ps_bit_allocation->i4_num_gops_in_period
640 > ps_bit_allocation->i4_actual_num_gops_in_period)
641 {
642 ps_bit_allocation->i4_num_gops_in_period--;
643 irc_ba_change_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling,
644 ps_bit_allocation->i4_bits_per_frm,
645 ps_bit_allocation->i4_num_gops_in_period);
646 }
647 /*
648 * If rem_bits_in_period < 0 decrease the number of bits allocated for
649 * the next period else increase it
650 */
651 irc_ba_update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling,
652 vq_num_bits_in_gop);
653 }
654 /* Update the lower modules */
655 irc_update_error_bits(ps_bit_allocation->ps_error_bits);
656 }
657
irc_ba_change_remaining_bits_in_period(bit_allocation_t * ps_bit_allocation,pic_handling_handle ps_pic_handling,WORD32 i4_bit_rate,WORD32 i4_frame_rate,WORD32 * i4_peak_bit_rate)658 void irc_ba_change_remaining_bits_in_period(bit_allocation_t *ps_bit_allocation,
659 pic_handling_handle ps_pic_handling,
660 WORD32 i4_bit_rate,
661 WORD32 i4_frame_rate,
662 WORD32 *i4_peak_bit_rate)
663 {
664 WORD32 i4_new_avg_bits_per_frm;
665 WORD32 i4_new_peak_bits_per_frm[MAX_NUM_DRAIN_RATES];
666 WORD32 i4_rem_frms_in_period[MAX_PIC_TYPE];
667 int i;
668
669 /* Calculate the new per frame bits */
670 X_PROD_Y_DIV_Z(i4_bit_rate, 1000, i4_frame_rate, i4_new_avg_bits_per_frm);
671 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
672 {
673 X_PROD_Y_DIV_Z(i4_peak_bit_rate[i], 1000, i4_frame_rate,
674 i4_new_peak_bits_per_frm[i]);
675 }
676
677 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
678 {
679 ps_bit_allocation->i4_max_bits_per_frm[i] = i4_new_peak_bits_per_frm[i];
680 }
681
682 /*
683 * Get the rem_frms_in_prd & the frms_in_prd from the pic_type state
684 * struct
685 */
686 irc_pic_type_get_rem_frms_in_gop(ps_pic_handling, i4_rem_frms_in_period);
687
688 /*
689 * If the difference > 0(/ <0), the remaining bits in period needs to be
690 * increased(/decreased) based on the remaining number of frames
691 */
692 irc_ba_change_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling,
693 i4_new_avg_bits_per_frm,
694 ps_bit_allocation->i4_num_gops_in_period);
695
696 /* Update the new average bits per frame */
697 ps_bit_allocation->i4_bits_per_frm = i4_new_avg_bits_per_frm;
698 /* change the lower modules state */
699 irc_change_bitrate_in_error_bits(ps_bit_allocation->ps_error_bits,
700 i4_bit_rate);
701 irc_change_frm_rate_in_error_bits(ps_bit_allocation->ps_error_bits,
702 i4_frame_rate);
703
704 /* Store the modified frame_rate */
705 ps_bit_allocation->i4_frame_rate = i4_frame_rate;
706 ps_bit_allocation->i4_bit_rate = i4_bit_rate;
707 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
708 ps_bit_allocation->ai4_peak_bit_rate[i] = i4_peak_bit_rate[i];
709 }
710
irc_ba_change_ba_peak_bit_rate(bit_allocation_t * ps_bit_allocation,WORD32 * ai4_peak_bit_rate)711 void irc_ba_change_ba_peak_bit_rate(bit_allocation_t *ps_bit_allocation,
712 WORD32 *ai4_peak_bit_rate)
713 {
714 WORD32 i;
715
716 /* Calculate the bits per frame */
717 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
718 {
719 X_PROD_Y_DIV_Z(ai4_peak_bit_rate[i], 1000,
720 ps_bit_allocation->i4_frame_rate,
721 ps_bit_allocation->i4_max_bits_per_frm[i]);
722 ps_bit_allocation->ai4_peak_bit_rate[i] = ai4_peak_bit_rate[i];
723 }
724 }
725
726 /******************************************************************************
727 * @brief Modifies the remaining bit in period for the gop which has fif.
728 * since fif would cause a new gop to be created, we need to add the number
729 * of encoded frames in the fif GOP worth of bits to remaining bits in
730 * period
731 ******************************************************************************/
irc_ba_change_rem_bits_in_prd_at_force_I_frame(bit_allocation_t * ps_bit_allocation,pic_handling_handle ps_pic_handling)732 void irc_ba_change_rem_bits_in_prd_at_force_I_frame(bit_allocation_t *ps_bit_allocation,
733 pic_handling_handle ps_pic_handling)
734 {
735 WORD32 i4_frms_in_period;
736 number_t vq_frms_in_period, vq_bits_per_frm, vq_num_bits_in_period;
737
738 i4_frms_in_period = irc_pic_type_get_frms_in_gop_force_I_frm(
739 ps_pic_handling);
740 SET_VAR_Q(vq_frms_in_period, i4_frms_in_period, 0);
741 SET_VAR_Q(vq_bits_per_frm, ps_bit_allocation->i4_bits_per_frm, 0);
742
743 mult32_var_q(vq_bits_per_frm, vq_frms_in_period, &vq_num_bits_in_period);
744
745 irc_ba_update_rbip(&ps_bit_allocation->s_rbip, ps_pic_handling, vq_num_bits_in_period);
746 }
747
irc_ba_check_and_update_bit_allocation(bit_allocation_t * ps_bit_allocation,pic_handling_handle ps_pic_handling,WORD32 i4_cur_buf_size,WORD32 i4_max_buf_size,WORD32 i4_max_bits_inflow_per_frm,WORD32 i4_tot_frame_bits)748 void irc_ba_check_and_update_bit_allocation(bit_allocation_t *ps_bit_allocation,
749 pic_handling_handle ps_pic_handling,
750 WORD32 i4_cur_buf_size,
751 WORD32 i4_max_buf_size,
752 WORD32 i4_max_bits_inflow_per_frm,
753 WORD32 i4_tot_frame_bits)
754 {
755
756 number_t vq_max_drain_bits, vq_extra_bits, vq_less_bits,
757 vq_allocated_saved_bits, vq_min_bits_for_period;
758 WORD32 i4_num_frms_in_period = get_number_of_frms_in_a_gop(ps_pic_handling);
759 number_t vq_rem_bits_in_period, vq_num_frms_in_period, vq_zero;
760 WORD32 b_rem_bits_gt_max_drain, b_rem_bits_lt_min_bits,
761 b_saved_bits_gt_zero;
762 rem_bit_in_prd_t *ps_rbip = &ps_bit_allocation->s_rbip;
763
764 UNUSED(i4_cur_buf_size);
765 UNUSED(i4_max_buf_size);
766 UNUSED(i4_tot_frame_bits);
767
768 /*
769 * If the remaining bits is greater than what can be drained in that period
770 * Clip the remaining bits in period to the maximum it can drain in that
771 * period with the error of current buffer size.Accumulate the saved bits
772 * if any. else if the remaining bits is lesser than the minimum bit rate
773 * promised in that period Add the excess bits to remaining bits in period
774 * and reduce it from the saved bits Else Provide the extra bits from the
775 * "saved bits pool".
776 */
777 /*
778 * max_drain_bits = num_gops_in_period * num_frms_in_period *
779 * * max_bits_inflow_per_frm
780 */
781 SET_VAR_Q(vq_num_frms_in_period,
782 (ps_bit_allocation->i4_num_gops_in_period * i4_num_frms_in_period),
783 0);
784 SET_VAR_Q(vq_max_drain_bits, i4_max_bits_inflow_per_frm, 0);
785 SET_VAR_Q(vq_zero, 0, 0);
786 mult32_var_q(vq_max_drain_bits, vq_num_frms_in_period, &vq_max_drain_bits);
787
788 /*
789 * min_bits_for_period = num_gops_in_period * num_frms_in_period *
790 * min_bits_per_frm
791 */
792 SET_VAR_Q(vq_min_bits_for_period, ps_bit_allocation->i4_min_bits_per_frm,
793 0);
794 mult32_var_q(vq_min_bits_for_period, vq_num_frms_in_period,
795 &vq_min_bits_for_period);
796
797 vq_rem_bits_in_period = ps_rbip->vq_rem_bits_in_period;
798
799 /* Evaluate rem_bits_in_period > max_drain_bits */
800 VQ_A_GT_VQ_B(ps_rbip->vq_rem_bits_in_period, vq_max_drain_bits,
801 b_rem_bits_gt_max_drain);
802
803 /* Evaluate rem_bits_in_period < min_bits_for_period */
804 VQ_A_LT_VQ_B(ps_rbip->vq_rem_bits_in_period, vq_min_bits_for_period,
805 b_rem_bits_lt_min_bits);
806
807 /* Evaluate saved_bits > 0 */
808 VQ_A_LT_VQ_B(ps_bit_allocation->vq_saved_bits, vq_zero,
809 b_saved_bits_gt_zero);
810
811 /* (i4_rem_bits_in_period > i4_max_drain_bits) */
812 if(b_rem_bits_gt_max_drain)
813 {
814 /* extra_bits = rem_bits_in_period - max_drain_bits */
815 sub32_var_q(ps_rbip->vq_rem_bits_in_period, vq_max_drain_bits,
816 &vq_extra_bits);
817
818 /* saved_bits += extra_bits */
819 add32_var_q(ps_bit_allocation->vq_saved_bits, vq_extra_bits,
820 &ps_bit_allocation->vq_saved_bits);
821
822 /* rem_bits_in_period = vq_max_drain_bits */
823 ps_rbip->vq_rem_bits_in_period = vq_max_drain_bits;
824 }
825 else if(b_rem_bits_lt_min_bits)
826 {
827 /* extra_bits(-ve) = rem_bits_in_period - i4_min_bits_for_period */
828 sub32_var_q(ps_rbip->vq_rem_bits_in_period, vq_min_bits_for_period,
829 &vq_extra_bits);
830
831 /* saved_bits += extra_bits(-ve) */
832 add32_var_q(ps_bit_allocation->vq_saved_bits, vq_extra_bits,
833 &ps_bit_allocation->vq_saved_bits);
834
835 /* rem_bits_in_period = min_bits_for_period */
836 ps_rbip->vq_rem_bits_in_period = vq_min_bits_for_period;
837 }
838 else if(b_saved_bits_gt_zero)
839 {
840 /* less_bits = max_drain_bits - _rem_bits_in_period */
841 sub32_var_q(vq_max_drain_bits, vq_rem_bits_in_period, &vq_less_bits);
842
843 /* allocated_saved_bits = MIN (less_bits, saved_bits) */
844 MIN_VARQ(ps_bit_allocation->vq_saved_bits, vq_less_bits,
845 vq_allocated_saved_bits);
846
847 /* rem_bits_in_period += allocted_save_bits */
848 add32_var_q(ps_rbip->vq_rem_bits_in_period, vq_allocated_saved_bits,
849 &ps_rbip->vq_rem_bits_in_period);
850
851 /* saved_bits -= allocted_save_bits */
852 sub32_var_q(ps_bit_allocation->vq_saved_bits, vq_allocated_saved_bits,
853 &ps_bit_allocation->vq_saved_bits);
854 }
855 return;
856 }
857
irc_ba_get_frame_rate(bit_allocation_t * ps_bit_allocation)858 WORD32 irc_ba_get_frame_rate(bit_allocation_t *ps_bit_allocation)
859 {
860 return (ps_bit_allocation->i4_frame_rate);
861 }
862
irc_ba_get_bit_rate(bit_allocation_t * ps_bit_allocation)863 WORD32 irc_ba_get_bit_rate(bit_allocation_t *ps_bit_allocation)
864 {
865 return (ps_bit_allocation->i4_bit_rate);
866 }
867
irc_ba_get_peak_bit_rate(bit_allocation_t * ps_bit_allocation,WORD32 * pi4_peak_bit_rate)868 void irc_ba_get_peak_bit_rate(bit_allocation_t *ps_bit_allocation,
869 WORD32 *pi4_peak_bit_rate)
870 {
871 WORD32 i;
872 for(i = 0; i < MAX_NUM_DRAIN_RATES; i++)
873 {
874 pi4_peak_bit_rate[i] = ps_bit_allocation->ai4_peak_bit_rate[i];
875 }
876 }
877