1 /* 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 12 #include <stdlib.h> 13 #include <stdio.h> 14 #include <string.h> 15 #include <limits.h> 16 #include <assert.h> 17 18 #include "math.h" 19 #include "vp8/common/common.h" 20 #include "ratectrl.h" 21 #include "vp8/common/entropymode.h" 22 #include "vpx_mem/vpx_mem.h" 23 #include "vp8/common/systemdependent.h" 24 #include "encodemv.h" 25 26 27 #define MIN_BPB_FACTOR 0.01 28 #define MAX_BPB_FACTOR 50 29 30 extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES]; 31 32 33 34 #ifdef MODE_STATS 35 extern int y_modes[5]; 36 extern int uv_modes[4]; 37 extern int b_modes[10]; 38 39 extern int inter_y_modes[10]; 40 extern int inter_uv_modes[4]; 41 extern int inter_b_modes[10]; 42 #endif 43 44 /* Bits Per MB at different Q (Multiplied by 512) */ 45 #define BPER_MB_NORMBITS 9 46 47 /* Work in progress recalibration of baseline rate tables based on 48 * the assumption that bits per mb is inversely proportional to the 49 * quantizer value. 50 */ 51 const int vp8_bits_per_mb[2][QINDEX_RANGE] = 52 { 53 /* Intra case 450000/Qintra */ 54 { 55 1125000,900000, 750000, 642857, 562500, 500000, 450000, 450000, 56 409090, 375000, 346153, 321428, 300000, 281250, 264705, 264705, 57 250000, 236842, 225000, 225000, 214285, 214285, 204545, 204545, 58 195652, 195652, 187500, 180000, 180000, 173076, 166666, 160714, 59 155172, 150000, 145161, 140625, 136363, 132352, 128571, 125000, 60 121621, 121621, 118421, 115384, 112500, 109756, 107142, 104651, 61 102272, 100000, 97826, 97826, 95744, 93750, 91836, 90000, 62 88235, 86538, 84905, 83333, 81818, 80357, 78947, 77586, 63 76271, 75000, 73770, 72580, 71428, 70312, 69230, 68181, 64 67164, 66176, 65217, 64285, 63380, 62500, 61643, 60810, 65 60000, 59210, 59210, 58441, 57692, 56962, 56250, 55555, 66 54878, 54216, 53571, 52941, 52325, 51724, 51136, 50561, 67 49450, 48387, 47368, 46875, 45918, 45000, 44554, 44117, 68 43269, 42452, 41666, 40909, 40178, 39473, 38793, 38135, 69 36885, 36290, 35714, 35156, 34615, 34090, 33582, 33088, 70 32608, 32142, 31468, 31034, 30405, 29801, 29220, 28662, 71 }, 72 /* Inter case 285000/Qinter */ 73 { 74 712500, 570000, 475000, 407142, 356250, 316666, 285000, 259090, 75 237500, 219230, 203571, 190000, 178125, 167647, 158333, 150000, 76 142500, 135714, 129545, 123913, 118750, 114000, 109615, 105555, 77 101785, 98275, 95000, 91935, 89062, 86363, 83823, 81428, 78 79166, 77027, 75000, 73076, 71250, 69512, 67857, 66279, 79 64772, 63333, 61956, 60638, 59375, 58163, 57000, 55882, 80 54807, 53773, 52777, 51818, 50892, 50000, 49137, 47500, 81 45967, 44531, 43181, 41911, 40714, 39583, 38513, 37500, 82 36538, 35625, 34756, 33928, 33139, 32386, 31666, 30978, 83 30319, 29687, 29081, 28500, 27941, 27403, 26886, 26388, 84 25909, 25446, 25000, 24568, 23949, 23360, 22800, 22265, 85 21755, 21268, 20802, 20357, 19930, 19520, 19127, 18750, 86 18387, 18037, 17701, 17378, 17065, 16764, 16473, 16101, 87 15745, 15405, 15079, 14766, 14467, 14179, 13902, 13636, 88 13380, 13133, 12895, 12666, 12445, 12179, 11924, 11632, 89 11445, 11220, 11003, 10795, 10594, 10401, 10215, 10035, 90 } 91 }; 92 93 static const int kf_boost_qadjustment[QINDEX_RANGE] = 94 { 95 128, 129, 130, 131, 132, 133, 134, 135, 96 136, 137, 138, 139, 140, 141, 142, 143, 97 144, 145, 146, 147, 148, 149, 150, 151, 98 152, 153, 154, 155, 156, 157, 158, 159, 99 160, 161, 162, 163, 164, 165, 166, 167, 100 168, 169, 170, 171, 172, 173, 174, 175, 101 176, 177, 178, 179, 180, 181, 182, 183, 102 184, 185, 186, 187, 188, 189, 190, 191, 103 192, 193, 194, 195, 196, 197, 198, 199, 104 200, 200, 201, 201, 202, 203, 203, 203, 105 204, 204, 205, 205, 206, 206, 207, 207, 106 208, 208, 209, 209, 210, 210, 211, 211, 107 212, 212, 213, 213, 214, 214, 215, 215, 108 216, 216, 217, 217, 218, 218, 219, 219, 109 220, 220, 220, 220, 220, 220, 220, 220, 110 220, 220, 220, 220, 220, 220, 220, 220, 111 }; 112 113 /* #define GFQ_ADJUSTMENT (Q+100) */ 114 #define GFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q] 115 const int vp8_gf_boost_qadjustment[QINDEX_RANGE] = 116 { 117 80, 82, 84, 86, 88, 90, 92, 94, 118 96, 97, 98, 99, 100, 101, 102, 103, 119 104, 105, 106, 107, 108, 109, 110, 111, 120 112, 113, 114, 115, 116, 117, 118, 119, 121 120, 121, 122, 123, 124, 125, 126, 127, 122 128, 129, 130, 131, 132, 133, 134, 135, 123 136, 137, 138, 139, 140, 141, 142, 143, 124 144, 145, 146, 147, 148, 149, 150, 151, 125 152, 153, 154, 155, 156, 157, 158, 159, 126 160, 161, 162, 163, 164, 165, 166, 167, 127 168, 169, 170, 171, 172, 173, 174, 175, 128 176, 177, 178, 179, 180, 181, 182, 183, 129 184, 184, 185, 185, 186, 186, 187, 187, 130 188, 188, 189, 189, 190, 190, 191, 191, 131 192, 192, 193, 193, 194, 194, 194, 194, 132 195, 195, 196, 196, 197, 197, 198, 198 133 }; 134 135 /* 136 const int vp8_gf_boost_qadjustment[QINDEX_RANGE] = 137 { 138 100,101,102,103,104,105,105,106, 139 106,107,107,108,109,109,110,111, 140 112,113,114,115,116,117,118,119, 141 120,121,122,123,124,125,126,127, 142 128,129,130,131,132,133,134,135, 143 136,137,138,139,140,141,142,143, 144 144,145,146,147,148,149,150,151, 145 152,153,154,155,156,157,158,159, 146 160,161,162,163,164,165,166,167, 147 168,169,170,170,171,171,172,172, 148 173,173,173,174,174,174,175,175, 149 175,176,176,176,177,177,177,177, 150 178,178,179,179,180,180,181,181, 151 182,182,183,183,184,184,185,185, 152 186,186,187,187,188,188,189,189, 153 190,190,191,191,192,192,193,193, 154 }; 155 */ 156 157 static const int kf_gf_boost_qlimits[QINDEX_RANGE] = 158 { 159 150, 155, 160, 165, 170, 175, 180, 185, 160 190, 195, 200, 205, 210, 215, 220, 225, 161 230, 235, 240, 245, 250, 255, 260, 265, 162 270, 275, 280, 285, 290, 295, 300, 305, 163 310, 320, 330, 340, 350, 360, 370, 380, 164 390, 400, 410, 420, 430, 440, 450, 460, 165 470, 480, 490, 500, 510, 520, 530, 540, 166 550, 560, 570, 580, 590, 600, 600, 600, 167 600, 600, 600, 600, 600, 600, 600, 600, 168 600, 600, 600, 600, 600, 600, 600, 600, 169 600, 600, 600, 600, 600, 600, 600, 600, 170 600, 600, 600, 600, 600, 600, 600, 600, 171 600, 600, 600, 600, 600, 600, 600, 600, 172 600, 600, 600, 600, 600, 600, 600, 600, 173 600, 600, 600, 600, 600, 600, 600, 600, 174 600, 600, 600, 600, 600, 600, 600, 600, 175 }; 176 177 /* % adjustment to target kf size based on seperation from previous frame */ 178 static const int kf_boost_seperation_adjustment[16] = 179 { 180 30, 40, 50, 55, 60, 65, 70, 75, 181 80, 85, 90, 95, 100, 100, 100, 100, 182 }; 183 184 185 static const int gf_adjust_table[101] = 186 { 187 100, 188 115, 130, 145, 160, 175, 190, 200, 210, 220, 230, 189 240, 260, 270, 280, 290, 300, 310, 320, 330, 340, 190 350, 360, 370, 380, 390, 400, 400, 400, 400, 400, 191 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 192 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 193 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 194 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 195 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 196 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 197 400, 400, 400, 400, 400, 400, 400, 400, 400, 400, 198 }; 199 200 static const int gf_intra_usage_adjustment[20] = 201 { 202 125, 120, 115, 110, 105, 100, 95, 85, 80, 75, 203 70, 65, 60, 55, 50, 50, 50, 50, 50, 50, 204 }; 205 206 static const int gf_interval_table[101] = 207 { 208 7, 209 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 210 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 211 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 212 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 213 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 214 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 215 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 216 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 217 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 218 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 219 }; 220 221 static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3, 4, 5 }; 222 223 224 void vp8_save_coding_context(VP8_COMP *cpi) 225 { 226 CODING_CONTEXT *const cc = & cpi->coding_context; 227 228 /* Stores a snapshot of key state variables which can subsequently be 229 * restored with a call to vp8_restore_coding_context. These functions are 230 * intended for use in a re-code loop in vp8_compress_frame where the 231 * quantizer value is adjusted between loop iterations. 232 */ 233 234 cc->frames_since_key = cpi->frames_since_key; 235 cc->filter_level = cpi->common.filter_level; 236 cc->frames_till_gf_update_due = cpi->frames_till_gf_update_due; 237 cc->frames_since_golden = cpi->frames_since_golden; 238 239 vp8_copy(cc->mvc, cpi->common.fc.mvc); 240 vp8_copy(cc->mvcosts, cpi->rd_costs.mvcosts); 241 242 vp8_copy(cc->ymode_prob, cpi->common.fc.ymode_prob); 243 vp8_copy(cc->uv_mode_prob, cpi->common.fc.uv_mode_prob); 244 245 vp8_copy(cc->ymode_count, cpi->mb.ymode_count); 246 vp8_copy(cc->uv_mode_count, cpi->mb.uv_mode_count); 247 248 249 /* Stats */ 250 #ifdef MODE_STATS 251 vp8_copy(cc->y_modes, y_modes); 252 vp8_copy(cc->uv_modes, uv_modes); 253 vp8_copy(cc->b_modes, b_modes); 254 vp8_copy(cc->inter_y_modes, inter_y_modes); 255 vp8_copy(cc->inter_uv_modes, inter_uv_modes); 256 vp8_copy(cc->inter_b_modes, inter_b_modes); 257 #endif 258 259 cc->this_frame_percent_intra = cpi->this_frame_percent_intra; 260 } 261 262 263 void vp8_restore_coding_context(VP8_COMP *cpi) 264 { 265 CODING_CONTEXT *const cc = & cpi->coding_context; 266 267 /* Restore key state variables to the snapshot state stored in the 268 * previous call to vp8_save_coding_context. 269 */ 270 271 cpi->frames_since_key = cc->frames_since_key; 272 cpi->common.filter_level = cc->filter_level; 273 cpi->frames_till_gf_update_due = cc->frames_till_gf_update_due; 274 cpi->frames_since_golden = cc->frames_since_golden; 275 276 vp8_copy(cpi->common.fc.mvc, cc->mvc); 277 278 vp8_copy(cpi->rd_costs.mvcosts, cc->mvcosts); 279 280 vp8_copy(cpi->common.fc.ymode_prob, cc->ymode_prob); 281 vp8_copy(cpi->common.fc.uv_mode_prob, cc->uv_mode_prob); 282 283 vp8_copy(cpi->mb.ymode_count, cc->ymode_count); 284 vp8_copy(cpi->mb.uv_mode_count, cc->uv_mode_count); 285 286 /* Stats */ 287 #ifdef MODE_STATS 288 vp8_copy(y_modes, cc->y_modes); 289 vp8_copy(uv_modes, cc->uv_modes); 290 vp8_copy(b_modes, cc->b_modes); 291 vp8_copy(inter_y_modes, cc->inter_y_modes); 292 vp8_copy(inter_uv_modes, cc->inter_uv_modes); 293 vp8_copy(inter_b_modes, cc->inter_b_modes); 294 #endif 295 296 297 cpi->this_frame_percent_intra = cc->this_frame_percent_intra; 298 } 299 300 301 void vp8_setup_key_frame(VP8_COMP *cpi) 302 { 303 /* Setup for Key frame: */ 304 305 vp8_default_coef_probs(& cpi->common); 306 307 vpx_memcpy(cpi->common.fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context)); 308 { 309 int flag[2] = {1, 1}; 310 vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cpi->common.fc.mvc, flag); 311 } 312 313 /* Make sure we initialize separate contexts for altref,gold, and normal. 314 * TODO shouldn't need 3 different copies of structure to do this! 315 */ 316 vpx_memcpy(&cpi->lfc_a, &cpi->common.fc, sizeof(cpi->common.fc)); 317 vpx_memcpy(&cpi->lfc_g, &cpi->common.fc, sizeof(cpi->common.fc)); 318 vpx_memcpy(&cpi->lfc_n, &cpi->common.fc, sizeof(cpi->common.fc)); 319 320 cpi->common.filter_level = cpi->common.base_qindex * 3 / 8 ; 321 322 /* Provisional interval before next GF */ 323 if (cpi->auto_gold) 324 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 325 else 326 cpi->frames_till_gf_update_due = DEFAULT_GF_INTERVAL; 327 328 cpi->common.refresh_golden_frame = 1; 329 cpi->common.refresh_alt_ref_frame = 1; 330 } 331 332 333 static int estimate_bits_at_q(int frame_kind, int Q, int MBs, 334 double correction_factor) 335 { 336 int Bpm = (int)(.5 + correction_factor * vp8_bits_per_mb[frame_kind][Q]); 337 338 /* Attempt to retain reasonable accuracy without overflow. The cutoff is 339 * chosen such that the maximum product of Bpm and MBs fits 31 bits. The 340 * largest Bpm takes 20 bits. 341 */ 342 if (MBs > (1 << 11)) 343 return (Bpm >> BPER_MB_NORMBITS) * MBs; 344 else 345 return (Bpm * MBs) >> BPER_MB_NORMBITS; 346 } 347 348 349 static void calc_iframe_target_size(VP8_COMP *cpi) 350 { 351 /* boost defaults to half second */ 352 int kf_boost; 353 uint64_t target; 354 355 /* Clear down mmx registers to allow floating point in what follows */ 356 vp8_clear_system_state(); 357 358 if (cpi->oxcf.fixed_q >= 0) 359 { 360 int Q = cpi->oxcf.key_q; 361 362 target = estimate_bits_at_q(INTRA_FRAME, Q, cpi->common.MBs, 363 cpi->key_frame_rate_correction_factor); 364 } 365 else if (cpi->pass == 2) 366 { 367 /* New Two pass RC */ 368 target = cpi->per_frame_bandwidth; 369 } 370 /* First Frame is a special case */ 371 else if (cpi->common.current_video_frame == 0) 372 { 373 /* 1 Pass there is no information on which to base size so use 374 * bandwidth per second * fraction of the initial buffer 375 * level 376 */ 377 target = cpi->oxcf.starting_buffer_level / 2; 378 379 if(target > cpi->oxcf.target_bandwidth * 3 / 2) 380 target = cpi->oxcf.target_bandwidth * 3 / 2; 381 } 382 else 383 { 384 /* if this keyframe was forced, use a more recent Q estimate */ 385 int Q = (cpi->common.frame_flags & FRAMEFLAGS_KEY) 386 ? cpi->avg_frame_qindex : cpi->ni_av_qi; 387 388 int initial_boost = 32; /* |3.0 * per_frame_bandwidth| */ 389 /* Boost depends somewhat on frame rate: only used for 1 layer case. */ 390 if (cpi->oxcf.number_of_layers == 1) { 391 kf_boost = MAX(initial_boost, (int)(2 * cpi->output_framerate - 16)); 392 } 393 else { 394 /* Initial factor: set target size to: |3.0 * per_frame_bandwidth|. */ 395 kf_boost = initial_boost; 396 } 397 398 /* adjustment up based on q: this factor ranges from ~1.2 to 2.2. */ 399 kf_boost = kf_boost * kf_boost_qadjustment[Q] / 100; 400 401 /* frame separation adjustment ( down) */ 402 if (cpi->frames_since_key < cpi->output_framerate / 2) 403 kf_boost = (int)(kf_boost 404 * cpi->frames_since_key / (cpi->output_framerate / 2)); 405 406 /* Minimal target size is |2* per_frame_bandwidth|. */ 407 if (kf_boost < 16) 408 kf_boost = 16; 409 410 target = ((16 + kf_boost) * cpi->per_frame_bandwidth) >> 4; 411 } 412 413 414 if (cpi->oxcf.rc_max_intra_bitrate_pct) 415 { 416 unsigned int max_rate = cpi->per_frame_bandwidth 417 * cpi->oxcf.rc_max_intra_bitrate_pct / 100; 418 419 if (target > max_rate) 420 target = max_rate; 421 } 422 423 cpi->this_frame_target = (int)target; 424 425 /* TODO: if we separate rate targeting from Q targetting, move this. 426 * Reset the active worst quality to the baseline value for key frames. 427 */ 428 if (cpi->pass != 2) 429 cpi->active_worst_quality = cpi->worst_quality; 430 431 #if 0 432 { 433 FILE *f; 434 435 f = fopen("kf_boost.stt", "a"); 436 fprintf(f, " %8u %10d %10d %10d\n", 437 cpi->common.current_video_frame, cpi->gfu_boost, cpi->baseline_gf_interval, cpi->source_alt_ref_pending); 438 439 fclose(f); 440 } 441 #endif 442 } 443 444 445 /* Do the best we can to define the parameters for the next GF based on what 446 * information we have available. 447 */ 448 static void calc_gf_params(VP8_COMP *cpi) 449 { 450 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q; 451 int Boost = 0; 452 453 int gf_frame_useage = 0; /* Golden frame useage since last GF */ 454 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] + 455 cpi->recent_ref_frame_usage[LAST_FRAME] + 456 cpi->recent_ref_frame_usage[GOLDEN_FRAME] + 457 cpi->recent_ref_frame_usage[ALTREF_FRAME]; 458 459 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols); 460 461 if (tot_mbs) 462 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs; 463 464 if (pct_gf_active > gf_frame_useage) 465 gf_frame_useage = pct_gf_active; 466 467 /* Not two pass */ 468 if (cpi->pass != 2) 469 { 470 /* Single Pass lagged mode: TBD */ 471 if (0) 472 { 473 } 474 475 /* Single Pass compression: Has to use current and historical data */ 476 else 477 { 478 #if 0 479 /* Experimental code */ 480 int index = cpi->one_pass_frame_index; 481 int frames_to_scan = (cpi->max_gf_interval <= MAX_LAG_BUFFERS) ? cpi->max_gf_interval : MAX_LAG_BUFFERS; 482 483 /* ************** Experimental code - incomplete */ 484 /* 485 double decay_val = 1.0; 486 double IIAccumulator = 0.0; 487 double last_iiaccumulator = 0.0; 488 double IIRatio; 489 490 cpi->one_pass_frame_index = cpi->common.current_video_frame%MAX_LAG_BUFFERS; 491 492 for ( i = 0; i < (frames_to_scan - 1); i++ ) 493 { 494 if ( index < 0 ) 495 index = MAX_LAG_BUFFERS; 496 index --; 497 498 if ( cpi->one_pass_frame_stats[index].frame_coded_error > 0.0 ) 499 { 500 IIRatio = cpi->one_pass_frame_stats[index].frame_intra_error / cpi->one_pass_frame_stats[index].frame_coded_error; 501 502 if ( IIRatio > 30.0 ) 503 IIRatio = 30.0; 504 } 505 else 506 IIRatio = 30.0; 507 508 IIAccumulator += IIRatio * decay_val; 509 510 decay_val = decay_val * cpi->one_pass_frame_stats[index].frame_pcnt_inter; 511 512 if ( (i > MIN_GF_INTERVAL) && 513 ((IIAccumulator - last_iiaccumulator) < 2.0) ) 514 { 515 break; 516 } 517 last_iiaccumulator = IIAccumulator; 518 } 519 520 Boost = IIAccumulator*100.0/16.0; 521 cpi->baseline_gf_interval = i; 522 523 */ 524 #else 525 526 /*************************************************************/ 527 /* OLD code */ 528 529 /* Adjust boost based upon ambient Q */ 530 Boost = GFQ_ADJUSTMENT; 531 532 /* Adjust based upon most recently measure intra useage */ 533 Boost = Boost * gf_intra_usage_adjustment[(cpi->this_frame_percent_intra < 15) ? cpi->this_frame_percent_intra : 14] / 100; 534 535 /* Adjust gf boost based upon GF usage since last GF */ 536 Boost = Boost * gf_adjust_table[gf_frame_useage] / 100; 537 #endif 538 } 539 540 /* golden frame boost without recode loop often goes awry. be 541 * safe by keeping numbers down. 542 */ 543 if (!cpi->sf.recode_loop) 544 { 545 if (cpi->compressor_speed == 2) 546 Boost = Boost / 2; 547 } 548 549 /* Apply an upper limit based on Q for 1 pass encodes */ 550 if (Boost > kf_gf_boost_qlimits[Q] && (cpi->pass == 0)) 551 Boost = kf_gf_boost_qlimits[Q]; 552 553 /* Apply lower limits to boost. */ 554 else if (Boost < 110) 555 Boost = 110; 556 557 /* Note the boost used */ 558 cpi->last_boost = Boost; 559 560 } 561 562 /* Estimate next interval 563 * This is updated once the real frame size/boost is known. 564 */ 565 if (cpi->oxcf.fixed_q == -1) 566 { 567 if (cpi->pass == 2) /* 2 Pass */ 568 { 569 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 570 } 571 else /* 1 Pass */ 572 { 573 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 574 575 if (cpi->last_boost > 750) 576 cpi->frames_till_gf_update_due++; 577 578 if (cpi->last_boost > 1000) 579 cpi->frames_till_gf_update_due++; 580 581 if (cpi->last_boost > 1250) 582 cpi->frames_till_gf_update_due++; 583 584 if (cpi->last_boost >= 1500) 585 cpi->frames_till_gf_update_due ++; 586 587 if (gf_interval_table[gf_frame_useage] > cpi->frames_till_gf_update_due) 588 cpi->frames_till_gf_update_due = gf_interval_table[gf_frame_useage]; 589 590 if (cpi->frames_till_gf_update_due > cpi->max_gf_interval) 591 cpi->frames_till_gf_update_due = cpi->max_gf_interval; 592 } 593 } 594 else 595 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 596 597 /* ARF on or off */ 598 if (cpi->pass != 2) 599 { 600 /* For now Alt ref is not allowed except in 2 pass modes. */ 601 cpi->source_alt_ref_pending = 0; 602 603 /*if ( cpi->oxcf.fixed_q == -1) 604 { 605 if ( cpi->oxcf.play_alternate && (cpi->last_boost > (100 + (AF_THRESH*cpi->frames_till_gf_update_due)) ) ) 606 cpi->source_alt_ref_pending = 1; 607 else 608 cpi->source_alt_ref_pending = 0; 609 }*/ 610 } 611 } 612 613 614 static void calc_pframe_target_size(VP8_COMP *cpi) 615 { 616 int min_frame_target; 617 int old_per_frame_bandwidth = cpi->per_frame_bandwidth; 618 619 if ( cpi->current_layer > 0) 620 cpi->per_frame_bandwidth = 621 cpi->layer_context[cpi->current_layer].avg_frame_size_for_layer; 622 623 min_frame_target = 0; 624 625 if (cpi->pass == 2) 626 { 627 min_frame_target = cpi->min_frame_bandwidth; 628 629 if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5)) 630 min_frame_target = cpi->av_per_frame_bandwidth >> 5; 631 } 632 else if (min_frame_target < cpi->per_frame_bandwidth / 4) 633 min_frame_target = cpi->per_frame_bandwidth / 4; 634 635 636 /* Special alt reference frame case */ 637 if((cpi->common.refresh_alt_ref_frame) && (cpi->oxcf.number_of_layers == 1)) 638 { 639 if (cpi->pass == 2) 640 { 641 /* Per frame bit target for the alt ref frame */ 642 cpi->per_frame_bandwidth = cpi->twopass.gf_bits; 643 cpi->this_frame_target = cpi->per_frame_bandwidth; 644 } 645 646 /* One Pass ??? TBD */ 647 } 648 649 /* Normal frames (gf,and inter) */ 650 else 651 { 652 /* 2 pass */ 653 if (cpi->pass == 2) 654 { 655 cpi->this_frame_target = cpi->per_frame_bandwidth; 656 } 657 /* 1 pass */ 658 else 659 { 660 int Adjustment; 661 /* Make rate adjustment to recover bits spent in key frame 662 * Test to see if the key frame inter data rate correction 663 * should still be in force 664 */ 665 if (cpi->kf_overspend_bits > 0) 666 { 667 Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits) ? cpi->kf_bitrate_adjustment : cpi->kf_overspend_bits; 668 669 if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target)) 670 Adjustment = (cpi->per_frame_bandwidth - min_frame_target); 671 672 cpi->kf_overspend_bits -= Adjustment; 673 674 /* Calculate an inter frame bandwidth target for the next 675 * few frames designed to recover any extra bits spent on 676 * the key frame. 677 */ 678 cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment; 679 680 if (cpi->this_frame_target < min_frame_target) 681 cpi->this_frame_target = min_frame_target; 682 } 683 else 684 cpi->this_frame_target = cpi->per_frame_bandwidth; 685 686 /* If appropriate make an adjustment to recover bits spent on a 687 * recent GF 688 */ 689 if ((cpi->gf_overspend_bits > 0) && (cpi->this_frame_target > min_frame_target)) 690 { 691 Adjustment = (cpi->non_gf_bitrate_adjustment <= cpi->gf_overspend_bits) ? cpi->non_gf_bitrate_adjustment : cpi->gf_overspend_bits; 692 693 if (Adjustment > (cpi->this_frame_target - min_frame_target)) 694 Adjustment = (cpi->this_frame_target - min_frame_target); 695 696 cpi->gf_overspend_bits -= Adjustment; 697 cpi->this_frame_target -= Adjustment; 698 } 699 700 /* Apply small + and - boosts for non gf frames */ 701 if ((cpi->last_boost > 150) && (cpi->frames_till_gf_update_due > 0) && 702 (cpi->current_gf_interval >= (MIN_GF_INTERVAL << 1))) 703 { 704 /* % Adjustment limited to the range 1% to 10% */ 705 Adjustment = (cpi->last_boost - 100) >> 5; 706 707 if (Adjustment < 1) 708 Adjustment = 1; 709 else if (Adjustment > 10) 710 Adjustment = 10; 711 712 /* Convert to bits */ 713 Adjustment = (cpi->this_frame_target * Adjustment) / 100; 714 715 if (Adjustment > (cpi->this_frame_target - min_frame_target)) 716 Adjustment = (cpi->this_frame_target - min_frame_target); 717 718 if (cpi->frames_since_golden == (cpi->current_gf_interval >> 1)) 719 cpi->this_frame_target += ((cpi->current_gf_interval - 1) * Adjustment); 720 else 721 cpi->this_frame_target -= Adjustment; 722 } 723 } 724 } 725 726 /* Sanity check that the total sum of adjustments is not above the 727 * maximum allowed That is that having allowed for KF and GF penalties 728 * we have not pushed the current interframe target to low. If the 729 * adjustment we apply here is not capable of recovering all the extra 730 * bits we have spent in the KF or GF then the remainder will have to 731 * be recovered over a longer time span via other buffer / rate control 732 * mechanisms. 733 */ 734 if (cpi->this_frame_target < min_frame_target) 735 cpi->this_frame_target = min_frame_target; 736 737 if (!cpi->common.refresh_alt_ref_frame) 738 /* Note the baseline target data rate for this inter frame. */ 739 cpi->inter_frame_target = cpi->this_frame_target; 740 741 /* One Pass specific code */ 742 if (cpi->pass == 0) 743 { 744 /* Adapt target frame size with respect to any buffering constraints: */ 745 if (cpi->buffered_mode) 746 { 747 int one_percent_bits = (int) 748 (1 + cpi->oxcf.optimal_buffer_level / 100); 749 750 if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) || 751 (cpi->bits_off_target < cpi->oxcf.optimal_buffer_level)) 752 { 753 int percent_low = 0; 754 755 /* Decide whether or not we need to adjust the frame data 756 * rate target. 757 * 758 * If we are are below the optimal buffer fullness level 759 * and adherence to buffering constraints is important to 760 * the end usage then adjust the per frame target. 761 */ 762 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) && 763 (cpi->buffer_level < cpi->oxcf.optimal_buffer_level)) 764 { 765 percent_low = (int) 766 ((cpi->oxcf.optimal_buffer_level - cpi->buffer_level) / 767 one_percent_bits); 768 } 769 /* Are we overshooting the long term clip data rate... */ 770 else if (cpi->bits_off_target < 0) 771 { 772 /* Adjust per frame data target downwards to compensate. */ 773 percent_low = (int)(100 * -cpi->bits_off_target / 774 (cpi->total_byte_count * 8)); 775 } 776 777 if (percent_low > cpi->oxcf.under_shoot_pct) 778 percent_low = cpi->oxcf.under_shoot_pct; 779 else if (percent_low < 0) 780 percent_low = 0; 781 782 /* lower the target bandwidth for this frame. */ 783 cpi->this_frame_target -= 784 (cpi->this_frame_target * percent_low) / 200; 785 786 /* Are we using allowing control of active_worst_allowed_q 787 * according to buffer level. 788 */ 789 if (cpi->auto_worst_q && cpi->ni_frames > 150) 790 { 791 int64_t critical_buffer_level; 792 793 /* For streaming applications the most important factor is 794 * cpi->buffer_level as this takes into account the 795 * specified short term buffering constraints. However, 796 * hitting the long term clip data rate target is also 797 * important. 798 */ 799 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 800 { 801 /* Take the smaller of cpi->buffer_level and 802 * cpi->bits_off_target 803 */ 804 critical_buffer_level = 805 (cpi->buffer_level < cpi->bits_off_target) 806 ? cpi->buffer_level : cpi->bits_off_target; 807 } 808 /* For local file playback short term buffering constraints 809 * are less of an issue 810 */ 811 else 812 { 813 /* Consider only how we are doing for the clip as a 814 * whole 815 */ 816 critical_buffer_level = cpi->bits_off_target; 817 } 818 819 /* Set the active worst quality based upon the selected 820 * buffer fullness number. 821 */ 822 if (critical_buffer_level < cpi->oxcf.optimal_buffer_level) 823 { 824 if ( critical_buffer_level > 825 (cpi->oxcf.optimal_buffer_level >> 2) ) 826 { 827 int64_t qadjustment_range = 828 cpi->worst_quality - cpi->ni_av_qi; 829 int64_t above_base = 830 (critical_buffer_level - 831 (cpi->oxcf.optimal_buffer_level >> 2)); 832 833 /* Step active worst quality down from 834 * cpi->ni_av_qi when (critical_buffer_level == 835 * cpi->optimal_buffer_level) to 836 * cpi->worst_quality when 837 * (critical_buffer_level == 838 * cpi->optimal_buffer_level >> 2) 839 */ 840 cpi->active_worst_quality = 841 cpi->worst_quality - 842 (int)((qadjustment_range * above_base) / 843 (cpi->oxcf.optimal_buffer_level*3>>2)); 844 } 845 else 846 { 847 cpi->active_worst_quality = cpi->worst_quality; 848 } 849 } 850 else 851 { 852 cpi->active_worst_quality = cpi->ni_av_qi; 853 } 854 } 855 else 856 { 857 cpi->active_worst_quality = cpi->worst_quality; 858 } 859 } 860 else 861 { 862 int percent_high = 0; 863 864 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 865 && (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)) 866 { 867 percent_high = (int)((cpi->buffer_level 868 - cpi->oxcf.optimal_buffer_level) 869 / one_percent_bits); 870 } 871 else if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level) 872 { 873 percent_high = (int)((100 * cpi->bits_off_target) 874 / (cpi->total_byte_count * 8)); 875 } 876 877 if (percent_high > cpi->oxcf.over_shoot_pct) 878 percent_high = cpi->oxcf.over_shoot_pct; 879 else if (percent_high < 0) 880 percent_high = 0; 881 882 cpi->this_frame_target += (cpi->this_frame_target * 883 percent_high) / 200; 884 885 /* Are we allowing control of active_worst_allowed_q according 886 * to buffer level. 887 */ 888 if (cpi->auto_worst_q && cpi->ni_frames > 150) 889 { 890 /* When using the relaxed buffer model stick to the 891 * user specified value 892 */ 893 cpi->active_worst_quality = cpi->ni_av_qi; 894 } 895 else 896 { 897 cpi->active_worst_quality = cpi->worst_quality; 898 } 899 } 900 901 /* Set active_best_quality to prevent quality rising too high */ 902 cpi->active_best_quality = cpi->best_quality; 903 904 /* Worst quality obviously must not be better than best quality */ 905 if (cpi->active_worst_quality <= cpi->active_best_quality) 906 cpi->active_worst_quality = cpi->active_best_quality + 1; 907 908 if(cpi->active_worst_quality > 127) 909 cpi->active_worst_quality = 127; 910 } 911 /* Unbuffered mode (eg. video conferencing) */ 912 else 913 { 914 /* Set the active worst quality */ 915 cpi->active_worst_quality = cpi->worst_quality; 916 } 917 918 /* Special trap for constrained quality mode 919 * "active_worst_quality" may never drop below cq level 920 * for any frame type. 921 */ 922 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY && 923 cpi->active_worst_quality < cpi->cq_target_quality) 924 { 925 cpi->active_worst_quality = cpi->cq_target_quality; 926 } 927 } 928 929 /* Test to see if we have to drop a frame 930 * The auto-drop frame code is only used in buffered mode. 931 * In unbufferd mode (eg vide conferencing) the descision to 932 * code or drop a frame is made outside the codec in response to real 933 * world comms or buffer considerations. 934 */ 935 if (cpi->drop_frames_allowed && 936 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) && 937 ((cpi->common.frame_type != KEY_FRAME))) 938 { 939 /* Check for a buffer underun-crisis in which case we have to drop 940 * a frame 941 */ 942 if ((cpi->buffer_level < 0)) 943 { 944 #if 0 945 FILE *f = fopen("dec.stt", "a"); 946 fprintf(f, "%10d %10d %10d %10d ***** BUFFER EMPTY\n", 947 (int) cpi->common.current_video_frame, 948 cpi->decimation_factor, cpi->common.horiz_scale, 949 (cpi->buffer_level * 100) / cpi->oxcf.optimal_buffer_level); 950 fclose(f); 951 #endif 952 cpi->drop_frame = 1; 953 954 /* Update the buffer level variable. */ 955 cpi->bits_off_target += cpi->av_per_frame_bandwidth; 956 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) 957 cpi->bits_off_target = (int)cpi->oxcf.maximum_buffer_size; 958 cpi->buffer_level = cpi->bits_off_target; 959 } 960 } 961 962 /* Adjust target frame size for Golden Frames: */ 963 if (cpi->oxcf.error_resilient_mode == 0 && 964 (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame) 965 { 966 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q; 967 968 int gf_frame_useage = 0; /* Golden frame useage since last GF */ 969 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] + 970 cpi->recent_ref_frame_usage[LAST_FRAME] + 971 cpi->recent_ref_frame_usage[GOLDEN_FRAME] + 972 cpi->recent_ref_frame_usage[ALTREF_FRAME]; 973 974 int pct_gf_active = (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols); 975 976 if (tot_mbs) 977 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 100 / tot_mbs; 978 979 if (pct_gf_active > gf_frame_useage) 980 gf_frame_useage = pct_gf_active; 981 982 /* Is a fixed manual GF frequency being used */ 983 if (cpi->auto_gold) 984 { 985 /* For one pass throw a GF if recent frame intra useage is 986 * low or the GF useage is high 987 */ 988 if ((cpi->pass == 0) && (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5)) 989 cpi->common.refresh_golden_frame = 1; 990 991 /* Two pass GF descision */ 992 else if (cpi->pass == 2) 993 cpi->common.refresh_golden_frame = 1; 994 } 995 996 #if 0 997 998 /* Debug stats */ 999 if (0) 1000 { 1001 FILE *f; 1002 1003 f = fopen("gf_useaget.stt", "a"); 1004 fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n", 1005 cpi->common.current_video_frame, cpi->gfu_boost, GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage); 1006 fclose(f); 1007 } 1008 1009 #endif 1010 1011 if (cpi->common.refresh_golden_frame == 1) 1012 { 1013 #if 0 1014 1015 if (0) 1016 { 1017 FILE *f; 1018 1019 f = fopen("GFexit.stt", "a"); 1020 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame); 1021 fclose(f); 1022 } 1023 1024 #endif 1025 1026 if (cpi->auto_adjust_gold_quantizer) 1027 { 1028 calc_gf_params(cpi); 1029 } 1030 1031 /* If we are using alternate ref instead of gf then do not apply the 1032 * boost It will instead be applied to the altref update Jims 1033 * modified boost 1034 */ 1035 if (!cpi->source_alt_ref_active) 1036 { 1037 if (cpi->oxcf.fixed_q < 0) 1038 { 1039 if (cpi->pass == 2) 1040 { 1041 /* The spend on the GF is defined in the two pass 1042 * code for two pass encodes 1043 */ 1044 cpi->this_frame_target = cpi->per_frame_bandwidth; 1045 } 1046 else 1047 { 1048 int Boost = cpi->last_boost; 1049 int frames_in_section = cpi->frames_till_gf_update_due + 1; 1050 int allocation_chunks = (frames_in_section * 100) + (Boost - 100); 1051 int bits_in_section = cpi->inter_frame_target * frames_in_section; 1052 1053 /* Normalize Altboost and allocations chunck down to 1054 * prevent overflow 1055 */ 1056 while (Boost > 1000) 1057 { 1058 Boost /= 2; 1059 allocation_chunks /= 2; 1060 } 1061 1062 /* Avoid loss of precision but avoid overflow */ 1063 if ((bits_in_section >> 7) > allocation_chunks) 1064 cpi->this_frame_target = Boost * (bits_in_section / allocation_chunks); 1065 else 1066 cpi->this_frame_target = (Boost * bits_in_section) / allocation_chunks; 1067 } 1068 } 1069 else 1070 cpi->this_frame_target = 1071 (estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0) 1072 * cpi->last_boost) / 100; 1073 1074 } 1075 /* If there is an active ARF at this location use the minimum 1076 * bits on this frame even if it is a contructed arf. 1077 * The active maximum quantizer insures that an appropriate 1078 * number of bits will be spent if needed for contstructed ARFs. 1079 */ 1080 else 1081 { 1082 cpi->this_frame_target = 0; 1083 } 1084 1085 cpi->current_gf_interval = cpi->frames_till_gf_update_due; 1086 1087 } 1088 } 1089 1090 cpi->per_frame_bandwidth = old_per_frame_bandwidth; 1091 } 1092 1093 1094 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var) 1095 { 1096 int Q = cpi->common.base_qindex; 1097 int correction_factor = 100; 1098 double rate_correction_factor; 1099 double adjustment_limit; 1100 1101 int projected_size_based_on_q = 0; 1102 1103 /* Clear down mmx registers to allow floating point in what follows */ 1104 vp8_clear_system_state(); 1105 1106 if (cpi->common.frame_type == KEY_FRAME) 1107 { 1108 rate_correction_factor = cpi->key_frame_rate_correction_factor; 1109 } 1110 else 1111 { 1112 if (cpi->oxcf.number_of_layers == 1 && 1113 (cpi->common.refresh_alt_ref_frame || 1114 cpi->common.refresh_golden_frame)) 1115 rate_correction_factor = cpi->gf_rate_correction_factor; 1116 else 1117 rate_correction_factor = cpi->rate_correction_factor; 1118 } 1119 1120 /* Work out how big we would have expected the frame to be at this Q 1121 * given the current correction factor. Stay in double to avoid int 1122 * overflow when values are large 1123 */ 1124 projected_size_based_on_q = (int)(((.5 + rate_correction_factor * vp8_bits_per_mb[cpi->common.frame_type][Q]) * cpi->common.MBs) / (1 << BPER_MB_NORMBITS)); 1125 1126 /* Make some allowance for cpi->zbin_over_quant */ 1127 if (cpi->mb.zbin_over_quant > 0) 1128 { 1129 int Z = cpi->mb.zbin_over_quant; 1130 double Factor = 0.99; 1131 double factor_adjustment = 0.01 / 256.0; 1132 1133 while (Z > 0) 1134 { 1135 Z --; 1136 projected_size_based_on_q = 1137 (int)(Factor * projected_size_based_on_q); 1138 Factor += factor_adjustment; 1139 1140 if (Factor >= 0.999) 1141 Factor = 0.999; 1142 } 1143 } 1144 1145 /* Work out a size correction factor. */ 1146 if (projected_size_based_on_q > 0) 1147 correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q; 1148 1149 /* More heavily damped adjustment used if we have been oscillating 1150 * either side of target 1151 */ 1152 switch (damp_var) 1153 { 1154 case 0: 1155 adjustment_limit = 0.75; 1156 break; 1157 case 1: 1158 adjustment_limit = 0.375; 1159 break; 1160 case 2: 1161 default: 1162 adjustment_limit = 0.25; 1163 break; 1164 } 1165 1166 if (correction_factor > 102) 1167 { 1168 /* We are not already at the worst allowable quality */ 1169 correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit)); 1170 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100); 1171 1172 /* Keep rate_correction_factor within limits */ 1173 if (rate_correction_factor > MAX_BPB_FACTOR) 1174 rate_correction_factor = MAX_BPB_FACTOR; 1175 } 1176 else if (correction_factor < 99) 1177 { 1178 /* We are not already at the best allowable quality */ 1179 correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit)); 1180 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100); 1181 1182 /* Keep rate_correction_factor within limits */ 1183 if (rate_correction_factor < MIN_BPB_FACTOR) 1184 rate_correction_factor = MIN_BPB_FACTOR; 1185 } 1186 1187 if (cpi->common.frame_type == KEY_FRAME) 1188 cpi->key_frame_rate_correction_factor = rate_correction_factor; 1189 else 1190 { 1191 if (cpi->oxcf.number_of_layers == 1 && 1192 (cpi->common.refresh_alt_ref_frame || 1193 cpi->common.refresh_golden_frame)) 1194 cpi->gf_rate_correction_factor = rate_correction_factor; 1195 else 1196 cpi->rate_correction_factor = rate_correction_factor; 1197 } 1198 } 1199 1200 1201 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame) 1202 { 1203 int Q = cpi->active_worst_quality; 1204 1205 /* Reset Zbin OQ value */ 1206 cpi->mb.zbin_over_quant = 0; 1207 1208 if (cpi->oxcf.fixed_q >= 0) 1209 { 1210 Q = cpi->oxcf.fixed_q; 1211 1212 if (cpi->common.frame_type == KEY_FRAME) 1213 { 1214 Q = cpi->oxcf.key_q; 1215 } 1216 else if (cpi->oxcf.number_of_layers == 1 && 1217 cpi->common.refresh_alt_ref_frame) 1218 { 1219 Q = cpi->oxcf.alt_q; 1220 } 1221 else if (cpi->oxcf.number_of_layers == 1 && 1222 cpi->common.refresh_golden_frame) 1223 { 1224 Q = cpi->oxcf.gold_q; 1225 } 1226 1227 } 1228 else 1229 { 1230 int i; 1231 int last_error = INT_MAX; 1232 int target_bits_per_mb; 1233 int bits_per_mb_at_this_q; 1234 double correction_factor; 1235 1236 /* Select the appropriate correction factor based upon type of frame. */ 1237 if (cpi->common.frame_type == KEY_FRAME) 1238 correction_factor = cpi->key_frame_rate_correction_factor; 1239 else 1240 { 1241 if (cpi->oxcf.number_of_layers == 1 && 1242 (cpi->common.refresh_alt_ref_frame || 1243 cpi->common.refresh_golden_frame)) 1244 correction_factor = cpi->gf_rate_correction_factor; 1245 else 1246 correction_factor = cpi->rate_correction_factor; 1247 } 1248 1249 /* Calculate required scaling factor based on target frame size and 1250 * size of frame produced using previous Q 1251 */ 1252 if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS)) 1253 /* Case where we would overflow int */ 1254 target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS; 1255 else 1256 target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs; 1257 1258 i = cpi->active_best_quality; 1259 1260 do 1261 { 1262 bits_per_mb_at_this_q = (int)(.5 + correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]); 1263 1264 if (bits_per_mb_at_this_q <= target_bits_per_mb) 1265 { 1266 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error) 1267 Q = i; 1268 else 1269 Q = i - 1; 1270 1271 break; 1272 } 1273 else 1274 last_error = bits_per_mb_at_this_q - target_bits_per_mb; 1275 } 1276 while (++i <= cpi->active_worst_quality); 1277 1278 1279 /* If we are at MAXQ then enable Q over-run which seeks to claw 1280 * back additional bits through things like the RD multiplier 1281 * and zero bin size. 1282 */ 1283 if (Q >= MAXQ) 1284 { 1285 int zbin_oqmax; 1286 1287 double Factor = 0.99; 1288 double factor_adjustment = 0.01 / 256.0; 1289 1290 if (cpi->common.frame_type == KEY_FRAME) 1291 zbin_oqmax = 0; 1292 else if (cpi->oxcf.number_of_layers == 1 && 1293 (cpi->common.refresh_alt_ref_frame || 1294 (cpi->common.refresh_golden_frame && 1295 !cpi->source_alt_ref_active))) 1296 zbin_oqmax = 16; 1297 else 1298 zbin_oqmax = ZBIN_OQ_MAX; 1299 1300 /*{ 1301 double Factor = (double)target_bits_per_mb/(double)bits_per_mb_at_this_q; 1302 double Oq; 1303 1304 Factor = Factor/1.2683; 1305 1306 Oq = pow( Factor, (1.0/-0.165) ); 1307 1308 if ( Oq > zbin_oqmax ) 1309 Oq = zbin_oqmax; 1310 1311 cpi->zbin_over_quant = (int)Oq; 1312 }*/ 1313 1314 /* Each incrment in the zbin is assumed to have a fixed effect 1315 * on bitrate. This is not of course true. The effect will be 1316 * highly clip dependent and may well have sudden steps. The 1317 * idea here is to acheive higher effective quantizers than the 1318 * normal maximum by expanding the zero bin and hence 1319 * decreasing the number of low magnitude non zero coefficients. 1320 */ 1321 while (cpi->mb.zbin_over_quant < zbin_oqmax) 1322 { 1323 cpi->mb.zbin_over_quant ++; 1324 1325 if (cpi->mb.zbin_over_quant > zbin_oqmax) 1326 cpi->mb.zbin_over_quant = zbin_oqmax; 1327 1328 /* Adjust bits_per_mb_at_this_q estimate */ 1329 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q); 1330 Factor += factor_adjustment; 1331 1332 if (Factor >= 0.999) 1333 Factor = 0.999; 1334 1335 /* Break out if we get down to the target rate */ 1336 if (bits_per_mb_at_this_q <= target_bits_per_mb) 1337 break; 1338 } 1339 1340 } 1341 } 1342 1343 return Q; 1344 } 1345 1346 1347 static int estimate_keyframe_frequency(VP8_COMP *cpi) 1348 { 1349 int i; 1350 1351 /* Average key frame frequency */ 1352 int av_key_frame_frequency = 0; 1353 1354 /* First key frame at start of sequence is a special case. We have no 1355 * frequency data. 1356 */ 1357 if (cpi->key_frame_count == 1) 1358 { 1359 /* Assume a default of 1 kf every 2 seconds, or the max kf interval, 1360 * whichever is smaller. 1361 */ 1362 int key_freq = cpi->oxcf.key_freq>0 ? cpi->oxcf.key_freq : 1; 1363 av_key_frame_frequency = 1 + (int)cpi->output_framerate * 2; 1364 1365 if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq) 1366 av_key_frame_frequency = key_freq; 1367 1368 cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1] 1369 = av_key_frame_frequency; 1370 } 1371 else 1372 { 1373 unsigned int total_weight = 0; 1374 int last_kf_interval = 1375 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1; 1376 1377 /* reset keyframe context and calculate weighted average of last 1378 * KEY_FRAME_CONTEXT keyframes 1379 */ 1380 for (i = 0; i < KEY_FRAME_CONTEXT; i++) 1381 { 1382 if (i < KEY_FRAME_CONTEXT - 1) 1383 cpi->prior_key_frame_distance[i] 1384 = cpi->prior_key_frame_distance[i+1]; 1385 else 1386 cpi->prior_key_frame_distance[i] = last_kf_interval; 1387 1388 av_key_frame_frequency += prior_key_frame_weight[i] 1389 * cpi->prior_key_frame_distance[i]; 1390 total_weight += prior_key_frame_weight[i]; 1391 } 1392 1393 av_key_frame_frequency /= total_weight; 1394 1395 } 1396 // TODO (marpan): Given the checks above, |av_key_frame_frequency| 1397 // should always be above 0. But for now we keep the sanity check in. 1398 if (av_key_frame_frequency == 0) 1399 av_key_frame_frequency = 1; 1400 return av_key_frame_frequency; 1401 } 1402 1403 1404 void vp8_adjust_key_frame_context(VP8_COMP *cpi) 1405 { 1406 /* Clear down mmx registers to allow floating point in what follows */ 1407 vp8_clear_system_state(); 1408 1409 /* Do we have any key frame overspend to recover? */ 1410 /* Two-pass overspend handled elsewhere. */ 1411 if ((cpi->pass != 2) 1412 && (cpi->projected_frame_size > cpi->per_frame_bandwidth)) 1413 { 1414 int overspend; 1415 1416 /* Update the count of key frame overspend to be recovered in 1417 * subsequent frames. A portion of the KF overspend is treated as gf 1418 * overspend (and hence recovered more quickly) as the kf is also a 1419 * gf. Otherwise the few frames following each kf tend to get more 1420 * bits allocated than those following other gfs. 1421 */ 1422 overspend = (cpi->projected_frame_size - cpi->per_frame_bandwidth); 1423 1424 if (cpi->oxcf.number_of_layers > 1) 1425 cpi->kf_overspend_bits += overspend; 1426 else 1427 { 1428 cpi->kf_overspend_bits += overspend * 7 / 8; 1429 cpi->gf_overspend_bits += overspend * 1 / 8; 1430 } 1431 1432 /* Work out how much to try and recover per frame. */ 1433 cpi->kf_bitrate_adjustment = cpi->kf_overspend_bits 1434 / estimate_keyframe_frequency(cpi); 1435 } 1436 1437 cpi->frames_since_key = 0; 1438 cpi->key_frame_count++; 1439 } 1440 1441 1442 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit, int *frame_over_shoot_limit) 1443 { 1444 /* Set-up bounds on acceptable frame size: */ 1445 if (cpi->oxcf.fixed_q >= 0) 1446 { 1447 /* Fixed Q scenario: frame size never outranges target 1448 * (there is no target!) 1449 */ 1450 *frame_under_shoot_limit = 0; 1451 *frame_over_shoot_limit = INT_MAX; 1452 } 1453 else 1454 { 1455 if (cpi->common.frame_type == KEY_FRAME) 1456 { 1457 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8; 1458 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8; 1459 } 1460 else 1461 { 1462 if (cpi->oxcf.number_of_layers > 1 || 1463 cpi->common.refresh_alt_ref_frame || 1464 cpi->common.refresh_golden_frame) 1465 { 1466 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8; 1467 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8; 1468 } 1469 else 1470 { 1471 /* For CBR take buffer fullness into account */ 1472 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) 1473 { 1474 if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level + cpi->oxcf.maximum_buffer_size) >> 1)) 1475 { 1476 /* Buffer is too full so relax overshoot and tighten 1477 * undershoot 1478 */ 1479 *frame_over_shoot_limit = cpi->this_frame_target * 12 / 8; 1480 *frame_under_shoot_limit = cpi->this_frame_target * 6 / 8; 1481 } 1482 else if (cpi->buffer_level <= (cpi->oxcf.optimal_buffer_level >> 1)) 1483 { 1484 /* Buffer is too low so relax undershoot and tighten 1485 * overshoot 1486 */ 1487 *frame_over_shoot_limit = cpi->this_frame_target * 10 / 8; 1488 *frame_under_shoot_limit = cpi->this_frame_target * 4 / 8; 1489 } 1490 else 1491 { 1492 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8; 1493 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8; 1494 } 1495 } 1496 /* VBR and CQ mode */ 1497 /* Note that tighter restrictions here can help quality 1498 * but hurt encode speed 1499 */ 1500 else 1501 { 1502 /* Stron overshoot limit for constrained quality */ 1503 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) 1504 { 1505 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8; 1506 *frame_under_shoot_limit = cpi->this_frame_target * 2 / 8; 1507 } 1508 else 1509 { 1510 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8; 1511 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8; 1512 } 1513 } 1514 } 1515 } 1516 1517 /* For very small rate targets where the fractional adjustment 1518 * (eg * 7/8) may be tiny make sure there is at least a minimum 1519 * range. 1520 */ 1521 *frame_over_shoot_limit += 200; 1522 *frame_under_shoot_limit -= 200; 1523 if ( *frame_under_shoot_limit < 0 ) 1524 *frame_under_shoot_limit = 0; 1525 1526 } 1527 } 1528 1529 1530 /* return of 0 means drop frame */ 1531 int vp8_pick_frame_size(VP8_COMP *cpi) 1532 { 1533 VP8_COMMON *cm = &cpi->common; 1534 1535 if (cm->frame_type == KEY_FRAME) 1536 calc_iframe_target_size(cpi); 1537 else 1538 { 1539 calc_pframe_target_size(cpi); 1540 1541 /* Check if we're dropping the frame: */ 1542 if (cpi->drop_frame) 1543 { 1544 cpi->drop_frame = 0; 1545 return 0; 1546 } 1547 } 1548 return 1; 1549 } 1550
