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 30 extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES]; 31 32 #ifdef MODE_STATS 33 extern int y_modes[5]; 34 extern int uv_modes[4]; 35 extern int b_modes[10]; 36 37 extern int inter_y_modes[10]; 38 extern int inter_uv_modes[4]; 39 extern 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 */ 49 const 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 88 static 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] 102 const 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 /* 115 const 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 136 static 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 148 static 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 158 static 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 163 static 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 172 static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = { 1, 2, 3, 173 4, 5 }; 174 175 void 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 211 void 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 246 void 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 279 static 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 294 static 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 */ 381 static 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 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 503 } else { /* 1 Pass */ 504 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 505 506 if (cpi->last_boost > 750) cpi->frames_till_gf_update_due++; 507 508 if (cpi->last_boost > 1000) cpi->frames_till_gf_update_due++; 509 510 if (cpi->last_boost > 1250) cpi->frames_till_gf_update_due++; 511 512 if (cpi->last_boost >= 1500) cpi->frames_till_gf_update_due++; 513 514 if (gf_interval_table[gf_frame_useage] > cpi->frames_till_gf_update_due) { 515 cpi->frames_till_gf_update_due = gf_interval_table[gf_frame_useage]; 516 } 517 518 if (cpi->frames_till_gf_update_due > cpi->max_gf_interval) { 519 cpi->frames_till_gf_update_due = cpi->max_gf_interval; 520 } 521 } 522 } else { 523 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 524 } 525 526 /* ARF on or off */ 527 if (cpi->pass != 2) { 528 /* For now Alt ref is not allowed except in 2 pass modes. */ 529 cpi->source_alt_ref_pending = 0; 530 531 /*if ( cpi->oxcf.fixed_q == -1) 532 { 533 if ( cpi->oxcf.play_alternate && (cpi->last_boost > (100 + 534 (AF_THRESH*cpi->frames_till_gf_update_due)) ) ) 535 cpi->source_alt_ref_pending = 1; 536 else 537 cpi->source_alt_ref_pending = 0; 538 }*/ 539 } 540 } 541 542 static void calc_pframe_target_size(VP8_COMP *cpi) { 543 int min_frame_target; 544 int old_per_frame_bandwidth = cpi->per_frame_bandwidth; 545 546 if (cpi->current_layer > 0) { 547 cpi->per_frame_bandwidth = 548 cpi->layer_context[cpi->current_layer].avg_frame_size_for_layer; 549 } 550 551 min_frame_target = 0; 552 553 if (cpi->pass == 2) { 554 min_frame_target = cpi->min_frame_bandwidth; 555 556 if (min_frame_target < (cpi->av_per_frame_bandwidth >> 5)) { 557 min_frame_target = cpi->av_per_frame_bandwidth >> 5; 558 } 559 } else if (min_frame_target < cpi->per_frame_bandwidth / 4) { 560 min_frame_target = cpi->per_frame_bandwidth / 4; 561 } 562 563 /* Special alt reference frame case */ 564 if ((cpi->common.refresh_alt_ref_frame) && 565 (cpi->oxcf.number_of_layers == 1)) { 566 if (cpi->pass == 2) { 567 /* Per frame bit target for the alt ref frame */ 568 cpi->per_frame_bandwidth = cpi->twopass.gf_bits; 569 cpi->this_frame_target = cpi->per_frame_bandwidth; 570 } 571 572 /* One Pass ??? TBD */ 573 } 574 575 /* Normal frames (gf,and inter) */ 576 else { 577 /* 2 pass */ 578 if (cpi->pass == 2) { 579 cpi->this_frame_target = cpi->per_frame_bandwidth; 580 } 581 /* 1 pass */ 582 else { 583 int Adjustment; 584 /* Make rate adjustment to recover bits spent in key frame 585 * Test to see if the key frame inter data rate correction 586 * should still be in force 587 */ 588 if (cpi->kf_overspend_bits > 0) { 589 Adjustment = (cpi->kf_bitrate_adjustment <= cpi->kf_overspend_bits) 590 ? cpi->kf_bitrate_adjustment 591 : cpi->kf_overspend_bits; 592 593 if (Adjustment > (cpi->per_frame_bandwidth - min_frame_target)) { 594 Adjustment = (cpi->per_frame_bandwidth - min_frame_target); 595 } 596 597 cpi->kf_overspend_bits -= Adjustment; 598 599 /* Calculate an inter frame bandwidth target for the next 600 * few frames designed to recover any extra bits spent on 601 * the key frame. 602 */ 603 cpi->this_frame_target = cpi->per_frame_bandwidth - Adjustment; 604 605 if (cpi->this_frame_target < min_frame_target) { 606 cpi->this_frame_target = min_frame_target; 607 } 608 } else { 609 cpi->this_frame_target = cpi->per_frame_bandwidth; 610 } 611 612 /* If appropriate make an adjustment to recover bits spent on a 613 * recent GF 614 */ 615 if ((cpi->gf_overspend_bits > 0) && 616 (cpi->this_frame_target > min_frame_target)) { 617 Adjustment = (cpi->non_gf_bitrate_adjustment <= cpi->gf_overspend_bits) 618 ? cpi->non_gf_bitrate_adjustment 619 : cpi->gf_overspend_bits; 620 621 if (Adjustment > (cpi->this_frame_target - min_frame_target)) { 622 Adjustment = (cpi->this_frame_target - min_frame_target); 623 } 624 625 cpi->gf_overspend_bits -= Adjustment; 626 cpi->this_frame_target -= Adjustment; 627 } 628 629 /* Apply small + and - boosts for non gf frames */ 630 if ((cpi->last_boost > 150) && (cpi->frames_till_gf_update_due > 0) && 631 (cpi->current_gf_interval >= (MIN_GF_INTERVAL << 1))) { 632 /* % Adjustment limited to the range 1% to 10% */ 633 Adjustment = (cpi->last_boost - 100) >> 5; 634 635 if (Adjustment < 1) { 636 Adjustment = 1; 637 } else if (Adjustment > 10) { 638 Adjustment = 10; 639 } 640 641 /* Convert to bits */ 642 Adjustment = (cpi->this_frame_target * Adjustment) / 100; 643 644 if (Adjustment > (cpi->this_frame_target - min_frame_target)) { 645 Adjustment = (cpi->this_frame_target - min_frame_target); 646 } 647 648 if (cpi->frames_since_golden == (cpi->current_gf_interval >> 1)) { 649 Adjustment = (cpi->current_gf_interval - 1) * Adjustment; 650 // Limit adjustment to 10% of current target. 651 if (Adjustment > (10 * cpi->this_frame_target) / 100) { 652 Adjustment = (10 * cpi->this_frame_target) / 100; 653 } 654 cpi->this_frame_target += Adjustment; 655 } else { 656 cpi->this_frame_target -= Adjustment; 657 } 658 } 659 } 660 } 661 662 /* Sanity check that the total sum of adjustments is not above the 663 * maximum allowed That is that having allowed for KF and GF penalties 664 * we have not pushed the current interframe target to low. If the 665 * adjustment we apply here is not capable of recovering all the extra 666 * bits we have spent in the KF or GF then the remainder will have to 667 * be recovered over a longer time span via other buffer / rate control 668 * mechanisms. 669 */ 670 if (cpi->this_frame_target < min_frame_target) { 671 cpi->this_frame_target = min_frame_target; 672 } 673 674 if (!cpi->common.refresh_alt_ref_frame) { 675 /* Note the baseline target data rate for this inter frame. */ 676 cpi->inter_frame_target = cpi->this_frame_target; 677 } 678 679 /* One Pass specific code */ 680 if (cpi->pass == 0) { 681 /* Adapt target frame size with respect to any buffering constraints: */ 682 if (cpi->buffered_mode) { 683 int one_percent_bits = (int)(1 + cpi->oxcf.optimal_buffer_level / 100); 684 685 if ((cpi->buffer_level < cpi->oxcf.optimal_buffer_level) || 686 (cpi->bits_off_target < cpi->oxcf.optimal_buffer_level)) { 687 int percent_low = 0; 688 689 /* Decide whether or not we need to adjust the frame data 690 * rate target. 691 * 692 * If we are are below the optimal buffer fullness level 693 * and adherence to buffering constraints is important to 694 * the end usage then adjust the per frame target. 695 */ 696 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) && 697 (cpi->buffer_level < cpi->oxcf.optimal_buffer_level)) { 698 percent_low = 699 (int)((cpi->oxcf.optimal_buffer_level - cpi->buffer_level) / 700 one_percent_bits); 701 } 702 /* Are we overshooting the long term clip data rate... */ 703 else if (cpi->bits_off_target < 0) { 704 /* Adjust per frame data target downwards to compensate. */ 705 percent_low = 706 (int)(100 * -cpi->bits_off_target / (cpi->total_byte_count * 8)); 707 } 708 709 if (percent_low > cpi->oxcf.under_shoot_pct) { 710 percent_low = cpi->oxcf.under_shoot_pct; 711 } else if (percent_low < 0) { 712 percent_low = 0; 713 } 714 715 /* lower the target bandwidth for this frame. */ 716 cpi->this_frame_target -= (cpi->this_frame_target * percent_low) / 200; 717 718 /* Are we using allowing control of active_worst_allowed_q 719 * according to buffer level. 720 */ 721 if (cpi->auto_worst_q && cpi->ni_frames > 150) { 722 int64_t critical_buffer_level; 723 724 /* For streaming applications the most important factor is 725 * cpi->buffer_level as this takes into account the 726 * specified short term buffering constraints. However, 727 * hitting the long term clip data rate target is also 728 * important. 729 */ 730 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) { 731 /* Take the smaller of cpi->buffer_level and 732 * cpi->bits_off_target 733 */ 734 critical_buffer_level = (cpi->buffer_level < cpi->bits_off_target) 735 ? cpi->buffer_level 736 : cpi->bits_off_target; 737 } 738 /* For local file playback short term buffering constraints 739 * are less of an issue 740 */ 741 else { 742 /* Consider only how we are doing for the clip as a 743 * whole 744 */ 745 critical_buffer_level = cpi->bits_off_target; 746 } 747 748 /* Set the active worst quality based upon the selected 749 * buffer fullness number. 750 */ 751 if (critical_buffer_level < cpi->oxcf.optimal_buffer_level) { 752 if (critical_buffer_level > (cpi->oxcf.optimal_buffer_level >> 2)) { 753 int64_t qadjustment_range = cpi->worst_quality - cpi->ni_av_qi; 754 int64_t above_base = (critical_buffer_level - 755 (cpi->oxcf.optimal_buffer_level >> 2)); 756 757 /* Step active worst quality down from 758 * cpi->ni_av_qi when (critical_buffer_level == 759 * cpi->optimal_buffer_level) to 760 * cpi->worst_quality when 761 * (critical_buffer_level == 762 * cpi->optimal_buffer_level >> 2) 763 */ 764 cpi->active_worst_quality = 765 cpi->worst_quality - 766 (int)((qadjustment_range * above_base) / 767 (cpi->oxcf.optimal_buffer_level * 3 >> 2)); 768 } else { 769 cpi->active_worst_quality = cpi->worst_quality; 770 } 771 } else { 772 cpi->active_worst_quality = cpi->ni_av_qi; 773 } 774 } else { 775 cpi->active_worst_quality = cpi->worst_quality; 776 } 777 } else { 778 int percent_high = 0; 779 780 if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) && 781 (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)) { 782 percent_high = 783 (int)((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) / 784 one_percent_bits); 785 } else if (cpi->bits_off_target > cpi->oxcf.optimal_buffer_level) { 786 percent_high = 787 (int)((100 * cpi->bits_off_target) / (cpi->total_byte_count * 8)); 788 } 789 790 if (percent_high > cpi->oxcf.over_shoot_pct) { 791 percent_high = cpi->oxcf.over_shoot_pct; 792 } else if (percent_high < 0) { 793 percent_high = 0; 794 } 795 796 cpi->this_frame_target += (cpi->this_frame_target * percent_high) / 200; 797 798 /* Are we allowing control of active_worst_allowed_q according 799 * to buffer level. 800 */ 801 if (cpi->auto_worst_q && cpi->ni_frames > 150) { 802 /* When using the relaxed buffer model stick to the 803 * user specified value 804 */ 805 cpi->active_worst_quality = cpi->ni_av_qi; 806 } else { 807 cpi->active_worst_quality = cpi->worst_quality; 808 } 809 } 810 811 /* Set active_best_quality to prevent quality rising too high */ 812 cpi->active_best_quality = cpi->best_quality; 813 814 /* Worst quality obviously must not be better than best quality */ 815 if (cpi->active_worst_quality <= cpi->active_best_quality) { 816 cpi->active_worst_quality = cpi->active_best_quality + 1; 817 } 818 819 if (cpi->active_worst_quality > 127) cpi->active_worst_quality = 127; 820 } 821 /* Unbuffered mode (eg. video conferencing) */ 822 else { 823 /* Set the active worst quality */ 824 cpi->active_worst_quality = cpi->worst_quality; 825 } 826 827 /* Special trap for constrained quality mode 828 * "active_worst_quality" may never drop below cq level 829 * for any frame type. 830 */ 831 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY && 832 cpi->active_worst_quality < cpi->cq_target_quality) { 833 cpi->active_worst_quality = cpi->cq_target_quality; 834 } 835 } 836 837 /* Test to see if we have to drop a frame 838 * The auto-drop frame code is only used in buffered mode. 839 * In unbufferd mode (eg vide conferencing) the descision to 840 * code or drop a frame is made outside the codec in response to real 841 * world comms or buffer considerations. 842 */ 843 if (cpi->drop_frames_allowed && 844 (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) && 845 ((cpi->common.frame_type != KEY_FRAME))) { 846 /* Check for a buffer underun-crisis in which case we have to drop 847 * a frame 848 */ 849 if ((cpi->buffer_level < 0)) { 850 #if 0 851 FILE *f = fopen("dec.stt", "a"); 852 fprintf(f, "%10d %10d %10d %10d ***** BUFFER EMPTY\n", 853 (int) cpi->common.current_video_frame, 854 cpi->decimation_factor, cpi->common.horiz_scale, 855 (cpi->buffer_level * 100) / cpi->oxcf.optimal_buffer_level); 856 fclose(f); 857 #endif 858 cpi->drop_frame = 1; 859 860 /* Update the buffer level variable. */ 861 cpi->bits_off_target += cpi->av_per_frame_bandwidth; 862 if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size) { 863 cpi->bits_off_target = (int)cpi->oxcf.maximum_buffer_size; 864 } 865 cpi->buffer_level = cpi->bits_off_target; 866 867 if (cpi->oxcf.number_of_layers > 1) { 868 unsigned int i; 869 870 // Propagate bits saved by dropping the frame to higher layers. 871 for (i = cpi->current_layer + 1; i < cpi->oxcf.number_of_layers; ++i) { 872 LAYER_CONTEXT *lc = &cpi->layer_context[i]; 873 lc->bits_off_target += (int)(lc->target_bandwidth / lc->framerate); 874 if (lc->bits_off_target > lc->maximum_buffer_size) { 875 lc->bits_off_target = lc->maximum_buffer_size; 876 } 877 lc->buffer_level = lc->bits_off_target; 878 } 879 } 880 } 881 } 882 883 /* Adjust target frame size for Golden Frames: */ 884 if (cpi->oxcf.error_resilient_mode == 0 && 885 (cpi->frames_till_gf_update_due == 0) && !cpi->drop_frame) { 886 if (!cpi->gf_update_onepass_cbr) { 887 int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] 888 : cpi->oxcf.fixed_q; 889 890 int gf_frame_useage = 0; /* Golden frame useage since last GF */ 891 int tot_mbs = cpi->recent_ref_frame_usage[INTRA_FRAME] + 892 cpi->recent_ref_frame_usage[LAST_FRAME] + 893 cpi->recent_ref_frame_usage[GOLDEN_FRAME] + 894 cpi->recent_ref_frame_usage[ALTREF_FRAME]; 895 896 int pct_gf_active = (100 * cpi->gf_active_count) / 897 (cpi->common.mb_rows * cpi->common.mb_cols); 898 899 if (tot_mbs) { 900 gf_frame_useage = (cpi->recent_ref_frame_usage[GOLDEN_FRAME] + 901 cpi->recent_ref_frame_usage[ALTREF_FRAME]) * 902 100 / tot_mbs; 903 } 904 905 if (pct_gf_active > gf_frame_useage) gf_frame_useage = pct_gf_active; 906 907 /* Is a fixed manual GF frequency being used */ 908 if (cpi->auto_gold) { 909 /* For one pass throw a GF if recent frame intra useage is 910 * low or the GF useage is high 911 */ 912 if ((cpi->pass == 0) && 913 (cpi->this_frame_percent_intra < 15 || gf_frame_useage >= 5)) { 914 cpi->common.refresh_golden_frame = 1; 915 916 /* Two pass GF descision */ 917 } else if (cpi->pass == 2) { 918 cpi->common.refresh_golden_frame = 1; 919 } 920 } 921 922 #if 0 923 924 /* Debug stats */ 925 if (0) { 926 FILE *f; 927 928 f = fopen("gf_useaget.stt", "a"); 929 fprintf(f, " %8ld %10ld %10ld %10ld %10ld\n", 930 cpi->common.current_video_frame, cpi->gfu_boost, 931 GFQ_ADJUSTMENT, cpi->gfu_boost, gf_frame_useage); 932 fclose(f); 933 } 934 935 #endif 936 937 if (cpi->common.refresh_golden_frame == 1) { 938 #if 0 939 940 if (0) { 941 FILE *f; 942 943 f = fopen("GFexit.stt", "a"); 944 fprintf(f, "%8ld GF coded\n", cpi->common.current_video_frame); 945 fclose(f); 946 } 947 948 #endif 949 950 if (cpi->auto_adjust_gold_quantizer) { 951 calc_gf_params(cpi); 952 } 953 954 /* If we are using alternate ref instead of gf then do not apply the 955 * boost It will instead be applied to the altref update Jims 956 * modified boost 957 */ 958 if (!cpi->source_alt_ref_active) { 959 if (cpi->oxcf.fixed_q < 0) { 960 if (cpi->pass == 2) { 961 /* The spend on the GF is defined in the two pass 962 * code for two pass encodes 963 */ 964 cpi->this_frame_target = cpi->per_frame_bandwidth; 965 } else { 966 int Boost = cpi->last_boost; 967 int frames_in_section = cpi->frames_till_gf_update_due + 1; 968 int allocation_chunks = (frames_in_section * 100) + (Boost - 100); 969 int bits_in_section = cpi->inter_frame_target * frames_in_section; 970 971 /* Normalize Altboost and allocations chunck down to 972 * prevent overflow 973 */ 974 while (Boost > 1000) { 975 Boost /= 2; 976 allocation_chunks /= 2; 977 } 978 979 /* Avoid loss of precision but avoid overflow */ 980 if ((bits_in_section >> 7) > allocation_chunks) { 981 cpi->this_frame_target = 982 Boost * (bits_in_section / allocation_chunks); 983 } else { 984 cpi->this_frame_target = 985 (Boost * bits_in_section) / allocation_chunks; 986 } 987 } 988 } else { 989 cpi->this_frame_target = 990 (estimate_bits_at_q(1, Q, cpi->common.MBs, 1.0) * 991 cpi->last_boost) / 992 100; 993 } 994 } else { 995 /* If there is an active ARF at this location use the minimum 996 * bits on this frame even if it is a contructed arf. 997 * The active maximum quantizer insures that an appropriate 998 * number of bits will be spent if needed for contstructed ARFs. 999 */ 1000 cpi->this_frame_target = 0; 1001 } 1002 1003 cpi->current_gf_interval = cpi->frames_till_gf_update_due; 1004 } 1005 } else { 1006 // Special case for 1 pass CBR: fixed gf period. 1007 // TODO(marpan): Adjust this boost/interval logic. 1008 // If gf_cbr_boost_pct is small (below threshold) set the flag 1009 // gf_noboost_onepass_cbr = 1, which forces the gf to use the same 1010 // rate correction factor as last. 1011 cpi->gf_noboost_onepass_cbr = (cpi->oxcf.gf_cbr_boost_pct <= 100); 1012 cpi->baseline_gf_interval = cpi->gf_interval_onepass_cbr; 1013 // Skip this update if the zero_mvcount is low. 1014 if (cpi->zeromv_count > (cpi->common.MBs >> 1)) { 1015 cpi->common.refresh_golden_frame = 1; 1016 cpi->this_frame_target = 1017 (cpi->this_frame_target * (100 + cpi->oxcf.gf_cbr_boost_pct)) / 100; 1018 } 1019 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 1020 cpi->current_gf_interval = cpi->frames_till_gf_update_due; 1021 } 1022 } 1023 1024 cpi->per_frame_bandwidth = old_per_frame_bandwidth; 1025 } 1026 1027 void vp8_update_rate_correction_factors(VP8_COMP *cpi, int damp_var) { 1028 int Q = cpi->common.base_qindex; 1029 int correction_factor = 100; 1030 double rate_correction_factor; 1031 double adjustment_limit; 1032 1033 int projected_size_based_on_q = 0; 1034 1035 /* Clear down mmx registers to allow floating point in what follows */ 1036 vpx_clear_system_state(); 1037 1038 if (cpi->common.frame_type == KEY_FRAME) { 1039 rate_correction_factor = cpi->key_frame_rate_correction_factor; 1040 } else { 1041 if (cpi->oxcf.number_of_layers == 1 && !cpi->gf_noboost_onepass_cbr && 1042 (cpi->common.refresh_alt_ref_frame || 1043 cpi->common.refresh_golden_frame)) { 1044 rate_correction_factor = cpi->gf_rate_correction_factor; 1045 } else { 1046 rate_correction_factor = cpi->rate_correction_factor; 1047 } 1048 } 1049 1050 /* Work out how big we would have expected the frame to be at this Q 1051 * given the current correction factor. Stay in double to avoid int 1052 * overflow when values are large 1053 */ 1054 projected_size_based_on_q = 1055 (int)(((.5 + 1056 rate_correction_factor * 1057 vp8_bits_per_mb[cpi->common.frame_type][Q]) * 1058 cpi->common.MBs) / 1059 (1 << BPER_MB_NORMBITS)); 1060 1061 /* Make some allowance for cpi->zbin_over_quant */ 1062 if (cpi->mb.zbin_over_quant > 0) { 1063 int Z = cpi->mb.zbin_over_quant; 1064 double Factor = 0.99; 1065 double factor_adjustment = 0.01 / 256.0; 1066 1067 while (Z > 0) { 1068 Z--; 1069 projected_size_based_on_q = (int)(Factor * projected_size_based_on_q); 1070 Factor += factor_adjustment; 1071 1072 if (Factor >= 0.999) Factor = 0.999; 1073 } 1074 } 1075 1076 /* Work out a size correction factor. */ 1077 if (projected_size_based_on_q > 0) { 1078 correction_factor = 1079 (100 * cpi->projected_frame_size) / projected_size_based_on_q; 1080 } 1081 1082 /* More heavily damped adjustment used if we have been oscillating 1083 * either side of target 1084 */ 1085 switch (damp_var) { 1086 case 0: adjustment_limit = 0.75; break; 1087 case 1: adjustment_limit = 0.375; break; 1088 case 2: 1089 default: adjustment_limit = 0.25; break; 1090 } 1091 1092 if (correction_factor > 102) { 1093 /* We are not already at the worst allowable quality */ 1094 correction_factor = 1095 (int)(100.5 + ((correction_factor - 100) * adjustment_limit)); 1096 rate_correction_factor = 1097 ((rate_correction_factor * correction_factor) / 100); 1098 1099 /* Keep rate_correction_factor within limits */ 1100 if (rate_correction_factor > MAX_BPB_FACTOR) { 1101 rate_correction_factor = MAX_BPB_FACTOR; 1102 } 1103 } else if (correction_factor < 99) { 1104 /* We are not already at the best allowable quality */ 1105 correction_factor = 1106 (int)(100.5 - ((100 - correction_factor) * adjustment_limit)); 1107 rate_correction_factor = 1108 ((rate_correction_factor * correction_factor) / 100); 1109 1110 /* Keep rate_correction_factor within limits */ 1111 if (rate_correction_factor < MIN_BPB_FACTOR) { 1112 rate_correction_factor = MIN_BPB_FACTOR; 1113 } 1114 } 1115 1116 if (cpi->common.frame_type == KEY_FRAME) { 1117 cpi->key_frame_rate_correction_factor = rate_correction_factor; 1118 } else { 1119 if (cpi->oxcf.number_of_layers == 1 && !cpi->gf_noboost_onepass_cbr && 1120 (cpi->common.refresh_alt_ref_frame || 1121 cpi->common.refresh_golden_frame)) { 1122 cpi->gf_rate_correction_factor = rate_correction_factor; 1123 } else { 1124 cpi->rate_correction_factor = rate_correction_factor; 1125 } 1126 } 1127 } 1128 1129 int vp8_regulate_q(VP8_COMP *cpi, int target_bits_per_frame) { 1130 int Q = cpi->active_worst_quality; 1131 1132 if (cpi->force_maxqp == 1) { 1133 cpi->active_worst_quality = cpi->worst_quality; 1134 return cpi->worst_quality; 1135 } 1136 /* Reset Zbin OQ value */ 1137 cpi->mb.zbin_over_quant = 0; 1138 1139 if (cpi->oxcf.fixed_q >= 0) { 1140 Q = cpi->oxcf.fixed_q; 1141 1142 if (cpi->common.frame_type == KEY_FRAME) { 1143 Q = cpi->oxcf.key_q; 1144 } else if (cpi->oxcf.number_of_layers == 1 && 1145 cpi->common.refresh_alt_ref_frame && 1146 !cpi->gf_noboost_onepass_cbr) { 1147 Q = cpi->oxcf.alt_q; 1148 } else if (cpi->oxcf.number_of_layers == 1 && 1149 cpi->common.refresh_golden_frame && 1150 !cpi->gf_noboost_onepass_cbr) { 1151 Q = cpi->oxcf.gold_q; 1152 } 1153 } else { 1154 int i; 1155 int last_error = INT_MAX; 1156 int target_bits_per_mb; 1157 int bits_per_mb_at_this_q; 1158 double correction_factor; 1159 1160 /* Select the appropriate correction factor based upon type of frame. */ 1161 if (cpi->common.frame_type == KEY_FRAME) { 1162 correction_factor = cpi->key_frame_rate_correction_factor; 1163 } else { 1164 if (cpi->oxcf.number_of_layers == 1 && !cpi->gf_noboost_onepass_cbr && 1165 (cpi->common.refresh_alt_ref_frame || 1166 cpi->common.refresh_golden_frame)) { 1167 correction_factor = cpi->gf_rate_correction_factor; 1168 } else { 1169 correction_factor = cpi->rate_correction_factor; 1170 } 1171 } 1172 1173 /* Calculate required scaling factor based on target frame size and 1174 * size of frame produced using previous Q 1175 */ 1176 if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS)) { 1177 /* Case where we would overflow int */ 1178 target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) 1179 << BPER_MB_NORMBITS; 1180 } else { 1181 target_bits_per_mb = 1182 (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs; 1183 } 1184 1185 i = cpi->active_best_quality; 1186 1187 do { 1188 bits_per_mb_at_this_q = 1189 (int)(.5 + 1190 correction_factor * vp8_bits_per_mb[cpi->common.frame_type][i]); 1191 1192 if (bits_per_mb_at_this_q <= target_bits_per_mb) { 1193 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error) { 1194 Q = i; 1195 } else { 1196 Q = i - 1; 1197 } 1198 1199 break; 1200 } else { 1201 last_error = bits_per_mb_at_this_q - target_bits_per_mb; 1202 } 1203 } while (++i <= cpi->active_worst_quality); 1204 1205 /* If we are at MAXQ then enable Q over-run which seeks to claw 1206 * back additional bits through things like the RD multiplier 1207 * and zero bin size. 1208 */ 1209 if (Q >= MAXQ) { 1210 int zbin_oqmax; 1211 1212 double Factor = 0.99; 1213 double factor_adjustment = 0.01 / 256.0; 1214 1215 if (cpi->common.frame_type == KEY_FRAME) { 1216 zbin_oqmax = 0; 1217 } else if (cpi->oxcf.number_of_layers == 1 && 1218 !cpi->gf_noboost_onepass_cbr && 1219 (cpi->common.refresh_alt_ref_frame || 1220 (cpi->common.refresh_golden_frame && 1221 !cpi->source_alt_ref_active))) { 1222 zbin_oqmax = 16; 1223 } else { 1224 zbin_oqmax = ZBIN_OQ_MAX; 1225 } 1226 1227 /*{ 1228 double Factor = 1229 (double)target_bits_per_mb/(double)bits_per_mb_at_this_q; 1230 double Oq; 1231 1232 Factor = Factor/1.2683; 1233 1234 Oq = pow( Factor, (1.0/-0.165) ); 1235 1236 if ( Oq > zbin_oqmax ) 1237 Oq = zbin_oqmax; 1238 1239 cpi->zbin_over_quant = (int)Oq; 1240 }*/ 1241 1242 /* Each incrment in the zbin is assumed to have a fixed effect 1243 * on bitrate. This is not of course true. The effect will be 1244 * highly clip dependent and may well have sudden steps. The 1245 * idea here is to acheive higher effective quantizers than the 1246 * normal maximum by expanding the zero bin and hence 1247 * decreasing the number of low magnitude non zero coefficients. 1248 */ 1249 while (cpi->mb.zbin_over_quant < zbin_oqmax) { 1250 cpi->mb.zbin_over_quant++; 1251 1252 if (cpi->mb.zbin_over_quant > zbin_oqmax) { 1253 cpi->mb.zbin_over_quant = zbin_oqmax; 1254 } 1255 1256 /* Adjust bits_per_mb_at_this_q estimate */ 1257 bits_per_mb_at_this_q = (int)(Factor * bits_per_mb_at_this_q); 1258 Factor += factor_adjustment; 1259 1260 if (Factor >= 0.999) Factor = 0.999; 1261 1262 /* Break out if we get down to the target rate */ 1263 if (bits_per_mb_at_this_q <= target_bits_per_mb) break; 1264 } 1265 } 1266 } 1267 1268 return Q; 1269 } 1270 1271 static int estimate_keyframe_frequency(VP8_COMP *cpi) { 1272 int i; 1273 1274 /* Average key frame frequency */ 1275 int av_key_frame_frequency = 0; 1276 1277 /* First key frame at start of sequence is a special case. We have no 1278 * frequency data. 1279 */ 1280 if (cpi->key_frame_count == 1) { 1281 /* Assume a default of 1 kf every 2 seconds, or the max kf interval, 1282 * whichever is smaller. 1283 */ 1284 int key_freq = cpi->oxcf.key_freq > 0 ? cpi->oxcf.key_freq : 1; 1285 av_key_frame_frequency = 1 + (int)cpi->output_framerate * 2; 1286 1287 if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq) { 1288 av_key_frame_frequency = key_freq; 1289 } 1290 1291 cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1] = 1292 av_key_frame_frequency; 1293 } else { 1294 unsigned int total_weight = 0; 1295 int last_kf_interval = 1296 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1; 1297 1298 /* reset keyframe context and calculate weighted average of last 1299 * KEY_FRAME_CONTEXT keyframes 1300 */ 1301 for (i = 0; i < KEY_FRAME_CONTEXT; ++i) { 1302 if (i < KEY_FRAME_CONTEXT - 1) { 1303 cpi->prior_key_frame_distance[i] = cpi->prior_key_frame_distance[i + 1]; 1304 } else { 1305 cpi->prior_key_frame_distance[i] = last_kf_interval; 1306 } 1307 1308 av_key_frame_frequency += 1309 prior_key_frame_weight[i] * cpi->prior_key_frame_distance[i]; 1310 total_weight += prior_key_frame_weight[i]; 1311 } 1312 1313 av_key_frame_frequency /= total_weight; 1314 } 1315 // TODO (marpan): Given the checks above, |av_key_frame_frequency| 1316 // should always be above 0. But for now we keep the sanity check in. 1317 if (av_key_frame_frequency == 0) av_key_frame_frequency = 1; 1318 return av_key_frame_frequency; 1319 } 1320 1321 void vp8_adjust_key_frame_context(VP8_COMP *cpi) { 1322 /* Clear down mmx registers to allow floating point in what follows */ 1323 vpx_clear_system_state(); 1324 1325 /* Do we have any key frame overspend to recover? */ 1326 /* Two-pass overspend handled elsewhere. */ 1327 if ((cpi->pass != 2) && 1328 (cpi->projected_frame_size > cpi->per_frame_bandwidth)) { 1329 int overspend; 1330 1331 /* Update the count of key frame overspend to be recovered in 1332 * subsequent frames. A portion of the KF overspend is treated as gf 1333 * overspend (and hence recovered more quickly) as the kf is also a 1334 * gf. Otherwise the few frames following each kf tend to get more 1335 * bits allocated than those following other gfs. 1336 */ 1337 overspend = (cpi->projected_frame_size - cpi->per_frame_bandwidth); 1338 1339 if (cpi->oxcf.number_of_layers > 1) { 1340 cpi->kf_overspend_bits += overspend; 1341 } else { 1342 cpi->kf_overspend_bits += overspend * 7 / 8; 1343 cpi->gf_overspend_bits += overspend * 1 / 8; 1344 } 1345 1346 /* Work out how much to try and recover per frame. */ 1347 cpi->kf_bitrate_adjustment = 1348 cpi->kf_overspend_bits / estimate_keyframe_frequency(cpi); 1349 } 1350 1351 cpi->frames_since_key = 0; 1352 cpi->key_frame_count++; 1353 } 1354 1355 void vp8_compute_frame_size_bounds(VP8_COMP *cpi, int *frame_under_shoot_limit, 1356 int *frame_over_shoot_limit) { 1357 /* Set-up bounds on acceptable frame size: */ 1358 if (cpi->oxcf.fixed_q >= 0) { 1359 /* Fixed Q scenario: frame size never outranges target 1360 * (there is no target!) 1361 */ 1362 *frame_under_shoot_limit = 0; 1363 *frame_over_shoot_limit = INT_MAX; 1364 } else { 1365 if (cpi->common.frame_type == KEY_FRAME) { 1366 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8; 1367 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8; 1368 } else { 1369 if (cpi->oxcf.number_of_layers > 1 || cpi->common.refresh_alt_ref_frame || 1370 cpi->common.refresh_golden_frame) { 1371 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8; 1372 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8; 1373 } else { 1374 /* For CBR take buffer fullness into account */ 1375 if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) { 1376 if (cpi->buffer_level >= ((cpi->oxcf.optimal_buffer_level + 1377 cpi->oxcf.maximum_buffer_size) >> 1378 1)) { 1379 /* Buffer is too full so relax overshoot and tighten 1380 * undershoot 1381 */ 1382 *frame_over_shoot_limit = cpi->this_frame_target * 12 / 8; 1383 *frame_under_shoot_limit = cpi->this_frame_target * 6 / 8; 1384 } else if (cpi->buffer_level <= 1385 (cpi->oxcf.optimal_buffer_level >> 1)) { 1386 /* Buffer is too low so relax undershoot and tighten 1387 * overshoot 1388 */ 1389 *frame_over_shoot_limit = cpi->this_frame_target * 10 / 8; 1390 *frame_under_shoot_limit = cpi->this_frame_target * 4 / 8; 1391 } else { 1392 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8; 1393 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8; 1394 } 1395 } 1396 /* VBR and CQ mode */ 1397 /* Note that tighter restrictions here can help quality 1398 * but hurt encode speed 1399 */ 1400 else { 1401 /* Stron overshoot limit for constrained quality */ 1402 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) { 1403 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8; 1404 *frame_under_shoot_limit = cpi->this_frame_target * 2 / 8; 1405 } else { 1406 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8; 1407 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8; 1408 } 1409 } 1410 } 1411 } 1412 1413 /* For very small rate targets where the fractional adjustment 1414 * (eg * 7/8) may be tiny make sure there is at least a minimum 1415 * range. 1416 */ 1417 *frame_over_shoot_limit += 200; 1418 *frame_under_shoot_limit -= 200; 1419 if (*frame_under_shoot_limit < 0) *frame_under_shoot_limit = 0; 1420 } 1421 } 1422 1423 /* return of 0 means drop frame */ 1424 int vp8_pick_frame_size(VP8_COMP *cpi) { 1425 VP8_COMMON *cm = &cpi->common; 1426 1427 if (cm->frame_type == KEY_FRAME) { 1428 calc_iframe_target_size(cpi); 1429 } else { 1430 calc_pframe_target_size(cpi); 1431 1432 /* Check if we're dropping the frame: */ 1433 if (cpi->drop_frame) { 1434 cpi->drop_frame = 0; 1435 return 0; 1436 } 1437 } 1438 return 1; 1439 } 1440 // If this just encoded frame (mcomp/transform/quant, but before loopfilter and 1441 // pack_bitstream) has large overshoot, and was not being encoded close to the 1442 // max QP, then drop this frame and force next frame to be encoded at max QP. 1443 // Allow this for screen_content_mode = 2, or if drop frames is allowed. 1444 // TODO(marpan): Should do this exit condition during the encode_frame 1445 // (i.e., halfway during the encoding of the frame) to save cycles. 1446 int vp8_drop_encodedframe_overshoot(VP8_COMP *cpi, int Q) { 1447 int force_drop_overshoot = 0; 1448 #if CONFIG_MULTI_RES_ENCODING 1449 // Only check for dropping due to overshoot on the lowest stream. 1450 // If the lowest stream of the multi-res encoding was dropped due to 1451 // overshoot, then force dropping on all upper layer streams 1452 // (mr_encoder_id > 0). 1453 LOWER_RES_FRAME_INFO *low_res_frame_info = 1454 (LOWER_RES_FRAME_INFO *)cpi->oxcf.mr_low_res_mode_info; 1455 if (cpi->oxcf.mr_total_resolutions > 1 && cpi->oxcf.mr_encoder_id > 0) { 1456 force_drop_overshoot = low_res_frame_info->is_frame_dropped_overshoot_maxqp; 1457 if (!force_drop_overshoot) { 1458 cpi->force_maxqp = 0; 1459 cpi->frames_since_last_drop_overshoot++; 1460 return 0; 1461 } 1462 } 1463 #endif 1464 if (cpi->common.frame_type != KEY_FRAME && 1465 (cpi->oxcf.screen_content_mode == 2 || 1466 (cpi->drop_frames_allowed && 1467 (force_drop_overshoot || 1468 (cpi->rate_correction_factor < (4.0f * MIN_BPB_FACTOR) && 1469 cpi->frames_since_last_drop_overshoot > (int)cpi->framerate))))) { 1470 // Note: the "projected_frame_size" from encode_frame() only gives estimate 1471 // of mode/motion vector rate (in non-rd mode): so below we only require 1472 // that projected_frame_size is somewhat greater than per-frame-bandwidth, 1473 // but add additional condition with high threshold on prediction residual. 1474 1475 // QP threshold: only allow dropping if we are not close to qp_max. 1476 int thresh_qp = 3 * cpi->worst_quality >> 2; 1477 // Rate threshold, in bytes. 1478 int thresh_rate = 2 * (cpi->av_per_frame_bandwidth >> 3); 1479 // Threshold for the average (over all macroblocks) of the pixel-sum 1480 // residual error over 16x16 block. 1481 int thresh_pred_err_mb = (200 << 4); 1482 int pred_err_mb = (int)(cpi->mb.prediction_error / cpi->common.MBs); 1483 // Reduce/ignore thresh_rate if pred_err_mb much larger than its threshold, 1484 // give more weight to pred_err metric for overshoot detection. 1485 if (cpi->drop_frames_allowed && pred_err_mb > (thresh_pred_err_mb << 4)) 1486 thresh_rate = thresh_rate >> 3; 1487 if ((Q < thresh_qp && cpi->projected_frame_size > thresh_rate && 1488 pred_err_mb > thresh_pred_err_mb) || 1489 force_drop_overshoot) { 1490 unsigned int i; 1491 double new_correction_factor; 1492 int target_bits_per_mb; 1493 const int target_size = cpi->av_per_frame_bandwidth; 1494 // Flag to indicate we will force next frame to be encoded at max QP. 1495 cpi->force_maxqp = 1; 1496 // Reset the buffer levels. 1497 cpi->buffer_level = cpi->oxcf.optimal_buffer_level; 1498 cpi->bits_off_target = cpi->oxcf.optimal_buffer_level; 1499 // Compute a new rate correction factor, corresponding to the current 1500 // target frame size and max_QP, and adjust the rate correction factor 1501 // upwards, if needed. 1502 // This is to prevent a bad state where the re-encoded frame at max_QP 1503 // undershoots significantly, and then we end up dropping every other 1504 // frame because the QP/rate_correction_factor may have been too low 1505 // before the drop and then takes too long to come up. 1506 if (target_size >= (INT_MAX >> BPER_MB_NORMBITS)) { 1507 target_bits_per_mb = (target_size / cpi->common.MBs) 1508 << BPER_MB_NORMBITS; 1509 } else { 1510 target_bits_per_mb = 1511 (target_size << BPER_MB_NORMBITS) / cpi->common.MBs; 1512 } 1513 // Rate correction factor based on target_size_per_mb and max_QP. 1514 new_correction_factor = 1515 (double)target_bits_per_mb / 1516 (double)vp8_bits_per_mb[INTER_FRAME][cpi->worst_quality]; 1517 if (new_correction_factor > cpi->rate_correction_factor) { 1518 cpi->rate_correction_factor = 1519 VPXMIN(2.0 * cpi->rate_correction_factor, new_correction_factor); 1520 } 1521 if (cpi->rate_correction_factor > MAX_BPB_FACTOR) { 1522 cpi->rate_correction_factor = MAX_BPB_FACTOR; 1523 } 1524 // Drop this frame: update frame counters. 1525 cpi->common.current_video_frame++; 1526 cpi->frames_since_key++; 1527 cpi->temporal_pattern_counter++; 1528 cpi->frames_since_last_drop_overshoot = 0; 1529 if (cpi->oxcf.number_of_layers > 1) { 1530 // Set max_qp and rate correction for all temporal layers if overshoot 1531 // is detected. 1532 for (i = 0; i < cpi->oxcf.number_of_layers; ++i) { 1533 LAYER_CONTEXT *lc = &cpi->layer_context[i]; 1534 lc->force_maxqp = 1; 1535 lc->frames_since_last_drop_overshoot = 0; 1536 lc->rate_correction_factor = cpi->rate_correction_factor; 1537 } 1538 } 1539 #if CONFIG_MULTI_RES_ENCODING 1540 if (cpi->oxcf.mr_total_resolutions > 1) 1541 low_res_frame_info->is_frame_dropped_overshoot_maxqp = 1; 1542 #endif 1543 return 1; 1544 } 1545 cpi->force_maxqp = 0; 1546 cpi->frames_since_last_drop_overshoot++; 1547 #if CONFIG_MULTI_RES_ENCODING 1548 if (cpi->oxcf.mr_total_resolutions > 1) 1549 low_res_frame_info->is_frame_dropped_overshoot_maxqp = 0; 1550 #endif 1551 return 0; 1552 } 1553 cpi->force_maxqp = 0; 1554 cpi->frames_since_last_drop_overshoot++; 1555 #if CONFIG_MULTI_RES_ENCODING 1556 if (cpi->oxcf.mr_total_resolutions > 1) 1557 low_res_frame_info->is_frame_dropped_overshoot_maxqp = 0; 1558 #endif 1559 return 0; 1560 } 1561
