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