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 <assert.h> 12#include <math.h> 13#include <stdio.h> 14 15#include "./vp9_rtcd.h" 16 17#include "vpx_mem/vpx_mem.h" 18 19#include "vp9/common/vp9_common.h" 20#include "vp9/common/vp9_entropy.h" 21#include "vp9/common/vp9_entropymode.h" 22#include "vp9/common/vp9_mvref_common.h" 23#include "vp9/common/vp9_pred_common.h" 24#include "vp9/common/vp9_quant_common.h" 25#include "vp9/common/vp9_reconinter.h" 26#include "vp9/common/vp9_reconintra.h" 27#include "vp9/common/vp9_seg_common.h" 28#include "vp9/common/vp9_systemdependent.h" 29 30#include "vp9/encoder/vp9_cost.h" 31#include "vp9/encoder/vp9_encodemb.h" 32#include "vp9/encoder/vp9_encodemv.h" 33#include "vp9/encoder/vp9_encoder.h" 34#include "vp9/encoder/vp9_mcomp.h" 35#include "vp9/encoder/vp9_quantize.h" 36#include "vp9/encoder/vp9_ratectrl.h" 37#include "vp9/encoder/vp9_rd.h" 38#include "vp9/encoder/vp9_tokenize.h" 39#include "vp9/encoder/vp9_variance.h" 40 41#define RD_THRESH_POW 1.25 42#define RD_MULT_EPB_RATIO 64 43 44// Factor to weigh the rate for switchable interp filters. 45#define SWITCHABLE_INTERP_RATE_FACTOR 1 46 47// The baseline rd thresholds for breaking out of the rd loop for 48// certain modes are assumed to be based on 8x8 blocks. 49// This table is used to correct for block size. 50// The factors here are << 2 (2 = x0.5, 32 = x8 etc). 51static const uint8_t rd_thresh_block_size_factor[BLOCK_SIZES] = { 52 2, 3, 3, 4, 6, 6, 8, 12, 12, 16, 24, 24, 32 53}; 54 55static void fill_mode_costs(VP9_COMP *cpi) { 56 const FRAME_CONTEXT *const fc = &cpi->common.fc; 57 int i, j; 58 59 for (i = 0; i < INTRA_MODES; ++i) 60 for (j = 0; j < INTRA_MODES; ++j) 61 vp9_cost_tokens(cpi->y_mode_costs[i][j], vp9_kf_y_mode_prob[i][j], 62 vp9_intra_mode_tree); 63 64 vp9_cost_tokens(cpi->mbmode_cost, fc->y_mode_prob[1], vp9_intra_mode_tree); 65 vp9_cost_tokens(cpi->intra_uv_mode_cost[KEY_FRAME], 66 vp9_kf_uv_mode_prob[TM_PRED], vp9_intra_mode_tree); 67 vp9_cost_tokens(cpi->intra_uv_mode_cost[INTER_FRAME], 68 fc->uv_mode_prob[TM_PRED], vp9_intra_mode_tree); 69 70 for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i) 71 vp9_cost_tokens(cpi->switchable_interp_costs[i], 72 fc->switchable_interp_prob[i], vp9_switchable_interp_tree); 73} 74 75static void fill_token_costs(vp9_coeff_cost *c, 76 vp9_coeff_probs_model (*p)[PLANE_TYPES]) { 77 int i, j, k, l; 78 TX_SIZE t; 79 for (t = TX_4X4; t <= TX_32X32; ++t) 80 for (i = 0; i < PLANE_TYPES; ++i) 81 for (j = 0; j < REF_TYPES; ++j) 82 for (k = 0; k < COEF_BANDS; ++k) 83 for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) { 84 vp9_prob probs[ENTROPY_NODES]; 85 vp9_model_to_full_probs(p[t][i][j][k][l], probs); 86 vp9_cost_tokens((int *)c[t][i][j][k][0][l], probs, 87 vp9_coef_tree); 88 vp9_cost_tokens_skip((int *)c[t][i][j][k][1][l], probs, 89 vp9_coef_tree); 90 assert(c[t][i][j][k][0][l][EOB_TOKEN] == 91 c[t][i][j][k][1][l][EOB_TOKEN]); 92 } 93} 94 95// Values are now correlated to quantizer. 96static int sad_per_bit16lut[QINDEX_RANGE]; 97static int sad_per_bit4lut[QINDEX_RANGE]; 98 99void vp9_init_me_luts() { 100 int i; 101 102 // Initialize the sad lut tables using a formulaic calculation for now. 103 // This is to make it easier to resolve the impact of experimental changes 104 // to the quantizer tables. 105 for (i = 0; i < QINDEX_RANGE; ++i) { 106 const double q = vp9_convert_qindex_to_q(i); 107 sad_per_bit16lut[i] = (int)(0.0418 * q + 2.4107); 108 sad_per_bit4lut[i] = (int)(0.063 * q + 2.742); 109 } 110} 111 112static const int rd_boost_factor[16] = { 113 64, 32, 32, 32, 24, 16, 12, 12, 114 8, 8, 4, 4, 2, 2, 1, 0 115}; 116static const int rd_frame_type_factor[FRAME_UPDATE_TYPES] = { 117128, 144, 128, 128, 144 118}; 119 120int vp9_compute_rd_mult(const VP9_COMP *cpi, int qindex) { 121 const int q = vp9_dc_quant(qindex, 0); 122 int rdmult = 88 * q * q / 24; 123 124 if (cpi->oxcf.pass == 2 && (cpi->common.frame_type != KEY_FRAME)) { 125 const GF_GROUP *const gf_group = &cpi->twopass.gf_group; 126 const FRAME_UPDATE_TYPE frame_type = gf_group->update_type[gf_group->index]; 127 const int boost_index = MIN(15, (cpi->rc.gfu_boost / 100)); 128 129 rdmult = (rdmult * rd_frame_type_factor[frame_type]) >> 7; 130 rdmult += ((rdmult * rd_boost_factor[boost_index]) >> 7); 131 } 132 return rdmult; 133} 134 135static int compute_rd_thresh_factor(int qindex) { 136 // TODO(debargha): Adjust the function below. 137 const int q = (int)(pow(vp9_dc_quant(qindex, 0) / 4.0, RD_THRESH_POW) * 5.12); 138 return MAX(q, 8); 139} 140 141void vp9_initialize_me_consts(VP9_COMP *cpi, int qindex) { 142 cpi->mb.sadperbit16 = sad_per_bit16lut[qindex]; 143 cpi->mb.sadperbit4 = sad_per_bit4lut[qindex]; 144} 145 146static void set_block_thresholds(const VP9_COMMON *cm, RD_OPT *rd) { 147 int i, bsize, segment_id; 148 149 for (segment_id = 0; segment_id < MAX_SEGMENTS; ++segment_id) { 150 const int qindex = 151 clamp(vp9_get_qindex(&cm->seg, segment_id, cm->base_qindex) + 152 cm->y_dc_delta_q, 153 0, MAXQ); 154 const int q = compute_rd_thresh_factor(qindex); 155 156 for (bsize = 0; bsize < BLOCK_SIZES; ++bsize) { 157 // Threshold here seems unnecessarily harsh but fine given actual 158 // range of values used for cpi->sf.thresh_mult[]. 159 const int t = q * rd_thresh_block_size_factor[bsize]; 160 const int thresh_max = INT_MAX / t; 161 162 if (bsize >= BLOCK_8X8) { 163 for (i = 0; i < MAX_MODES; ++i) 164 rd->threshes[segment_id][bsize][i] = 165 rd->thresh_mult[i] < thresh_max 166 ? rd->thresh_mult[i] * t / 4 167 : INT_MAX; 168 } else { 169 for (i = 0; i < MAX_REFS; ++i) 170 rd->threshes[segment_id][bsize][i] = 171 rd->thresh_mult_sub8x8[i] < thresh_max 172 ? rd->thresh_mult_sub8x8[i] * t / 4 173 : INT_MAX; 174 } 175 } 176 } 177} 178 179void vp9_initialize_rd_consts(VP9_COMP *cpi) { 180 VP9_COMMON *const cm = &cpi->common; 181 MACROBLOCK *const x = &cpi->mb; 182 RD_OPT *const rd = &cpi->rd; 183 int i; 184 185 vp9_clear_system_state(); 186 187 rd->RDDIV = RDDIV_BITS; // In bits (to multiply D by 128). 188 rd->RDMULT = vp9_compute_rd_mult(cpi, cm->base_qindex + cm->y_dc_delta_q); 189 190 x->errorperbit = rd->RDMULT / RD_MULT_EPB_RATIO; 191 x->errorperbit += (x->errorperbit == 0); 192 193 x->select_tx_size = (cpi->sf.tx_size_search_method == USE_LARGESTALL && 194 cm->frame_type != KEY_FRAME) ? 0 : 1; 195 196 set_block_thresholds(cm, rd); 197 198 if (!cpi->sf.use_nonrd_pick_mode || cm->frame_type == KEY_FRAME) { 199 fill_token_costs(x->token_costs, cm->fc.coef_probs); 200 201 for (i = 0; i < PARTITION_CONTEXTS; ++i) 202 vp9_cost_tokens(cpi->partition_cost[i], get_partition_probs(cm, i), 203 vp9_partition_tree); 204 } 205 206 if (!cpi->sf.use_nonrd_pick_mode || (cm->current_video_frame & 0x07) == 1 || 207 cm->frame_type == KEY_FRAME) { 208 fill_mode_costs(cpi); 209 210 if (!frame_is_intra_only(cm)) { 211 vp9_build_nmv_cost_table(x->nmvjointcost, 212 cm->allow_high_precision_mv ? x->nmvcost_hp 213 : x->nmvcost, 214 &cm->fc.nmvc, cm->allow_high_precision_mv); 215 216 for (i = 0; i < INTER_MODE_CONTEXTS; ++i) 217 vp9_cost_tokens((int *)cpi->inter_mode_cost[i], 218 cm->fc.inter_mode_probs[i], vp9_inter_mode_tree); 219 } 220 } 221} 222 223static void model_rd_norm(int xsq_q10, int *r_q10, int *d_q10) { 224 // NOTE: The tables below must be of the same size. 225 226 // The functions described below are sampled at the four most significant 227 // bits of x^2 + 8 / 256. 228 229 // Normalized rate: 230 // This table models the rate for a Laplacian source with given variance 231 // when quantized with a uniform quantizer with given stepsize. The 232 // closed form expression is: 233 // Rn(x) = H(sqrt(r)) + sqrt(r)*[1 + H(r)/(1 - r)], 234 // where r = exp(-sqrt(2) * x) and x = qpstep / sqrt(variance), 235 // and H(x) is the binary entropy function. 236 static const int rate_tab_q10[] = { 237 65536, 6086, 5574, 5275, 5063, 4899, 4764, 4651, 238 4553, 4389, 4255, 4142, 4044, 3958, 3881, 3811, 239 3748, 3635, 3538, 3453, 3376, 3307, 3244, 3186, 240 3133, 3037, 2952, 2877, 2809, 2747, 2690, 2638, 241 2589, 2501, 2423, 2353, 2290, 2232, 2179, 2130, 242 2084, 2001, 1928, 1862, 1802, 1748, 1698, 1651, 243 1608, 1530, 1460, 1398, 1342, 1290, 1243, 1199, 244 1159, 1086, 1021, 963, 911, 864, 821, 781, 245 745, 680, 623, 574, 530, 490, 455, 424, 246 395, 345, 304, 269, 239, 213, 190, 171, 247 154, 126, 104, 87, 73, 61, 52, 44, 248 38, 28, 21, 16, 12, 10, 8, 6, 249 5, 3, 2, 1, 1, 1, 0, 0, 250 }; 251 // Normalized distortion: 252 // This table models the normalized distortion for a Laplacian source 253 // with given variance when quantized with a uniform quantizer 254 // with given stepsize. The closed form expression is: 255 // Dn(x) = 1 - 1/sqrt(2) * x / sinh(x/sqrt(2)) 256 // where x = qpstep / sqrt(variance). 257 // Note the actual distortion is Dn * variance. 258 static const int dist_tab_q10[] = { 259 0, 0, 1, 1, 1, 2, 2, 2, 260 3, 3, 4, 5, 5, 6, 7, 7, 261 8, 9, 11, 12, 13, 15, 16, 17, 262 18, 21, 24, 26, 29, 31, 34, 36, 263 39, 44, 49, 54, 59, 64, 69, 73, 264 78, 88, 97, 106, 115, 124, 133, 142, 265 151, 167, 184, 200, 215, 231, 245, 260, 266 274, 301, 327, 351, 375, 397, 418, 439, 267 458, 495, 528, 559, 587, 613, 637, 659, 268 680, 717, 749, 777, 801, 823, 842, 859, 269 874, 899, 919, 936, 949, 960, 969, 977, 270 983, 994, 1001, 1006, 1010, 1013, 1015, 1017, 271 1018, 1020, 1022, 1022, 1023, 1023, 1023, 1024, 272 }; 273 static const int xsq_iq_q10[] = { 274 0, 4, 8, 12, 16, 20, 24, 28, 275 32, 40, 48, 56, 64, 72, 80, 88, 276 96, 112, 128, 144, 160, 176, 192, 208, 277 224, 256, 288, 320, 352, 384, 416, 448, 278 480, 544, 608, 672, 736, 800, 864, 928, 279 992, 1120, 1248, 1376, 1504, 1632, 1760, 1888, 280 2016, 2272, 2528, 2784, 3040, 3296, 3552, 3808, 281 4064, 4576, 5088, 5600, 6112, 6624, 7136, 7648, 282 8160, 9184, 10208, 11232, 12256, 13280, 14304, 15328, 283 16352, 18400, 20448, 22496, 24544, 26592, 28640, 30688, 284 32736, 36832, 40928, 45024, 49120, 53216, 57312, 61408, 285 65504, 73696, 81888, 90080, 98272, 106464, 114656, 122848, 286 131040, 147424, 163808, 180192, 196576, 212960, 229344, 245728, 287 }; 288 const int tmp = (xsq_q10 >> 2) + 8; 289 const int k = get_msb(tmp) - 3; 290 const int xq = (k << 3) + ((tmp >> k) & 0x7); 291 const int one_q10 = 1 << 10; 292 const int a_q10 = ((xsq_q10 - xsq_iq_q10[xq]) << 10) >> (2 + k); 293 const int b_q10 = one_q10 - a_q10; 294 *r_q10 = (rate_tab_q10[xq] * b_q10 + rate_tab_q10[xq + 1] * a_q10) >> 10; 295 *d_q10 = (dist_tab_q10[xq] * b_q10 + dist_tab_q10[xq + 1] * a_q10) >> 10; 296} 297 298void vp9_model_rd_from_var_lapndz(unsigned int var, unsigned int n, 299 unsigned int qstep, int *rate, 300 int64_t *dist) { 301 // This function models the rate and distortion for a Laplacian 302 // source with given variance when quantized with a uniform quantizer 303 // with given stepsize. The closed form expressions are in: 304 // Hang and Chen, "Source Model for transform video coder and its 305 // application - Part I: Fundamental Theory", IEEE Trans. Circ. 306 // Sys. for Video Tech., April 1997. 307 if (var == 0) { 308 *rate = 0; 309 *dist = 0; 310 } else { 311 int d_q10, r_q10; 312 static const uint32_t MAX_XSQ_Q10 = 245727; 313 const uint64_t xsq_q10_64 = 314 ((((uint64_t)qstep * qstep * n) << 10) + (var >> 1)) / var; 315 const int xsq_q10 = (int)MIN(xsq_q10_64, MAX_XSQ_Q10); 316 model_rd_norm(xsq_q10, &r_q10, &d_q10); 317 *rate = (n * r_q10 + 2) >> 2; 318 *dist = (var * (int64_t)d_q10 + 512) >> 10; 319 } 320} 321 322void vp9_get_entropy_contexts(BLOCK_SIZE bsize, TX_SIZE tx_size, 323 const struct macroblockd_plane *pd, 324 ENTROPY_CONTEXT t_above[16], 325 ENTROPY_CONTEXT t_left[16]) { 326 const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd); 327 const int num_4x4_w = num_4x4_blocks_wide_lookup[plane_bsize]; 328 const int num_4x4_h = num_4x4_blocks_high_lookup[plane_bsize]; 329 const ENTROPY_CONTEXT *const above = pd->above_context; 330 const ENTROPY_CONTEXT *const left = pd->left_context; 331 332 int i; 333 switch (tx_size) { 334 case TX_4X4: 335 vpx_memcpy(t_above, above, sizeof(ENTROPY_CONTEXT) * num_4x4_w); 336 vpx_memcpy(t_left, left, sizeof(ENTROPY_CONTEXT) * num_4x4_h); 337 break; 338 case TX_8X8: 339 for (i = 0; i < num_4x4_w; i += 2) 340 t_above[i] = !!*(const uint16_t *)&above[i]; 341 for (i = 0; i < num_4x4_h; i += 2) 342 t_left[i] = !!*(const uint16_t *)&left[i]; 343 break; 344 case TX_16X16: 345 for (i = 0; i < num_4x4_w; i += 4) 346 t_above[i] = !!*(const uint32_t *)&above[i]; 347 for (i = 0; i < num_4x4_h; i += 4) 348 t_left[i] = !!*(const uint32_t *)&left[i]; 349 break; 350 case TX_32X32: 351 for (i = 0; i < num_4x4_w; i += 8) 352 t_above[i] = !!*(const uint64_t *)&above[i]; 353 for (i = 0; i < num_4x4_h; i += 8) 354 t_left[i] = !!*(const uint64_t *)&left[i]; 355 break; 356 default: 357 assert(0 && "Invalid transform size."); 358 break; 359 } 360} 361 362void vp9_mv_pred(VP9_COMP *cpi, MACROBLOCK *x, 363 uint8_t *ref_y_buffer, int ref_y_stride, 364 int ref_frame, BLOCK_SIZE block_size) { 365 MACROBLOCKD *xd = &x->e_mbd; 366 MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; 367 int_mv this_mv; 368 int i; 369 int zero_seen = 0; 370 int best_index = 0; 371 int best_sad = INT_MAX; 372 int this_sad = INT_MAX; 373 int max_mv = 0; 374 375 uint8_t *src_y_ptr = x->plane[0].src.buf; 376 uint8_t *ref_y_ptr; 377 int row_offset, col_offset; 378 int num_mv_refs = MAX_MV_REF_CANDIDATES + 379 (cpi->sf.adaptive_motion_search && 380 cpi->common.show_frame && 381 block_size < cpi->sf.max_partition_size); 382 383 MV pred_mv[3]; 384 pred_mv[0] = mbmi->ref_mvs[ref_frame][0].as_mv; 385 pred_mv[1] = mbmi->ref_mvs[ref_frame][1].as_mv; 386 pred_mv[2] = x->pred_mv[ref_frame]; 387 388 // Get the sad for each candidate reference mv. 389 for (i = 0; i < num_mv_refs; ++i) { 390 this_mv.as_mv = pred_mv[i]; 391 392 max_mv = MAX(max_mv, 393 MAX(abs(this_mv.as_mv.row), abs(this_mv.as_mv.col)) >> 3); 394 // Only need to check zero mv once. 395 if (!this_mv.as_int && zero_seen) 396 continue; 397 398 zero_seen = zero_seen || !this_mv.as_int; 399 400 row_offset = this_mv.as_mv.row >> 3; 401 col_offset = this_mv.as_mv.col >> 3; 402 ref_y_ptr = ref_y_buffer + (ref_y_stride * row_offset) + col_offset; 403 404 // Find sad for current vector. 405 this_sad = cpi->fn_ptr[block_size].sdf(src_y_ptr, x->plane[0].src.stride, 406 ref_y_ptr, ref_y_stride); 407 408 // Note if it is the best so far. 409 if (this_sad < best_sad) { 410 best_sad = this_sad; 411 best_index = i; 412 } 413 } 414 415 // Note the index of the mv that worked best in the reference list. 416 x->mv_best_ref_index[ref_frame] = best_index; 417 x->max_mv_context[ref_frame] = max_mv; 418 x->pred_mv_sad[ref_frame] = best_sad; 419} 420 421void vp9_setup_pred_block(const MACROBLOCKD *xd, 422 struct buf_2d dst[MAX_MB_PLANE], 423 const YV12_BUFFER_CONFIG *src, 424 int mi_row, int mi_col, 425 const struct scale_factors *scale, 426 const struct scale_factors *scale_uv) { 427 int i; 428 429 dst[0].buf = src->y_buffer; 430 dst[0].stride = src->y_stride; 431 dst[1].buf = src->u_buffer; 432 dst[2].buf = src->v_buffer; 433 dst[1].stride = dst[2].stride = src->uv_stride; 434 435 for (i = 0; i < MAX_MB_PLANE; ++i) { 436 setup_pred_plane(dst + i, dst[i].buf, dst[i].stride, mi_row, mi_col, 437 i ? scale_uv : scale, 438 xd->plane[i].subsampling_x, xd->plane[i].subsampling_y); 439 } 440} 441 442const YV12_BUFFER_CONFIG *vp9_get_scaled_ref_frame(const VP9_COMP *cpi, 443 int ref_frame) { 444 const VP9_COMMON *const cm = &cpi->common; 445 const int ref_idx = cm->ref_frame_map[get_ref_frame_idx(cpi, ref_frame)]; 446 const int scaled_idx = cpi->scaled_ref_idx[ref_frame - 1]; 447 return (scaled_idx != ref_idx) ? &cm->frame_bufs[scaled_idx].buf : NULL; 448} 449 450int vp9_get_switchable_rate(const VP9_COMP *cpi) { 451 const MACROBLOCKD *const xd = &cpi->mb.e_mbd; 452 const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; 453 const int ctx = vp9_get_pred_context_switchable_interp(xd); 454 return SWITCHABLE_INTERP_RATE_FACTOR * 455 cpi->switchable_interp_costs[ctx][mbmi->interp_filter]; 456} 457 458void vp9_set_rd_speed_thresholds(VP9_COMP *cpi) { 459 int i; 460 RD_OPT *const rd = &cpi->rd; 461 SPEED_FEATURES *const sf = &cpi->sf; 462 463 // Set baseline threshold values. 464 for (i = 0; i < MAX_MODES; ++i) 465 rd->thresh_mult[i] = is_best_mode(cpi->oxcf.mode) ? -500 : 0; 466 467 rd->thresh_mult[THR_NEARESTMV] = 0; 468 rd->thresh_mult[THR_NEARESTG] = 0; 469 rd->thresh_mult[THR_NEARESTA] = 0; 470 471 rd->thresh_mult[THR_DC] += 1000; 472 473 rd->thresh_mult[THR_NEWMV] += 1000; 474 rd->thresh_mult[THR_NEWA] += 1000; 475 rd->thresh_mult[THR_NEWG] += 1000; 476 477 // Adjust threshold only in real time mode, which only uses last 478 // reference frame. 479 rd->thresh_mult[THR_NEWMV] += sf->elevate_newmv_thresh; 480 481 rd->thresh_mult[THR_NEARMV] += 1000; 482 rd->thresh_mult[THR_NEARA] += 1000; 483 rd->thresh_mult[THR_COMP_NEARESTLA] += 1000; 484 rd->thresh_mult[THR_COMP_NEARESTGA] += 1000; 485 486 rd->thresh_mult[THR_TM] += 1000; 487 488 rd->thresh_mult[THR_COMP_NEARLA] += 1500; 489 rd->thresh_mult[THR_COMP_NEWLA] += 2000; 490 rd->thresh_mult[THR_NEARG] += 1000; 491 rd->thresh_mult[THR_COMP_NEARGA] += 1500; 492 rd->thresh_mult[THR_COMP_NEWGA] += 2000; 493 494 rd->thresh_mult[THR_ZEROMV] += 2000; 495 rd->thresh_mult[THR_ZEROG] += 2000; 496 rd->thresh_mult[THR_ZEROA] += 2000; 497 rd->thresh_mult[THR_COMP_ZEROLA] += 2500; 498 rd->thresh_mult[THR_COMP_ZEROGA] += 2500; 499 500 rd->thresh_mult[THR_H_PRED] += 2000; 501 rd->thresh_mult[THR_V_PRED] += 2000; 502 rd->thresh_mult[THR_D45_PRED ] += 2500; 503 rd->thresh_mult[THR_D135_PRED] += 2500; 504 rd->thresh_mult[THR_D117_PRED] += 2500; 505 rd->thresh_mult[THR_D153_PRED] += 2500; 506 rd->thresh_mult[THR_D207_PRED] += 2500; 507 rd->thresh_mult[THR_D63_PRED] += 2500; 508 509 // Disable frame modes if flags not set. 510 if (!(cpi->ref_frame_flags & VP9_LAST_FLAG)) { 511 rd->thresh_mult[THR_NEWMV ] = INT_MAX; 512 rd->thresh_mult[THR_NEARESTMV] = INT_MAX; 513 rd->thresh_mult[THR_ZEROMV ] = INT_MAX; 514 rd->thresh_mult[THR_NEARMV ] = INT_MAX; 515 } 516 if (!(cpi->ref_frame_flags & VP9_GOLD_FLAG)) { 517 rd->thresh_mult[THR_NEARESTG ] = INT_MAX; 518 rd->thresh_mult[THR_ZEROG ] = INT_MAX; 519 rd->thresh_mult[THR_NEARG ] = INT_MAX; 520 rd->thresh_mult[THR_NEWG ] = INT_MAX; 521 } 522 if (!(cpi->ref_frame_flags & VP9_ALT_FLAG)) { 523 rd->thresh_mult[THR_NEARESTA ] = INT_MAX; 524 rd->thresh_mult[THR_ZEROA ] = INT_MAX; 525 rd->thresh_mult[THR_NEARA ] = INT_MAX; 526 rd->thresh_mult[THR_NEWA ] = INT_MAX; 527 } 528 529 if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_ALT_FLAG)) != 530 (VP9_LAST_FLAG | VP9_ALT_FLAG)) { 531 rd->thresh_mult[THR_COMP_ZEROLA ] = INT_MAX; 532 rd->thresh_mult[THR_COMP_NEARESTLA] = INT_MAX; 533 rd->thresh_mult[THR_COMP_NEARLA ] = INT_MAX; 534 rd->thresh_mult[THR_COMP_NEWLA ] = INT_MAX; 535 } 536 if ((cpi->ref_frame_flags & (VP9_GOLD_FLAG | VP9_ALT_FLAG)) != 537 (VP9_GOLD_FLAG | VP9_ALT_FLAG)) { 538 rd->thresh_mult[THR_COMP_ZEROGA ] = INT_MAX; 539 rd->thresh_mult[THR_COMP_NEARESTGA] = INT_MAX; 540 rd->thresh_mult[THR_COMP_NEARGA ] = INT_MAX; 541 rd->thresh_mult[THR_COMP_NEWGA ] = INT_MAX; 542 } 543} 544 545void vp9_set_rd_speed_thresholds_sub8x8(VP9_COMP *cpi) { 546 const SPEED_FEATURES *const sf = &cpi->sf; 547 RD_OPT *const rd = &cpi->rd; 548 int i; 549 550 for (i = 0; i < MAX_REFS; ++i) 551 rd->thresh_mult_sub8x8[i] = is_best_mode(cpi->oxcf.mode) ? -500 : 0; 552 553 rd->thresh_mult_sub8x8[THR_LAST] += 2500; 554 rd->thresh_mult_sub8x8[THR_GOLD] += 2500; 555 rd->thresh_mult_sub8x8[THR_ALTR] += 2500; 556 rd->thresh_mult_sub8x8[THR_INTRA] += 2500; 557 rd->thresh_mult_sub8x8[THR_COMP_LA] += 4500; 558 rd->thresh_mult_sub8x8[THR_COMP_GA] += 4500; 559 560 // Check for masked out split cases. 561 for (i = 0; i < MAX_REFS; ++i) 562 if (sf->disable_split_mask & (1 << i)) 563 rd->thresh_mult_sub8x8[i] = INT_MAX; 564 565 // Disable mode test if frame flag is not set. 566 if (!(cpi->ref_frame_flags & VP9_LAST_FLAG)) 567 rd->thresh_mult_sub8x8[THR_LAST] = INT_MAX; 568 if (!(cpi->ref_frame_flags & VP9_GOLD_FLAG)) 569 rd->thresh_mult_sub8x8[THR_GOLD] = INT_MAX; 570 if (!(cpi->ref_frame_flags & VP9_ALT_FLAG)) 571 rd->thresh_mult_sub8x8[THR_ALTR] = INT_MAX; 572 if ((cpi->ref_frame_flags & (VP9_LAST_FLAG | VP9_ALT_FLAG)) != 573 (VP9_LAST_FLAG | VP9_ALT_FLAG)) 574 rd->thresh_mult_sub8x8[THR_COMP_LA] = INT_MAX; 575 if ((cpi->ref_frame_flags & (VP9_GOLD_FLAG | VP9_ALT_FLAG)) != 576 (VP9_GOLD_FLAG | VP9_ALT_FLAG)) 577 rd->thresh_mult_sub8x8[THR_COMP_GA] = INT_MAX; 578} 579