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