1 /* 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 12 #include <stdlib.h> 13 #include <stdio.h> 14 #include <string.h> 15 #include <limits.h> 16 #include <assert.h> 17 #include <math.h> 18 19 #include "vp9/common/vp9_alloccommon.h" 20 #include "vp9/common/vp9_common.h" 21 #include "vp9/encoder/vp9_ratectrl.h" 22 #include "vp9/common/vp9_entropymode.h" 23 #include "vpx_mem/vpx_mem.h" 24 #include "vp9/common/vp9_systemdependent.h" 25 #include "vp9/encoder/vp9_encodemv.h" 26 #include "vp9/common/vp9_quant_common.h" 27 #include "vp9/common/vp9_seg_common.h" 28 29 #define MIN_BPB_FACTOR 0.005 30 #define MAX_BPB_FACTOR 50 31 32 // Bits Per MB at different Q (Multiplied by 512) 33 #define BPER_MB_NORMBITS 9 34 35 static const unsigned int prior_key_frame_weight[KEY_FRAME_CONTEXT] = 36 { 1, 2, 3, 4, 5 }; 37 38 // These functions use formulaic calculations to make playing with the 39 // quantizer tables easier. If necessary they can be replaced by lookup 40 // tables if and when things settle down in the experimental bitstream 41 double vp9_convert_qindex_to_q(int qindex) { 42 // Convert the index to a real Q value (scaled down to match old Q values) 43 return vp9_ac_quant(qindex, 0) / 4.0; 44 } 45 46 int vp9_gfboost_qadjust(int qindex) { 47 const double q = vp9_convert_qindex_to_q(qindex); 48 return (int)((0.00000828 * q * q * q) + 49 (-0.0055 * q * q) + 50 (1.32 * q) + 79.3); 51 } 52 53 static int kfboost_qadjust(int qindex) { 54 const double q = vp9_convert_qindex_to_q(qindex); 55 return (int)((0.00000973 * q * q * q) + 56 (-0.00613 * q * q) + 57 (1.316 * q) + 121.2); 58 } 59 60 int vp9_bits_per_mb(FRAME_TYPE frame_type, int qindex, 61 double correction_factor) { 62 63 const double q = vp9_convert_qindex_to_q(qindex); 64 int enumerator = frame_type == KEY_FRAME ? 4000000 : 2500000; 65 66 // q based adjustment to baseline enumerator 67 enumerator += (int)(enumerator * q) >> 12; 68 return (int)(0.5 + (enumerator * correction_factor / q)); 69 } 70 71 void vp9_save_coding_context(VP9_COMP *cpi) { 72 CODING_CONTEXT *const cc = &cpi->coding_context; 73 VP9_COMMON *cm = &cpi->common; 74 75 // Stores a snapshot of key state variables which can subsequently be 76 // restored with a call to vp9_restore_coding_context. These functions are 77 // intended for use in a re-code loop in vp9_compress_frame where the 78 // quantizer value is adjusted between loop iterations. 79 80 cc->nmvc = cm->fc.nmvc; 81 vp9_copy(cc->nmvjointcost, cpi->mb.nmvjointcost); 82 vp9_copy(cc->nmvcosts, cpi->mb.nmvcosts); 83 vp9_copy(cc->nmvcosts_hp, cpi->mb.nmvcosts_hp); 84 85 vp9_copy(cc->inter_mode_probs, cm->fc.inter_mode_probs); 86 87 vp9_copy(cc->y_mode_prob, cm->fc.y_mode_prob); 88 vp9_copy(cc->uv_mode_prob, cm->fc.uv_mode_prob); 89 vp9_copy(cc->partition_prob, cm->fc.partition_prob); 90 91 vp9_copy(cc->segment_pred_probs, cm->seg.pred_probs); 92 93 vp9_copy(cc->intra_inter_prob, cm->fc.intra_inter_prob); 94 vp9_copy(cc->comp_inter_prob, cm->fc.comp_inter_prob); 95 vp9_copy(cc->single_ref_prob, cm->fc.single_ref_prob); 96 vp9_copy(cc->comp_ref_prob, cm->fc.comp_ref_prob); 97 98 vpx_memcpy(cpi->coding_context.last_frame_seg_map_copy, 99 cm->last_frame_seg_map, (cm->mi_rows * cm->mi_cols)); 100 101 vp9_copy(cc->last_ref_lf_deltas, cm->lf.last_ref_deltas); 102 vp9_copy(cc->last_mode_lf_deltas, cm->lf.last_mode_deltas); 103 104 vp9_copy(cc->coef_probs, cm->fc.coef_probs); 105 vp9_copy(cc->switchable_interp_prob, cm->fc.switchable_interp_prob); 106 cc->tx_probs = cm->fc.tx_probs; 107 vp9_copy(cc->mbskip_probs, cm->fc.mbskip_probs); 108 } 109 110 void vp9_restore_coding_context(VP9_COMP *cpi) { 111 CODING_CONTEXT *const cc = &cpi->coding_context; 112 VP9_COMMON *cm = &cpi->common; 113 114 // Restore key state variables to the snapshot state stored in the 115 // previous call to vp9_save_coding_context. 116 117 cm->fc.nmvc = cc->nmvc; 118 vp9_copy(cpi->mb.nmvjointcost, cc->nmvjointcost); 119 vp9_copy(cpi->mb.nmvcosts, cc->nmvcosts); 120 vp9_copy(cpi->mb.nmvcosts_hp, cc->nmvcosts_hp); 121 122 vp9_copy(cm->fc.inter_mode_probs, cc->inter_mode_probs); 123 124 vp9_copy(cm->fc.y_mode_prob, cc->y_mode_prob); 125 vp9_copy(cm->fc.uv_mode_prob, cc->uv_mode_prob); 126 vp9_copy(cm->fc.partition_prob, cc->partition_prob); 127 128 vp9_copy(cm->seg.pred_probs, cc->segment_pred_probs); 129 130 vp9_copy(cm->fc.intra_inter_prob, cc->intra_inter_prob); 131 vp9_copy(cm->fc.comp_inter_prob, cc->comp_inter_prob); 132 vp9_copy(cm->fc.single_ref_prob, cc->single_ref_prob); 133 vp9_copy(cm->fc.comp_ref_prob, cc->comp_ref_prob); 134 135 vpx_memcpy(cm->last_frame_seg_map, 136 cpi->coding_context.last_frame_seg_map_copy, 137 (cm->mi_rows * cm->mi_cols)); 138 139 vp9_copy(cm->lf.last_ref_deltas, cc->last_ref_lf_deltas); 140 vp9_copy(cm->lf.last_mode_deltas, cc->last_mode_lf_deltas); 141 142 vp9_copy(cm->fc.coef_probs, cc->coef_probs); 143 vp9_copy(cm->fc.switchable_interp_prob, cc->switchable_interp_prob); 144 cm->fc.tx_probs = cc->tx_probs; 145 vp9_copy(cm->fc.mbskip_probs, cc->mbskip_probs); 146 } 147 148 void vp9_setup_key_frame(VP9_COMP *cpi) { 149 VP9_COMMON *cm = &cpi->common; 150 151 vp9_setup_past_independence(cm); 152 153 // interval before next GF 154 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 155 /* All buffers are implicitly updated on key frames. */ 156 cpi->refresh_golden_frame = 1; 157 cpi->refresh_alt_ref_frame = 1; 158 } 159 160 void vp9_setup_inter_frame(VP9_COMP *cpi) { 161 VP9_COMMON *cm = &cpi->common; 162 if (cm->error_resilient_mode || cm->intra_only) 163 vp9_setup_past_independence(cm); 164 165 assert(cm->frame_context_idx < NUM_FRAME_CONTEXTS); 166 cm->fc = cm->frame_contexts[cm->frame_context_idx]; 167 } 168 169 static int estimate_bits_at_q(int frame_kind, int q, int mbs, 170 double correction_factor) { 171 const int bpm = (int)(vp9_bits_per_mb(frame_kind, q, correction_factor)); 172 173 // Attempt to retain reasonable accuracy without overflow. The cutoff is 174 // chosen such that the maximum product of Bpm and MBs fits 31 bits. The 175 // largest Bpm takes 20 bits. 176 return (mbs > (1 << 11)) ? (bpm >> BPER_MB_NORMBITS) * mbs 177 : (bpm * mbs) >> BPER_MB_NORMBITS; 178 } 179 180 181 static void calc_iframe_target_size(VP9_COMP *cpi) { 182 // boost defaults to half second 183 int target; 184 185 // Clear down mmx registers to allow floating point in what follows 186 vp9_clear_system_state(); // __asm emms; 187 188 // New Two pass RC 189 target = cpi->per_frame_bandwidth; 190 191 if (cpi->oxcf.rc_max_intra_bitrate_pct) { 192 int max_rate = cpi->per_frame_bandwidth 193 * cpi->oxcf.rc_max_intra_bitrate_pct / 100; 194 195 if (target > max_rate) 196 target = max_rate; 197 } 198 199 cpi->this_frame_target = target; 200 } 201 202 203 // Do the best we can to define the parameters for the next GF based 204 // on what information we have available. 205 // 206 // In this experimental code only two pass is supported 207 // so we just use the interval determined in the two pass code. 208 static void calc_gf_params(VP9_COMP *cpi) { 209 // Set the gf interval 210 cpi->frames_till_gf_update_due = cpi->baseline_gf_interval; 211 } 212 213 214 static void calc_pframe_target_size(VP9_COMP *cpi) { 215 const int min_frame_target = MAX(cpi->min_frame_bandwidth, 216 cpi->av_per_frame_bandwidth >> 5); 217 if (cpi->refresh_alt_ref_frame) { 218 // Special alt reference frame case 219 // Per frame bit target for the alt ref frame 220 cpi->per_frame_bandwidth = cpi->twopass.gf_bits; 221 cpi->this_frame_target = cpi->per_frame_bandwidth; 222 } else { 223 // Normal frames (gf,and inter) 224 cpi->this_frame_target = cpi->per_frame_bandwidth; 225 } 226 227 // Sanity check that the total sum of adjustments is not above the maximum allowed 228 // That is that having allowed for KF and GF penalties we have not pushed the 229 // current interframe target to low. If the adjustment we apply here is not capable of recovering 230 // all the extra bits we have spent in the KF or GF then the remainder will have to be recovered over 231 // a longer time span via other buffer / rate control mechanisms. 232 if (cpi->this_frame_target < min_frame_target) 233 cpi->this_frame_target = min_frame_target; 234 235 if (!cpi->refresh_alt_ref_frame) 236 // Note the baseline target data rate for this inter frame. 237 cpi->inter_frame_target = cpi->this_frame_target; 238 239 // Adjust target frame size for Golden Frames: 240 if (cpi->frames_till_gf_update_due == 0) { 241 const int q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] 242 : cpi->oxcf.fixed_q; 243 244 cpi->refresh_golden_frame = 1; 245 246 calc_gf_params(cpi); 247 248 // If we are using alternate ref instead of gf then do not apply the boost 249 // It will instead be applied to the altref update 250 // Jims modified boost 251 if (!cpi->source_alt_ref_active) { 252 if (cpi->oxcf.fixed_q < 0) { 253 // The spend on the GF is defined in the two pass code 254 // for two pass encodes 255 cpi->this_frame_target = cpi->per_frame_bandwidth; 256 } else { 257 cpi->this_frame_target = 258 (estimate_bits_at_q(1, q, cpi->common.MBs, 1.0) 259 * cpi->last_boost) / 100; 260 } 261 } else { 262 // If there is an active ARF at this location use the minimum 263 // bits on this frame even if it is a constructed arf. 264 // The active maximum quantizer insures that an appropriate 265 // number of bits will be spent if needed for constructed ARFs. 266 cpi->this_frame_target = 0; 267 } 268 } 269 } 270 271 272 void vp9_update_rate_correction_factors(VP9_COMP *cpi, int damp_var) { 273 const int q = cpi->common.base_qindex; 274 int correction_factor = 100; 275 double rate_correction_factor; 276 double adjustment_limit; 277 278 int projected_size_based_on_q = 0; 279 280 // Clear down mmx registers to allow floating point in what follows 281 vp9_clear_system_state(); // __asm emms; 282 283 if (cpi->common.frame_type == KEY_FRAME) { 284 rate_correction_factor = cpi->key_frame_rate_correction_factor; 285 } else { 286 if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) 287 rate_correction_factor = cpi->gf_rate_correction_factor; 288 else 289 rate_correction_factor = cpi->rate_correction_factor; 290 } 291 292 // Work out how big we would have expected the frame to be at this Q given 293 // the current correction factor. 294 // Stay in double to avoid int overflow when values are large 295 projected_size_based_on_q = estimate_bits_at_q(cpi->common.frame_type, q, 296 cpi->common.MBs, 297 rate_correction_factor); 298 299 // Work out a size correction factor. 300 // if ( cpi->this_frame_target > 0 ) 301 // correction_factor = (100 * cpi->projected_frame_size) / cpi->this_frame_target; 302 if (projected_size_based_on_q > 0) 303 correction_factor = (100 * cpi->projected_frame_size) / projected_size_based_on_q; 304 305 // More heavily damped adjustment used if we have been oscillating either side of target 306 switch (damp_var) { 307 case 0: 308 adjustment_limit = 0.75; 309 break; 310 case 1: 311 adjustment_limit = 0.375; 312 break; 313 case 2: 314 default: 315 adjustment_limit = 0.25; 316 break; 317 } 318 319 // if ( (correction_factor > 102) && (Q < cpi->active_worst_quality) ) 320 if (correction_factor > 102) { 321 // We are not already at the worst allowable quality 322 correction_factor = (int)(100.5 + ((correction_factor - 100) * adjustment_limit)); 323 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100); 324 325 // Keep rate_correction_factor within limits 326 if (rate_correction_factor > MAX_BPB_FACTOR) 327 rate_correction_factor = MAX_BPB_FACTOR; 328 } 329 // else if ( (correction_factor < 99) && (Q > cpi->active_best_quality) ) 330 else if (correction_factor < 99) { 331 // We are not already at the best allowable quality 332 correction_factor = (int)(100.5 - ((100 - correction_factor) * adjustment_limit)); 333 rate_correction_factor = ((rate_correction_factor * correction_factor) / 100); 334 335 // Keep rate_correction_factor within limits 336 if (rate_correction_factor < MIN_BPB_FACTOR) 337 rate_correction_factor = MIN_BPB_FACTOR; 338 } 339 340 if (cpi->common.frame_type == KEY_FRAME) 341 cpi->key_frame_rate_correction_factor = rate_correction_factor; 342 else { 343 if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) 344 cpi->gf_rate_correction_factor = rate_correction_factor; 345 else 346 cpi->rate_correction_factor = rate_correction_factor; 347 } 348 } 349 350 351 int vp9_regulate_q(VP9_COMP *cpi, int target_bits_per_frame) { 352 int q = cpi->active_worst_quality; 353 354 int i; 355 int last_error = INT_MAX; 356 int target_bits_per_mb; 357 int bits_per_mb_at_this_q; 358 double correction_factor; 359 360 // Select the appropriate correction factor based upon type of frame. 361 if (cpi->common.frame_type == KEY_FRAME) 362 correction_factor = cpi->key_frame_rate_correction_factor; 363 else { 364 if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) 365 correction_factor = cpi->gf_rate_correction_factor; 366 else 367 correction_factor = cpi->rate_correction_factor; 368 } 369 370 // Calculate required scaling factor based on target frame size and size of frame produced using previous Q 371 if (target_bits_per_frame >= (INT_MAX >> BPER_MB_NORMBITS)) 372 target_bits_per_mb = (target_bits_per_frame / cpi->common.MBs) << BPER_MB_NORMBITS; // Case where we would overflow int 373 else 374 target_bits_per_mb = (target_bits_per_frame << BPER_MB_NORMBITS) / cpi->common.MBs; 375 376 i = cpi->active_best_quality; 377 378 do { 379 bits_per_mb_at_this_q = (int)vp9_bits_per_mb(cpi->common.frame_type, i, 380 correction_factor); 381 382 if (bits_per_mb_at_this_q <= target_bits_per_mb) { 383 if ((target_bits_per_mb - bits_per_mb_at_this_q) <= last_error) 384 q = i; 385 else 386 q = i - 1; 387 388 break; 389 } else { 390 last_error = bits_per_mb_at_this_q - target_bits_per_mb; 391 } 392 } while (++i <= cpi->active_worst_quality); 393 394 return q; 395 } 396 397 398 static int estimate_keyframe_frequency(VP9_COMP *cpi) { 399 int i; 400 401 // Average key frame frequency 402 int av_key_frame_frequency = 0; 403 404 /* First key frame at start of sequence is a special case. We have no 405 * frequency data. 406 */ 407 if (cpi->key_frame_count == 1) { 408 /* Assume a default of 1 kf every 2 seconds, or the max kf interval, 409 * whichever is smaller. 410 */ 411 int key_freq = cpi->oxcf.key_freq > 0 ? cpi->oxcf.key_freq : 1; 412 av_key_frame_frequency = (int)cpi->output_framerate * 2; 413 414 if (cpi->oxcf.auto_key && av_key_frame_frequency > key_freq) 415 av_key_frame_frequency = cpi->oxcf.key_freq; 416 417 cpi->prior_key_frame_distance[KEY_FRAME_CONTEXT - 1] 418 = av_key_frame_frequency; 419 } else { 420 unsigned int total_weight = 0; 421 int last_kf_interval = 422 (cpi->frames_since_key > 0) ? cpi->frames_since_key : 1; 423 424 /* reset keyframe context and calculate weighted average of last 425 * KEY_FRAME_CONTEXT keyframes 426 */ 427 for (i = 0; i < KEY_FRAME_CONTEXT; i++) { 428 if (i < KEY_FRAME_CONTEXT - 1) 429 cpi->prior_key_frame_distance[i] 430 = cpi->prior_key_frame_distance[i + 1]; 431 else 432 cpi->prior_key_frame_distance[i] = last_kf_interval; 433 434 av_key_frame_frequency += prior_key_frame_weight[i] 435 * cpi->prior_key_frame_distance[i]; 436 total_weight += prior_key_frame_weight[i]; 437 } 438 439 av_key_frame_frequency /= total_weight; 440 441 } 442 return av_key_frame_frequency; 443 } 444 445 446 void vp9_adjust_key_frame_context(VP9_COMP *cpi) { 447 // Clear down mmx registers to allow floating point in what follows 448 vp9_clear_system_state(); 449 450 cpi->frames_since_key = 0; 451 cpi->key_frame_count++; 452 } 453 454 455 void vp9_compute_frame_size_bounds(VP9_COMP *cpi, int *frame_under_shoot_limit, 456 int *frame_over_shoot_limit) { 457 // Set-up bounds on acceptable frame size: 458 if (cpi->oxcf.fixed_q >= 0) { 459 // Fixed Q scenario: frame size never outranges target (there is no target!) 460 *frame_under_shoot_limit = 0; 461 *frame_over_shoot_limit = INT_MAX; 462 } else { 463 if (cpi->common.frame_type == KEY_FRAME) { 464 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8; 465 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8; 466 } else { 467 if (cpi->refresh_alt_ref_frame || cpi->refresh_golden_frame) { 468 *frame_over_shoot_limit = cpi->this_frame_target * 9 / 8; 469 *frame_under_shoot_limit = cpi->this_frame_target * 7 / 8; 470 } else { 471 // Stron overshoot limit for constrained quality 472 if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) { 473 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8; 474 *frame_under_shoot_limit = cpi->this_frame_target * 2 / 8; 475 } else { 476 *frame_over_shoot_limit = cpi->this_frame_target * 11 / 8; 477 *frame_under_shoot_limit = cpi->this_frame_target * 5 / 8; 478 } 479 } 480 } 481 482 // For very small rate targets where the fractional adjustment 483 // (eg * 7/8) may be tiny make sure there is at least a minimum 484 // range. 485 *frame_over_shoot_limit += 200; 486 *frame_under_shoot_limit -= 200; 487 if (*frame_under_shoot_limit < 0) 488 *frame_under_shoot_limit = 0; 489 } 490 } 491 492 493 // return of 0 means drop frame 494 int vp9_pick_frame_size(VP9_COMP *cpi) { 495 VP9_COMMON *cm = &cpi->common; 496 497 if (cm->frame_type == KEY_FRAME) 498 calc_iframe_target_size(cpi); 499 else 500 calc_pframe_target_size(cpi); 501 502 return 1; 503 } 504
