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).
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
53 };
54
fill_mode_costs(VP9_COMP * cpi)55 static 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
fill_token_costs(vp9_coeff_cost * c,vp9_coeff_probs_model (* p)[PLANE_TYPES])75 static 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.
96 static int sad_per_bit16lut[QINDEX_RANGE];
97 static int sad_per_bit4lut[QINDEX_RANGE];
98
vp9_init_me_luts()99 void 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
112 static 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 };
116 static const int rd_frame_type_factor[FRAME_UPDATE_TYPES] = {
117 128, 144, 128, 128, 144
118 };
119
vp9_compute_rd_mult(const VP9_COMP * cpi,int qindex)120 int 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
compute_rd_thresh_factor(int qindex)135 static 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
vp9_initialize_me_consts(VP9_COMP * cpi,int qindex)141 void 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
set_block_thresholds(const VP9_COMMON * cm,RD_OPT * rd)146 static 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
vp9_initialize_rd_consts(VP9_COMP * cpi)179 void 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
model_rd_norm(int xsq_q10,int * r_q10,int * d_q10)223 static 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
vp9_model_rd_from_var_lapndz(unsigned int var,unsigned int n,unsigned int qstep,int * rate,int64_t * dist)298 void 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
vp9_get_entropy_contexts(BLOCK_SIZE bsize,TX_SIZE tx_size,const struct macroblockd_plane * pd,ENTROPY_CONTEXT t_above[16],ENTROPY_CONTEXT t_left[16])322 void 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
vp9_mv_pred(VP9_COMP * cpi,MACROBLOCK * x,uint8_t * ref_y_buffer,int ref_y_stride,int ref_frame,BLOCK_SIZE block_size)362 void 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
vp9_setup_pred_block(const MACROBLOCKD * xd,struct buf_2d dst[MAX_MB_PLANE],const YV12_BUFFER_CONFIG * src,int mi_row,int mi_col,const struct scale_factors * scale,const struct scale_factors * scale_uv)421 void 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
vp9_get_scaled_ref_frame(const VP9_COMP * cpi,int ref_frame)442 const 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
vp9_get_switchable_rate(const VP9_COMP * cpi)450 int 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
vp9_set_rd_speed_thresholds(VP9_COMP * cpi)458 void 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
vp9_set_rd_speed_thresholds_sub8x8(VP9_COMP * cpi)545 void 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