2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
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.
15 #include "./vp9_rtcd.h"
17 #include "vpx_mem/vpx_mem.h"
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"
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"
41 #define RD_THRESH_POW 1.25
42 #define RD_MULT_EPB_RATIO 64
44 // Factor to weigh the rate for switchable interp filters.
45 #define SWITCHABLE_INTERP_RATE_FACTOR 1
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).
51 static const uint8_t rd_thresh_block_size_factor[BLOCK_SIZES] = {
52 2, 3, 3, 4, 6, 6, 8, 12, 12, 16, 24, 24, 32
55 static void fill_mode_costs(VP9_COMP *cpi) {
56 const FRAME_CONTEXT *const fc = &cpi->common.fc;
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],
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);
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);
75 static void fill_token_costs(vp9_coeff_cost *c,
76 vp9_coeff_probs_model (*p)[PLANE_TYPES]) {
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,
88 vp9_cost_tokens_skip((int *)c[t][i][j][k][1][l], probs,
90 assert(c[t][i][j][k][0][l][EOB_TOKEN] ==
91 c[t][i][j][k][1][l][EOB_TOKEN]);
95 // Values are now correlated to quantizer.
96 static int sad_per_bit16lut_8[QINDEX_RANGE];
97 static int sad_per_bit4lut_8[QINDEX_RANGE];
99 #if CONFIG_VP9_HIGHBITDEPTH
100 static int sad_per_bit16lut_10[QINDEX_RANGE];
101 static int sad_per_bit4lut_10[QINDEX_RANGE];
102 static int sad_per_bit16lut_12[QINDEX_RANGE];
103 static int sad_per_bit4lut_12[QINDEX_RANGE];
106 static void init_me_luts_bd(int *bit16lut, int *bit4lut, int range,
107 vpx_bit_depth_t bit_depth) {
109 // Initialize the sad lut tables using a formulaic calculation for now.
110 // This is to make it easier to resolve the impact of experimental changes
111 // to the quantizer tables.
112 for (i = 0; i < range; i++) {
113 const double q = vp9_convert_qindex_to_q(i, bit_depth);
114 bit16lut[i] = (int)(0.0418 * q + 2.4107);
115 bit4lut[i] = (int)(0.063 * q + 2.742);
119 void vp9_init_me_luts() {
120 init_me_luts_bd(sad_per_bit16lut_8, sad_per_bit4lut_8, QINDEX_RANGE,
122 #if CONFIG_VP9_HIGHBITDEPTH
123 init_me_luts_bd(sad_per_bit16lut_10, sad_per_bit4lut_10, QINDEX_RANGE,
125 init_me_luts_bd(sad_per_bit16lut_12, sad_per_bit4lut_12, QINDEX_RANGE,
130 static const int rd_boost_factor[16] = {
131 64, 32, 32, 32, 24, 16, 12, 12,
132 8, 8, 4, 4, 2, 2, 1, 0
134 static const int rd_frame_type_factor[FRAME_UPDATE_TYPES] = {
135 128, 144, 128, 128, 144
138 int vp9_compute_rd_mult(const VP9_COMP *cpi, int qindex) {
139 const int q = vp9_dc_quant(qindex, 0, cpi->common.bit_depth);
140 #if CONFIG_VP9_HIGHBITDEPTH
142 switch (cpi->common.bit_depth) {
144 rdmult = 88 * q * q / 24;
147 rdmult = ROUND_POWER_OF_TWO(88 * q * q / 24, 4);
150 rdmult = ROUND_POWER_OF_TWO(88 * q * q / 24, 8);
153 assert(0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12");
157 int rdmult = 88 * q * q / 24;
158 #endif // CONFIG_VP9_HIGHBITDEPTH
159 if (cpi->oxcf.pass == 2 && (cpi->common.frame_type != KEY_FRAME)) {
160 const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
161 const FRAME_UPDATE_TYPE frame_type = gf_group->update_type[gf_group->index];
162 const int boost_index = MIN(15, (cpi->rc.gfu_boost / 100));
164 rdmult = (rdmult * rd_frame_type_factor[frame_type]) >> 7;
165 rdmult += ((rdmult * rd_boost_factor[boost_index]) >> 7);
170 static int compute_rd_thresh_factor(int qindex, vpx_bit_depth_t bit_depth) {
172 #if CONFIG_VP9_HIGHBITDEPTH
175 q = vp9_dc_quant(qindex, 0, VPX_BITS_8) / 4.0;
178 q = vp9_dc_quant(qindex, 0, VPX_BITS_10) / 16.0;
181 q = vp9_dc_quant(qindex, 0, VPX_BITS_12) / 64.0;
184 assert(0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12");
189 q = vp9_dc_quant(qindex, 0, VPX_BITS_8) / 4.0;
190 #endif // CONFIG_VP9_HIGHBITDEPTH
191 // TODO(debargha): Adjust the function below.
192 return MAX((int)(pow(q, RD_THRESH_POW) * 5.12), 8);
195 void vp9_initialize_me_consts(VP9_COMP *cpi, int qindex) {
196 #if CONFIG_VP9_HIGHBITDEPTH
197 switch (cpi->common.bit_depth) {
199 cpi->mb.sadperbit16 = sad_per_bit16lut_8[qindex];
200 cpi->mb.sadperbit4 = sad_per_bit4lut_8[qindex];
203 cpi->mb.sadperbit16 = sad_per_bit16lut_10[qindex];
204 cpi->mb.sadperbit4 = sad_per_bit4lut_10[qindex];
207 cpi->mb.sadperbit16 = sad_per_bit16lut_12[qindex];
208 cpi->mb.sadperbit4 = sad_per_bit4lut_12[qindex];
211 assert(0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12");
214 cpi->mb.sadperbit16 = sad_per_bit16lut_8[qindex];
215 cpi->mb.sadperbit4 = sad_per_bit4lut_8[qindex];
216 #endif // CONFIG_VP9_HIGHBITDEPTH
219 static void set_block_thresholds(const VP9_COMMON *cm, RD_OPT *rd) {
220 int i, bsize, segment_id;
222 for (segment_id = 0; segment_id < MAX_SEGMENTS; ++segment_id) {
224 clamp(vp9_get_qindex(&cm->seg, segment_id, cm->base_qindex) +
225 cm->y_dc_delta_q, 0, MAXQ);
226 const int q = compute_rd_thresh_factor(qindex, cm->bit_depth);
228 for (bsize = 0; bsize < BLOCK_SIZES; ++bsize) {
229 // Threshold here seems unnecessarily harsh but fine given actual
230 // range of values used for cpi->sf.thresh_mult[].
231 const int t = q * rd_thresh_block_size_factor[bsize];
232 const int thresh_max = INT_MAX / t;
234 if (bsize >= BLOCK_8X8) {
235 for (i = 0; i < MAX_MODES; ++i)
236 rd->threshes[segment_id][bsize][i] =
237 rd->thresh_mult[i] < thresh_max
238 ? rd->thresh_mult[i] * t / 4
241 for (i = 0; i < MAX_REFS; ++i)
242 rd->threshes[segment_id][bsize][i] =
243 rd->thresh_mult_sub8x8[i] < thresh_max
244 ? rd->thresh_mult_sub8x8[i] * t / 4
251 void vp9_initialize_rd_consts(VP9_COMP *cpi) {
252 VP9_COMMON *const cm = &cpi->common;
253 MACROBLOCK *const x = &cpi->mb;
254 RD_OPT *const rd = &cpi->rd;
257 vp9_clear_system_state();
259 rd->RDDIV = RDDIV_BITS; // In bits (to multiply D by 128).
260 rd->RDMULT = vp9_compute_rd_mult(cpi, cm->base_qindex + cm->y_dc_delta_q);
262 x->errorperbit = rd->RDMULT / RD_MULT_EPB_RATIO;
263 x->errorperbit += (x->errorperbit == 0);
265 x->select_tx_size = (cpi->sf.tx_size_search_method == USE_LARGESTALL &&
266 cm->frame_type != KEY_FRAME) ? 0 : 1;
268 set_block_thresholds(cm, rd);
270 if (!cpi->sf.use_nonrd_pick_mode || cm->frame_type == KEY_FRAME) {
271 fill_token_costs(x->token_costs, cm->fc.coef_probs);
273 for (i = 0; i < PARTITION_CONTEXTS; ++i)
274 vp9_cost_tokens(cpi->partition_cost[i], get_partition_probs(cm, i),
278 if (!cpi->sf.use_nonrd_pick_mode || (cm->current_video_frame & 0x07) == 1 ||
279 cm->frame_type == KEY_FRAME) {
280 fill_mode_costs(cpi);
282 if (!frame_is_intra_only(cm)) {
283 vp9_build_nmv_cost_table(x->nmvjointcost,
284 cm->allow_high_precision_mv ? x->nmvcost_hp
286 &cm->fc.nmvc, cm->allow_high_precision_mv);
288 for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
289 vp9_cost_tokens((int *)cpi->inter_mode_cost[i],
290 cm->fc.inter_mode_probs[i], vp9_inter_mode_tree);
295 static void model_rd_norm(int xsq_q10, int *r_q10, int *d_q10) {
296 // NOTE: The tables below must be of the same size.
298 // The functions described below are sampled at the four most significant
299 // bits of x^2 + 8 / 256.
302 // This table models the rate for a Laplacian source with given variance
303 // when quantized with a uniform quantizer with given stepsize. The
304 // closed form expression is:
305 // Rn(x) = H(sqrt(r)) + sqrt(r)*[1 + H(r)/(1 - r)],
306 // where r = exp(-sqrt(2) * x) and x = qpstep / sqrt(variance),
307 // and H(x) is the binary entropy function.
308 static const int rate_tab_q10[] = {
309 65536, 6086, 5574, 5275, 5063, 4899, 4764, 4651,
310 4553, 4389, 4255, 4142, 4044, 3958, 3881, 3811,
311 3748, 3635, 3538, 3453, 3376, 3307, 3244, 3186,
312 3133, 3037, 2952, 2877, 2809, 2747, 2690, 2638,
313 2589, 2501, 2423, 2353, 2290, 2232, 2179, 2130,
314 2084, 2001, 1928, 1862, 1802, 1748, 1698, 1651,
315 1608, 1530, 1460, 1398, 1342, 1290, 1243, 1199,
316 1159, 1086, 1021, 963, 911, 864, 821, 781,
317 745, 680, 623, 574, 530, 490, 455, 424,
318 395, 345, 304, 269, 239, 213, 190, 171,
319 154, 126, 104, 87, 73, 61, 52, 44,
320 38, 28, 21, 16, 12, 10, 8, 6,
321 5, 3, 2, 1, 1, 1, 0, 0,
323 // Normalized distortion:
324 // This table models the normalized distortion for a Laplacian source
325 // with given variance when quantized with a uniform quantizer
326 // with given stepsize. The closed form expression is:
327 // Dn(x) = 1 - 1/sqrt(2) * x / sinh(x/sqrt(2))
328 // where x = qpstep / sqrt(variance).
329 // Note the actual distortion is Dn * variance.
330 static const int dist_tab_q10[] = {
331 0, 0, 1, 1, 1, 2, 2, 2,
332 3, 3, 4, 5, 5, 6, 7, 7,
333 8, 9, 11, 12, 13, 15, 16, 17,
334 18, 21, 24, 26, 29, 31, 34, 36,
335 39, 44, 49, 54, 59, 64, 69, 73,
336 78, 88, 97, 106, 115, 124, 133, 142,
337 151, 167, 184, 200, 215, 231, 245, 260,
338 274, 301, 327, 351, 375, 397, 418, 439,
339 458, 495, 528, 559, 587, 613, 637, 659,
340 680, 717, 749, 777, 801, 823, 842, 859,
341 874, 899, 919, 936, 949, 960, 969, 977,
342 983, 994, 1001, 1006, 1010, 1013, 1015, 1017,
343 1018, 1020, 1022, 1022, 1023, 1023, 1023, 1024,
345 static const int xsq_iq_q10[] = {
346 0, 4, 8, 12, 16, 20, 24, 28,
347 32, 40, 48, 56, 64, 72, 80, 88,
348 96, 112, 128, 144, 160, 176, 192, 208,
349 224, 256, 288, 320, 352, 384, 416, 448,
350 480, 544, 608, 672, 736, 800, 864, 928,
351 992, 1120, 1248, 1376, 1504, 1632, 1760, 1888,
352 2016, 2272, 2528, 2784, 3040, 3296, 3552, 3808,
353 4064, 4576, 5088, 5600, 6112, 6624, 7136, 7648,
354 8160, 9184, 10208, 11232, 12256, 13280, 14304, 15328,
355 16352, 18400, 20448, 22496, 24544, 26592, 28640, 30688,
356 32736, 36832, 40928, 45024, 49120, 53216, 57312, 61408,
357 65504, 73696, 81888, 90080, 98272, 106464, 114656, 122848,
358 131040, 147424, 163808, 180192, 196576, 212960, 229344, 245728,
360 const int tmp = (xsq_q10 >> 2) + 8;
361 const int k = get_msb(tmp) - 3;
362 const int xq = (k << 3) + ((tmp >> k) & 0x7);
363 const int one_q10 = 1 << 10;
364 const int a_q10 = ((xsq_q10 - xsq_iq_q10[xq]) << 10) >> (2 + k);
365 const int b_q10 = one_q10 - a_q10;
366 *r_q10 = (rate_tab_q10[xq] * b_q10 + rate_tab_q10[xq + 1] * a_q10) >> 10;
367 *d_q10 = (dist_tab_q10[xq] * b_q10 + dist_tab_q10[xq + 1] * a_q10) >> 10;
370 void vp9_model_rd_from_var_lapndz(unsigned int var, unsigned int n,
371 unsigned int qstep, int *rate,
373 // This function models the rate and distortion for a Laplacian
374 // source with given variance when quantized with a uniform quantizer
375 // with given stepsize. The closed form expressions are in:
376 // Hang and Chen, "Source Model for transform video coder and its
377 // application - Part I: Fundamental Theory", IEEE Trans. Circ.
378 // Sys. for Video Tech., April 1997.
384 static const uint32_t MAX_XSQ_Q10 = 245727;
385 const uint64_t xsq_q10_64 =
386 ((((uint64_t)qstep * qstep * n) << 10) + (var >> 1)) / var;
387 const int xsq_q10 = (int)MIN(xsq_q10_64, MAX_XSQ_Q10);
388 model_rd_norm(xsq_q10, &r_q10, &d_q10);
389 *rate = (n * r_q10 + 2) >> 2;
390 *dist = (var * (int64_t)d_q10 + 512) >> 10;
394 void vp9_get_entropy_contexts(BLOCK_SIZE bsize, TX_SIZE tx_size,
395 const struct macroblockd_plane *pd,
396 ENTROPY_CONTEXT t_above[16],
397 ENTROPY_CONTEXT t_left[16]) {
398 const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
399 const int num_4x4_w = num_4x4_blocks_wide_lookup[plane_bsize];
400 const int num_4x4_h = num_4x4_blocks_high_lookup[plane_bsize];
401 const ENTROPY_CONTEXT *const above = pd->above_context;
402 const ENTROPY_CONTEXT *const left = pd->left_context;
407 vpx_memcpy(t_above, above, sizeof(ENTROPY_CONTEXT) * num_4x4_w);
408 vpx_memcpy(t_left, left, sizeof(ENTROPY_CONTEXT) * num_4x4_h);
411 for (i = 0; i < num_4x4_w; i += 2)
412 t_above[i] = !!*(const uint16_t *)&above[i];
413 for (i = 0; i < num_4x4_h; i += 2)
414 t_left[i] = !!*(const uint16_t *)&left[i];
417 for (i = 0; i < num_4x4_w; i += 4)
418 t_above[i] = !!*(const uint32_t *)&above[i];
419 for (i = 0; i < num_4x4_h; i += 4)
420 t_left[i] = !!*(const uint32_t *)&left[i];
423 for (i = 0; i < num_4x4_w; i += 8)
424 t_above[i] = !!*(const uint64_t *)&above[i];
425 for (i = 0; i < num_4x4_h; i += 8)
426 t_left[i] = !!*(const uint64_t *)&left[i];
429 assert(0 && "Invalid transform size.");
434 void vp9_mv_pred(VP9_COMP *cpi, MACROBLOCK *x,
435 uint8_t *ref_y_buffer, int ref_y_stride,
436 int ref_frame, BLOCK_SIZE block_size) {
437 MACROBLOCKD *xd = &x->e_mbd;
438 MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi;
442 int best_sad = INT_MAX;
443 int this_sad = INT_MAX;
445 uint8_t *src_y_ptr = x->plane[0].src.buf;
447 const int num_mv_refs = MAX_MV_REF_CANDIDATES +
448 (cpi->sf.adaptive_motion_search &&
449 block_size < cpi->sf.max_partition_size);
452 pred_mv[0] = mbmi->ref_mvs[ref_frame][0].as_mv;
453 pred_mv[1] = mbmi->ref_mvs[ref_frame][1].as_mv;
454 pred_mv[2] = x->pred_mv[ref_frame];
456 // Get the sad for each candidate reference mv.
457 for (i = 0; i < num_mv_refs; ++i) {
458 const MV *this_mv = &pred_mv[i];
460 max_mv = MAX(max_mv, MAX(abs(this_mv->row), abs(this_mv->col)) >> 3);
461 if (is_zero_mv(this_mv) && zero_seen)
464 zero_seen |= is_zero_mv(this_mv);
467 &ref_y_buffer[ref_y_stride * (this_mv->row >> 3) + (this_mv->col >> 3)];
469 // Find sad for current vector.
470 this_sad = cpi->fn_ptr[block_size].sdf(src_y_ptr, x->plane[0].src.stride,
471 ref_y_ptr, ref_y_stride);
473 // Note if it is the best so far.
474 if (this_sad < best_sad) {
480 // Note the index of the mv that worked best in the reference list.
481 x->mv_best_ref_index[ref_frame] = best_index;
482 x->max_mv_context[ref_frame] = max_mv;
483 x->pred_mv_sad[ref_frame] = best_sad;
486 void vp9_setup_pred_block(const MACROBLOCKD *xd,
487 struct buf_2d dst[MAX_MB_PLANE],
488 const YV12_BUFFER_CONFIG *src,
489 int mi_row, int mi_col,
490 const struct scale_factors *scale,
491 const struct scale_factors *scale_uv) {
494 dst[0].buf = src->y_buffer;
495 dst[0].stride = src->y_stride;
496 dst[1].buf = src->u_buffer;
497 dst[2].buf = src->v_buffer;
498 dst[1].stride = dst[2].stride = src->uv_stride;
500 for (i = 0; i < MAX_MB_PLANE; ++i) {
501 setup_pred_plane(dst + i, dst[i].buf, dst[i].stride, mi_row, mi_col,
502 i ? scale_uv : scale,
503 xd->plane[i].subsampling_x, xd->plane[i].subsampling_y);
507 const YV12_BUFFER_CONFIG *vp9_get_scaled_ref_frame(const VP9_COMP *cpi,
509 const VP9_COMMON *const cm = &cpi->common;
510 const int ref_idx = cm->ref_frame_map[get_ref_frame_idx(cpi, ref_frame)];
511 const int scaled_idx = cpi->scaled_ref_idx[ref_frame - 1];
512 return (scaled_idx != ref_idx) ? &cm->frame_bufs[scaled_idx].buf : NULL;
515 int vp9_get_switchable_rate(const VP9_COMP *cpi) {
516 const MACROBLOCKD *const xd = &cpi->mb.e_mbd;
517 const MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi;
518 const int ctx = vp9_get_pred_context_switchable_interp(xd);
519 return SWITCHABLE_INTERP_RATE_FACTOR *
520 cpi->switchable_interp_costs[ctx][mbmi->interp_filter];
523 void vp9_set_rd_speed_thresholds(VP9_COMP *cpi) {
525 RD_OPT *const rd = &cpi->rd;
526 SPEED_FEATURES *const sf = &cpi->sf;
528 // Set baseline threshold values.
529 for (i = 0; i < MAX_MODES; ++i)
530 rd->thresh_mult[i] = cpi->oxcf.mode == BEST ? -500 : 0;
532 if (sf->adaptive_rd_thresh) {
533 rd->thresh_mult[THR_NEARESTMV] = 300;
534 rd->thresh_mult[THR_NEARESTG] = 300;
535 rd->thresh_mult[THR_NEARESTA] = 300;
537 rd->thresh_mult[THR_NEARESTMV] = 0;
538 rd->thresh_mult[THR_NEARESTG] = 0;
539 rd->thresh_mult[THR_NEARESTA] = 0;
542 rd->thresh_mult[THR_DC] += 1000;
544 rd->thresh_mult[THR_NEWMV] += 1000;
545 rd->thresh_mult[THR_NEWA] += 1000;
546 rd->thresh_mult[THR_NEWG] += 1000;
548 // Adjust threshold only in real time mode, which only uses last
550 rd->thresh_mult[THR_NEWMV] += sf->elevate_newmv_thresh;
552 rd->thresh_mult[THR_NEARMV] += 1000;
553 rd->thresh_mult[THR_NEARA] += 1000;
554 rd->thresh_mult[THR_COMP_NEARESTLA] += 1000;
555 rd->thresh_mult[THR_COMP_NEARESTGA] += 1000;
557 rd->thresh_mult[THR_TM] += 1000;
559 rd->thresh_mult[THR_COMP_NEARLA] += 1500;
560 rd->thresh_mult[THR_COMP_NEWLA] += 2000;
561 rd->thresh_mult[THR_NEARG] += 1000;
562 rd->thresh_mult[THR_COMP_NEARGA] += 1500;
563 rd->thresh_mult[THR_COMP_NEWGA] += 2000;
565 rd->thresh_mult[THR_ZEROMV] += 2000;
566 rd->thresh_mult[THR_ZEROG] += 2000;
567 rd->thresh_mult[THR_ZEROA] += 2000;
568 rd->thresh_mult[THR_COMP_ZEROLA] += 2500;
569 rd->thresh_mult[THR_COMP_ZEROGA] += 2500;
571 rd->thresh_mult[THR_H_PRED] += 2000;
572 rd->thresh_mult[THR_V_PRED] += 2000;
573 rd->thresh_mult[THR_D45_PRED ] += 2500;
574 rd->thresh_mult[THR_D135_PRED] += 2500;
575 rd->thresh_mult[THR_D117_PRED] += 2500;
576 rd->thresh_mult[THR_D153_PRED] += 2500;
577 rd->thresh_mult[THR_D207_PRED] += 2500;
578 rd->thresh_mult[THR_D63_PRED] += 2500;
581 void vp9_set_rd_speed_thresholds_sub8x8(VP9_COMP *cpi) {
582 const SPEED_FEATURES *const sf = &cpi->sf;
583 RD_OPT *const rd = &cpi->rd;
586 for (i = 0; i < MAX_REFS; ++i)
587 rd->thresh_mult_sub8x8[i] = cpi->oxcf.mode == BEST ? -500 : 0;
589 rd->thresh_mult_sub8x8[THR_LAST] += 2500;
590 rd->thresh_mult_sub8x8[THR_GOLD] += 2500;
591 rd->thresh_mult_sub8x8[THR_ALTR] += 2500;
592 rd->thresh_mult_sub8x8[THR_INTRA] += 2500;
593 rd->thresh_mult_sub8x8[THR_COMP_LA] += 4500;
594 rd->thresh_mult_sub8x8[THR_COMP_GA] += 4500;
596 // Check for masked out split cases.
597 for (i = 0; i < MAX_REFS; ++i)
598 if (sf->disable_split_mask & (1 << i))
599 rd->thresh_mult_sub8x8[i] = INT_MAX;
602 int vp9_get_intra_cost_penalty(int qindex, int qdelta,
603 vpx_bit_depth_t bit_depth) {
604 const int q = vp9_dc_quant(qindex, qdelta, bit_depth);
605 #if CONFIG_VP9_HIGHBITDEPTH
612 return ROUND_POWER_OF_TWO(5 * q, 2);
614 assert(0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12");
619 #endif // CONFIG_VP9_HIGHBITDEPTH