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 Name : irc_rd_model.c */ 23 /* */ 24 /* Description : Implall the Functions to Model the */ 25 /* Rate Distortion Behaviour of the Codec over the Last */ 26 /* Few Frames. */ 27 /* */ 28 /* List of Functions : irc_update_frame_rd_model */ 29 /* estimate_mpeg2_qp_for_resbits */ 30 /* */ 31 /* Issues / Problems : None */ 32 /* */ 33 /* Revision History : */ 34 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 35 /* 21 06 2006 Sarat Initial Version */ 36 /****************************************************************************/ 37 38 /* System include files */ 39 #include <stdarg.h> 40 #include <stdlib.h> 41 #include <stdio.h> 42 #include <string.h> 43 #include "math.h" 44 45 /* User include files */ 46 #include "irc_datatypes.h" 47 #include "irc_common.h" 48 #include "irc_mem_req_and_acq.h" 49 #include "irc_rd_model.h" 50 #include "irc_rd_model_struct.h" 51 52 53 WORD32 irc_rd_model_num_fill_use_free_memtab(rc_rd_model_t **pps_rc_rd_model, 54 itt_memtab_t *ps_memtab, 55 ITT_FUNC_TYPE_E e_func_type) 56 { 57 WORD32 i4_mem_tab_idx = 0; 58 rc_rd_model_t s_rc_rd_model_temp; 59 60 /* 61 * Hack for al alloc, during which we don't have any state memory. 62 * Dereferencing can cause issues 63 */ 64 if(e_func_type == GET_NUM_MEMTAB || e_func_type == FILL_MEMTAB) 65 (*pps_rc_rd_model) = &s_rc_rd_model_temp; 66 67 /*for src rate control state structure*/ 68 if(e_func_type != GET_NUM_MEMTAB) 69 { 70 fill_memtab(&ps_memtab[i4_mem_tab_idx], sizeof(rc_rd_model_t), 71 ALIGN_128_BYTE, PERSISTENT, DDR); 72 use_or_fill_base(&ps_memtab[0], (void**)pps_rc_rd_model, e_func_type); 73 } 74 i4_mem_tab_idx++; 75 76 return (i4_mem_tab_idx); 77 } 78 79 void irc_init_frm_rc_rd_model(rc_rd_model_t *ps_rd_model, 80 UWORD8 u1_max_frames_modelled) 81 { 82 83 ps_rd_model->u1_num_frms_in_model = 0; 84 ps_rd_model->u1_curr_frm_counter = 0; 85 ps_rd_model->u1_max_frms_to_model = u1_max_frames_modelled; 86 87 ps_rd_model->model_coeff_a_lin_wo_int = 0; 88 ps_rd_model->model_coeff_b_lin_wo_int = 0; 89 ps_rd_model->model_coeff_c_lin_wo_int = 0; 90 } 91 92 void irc_reset_frm_rc_rd_model(rc_rd_model_t *ps_rd_model) 93 { 94 ps_rd_model->u1_num_frms_in_model = 0; 95 ps_rd_model->u1_curr_frm_counter = 0; 96 97 ps_rd_model->model_coeff_a_lin_wo_int = 0; 98 ps_rd_model->model_coeff_b_lin_wo_int = 0; 99 ps_rd_model->model_coeff_c_lin_wo_int = 0; 100 } 101 102 static UWORD8 find_model_coeffs(UWORD32 *pi4_res_bits, 103 UWORD32 *pi4_sad_h264, 104 UWORD8 *pu1_num_skips, 105 UWORD8 *pui_avg_mpeg2_qp, 106 UWORD8 u1_num_frms, 107 UWORD8 u1_model_used, 108 WORD8 *pi1_frame_index, 109 model_coeff *pmc_model_coeff, 110 model_coeff *pmc_model_coeff_lin, 111 model_coeff *pmc_model_coeff_lin_wo_int, 112 rc_rd_model_t *ps_rd_model) 113 { 114 UWORD32 i; 115 UWORD8 u1_num_frms_used = 0; 116 UWORD8 u1_frm_indx; 117 118 float sum_y = 0; 119 float sum_x_y = 0; 120 float sum_x2_y = 0; 121 float sum_x = 0; 122 float sum_x2 = 0; 123 float sum_x3 = 0; 124 float sum_x4 = 0; 125 126 float x0, y0; 127 float model_coeff_a = 0.0, model_coeff_b = 0.0, model_coeff_c = 0.0; 128 129 #if !(ENABLE_QUAD_RC_MODEL||ENABLE_LIN_MODEL_WITH_INTERCEPT) 130 UNUSED(pu1_num_skips); 131 UNUSED(pmc_model_coeff); 132 UNUSED(pmc_model_coeff_lin); 133 #endif 134 135 for(i = 0; i < u1_num_frms; i++) 136 { 137 if(-1 == pi1_frame_index[i]) 138 continue; 139 140 u1_frm_indx = (UWORD8)pi1_frame_index[i]; 141 142 y0 = (float)(pi4_res_bits[u1_frm_indx]); 143 x0 = (float)(pi4_sad_h264[u1_frm_indx] 144 / (float)pui_avg_mpeg2_qp[u1_frm_indx]); 145 146 sum_y += y0; 147 sum_x_y += x0 * y0; 148 sum_x2_y += x0 * x0 * y0; 149 sum_x += x0; 150 sum_x2 += x0 * x0; 151 sum_x3 += x0 * x0 * x0; 152 sum_x4 += x0 * x0 * x0 * x0; 153 u1_num_frms_used++; 154 } 155 156 sum_y /= u1_num_frms_used; 157 sum_x_y /= u1_num_frms_used; 158 sum_x2_y /= u1_num_frms_used; 159 sum_x /= u1_num_frms_used; 160 sum_x2 /= u1_num_frms_used; 161 sum_x3 /= u1_num_frms_used; 162 sum_x4 /= u1_num_frms_used; 163 164 { 165 UWORD8 u1_curr_frame_index; 166 UWORD8 u1_avgqp_prvfrm; 167 UWORD32 u4_prevfrm_bits, u4_prevfrm_sad; 168 169 u1_curr_frame_index = ps_rd_model->u1_curr_frm_counter; 170 if(0 == u1_curr_frame_index) 171 u1_curr_frame_index = (MAX_FRAMES_MODELLED - 1); 172 else 173 u1_curr_frame_index--; 174 175 u1_avgqp_prvfrm = ps_rd_model->pu1_avg_qp[u1_curr_frame_index]; 176 u4_prevfrm_bits = ps_rd_model->pi4_res_bits[u1_curr_frame_index]; 177 u4_prevfrm_sad = ps_rd_model->pi4_sad[u1_curr_frame_index]; 178 179 if(0 != u4_prevfrm_sad) 180 model_coeff_a = (float)(u4_prevfrm_bits * u1_avgqp_prvfrm) 181 / u4_prevfrm_sad; 182 else 183 model_coeff_a = 0; 184 185 model_coeff_b = 0; 186 model_coeff_c = 0; 187 188 pmc_model_coeff_lin_wo_int[0] = model_coeff_b; 189 pmc_model_coeff_lin_wo_int[1] = model_coeff_a; 190 pmc_model_coeff_lin_wo_int[2] = model_coeff_c; 191 } 192 193 return u1_model_used; 194 } 195 196 static void irc_update_frame_rd_model(rc_rd_model_t *ps_rd_model) 197 { 198 WORD8 pi1_frame_index[MAX_FRAMES_MODELLED], 199 pi1_frame_index_initial[MAX_FRAMES_MODELLED]; 200 201 UWORD8 u1_num_skips_temp; 202 UWORD8 u1_avg_mpeg2_qp_temp, u1_min_mpeg2_qp, u1_max_mpeg2_qp; 203 UWORD8 u1_num_frms_input, u1_num_active_frames, u1_reject_frame; 204 UWORD32 u4_num_skips; 205 206 UWORD8 u1_min2_mpeg2_qp, u1_max2_mpeg2_qp; 207 UWORD8 u1_min_qp_frame_indx, u1_max_qp_frame_indx; 208 UWORD8 pu1_num_frames[MPEG2_QP_ELEM]; 209 model_coeff model_coeff_array[3], model_coeff_array_lin[3], 210 model_coeff_array_lin_wo_int[3]; 211 UWORD32 i; 212 UWORD8 u1_curr_frame_index; 213 214 u1_curr_frame_index = ps_rd_model->u1_curr_frm_counter; 215 216 ps_rd_model->u1_model_used = PREV_FRAME_MODEL; 217 218 if(0 == u1_curr_frame_index) 219 u1_curr_frame_index = (MAX_FRAMES_MODELLED - 1); 220 else 221 u1_curr_frame_index--; 222 223 /************************************************************************/ 224 /* Rearrange data to be fed into a Linear Regression Module */ 225 /* Module finds a,b,c such that */ 226 /* y = ax + bx^2 + c */ 227 /************************************************************************/ 228 u4_num_skips = 0; 229 u1_num_frms_input = 0; 230 memset(pu1_num_frames, 0, MPEG2_QP_ELEM); 231 memset(pi1_frame_index, -1, MAX_FRAMES_MODELLED); 232 u1_min_mpeg2_qp = MAX_MPEG2_QP; 233 u1_max_mpeg2_qp = 0; 234 235 u1_num_active_frames = ps_rd_model->u1_num_frms_in_model; 236 if(u1_num_active_frames > MAX_ACTIVE_FRAMES) 237 { 238 u1_num_active_frames = MAX_ACTIVE_FRAMES; 239 } 240 241 /************************************************************************/ 242 /* Choose the set of Points to be used for MSE fit of Quadratic model */ 243 /* Points chosen are spread across the Qp range. Max of 2 points are */ 244 /* chosen for a Qp. */ 245 /************************************************************************/ 246 for(i = 0; i < u1_num_active_frames; i++) 247 { 248 u1_reject_frame = 0; 249 u1_num_skips_temp = ps_rd_model->pu1_num_skips[u1_curr_frame_index]; 250 u1_avg_mpeg2_qp_temp = ps_rd_model->pu1_avg_qp[u1_curr_frame_index]; 251 252 if((0 == u4_num_skips) && (0 != u1_num_skips_temp)) 253 u1_reject_frame = 1; 254 if((1 == u4_num_skips) && (u1_num_skips_temp > 1)) 255 u1_reject_frame = 1; 256 if(pu1_num_frames[u1_avg_mpeg2_qp_temp] >= 2) 257 u1_reject_frame = 1; 258 259 if(0 == i) 260 u1_reject_frame = 0; 261 262 if(0 == u1_reject_frame) 263 { 264 pi1_frame_index[u1_num_frms_input] = (WORD8)u1_curr_frame_index; 265 pu1_num_frames[u1_avg_mpeg2_qp_temp] += 1; 266 267 if(u1_min_mpeg2_qp > u1_avg_mpeg2_qp_temp) 268 u1_min_mpeg2_qp = u1_avg_mpeg2_qp_temp; 269 if(u1_max_mpeg2_qp < u1_avg_mpeg2_qp_temp) 270 u1_max_mpeg2_qp = u1_avg_mpeg2_qp_temp; 271 272 u1_num_frms_input++; 273 } 274 275 if(0 == u1_curr_frame_index) 276 u1_curr_frame_index = (MAX_FRAMES_MODELLED - 1); 277 else 278 u1_curr_frame_index--; 279 } 280 281 /************************************************************************/ 282 /* Add Pivot Points to the Data set to be used for finding Quadratic */ 283 /* Model Coeffs. These will help in constraining the shape of Quadratic*/ 284 /* to adapt too much to the Local deviations. */ 285 /************************************************************************/ 286 u1_min2_mpeg2_qp = u1_min_mpeg2_qp; 287 u1_max2_mpeg2_qp = u1_max_mpeg2_qp; 288 u1_min_qp_frame_indx = INVALID_FRAME_INDEX; 289 u1_max_qp_frame_indx = INVALID_FRAME_INDEX; 290 291 /* Loop runnning over the Stored Frame Level Data 292 to find frames of MinQp and MaxQp */ 293 for(; i < ps_rd_model->u1_num_frms_in_model; i++) 294 { 295 u1_num_skips_temp = ps_rd_model->pu1_num_skips[u1_curr_frame_index]; 296 u1_avg_mpeg2_qp_temp = ps_rd_model->pu1_avg_qp[u1_curr_frame_index]; 297 298 if(((0 == u4_num_skips) && (0 != u1_num_skips_temp)) 299 || ((1 == u4_num_skips) && (u1_num_skips_temp > 1))) 300 continue; 301 302 if(u1_min2_mpeg2_qp > u1_avg_mpeg2_qp_temp) 303 { 304 u1_min2_mpeg2_qp = u1_avg_mpeg2_qp_temp; 305 u1_min_qp_frame_indx = u1_curr_frame_index; 306 } 307 if(u1_max2_mpeg2_qp < u1_avg_mpeg2_qp_temp) 308 { 309 u1_max2_mpeg2_qp = u1_avg_mpeg2_qp_temp; 310 u1_max_qp_frame_indx = u1_curr_frame_index; 311 } 312 if(0 == u1_curr_frame_index) 313 u1_curr_frame_index = (MAX_FRAMES_MODELLED - 1); 314 else 315 u1_curr_frame_index--; 316 } 317 318 /* Add the Chosen Points to the regression data set */ 319 if(INVALID_FRAME_INDEX != u1_min_qp_frame_indx) 320 { 321 pi1_frame_index[u1_num_frms_input] = (WORD8)u1_min_qp_frame_indx; 322 u1_num_frms_input++; 323 } 324 if(INVALID_FRAME_INDEX != u1_max_qp_frame_indx) 325 { 326 pi1_frame_index[u1_num_frms_input] = (WORD8)u1_max_qp_frame_indx; 327 u1_num_frms_input++; 328 } 329 memcpy(pi1_frame_index_initial, pi1_frame_index, MAX_FRAMES_MODELLED); 330 331 /***** Call the Module to Return the Coeffs for the Fed Data *****/ 332 ps_rd_model->u1_model_used = find_model_coeffs(ps_rd_model->pi4_res_bits, 333 ps_rd_model->pi4_sad, 334 ps_rd_model->pu1_num_skips, 335 ps_rd_model->pu1_avg_qp, 336 u1_num_frms_input, 337 ps_rd_model->u1_model_used, 338 pi1_frame_index, 339 model_coeff_array, 340 model_coeff_array_lin, 341 model_coeff_array_lin_wo_int, 342 ps_rd_model); 343 344 ps_rd_model->model_coeff_b_lin_wo_int = model_coeff_array_lin_wo_int[0]; 345 ps_rd_model->model_coeff_a_lin_wo_int = model_coeff_array_lin_wo_int[1]; 346 ps_rd_model->model_coeff_c_lin_wo_int = model_coeff_array_lin_wo_int[2]; 347 } 348 349 UWORD32 irc_estimate_bits_for_qp(rc_rd_model_t *ps_rd_model, 350 UWORD32 u4_estimated_sad, 351 UWORD8 u1_avg_qp) 352 { 353 float fl_num_bits = 0; 354 355 fl_num_bits = ps_rd_model->model_coeff_a_lin_wo_int 356 * ((float)(u4_estimated_sad / u1_avg_qp)); 357 358 return ((UWORD32)fl_num_bits); 359 } 360 361 UWORD8 irc_find_qp_for_target_bits(rc_rd_model_t *ps_rd_model, 362 UWORD32 u4_target_res_bits, 363 UWORD32 u4_estimated_sad, 364 UWORD8 u1_min_qp, 365 UWORD8 u1_max_qp) 366 { 367 UWORD8 u1_qp; 368 float x_value = 1.0, f_qp; 369 370 ps_rd_model->u1_model_used = PREV_FRAME_MODEL; 371 372 { 373 x_value = (float)u4_target_res_bits 374 / ps_rd_model->model_coeff_a_lin_wo_int; 375 } 376 377 if(0 != x_value) 378 f_qp = u4_estimated_sad / x_value; 379 else 380 f_qp = 255; 381 382 if(f_qp > 255) 383 f_qp = 255; 384 385 /* Truncating the QP to the Max and Min Qp values possible */ 386 if(f_qp < u1_min_qp) 387 f_qp = u1_min_qp; 388 if(f_qp > u1_max_qp) 389 f_qp = u1_max_qp; 390 391 u1_qp = (UWORD8)(f_qp + 0.5); 392 393 return u1_qp; 394 } 395 396 void irc_add_frame_to_rd_model(rc_rd_model_t *ps_rd_model, 397 UWORD32 i4_res_bits, 398 UWORD8 u1_avg_mp2qp, 399 UWORD32 i4_sad_h264, 400 UWORD8 u1_num_skips) 401 { 402 UWORD8 u1_curr_frame_index; 403 u1_curr_frame_index = ps_rd_model->u1_curr_frm_counter; 404 405 /*Insert the Present Frame Data into the RD Model State Memory*/ 406 ps_rd_model->pi4_res_bits[u1_curr_frame_index] = i4_res_bits; 407 ps_rd_model->pi4_sad[u1_curr_frame_index] = i4_sad_h264; 408 ps_rd_model->pu1_num_skips[u1_curr_frame_index] = u1_num_skips; 409 ps_rd_model->pu1_avg_qp[u1_curr_frame_index] = u1_avg_mp2qp; 410 411 ps_rd_model->u1_curr_frm_counter++; 412 if(MAX_FRAMES_MODELLED == ps_rd_model->u1_curr_frm_counter) 413 ps_rd_model->u1_curr_frm_counter = 0; 414 415 if(ps_rd_model->u1_num_frms_in_model < ps_rd_model->u1_max_frms_to_model) 416 { 417 ps_rd_model->u1_num_frms_in_model++; 418 } 419 irc_update_frame_rd_model(ps_rd_model); 420 } 421 422 /***************************************************************************** 423 *Function Name : irc_calc_per_frm_bits 424 *Description : 425 *Inputs : pu2_num_pics_of_a_pic_type 426 * - pointer to RC api pointer 427 * pu2_num_pics_of_a_pic_type 428 * - N1, N2,...Nk 429 * pu1_update_pic_type_model 430 * - flag which tells whether or not to update model 431 * coefficients of a particular pic-type 432 * u1_num_pic_types 433 * - value of k 434 * pu4_num_skip_of_a_pic_type 435 * - the number of skips of that pic-type. It "may" be used to 436 * update the model coefficients at a later point. Right now 437 * it is not being used at all. 438 * u1_base_pic_type 439 * - base pic type index wrt which alpha & beta are calculated 440 * pfl_gamma 441 * - gamma_i = beta_i / alpha_i 442 * pfl_eta 443 * - 444 * u1_curr_pic_type 445 * - the current pic-type for which the targetted bits need to 446 * be computed 447 * u4_bits_for_sub_gop 448 * - the number of bits to be consumed for the remaining part of 449 * sub-gop 450 * u4_curr_estimated_sad 451 * - 452 * pu1_curr_pic_type_qp 453 * - output of this function 454 *****************************************************************************/ 455 456 WORD32 irc_calc_per_frm_bits(rc_rd_model_t *ps_rd_model, 457 UWORD16 *pu2_num_pics_of_a_pic_type, 458 UWORD8 *pu1_update_pic_type_model, 459 UWORD8 u1_num_pic_types, 460 UWORD32 *pu4_num_skip_of_a_pic_type, 461 UWORD8 u1_base_pic_type, 462 float *pfl_gamma, 463 float *pfl_eta, 464 UWORD8 u1_curr_pic_type, 465 UWORD32 u4_bits_for_sub_gop, 466 UWORD32 u4_curr_estimated_sad, 467 UWORD8 *pu1_curr_pic_type_qp) 468 { 469 WORD32 i4_per_frm_bits_Ti; 470 UWORD8 u1_i; 471 rc_rd_model_t *ps_rd_model_of_pic_type; 472 473 UNUSED(pu4_num_skip_of_a_pic_type); 474 UNUSED(u1_base_pic_type); 475 476 /* First part of this function updates all the model coefficients */ 477 /*for all the pic-types */ 478 { 479 for(u1_i = 0; u1_i < u1_num_pic_types; u1_i++) 480 { 481 if((0 != pu2_num_pics_of_a_pic_type[u1_i]) 482 && (1 == pu1_update_pic_type_model[u1_i])) 483 { 484 irc_update_frame_rd_model(&ps_rd_model[u1_i]); 485 } 486 } 487 } 488 489 /* 490 * The second part of this function deals with solving the 491 * equation using all the pic-types models 492 */ 493 { 494 UWORD8 u1_combined_model_used; 495 496 /* solve the equation */ 497 { 498 model_coeff eff_A; 499 float fl_sad_by_qp_base; 500 float fl_sad_by_qp_curr_frm = 1.0; 501 float fl_qp_curr_frm; 502 float fl_bits_for_curr_frm = 0; 503 504 505 506 /* If the combined chosen model is linear model without an intercept */ 507 508 u1_combined_model_used = PREV_FRAME_MODEL; 509 { 510 eff_A = 0.0; 511 512 for(u1_i = 0; u1_i < u1_num_pic_types; u1_i++) 513 { 514 ps_rd_model_of_pic_type = ps_rd_model + u1_i; 515 516 eff_A += ((pfl_eta[u1_i] 517 + pu2_num_pics_of_a_pic_type[u1_i]- 1) 518 * ps_rd_model_of_pic_type->model_coeff_a_lin_wo_int 519 * pfl_gamma[u1_i]); 520 } 521 522 fl_sad_by_qp_base = u4_bits_for_sub_gop / eff_A; 523 524 fl_sad_by_qp_curr_frm = fl_sad_by_qp_base 525 * pfl_gamma[u1_curr_pic_type] 526 * pfl_eta[u1_curr_pic_type]; 527 528 ps_rd_model_of_pic_type = ps_rd_model + u1_curr_pic_type; 529 530 fl_bits_for_curr_frm = 531 ps_rd_model_of_pic_type->model_coeff_a_lin_wo_int 532 * fl_sad_by_qp_curr_frm; 533 } 534 535 /* 536 * Store the model that was finally used to calculate Qp. 537 * This is so that the same model is used in further calculations 538 * for this picture. 539 */ 540 ps_rd_model_of_pic_type = ps_rd_model + u1_curr_pic_type; 541 ps_rd_model_of_pic_type->u1_model_used = u1_combined_model_used; 542 543 i4_per_frm_bits_Ti = (WORD32)(fl_bits_for_curr_frm + 0.5); 544 545 if(fl_sad_by_qp_curr_frm > 0) 546 fl_qp_curr_frm = (float)u4_curr_estimated_sad 547 / fl_sad_by_qp_curr_frm; 548 else 549 fl_qp_curr_frm = 255; 550 551 if(fl_qp_curr_frm > 255) 552 fl_qp_curr_frm = 255; 553 554 *pu1_curr_pic_type_qp = (fl_qp_curr_frm + 0.5); 555 556 } 557 } 558 return (i4_per_frm_bits_Ti); 559 } 560 561 model_coeff irc_get_linear_coefficient(rc_rd_model_t *ps_rd_model) 562 { 563 return (ps_rd_model->model_coeff_a_lin_wo_int); 564 } 565 566 567
