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