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