rd.c 40.8 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1
/*
Yaowu Xu's avatar
Yaowu Xu committed
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
Jingning Han's avatar
Jingning Han committed
3
 *
Yaowu Xu's avatar
Yaowu Xu committed
4
5
6
7
8
9
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
Jingning Han's avatar
Jingning Han committed
10
11
12
13
14
15
 */

#include <assert.h>
#include <math.h>
#include <stdio.h>

Yaowu Xu's avatar
Yaowu Xu committed
16
#include "./av1_rtcd.h"
Jingning Han's avatar
Jingning Han committed
17

Yaowu Xu's avatar
Yaowu Xu committed
18
19
#include "aom_dsp/aom_dsp_common.h"
#include "aom_mem/aom_mem.h"
20
21
22
#include "aom_ports/bitops.h"
#include "aom_ports/mem.h"
#include "aom_ports/system_state.h"
Jingning Han's avatar
Jingning Han committed
23

24
25
26
27
28
29
30
31
32
#include "av1/common/common.h"
#include "av1/common/entropy.h"
#include "av1/common/entropymode.h"
#include "av1/common/mvref_common.h"
#include "av1/common/pred_common.h"
#include "av1/common/quant_common.h"
#include "av1/common/reconinter.h"
#include "av1/common/reconintra.h"
#include "av1/common/seg_common.h"
33

34
35
36
37
38
39
40
41
42
#include "av1/encoder/cost.h"
#include "av1/encoder/encodemb.h"
#include "av1/encoder/encodemv.h"
#include "av1/encoder/encoder.h"
#include "av1/encoder/mcomp.h"
#include "av1/encoder/quantize.h"
#include "av1/encoder/ratectrl.h"
#include "av1/encoder/rd.h"
#include "av1/encoder/tokenize.h"
Jingning Han's avatar
Jingning Han committed
43

44
#define RD_THRESH_POW 1.25
Jingning Han's avatar
Jingning Han committed
45
46
47
48

// Factor to weigh the rate for switchable interp filters.
#define SWITCHABLE_INTERP_RATE_FACTOR 1

Yaowu Xu's avatar
Yaowu Xu committed
49
void av1_rd_cost_reset(RD_COST *rd_cost) {
Jingning Han's avatar
Jingning Han committed
50
51
52
53
54
  rd_cost->rate = INT_MAX;
  rd_cost->dist = INT64_MAX;
  rd_cost->rdcost = INT64_MAX;
}

Yaowu Xu's avatar
Yaowu Xu committed
55
void av1_rd_cost_init(RD_COST *rd_cost) {
Jingning Han's avatar
Jingning Han committed
56
57
58
59
60
61
62
63
64
65
  rd_cost->rate = 0;
  rd_cost->dist = 0;
  rd_cost->rdcost = 0;
}

// The baseline rd thresholds for breaking out of the rd loop for
// certain modes are assumed to be based on 8x8 blocks.
// This table is used to correct for block size.
// The factors here are << 2 (2 = x0.5, 32 = x8 etc).
static const uint8_t rd_thresh_block_size_factor[BLOCK_SIZES] = {
Jingning Han's avatar
Jingning Han committed
66
67
68
#if CONFIG_CB4X4
  2,  2,  2,
#endif
69
  2,  3,  3, 4, 6, 6, 8, 12, 12, 16, 24, 24, 32,
70
71
72
#if CONFIG_EXT_PARTITION
  48, 48, 64
#endif  // CONFIG_EXT_PARTITION
Jingning Han's avatar
Jingning Han committed
73
74
};

Yaowu Xu's avatar
Yaowu Xu committed
75
static void fill_mode_costs(AV1_COMP *cpi) {
Jingning Han's avatar
Jingning Han committed
76
77
78
79
80
  const FRAME_CONTEXT *const fc = cpi->common.fc;
  int i, j;

  for (i = 0; i < INTRA_MODES; ++i)
    for (j = 0; j < INTRA_MODES; ++j)
Yaowu Xu's avatar
Yaowu Xu committed
81
82
      av1_cost_tokens(cpi->y_mode_costs[i][j], av1_kf_y_mode_prob[i][j],
                      av1_intra_mode_tree);
Jingning Han's avatar
Jingning Han committed
83

84
  for (i = 0; i < BLOCK_SIZE_GROUPS; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
85
86
    av1_cost_tokens(cpi->mbmode_cost[i], fc->y_mode_prob[i],
                    av1_intra_mode_tree);
87

88
  for (i = 0; i < INTRA_MODES; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
89
90
    av1_cost_tokens(cpi->intra_uv_mode_cost[i], fc->uv_mode_prob[i],
                    av1_intra_mode_tree);
Jingning Han's avatar
Jingning Han committed
91
92

  for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
93
94
    av1_cost_tokens(cpi->switchable_interp_costs[i],
                    fc->switchable_interp_prob[i], av1_switchable_interp_tree);
hui su's avatar
hui su committed
95

96
#if CONFIG_PALETTE
hui su's avatar
hui su committed
97
  for (i = 0; i < PALETTE_BLOCK_SIZES; ++i) {
Yaowu Xu's avatar
Yaowu Xu committed
98
99
100
101
    av1_cost_tokens(cpi->palette_y_size_cost[i],
                    av1_default_palette_y_size_prob[i], av1_palette_size_tree);
    av1_cost_tokens(cpi->palette_uv_size_cost[i],
                    av1_default_palette_uv_size_prob[i], av1_palette_size_tree);
hui su's avatar
hui su committed
102
103
  }

104
  for (i = 0; i < PALETTE_MAX_SIZE - 1; ++i) {
hui su's avatar
hui su committed
105
    for (j = 0; j < PALETTE_COLOR_CONTEXTS; ++j) {
Yaowu Xu's avatar
Yaowu Xu committed
106
107
108
109
110
111
      av1_cost_tokens(cpi->palette_y_color_cost[i][j],
                      av1_default_palette_y_color_prob[i][j],
                      av1_palette_color_tree[i]);
      av1_cost_tokens(cpi->palette_uv_color_cost[i][j],
                      av1_default_palette_uv_color_prob[i][j],
                      av1_palette_color_tree[i]);
hui su's avatar
hui su committed
112
    }
113
114
  }
#endif  // CONFIG_PALETTE
115

Jingning Han's avatar
Jingning Han committed
116
  for (i = 0; i < MAX_TX_DEPTH; ++i)
117
    for (j = 0; j < TX_SIZE_CONTEXTS; ++j)
Yaowu Xu's avatar
Yaowu Xu committed
118
119
      av1_cost_tokens(cpi->tx_size_cost[i][j], fc->tx_size_probs[i][j],
                      av1_tx_size_tree[i]);
120

121
#if CONFIG_EXT_TX
122
123
124
  for (i = TX_4X4; i < EXT_TX_SIZES; ++i) {
    int s;
    for (s = 1; s < EXT_TX_SETS_INTER; ++s) {
125
      if (use_inter_ext_tx_for_txsize[s][i]) {
Yaowu Xu's avatar
Yaowu Xu committed
126
127
        av1_cost_tokens(cpi->inter_tx_type_costs[s][i],
                        fc->inter_ext_tx_prob[s][i], av1_ext_tx_inter_tree[s]);
128
129
130
      }
    }
    for (s = 1; s < EXT_TX_SETS_INTRA; ++s) {
131
      if (use_intra_ext_tx_for_txsize[s][i]) {
132
        for (j = 0; j < INTRA_MODES; ++j)
Yaowu Xu's avatar
Yaowu Xu committed
133
134
135
          av1_cost_tokens(cpi->intra_tx_type_costs[s][i][j],
                          fc->intra_ext_tx_prob[s][i][j],
                          av1_ext_tx_intra_tree[s]);
136
137
      }
    }
138
  }
139
#else
140
141
  for (i = TX_4X4; i < EXT_TX_SIZES; ++i) {
    for (j = 0; j < TX_TYPES; ++j)
Yaowu Xu's avatar
Yaowu Xu committed
142
143
      av1_cost_tokens(cpi->intra_tx_type_costs[i][j],
                      fc->intra_ext_tx_prob[i][j], av1_ext_tx_tree);
144
145
  }
  for (i = TX_4X4; i < EXT_TX_SIZES; ++i) {
Yaowu Xu's avatar
Yaowu Xu committed
146
147
    av1_cost_tokens(cpi->inter_tx_type_costs[i], fc->inter_ext_tx_prob[i],
                    av1_ext_tx_tree);
148
  }
149
#endif  // CONFIG_EXT_TX
150
151
#if CONFIG_EXT_INTRA
  for (i = 0; i < INTRA_FILTERS + 1; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
152
153
    av1_cost_tokens(cpi->intra_filter_cost[i], fc->intra_filter_probs[i],
                    av1_intra_filter_tree);
154
#endif  // CONFIG_EXT_INTRA
155
156
157
158
#if CONFIG_LOOP_RESTORATION
  av1_cost_tokens(cpi->switchable_restore_cost, fc->switchable_restore_prob,
                  av1_switchable_restore_tree);
#endif  // CONFIG_LOOP_RESTORATION
Jingning Han's avatar
Jingning Han committed
159
160
}

Yaowu Xu's avatar
Yaowu Xu committed
161
162
void av1_fill_token_costs(av1_coeff_cost *c,
                          av1_coeff_probs_model (*p)[PLANE_TYPES]) {
Jingning Han's avatar
Jingning Han committed
163
164
  int i, j, k, l;
  TX_SIZE t;
165
  for (t = TX_4X4; t < TX_SIZES; ++t)
Jingning Han's avatar
Jingning Han committed
166
167
168
169
    for (i = 0; i < PLANE_TYPES; ++i)
      for (j = 0; j < REF_TYPES; ++j)
        for (k = 0; k < COEF_BANDS; ++k)
          for (l = 0; l < BAND_COEFF_CONTEXTS(k); ++l) {
Yaowu Xu's avatar
Yaowu Xu committed
170
171
172
173
174
            aom_prob probs[ENTROPY_NODES];
            av1_model_to_full_probs(p[t][i][j][k][l], probs);
            av1_cost_tokens((int *)c[t][i][j][k][0][l], probs, av1_coef_tree);
            av1_cost_tokens_skip((int *)c[t][i][j][k][1][l], probs,
                                 av1_coef_tree);
Jingning Han's avatar
Jingning Han committed
175
176
177
178
179
180
181
182
183
            assert(c[t][i][j][k][0][l][EOB_TOKEN] ==
                   c[t][i][j][k][1][l][EOB_TOKEN]);
          }
}

// Values are now correlated to quantizer.
static int sad_per_bit16lut_8[QINDEX_RANGE];
static int sad_per_bit4lut_8[QINDEX_RANGE];

Yaowu Xu's avatar
Yaowu Xu committed
184
#if CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
185
186
187
188
189
190
191
static int sad_per_bit16lut_10[QINDEX_RANGE];
static int sad_per_bit4lut_10[QINDEX_RANGE];
static int sad_per_bit16lut_12[QINDEX_RANGE];
static int sad_per_bit4lut_12[QINDEX_RANGE];
#endif

static void init_me_luts_bd(int *bit16lut, int *bit4lut, int range,
Yaowu Xu's avatar
Yaowu Xu committed
192
                            aom_bit_depth_t bit_depth) {
Jingning Han's avatar
Jingning Han committed
193
194
195
196
197
  int i;
  // Initialize the sad lut tables using a formulaic calculation for now.
  // This is to make it easier to resolve the impact of experimental changes
  // to the quantizer tables.
  for (i = 0; i < range; i++) {
Yaowu Xu's avatar
Yaowu Xu committed
198
    const double q = av1_convert_qindex_to_q(i, bit_depth);
Jingning Han's avatar
Jingning Han committed
199
200
201
202
203
    bit16lut[i] = (int)(0.0418 * q + 2.4107);
    bit4lut[i] = (int)(0.063 * q + 2.742);
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
204
void av1_init_me_luts(void) {
Jingning Han's avatar
Jingning Han committed
205
  init_me_luts_bd(sad_per_bit16lut_8, sad_per_bit4lut_8, QINDEX_RANGE,
Yaowu Xu's avatar
Yaowu Xu committed
206
207
                  AOM_BITS_8);
#if CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
208
  init_me_luts_bd(sad_per_bit16lut_10, sad_per_bit4lut_10, QINDEX_RANGE,
Yaowu Xu's avatar
Yaowu Xu committed
209
                  AOM_BITS_10);
Jingning Han's avatar
Jingning Han committed
210
  init_me_luts_bd(sad_per_bit16lut_12, sad_per_bit4lut_12, QINDEX_RANGE,
Yaowu Xu's avatar
Yaowu Xu committed
211
                  AOM_BITS_12);
Jingning Han's avatar
Jingning Han committed
212
213
214
#endif
}

215
216
static const int rd_boost_factor[16] = { 64, 32, 32, 32, 24, 16, 12, 12,
                                         8,  8,  4,  4,  2,  2,  1,  0 };
Jingning Han's avatar
Jingning Han committed
217
static const int rd_frame_type_factor[FRAME_UPDATE_TYPES] = {
218
  128, 144, 128, 128, 144,
219
#if CONFIG_EXT_REFS
220
221
  // TODO(zoeliu): To adjust further following factor values.
  128, 128, 128
222
223
  // TODO(weitinglin): We should investigate if the values should be the same
  //                   as the value used by OVERLAY frame
Yaowu Xu's avatar
Yaowu Xu committed
224
225
  ,
  144
226
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
227
228
};

Yaowu Xu's avatar
Yaowu Xu committed
229
230
231
int av1_compute_rd_mult(const AV1_COMP *cpi, int qindex) {
  const int64_t q = av1_dc_quant(qindex, 0, cpi->common.bit_depth);
#if CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
232
233
  int64_t rdmult = 0;
  switch (cpi->common.bit_depth) {
Yaowu Xu's avatar
Yaowu Xu committed
234
235
236
    case AOM_BITS_8: rdmult = 88 * q * q / 24; break;
    case AOM_BITS_10: rdmult = ROUND_POWER_OF_TWO(88 * q * q / 24, 4); break;
    case AOM_BITS_12: rdmult = ROUND_POWER_OF_TWO(88 * q * q / 24, 8); break;
Jingning Han's avatar
Jingning Han committed
237
    default:
Yaowu Xu's avatar
Yaowu Xu committed
238
      assert(0 && "bit_depth should be AOM_BITS_8, AOM_BITS_10 or AOM_BITS_12");
Jingning Han's avatar
Jingning Han committed
239
240
241
242
      return -1;
  }
#else
  int64_t rdmult = 88 * q * q / 24;
Yaowu Xu's avatar
Yaowu Xu committed
243
#endif  // CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
244
245
246
  if (cpi->oxcf.pass == 2 && (cpi->common.frame_type != KEY_FRAME)) {
    const GF_GROUP *const gf_group = &cpi->twopass.gf_group;
    const FRAME_UPDATE_TYPE frame_type = gf_group->update_type[gf_group->index];
Yaowu Xu's avatar
Yaowu Xu committed
247
    const int boost_index = AOMMIN(15, (cpi->rc.gfu_boost / 100));
Jingning Han's avatar
Jingning Han committed
248
249
250
251

    rdmult = (rdmult * rd_frame_type_factor[frame_type]) >> 7;
    rdmult += ((rdmult * rd_boost_factor[boost_index]) >> 7);
  }
252
  if (rdmult < 1) rdmult = 1;
Jingning Han's avatar
Jingning Han committed
253
254
255
  return (int)rdmult;
}

Yaowu Xu's avatar
Yaowu Xu committed
256
static int compute_rd_thresh_factor(int qindex, aom_bit_depth_t bit_depth) {
Jingning Han's avatar
Jingning Han committed
257
  double q;
Yaowu Xu's avatar
Yaowu Xu committed
258
#if CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
259
  switch (bit_depth) {
Yaowu Xu's avatar
Yaowu Xu committed
260
261
262
    case AOM_BITS_8: q = av1_dc_quant(qindex, 0, AOM_BITS_8) / 4.0; break;
    case AOM_BITS_10: q = av1_dc_quant(qindex, 0, AOM_BITS_10) / 16.0; break;
    case AOM_BITS_12: q = av1_dc_quant(qindex, 0, AOM_BITS_12) / 64.0; break;
Jingning Han's avatar
Jingning Han committed
263
    default:
Yaowu Xu's avatar
Yaowu Xu committed
264
      assert(0 && "bit_depth should be AOM_BITS_8, AOM_BITS_10 or AOM_BITS_12");
Jingning Han's avatar
Jingning Han committed
265
266
267
      return -1;
  }
#else
268
  (void)bit_depth;
Yaowu Xu's avatar
Yaowu Xu committed
269
270
  q = av1_dc_quant(qindex, 0, AOM_BITS_8) / 4.0;
#endif  // CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
271
  // TODO(debargha): Adjust the function below.
Yaowu Xu's avatar
Yaowu Xu committed
272
  return AOMMAX((int)(pow(q, RD_THRESH_POW) * 5.12), 8);
Jingning Han's avatar
Jingning Han committed
273
274
}

Yaowu Xu's avatar
Yaowu Xu committed
275
276
void av1_initialize_me_consts(const AV1_COMP *cpi, MACROBLOCK *x, int qindex) {
#if CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
277
  switch (cpi->common.bit_depth) {
Yaowu Xu's avatar
Yaowu Xu committed
278
    case AOM_BITS_8:
Jingning Han's avatar
Jingning Han committed
279
280
281
      x->sadperbit16 = sad_per_bit16lut_8[qindex];
      x->sadperbit4 = sad_per_bit4lut_8[qindex];
      break;
Yaowu Xu's avatar
Yaowu Xu committed
282
    case AOM_BITS_10:
Jingning Han's avatar
Jingning Han committed
283
284
285
      x->sadperbit16 = sad_per_bit16lut_10[qindex];
      x->sadperbit4 = sad_per_bit4lut_10[qindex];
      break;
Yaowu Xu's avatar
Yaowu Xu committed
286
    case AOM_BITS_12:
Jingning Han's avatar
Jingning Han committed
287
288
289
290
      x->sadperbit16 = sad_per_bit16lut_12[qindex];
      x->sadperbit4 = sad_per_bit4lut_12[qindex];
      break;
    default:
Yaowu Xu's avatar
Yaowu Xu committed
291
      assert(0 && "bit_depth should be AOM_BITS_8, AOM_BITS_10 or AOM_BITS_12");
Jingning Han's avatar
Jingning Han committed
292
293
294
295
296
  }
#else
  (void)cpi;
  x->sadperbit16 = sad_per_bit16lut_8[qindex];
  x->sadperbit4 = sad_per_bit4lut_8[qindex];
Yaowu Xu's avatar
Yaowu Xu committed
297
#endif  // CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
298
299
}

Yaowu Xu's avatar
Yaowu Xu committed
300
static void set_block_thresholds(const AV1_COMMON *cm, RD_OPT *rd) {
Jingning Han's avatar
Jingning Han committed
301
302
303
304
  int i, bsize, segment_id;

  for (segment_id = 0; segment_id < MAX_SEGMENTS; ++segment_id) {
    const int qindex =
Yaowu Xu's avatar
Yaowu Xu committed
305
        clamp(av1_get_qindex(&cm->seg, segment_id, cm->base_qindex) +
306
307
                  cm->y_dc_delta_q,
              0, MAXQ);
Jingning Han's avatar
Jingning Han committed
308
309
310
311
312
313
314
315
316
317
    const int q = compute_rd_thresh_factor(qindex, cm->bit_depth);

    for (bsize = 0; bsize < BLOCK_SIZES; ++bsize) {
      // Threshold here seems unnecessarily harsh but fine given actual
      // range of values used for cpi->sf.thresh_mult[].
      const int t = q * rd_thresh_block_size_factor[bsize];
      const int thresh_max = INT_MAX / t;

      if (bsize >= BLOCK_8X8) {
        for (i = 0; i < MAX_MODES; ++i)
318
319
320
          rd->threshes[segment_id][bsize][i] = rd->thresh_mult[i] < thresh_max
                                                   ? rd->thresh_mult[i] * t / 4
                                                   : INT_MAX;
Jingning Han's avatar
Jingning Han committed
321
322
323
324
325
326
327
328
329
330
331
      } else {
        for (i = 0; i < MAX_REFS; ++i)
          rd->threshes[segment_id][bsize][i] =
              rd->thresh_mult_sub8x8[i] < thresh_max
                  ? rd->thresh_mult_sub8x8[i] * t / 4
                  : INT_MAX;
      }
    }
  }
}

332
#if CONFIG_REF_MV
Yaowu Xu's avatar
Yaowu Xu committed
333
334
void av1_set_mvcost(MACROBLOCK *x, MV_REFERENCE_FRAME ref_frame, int ref,
                    int ref_mv_idx) {
335
  MB_MODE_INFO_EXT *mbmi_ext = x->mbmi_ext;
Yaowu Xu's avatar
Yaowu Xu committed
336
337
338
339
  int8_t rf_type = av1_ref_frame_type(x->e_mbd.mi[0]->mbmi.ref_frame);
  int nmv_ctx = av1_nmv_ctx(mbmi_ext->ref_mv_count[rf_type],
                            mbmi_ext->ref_mv_stack[rf_type], ref, ref_mv_idx);
  (void)ref_frame;
340
341
  x->mvcost = x->mv_cost_stack[nmv_ctx];
  x->nmvjointcost = x->nmv_vec_cost[nmv_ctx];
Jingning Han's avatar
Jingning Han committed
342
343
  x->mvsadcost = x->mvcost;
  x->nmvjointsadcost = x->nmvjointcost;
344
345
346
}
#endif

Yaowu Xu's avatar
Yaowu Xu committed
347
348
void av1_initialize_rd_consts(AV1_COMP *cpi) {
  AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
349
350
351
  MACROBLOCK *const x = &cpi->td.mb;
  RD_OPT *const rd = &cpi->rd;
  int i;
Jingning Han's avatar
Jingning Han committed
352
353
354
#if CONFIG_REF_MV
  int nmv_ctx;
#endif
Jingning Han's avatar
Jingning Han committed
355

Yaowu Xu's avatar
Yaowu Xu committed
356
  aom_clear_system_state();
Jingning Han's avatar
Jingning Han committed
357
358

  rd->RDDIV = RDDIV_BITS;  // In bits (to multiply D by 128).
Yaowu Xu's avatar
Yaowu Xu committed
359
  rd->RDMULT = av1_compute_rd_mult(cpi, cm->base_qindex + cm->y_dc_delta_q);
Jingning Han's avatar
Jingning Han committed
360

361
  set_error_per_bit(x, rd->RDMULT);
Jingning Han's avatar
Jingning Han committed
362
363
364

  set_block_thresholds(cm, rd);

365
#if CONFIG_REF_MV
Jingning Han's avatar
Jingning Han committed
366
  for (nmv_ctx = 0; nmv_ctx < NMV_CONTEXTS; ++nmv_ctx) {
Yaowu Xu's avatar
Yaowu Xu committed
367
    av1_build_nmv_cost_table(
Jingning Han's avatar
Jingning Han committed
368
369
370
371
        x->nmv_vec_cost[nmv_ctx],
        cm->allow_high_precision_mv ? x->nmvcost_hp[nmv_ctx]
                                    : x->nmvcost[nmv_ctx],
        &cm->fc->nmvc[nmv_ctx], cm->allow_high_precision_mv);
372
  }
Jingning Han's avatar
Jingning Han committed
373
374
375
376
377
378
379
380
381
382
  x->mvcost = x->mv_cost_stack[0];
  x->nmvjointcost = x->nmv_vec_cost[0];
  x->mvsadcost = x->mvcost;
  x->nmvjointsadcost = x->nmvjointcost;
#else
  av1_build_nmv_cost_table(
      x->nmvjointcost, cm->allow_high_precision_mv ? x->nmvcost_hp : x->nmvcost,
      &cm->fc->nmvc, cm->allow_high_precision_mv);
#endif

383
  if (cpi->oxcf.pass != 1) {
384
    av1_fill_token_costs(x->token_costs, cm->fc->coef_probs);
385
386
387

    if (cpi->sf.partition_search_type != VAR_BASED_PARTITION ||
        cm->frame_type == KEY_FRAME) {
388
#if CONFIG_EXT_PARTITION_TYPES
Yaowu Xu's avatar
Yaowu Xu committed
389
390
      av1_cost_tokens(cpi->partition_cost[0], cm->fc->partition_prob[0],
                      av1_partition_tree);
391
      for (i = 1; i < PARTITION_CONTEXTS; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
392
393
        av1_cost_tokens(cpi->partition_cost[i], cm->fc->partition_prob[i],
                        av1_ext_partition_tree);
394
#else
395
      for (i = 0; i < PARTITION_CONTEXTS; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
396
397
        av1_cost_tokens(cpi->partition_cost[i], cm->fc->partition_prob[i],
                        av1_partition_tree);
398
#endif  // CONFIG_EXT_PARTITION_TYPES
399
400
401
    }

    fill_mode_costs(cpi);
402

403
    if (!frame_is_intra_only(cm)) {
404
#if CONFIG_REF_MV
405
      for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i) {
Yaowu Xu's avatar
Yaowu Xu committed
406
407
        cpi->newmv_mode_cost[i][0] = av1_cost_bit(cm->fc->newmv_prob[i], 0);
        cpi->newmv_mode_cost[i][1] = av1_cost_bit(cm->fc->newmv_prob[i], 1);
408
      }
409

410
      for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i) {
Yaowu Xu's avatar
Yaowu Xu committed
411
412
        cpi->zeromv_mode_cost[i][0] = av1_cost_bit(cm->fc->zeromv_prob[i], 0);
        cpi->zeromv_mode_cost[i][1] = av1_cost_bit(cm->fc->zeromv_prob[i], 1);
413
      }
Jingning Han's avatar
Jingning Han committed
414

415
      for (i = 0; i < REFMV_MODE_CONTEXTS; ++i) {
Yaowu Xu's avatar
Yaowu Xu committed
416
417
        cpi->refmv_mode_cost[i][0] = av1_cost_bit(cm->fc->refmv_prob[i], 0);
        cpi->refmv_mode_cost[i][1] = av1_cost_bit(cm->fc->refmv_prob[i], 1);
418
      }
419

420
      for (i = 0; i < DRL_MODE_CONTEXTS; ++i) {
Yaowu Xu's avatar
Yaowu Xu committed
421
422
        cpi->drl_mode_cost0[i][0] = av1_cost_bit(cm->fc->drl_prob[i], 0);
        cpi->drl_mode_cost0[i][1] = av1_cost_bit(cm->fc->drl_prob[i], 1);
423
      }
Yue Chen's avatar
Yue Chen committed
424
#if CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
425
426
      cpi->new2mv_mode_cost[0] = av1_cost_bit(cm->fc->new2mv_prob, 0);
      cpi->new2mv_mode_cost[1] = av1_cost_bit(cm->fc->new2mv_prob, 1);
Yue Chen's avatar
Yue Chen committed
427
#endif  // CONFIG_EXT_INTER
428
#else
429
      for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
430
431
        av1_cost_tokens((int *)cpi->inter_mode_cost[i],
                        cm->fc->inter_mode_probs[i], av1_inter_mode_tree);
432
#endif  // CONFIG_REF_MV
433
#if CONFIG_EXT_INTER
434
      for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
435
436
437
        av1_cost_tokens((int *)cpi->inter_compound_mode_cost[i],
                        cm->fc->inter_compound_mode_probs[i],
                        av1_inter_compound_mode_tree);
438
      for (i = 0; i < BLOCK_SIZE_GROUPS; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
439
440
441
        av1_cost_tokens((int *)cpi->interintra_mode_cost[i],
                        cm->fc->interintra_mode_prob[i],
                        av1_interintra_mode_tree);
442
#endif  // CONFIG_EXT_INTER
Yue Chen's avatar
Yue Chen committed
443
#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
444
      for (i = BLOCK_8X8; i < BLOCK_SIZES; i++) {
Yue Chen's avatar
Yue Chen committed
445
446
        av1_cost_tokens((int *)cpi->motion_mode_cost[i],
                        cm->fc->motion_mode_prob[i], av1_motion_mode_tree);
447
      }
Yue Chen's avatar
Yue Chen committed
448
449
450
451
452
453
#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
      for (i = BLOCK_8X8; i < BLOCK_SIZES; i++) {
        cpi->motion_mode_cost1[i][0] = av1_cost_bit(cm->fc->obmc_prob[i], 0);
        cpi->motion_mode_cost1[i][1] = av1_cost_bit(cm->fc->obmc_prob[i], 1);
      }
#endif  // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
Yue Chen's avatar
Yue Chen committed
454
#endif  // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
455
    }
Jingning Han's avatar
Jingning Han committed
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
  }
}

static void model_rd_norm(int xsq_q10, int *r_q10, int *d_q10) {
  // NOTE: The tables below must be of the same size.

  // The functions described below are sampled at the four most significant
  // bits of x^2 + 8 / 256.

  // Normalized rate:
  // This table models the rate for a Laplacian source with given variance
  // when quantized with a uniform quantizer with given stepsize. The
  // closed form expression is:
  // Rn(x) = H(sqrt(r)) + sqrt(r)*[1 + H(r)/(1 - r)],
  // where r = exp(-sqrt(2) * x) and x = qpstep / sqrt(variance),
  // and H(x) is the binary entropy function.
  static const int rate_tab_q10[] = {
473
474
475
476
477
478
479
480
481
    65536, 6086, 5574, 5275, 5063, 4899, 4764, 4651, 4553, 4389, 4255, 4142,
    4044,  3958, 3881, 3811, 3748, 3635, 3538, 3453, 3376, 3307, 3244, 3186,
    3133,  3037, 2952, 2877, 2809, 2747, 2690, 2638, 2589, 2501, 2423, 2353,
    2290,  2232, 2179, 2130, 2084, 2001, 1928, 1862, 1802, 1748, 1698, 1651,
    1608,  1530, 1460, 1398, 1342, 1290, 1243, 1199, 1159, 1086, 1021, 963,
    911,   864,  821,  781,  745,  680,  623,  574,  530,  490,  455,  424,
    395,   345,  304,  269,  239,  213,  190,  171,  154,  126,  104,  87,
    73,    61,   52,   44,   38,   28,   21,   16,   12,   10,   8,    6,
    5,     3,    2,    1,    1,    1,    0,    0,
Jingning Han's avatar
Jingning Han committed
482
483
484
485
486
487
488
489
490
  };
  // Normalized distortion:
  // This table models the normalized distortion for a Laplacian source
  // with given variance when quantized with a uniform quantizer
  // with given stepsize. The closed form expression is:
  // Dn(x) = 1 - 1/sqrt(2) * x / sinh(x/sqrt(2))
  // where x = qpstep / sqrt(variance).
  // Note the actual distortion is Dn * variance.
  static const int dist_tab_q10[] = {
491
492
493
494
495
496
497
498
499
    0,    0,    1,    1,    1,    2,    2,    2,    3,    3,    4,    5,
    5,    6,    7,    7,    8,    9,    11,   12,   13,   15,   16,   17,
    18,   21,   24,   26,   29,   31,   34,   36,   39,   44,   49,   54,
    59,   64,   69,   73,   78,   88,   97,   106,  115,  124,  133,  142,
    151,  167,  184,  200,  215,  231,  245,  260,  274,  301,  327,  351,
    375,  397,  418,  439,  458,  495,  528,  559,  587,  613,  637,  659,
    680,  717,  749,  777,  801,  823,  842,  859,  874,  899,  919,  936,
    949,  960,  969,  977,  983,  994,  1001, 1006, 1010, 1013, 1015, 1017,
    1018, 1020, 1022, 1022, 1023, 1023, 1023, 1024,
Jingning Han's avatar
Jingning Han committed
500
501
  };
  static const int xsq_iq_q10[] = {
502
503
504
505
506
507
508
509
510
511
512
513
    0,      4,      8,      12,     16,     20,     24,     28,     32,
    40,     48,     56,     64,     72,     80,     88,     96,     112,
    128,    144,    160,    176,    192,    208,    224,    256,    288,
    320,    352,    384,    416,    448,    480,    544,    608,    672,
    736,    800,    864,    928,    992,    1120,   1248,   1376,   1504,
    1632,   1760,   1888,   2016,   2272,   2528,   2784,   3040,   3296,
    3552,   3808,   4064,   4576,   5088,   5600,   6112,   6624,   7136,
    7648,   8160,   9184,   10208,  11232,  12256,  13280,  14304,  15328,
    16352,  18400,  20448,  22496,  24544,  26592,  28640,  30688,  32736,
    36832,  40928,  45024,  49120,  53216,  57312,  61408,  65504,  73696,
    81888,  90080,  98272,  106464, 114656, 122848, 131040, 147424, 163808,
    180192, 196576, 212960, 229344, 245728,
Jingning Han's avatar
Jingning Han committed
514
515
516
517
518
519
520
521
522
523
524
  };
  const int tmp = (xsq_q10 >> 2) + 8;
  const int k = get_msb(tmp) - 3;
  const int xq = (k << 3) + ((tmp >> k) & 0x7);
  const int one_q10 = 1 << 10;
  const int a_q10 = ((xsq_q10 - xsq_iq_q10[xq]) << 10) >> (2 + k);
  const int b_q10 = one_q10 - a_q10;
  *r_q10 = (rate_tab_q10[xq] * b_q10 + rate_tab_q10[xq + 1] * a_q10) >> 10;
  *d_q10 = (dist_tab_q10[xq] * b_q10 + dist_tab_q10[xq + 1] * a_q10) >> 10;
}

Yaowu Xu's avatar
Yaowu Xu committed
525
526
527
void av1_model_rd_from_var_lapndz(int64_t var, unsigned int n_log2,
                                  unsigned int qstep, int *rate,
                                  int64_t *dist) {
Jingning Han's avatar
Jingning Han committed
528
529
530
531
532
533
534
535
536
537
538
539
540
541
  // This function models the rate and distortion for a Laplacian
  // source with given variance when quantized with a uniform quantizer
  // with given stepsize. The closed form expressions are in:
  // Hang and Chen, "Source Model for transform video coder and its
  // application - Part I: Fundamental Theory", IEEE Trans. Circ.
  // Sys. for Video Tech., April 1997.
  if (var == 0) {
    *rate = 0;
    *dist = 0;
  } else {
    int d_q10, r_q10;
    static const uint32_t MAX_XSQ_Q10 = 245727;
    const uint64_t xsq_q10_64 =
        (((uint64_t)qstep * qstep << (n_log2 + 10)) + (var >> 1)) / var;
Yaowu Xu's avatar
Yaowu Xu committed
542
    const int xsq_q10 = (int)AOMMIN(xsq_q10_64, MAX_XSQ_Q10);
Jingning Han's avatar
Jingning Han committed
543
    model_rd_norm(xsq_q10, &r_q10, &d_q10);
Yaowu Xu's avatar
Yaowu Xu committed
544
    *rate = ROUND_POWER_OF_TWO(r_q10 << n_log2, 10 - AV1_PROB_COST_SHIFT);
Jingning Han's avatar
Jingning Han committed
545
546
547
548
    *dist = (var * (int64_t)d_q10 + 512) >> 10;
  }
}

549
550
551
552
static void get_entropy_contexts_plane(
    BLOCK_SIZE plane_bsize, TX_SIZE tx_size, const struct macroblockd_plane *pd,
    ENTROPY_CONTEXT t_above[2 * MAX_MIB_SIZE],
    ENTROPY_CONTEXT t_left[2 * MAX_MIB_SIZE]) {
Jingning Han's avatar
Jingning Han committed
553
554
555
556
557
558
559
  const int num_4x4_w = num_4x4_blocks_wide_lookup[plane_bsize];
  const int num_4x4_h = num_4x4_blocks_high_lookup[plane_bsize];
  const ENTROPY_CONTEXT *const above = pd->above_context;
  const ENTROPY_CONTEXT *const left = pd->left_context;

  int i;
  switch (tx_size) {
560
561
562
#if CONFIG_CB4X4
    case TX_2X2:
#endif
Jingning Han's avatar
Jingning Han committed
563
564
565
566
    case TX_4X4:
      memcpy(t_above, above, sizeof(ENTROPY_CONTEXT) * num_4x4_w);
      memcpy(t_left, left, sizeof(ENTROPY_CONTEXT) * num_4x4_h);
      break;
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
    case TX_8X8:
      for (i = 0; i < num_4x4_w; i += 2)
        t_above[i] = !!*(const uint16_t *)&above[i];
      for (i = 0; i < num_4x4_h; i += 2)
        t_left[i] = !!*(const uint16_t *)&left[i];
      break;
    case TX_16X16:
      for (i = 0; i < num_4x4_w; i += 4)
        t_above[i] = !!*(const uint32_t *)&above[i];
      for (i = 0; i < num_4x4_h; i += 4)
        t_left[i] = !!*(const uint32_t *)&left[i];
      break;
    case TX_32X32:
      for (i = 0; i < num_4x4_w; i += 8)
        t_above[i] = !!*(const uint64_t *)&above[i];
      for (i = 0; i < num_4x4_h; i += 8)
        t_left[i] = !!*(const uint64_t *)&left[i];
      break;
585
586
587
588
589
590
#if CONFIG_TX64X64
    case TX_64X64:
      for (i = 0; i < num_4x4_w; i += 16)
        t_above[i] =
            !!(*(const uint64_t *)&above[i] | *(const uint64_t *)&above[i + 8]);
      for (i = 0; i < num_4x4_h; i += 16)
591
592
        t_left[i] =
            !!(*(const uint64_t *)&left[i] | *(const uint64_t *)&left[i + 8]);
593
594
      break;
#endif  // CONFIG_TX64X64
595
596
597
598
599
600
601
602
603
604
    case TX_4X8:
      memcpy(t_above, above, sizeof(ENTROPY_CONTEXT) * num_4x4_w);
      for (i = 0; i < num_4x4_h; i += 2)
        t_left[i] = !!*(const uint16_t *)&left[i];
      break;
    case TX_8X4:
      for (i = 0; i < num_4x4_w; i += 2)
        t_above[i] = !!*(const uint16_t *)&above[i];
      memcpy(t_left, left, sizeof(ENTROPY_CONTEXT) * num_4x4_h);
      break;
605
    case TX_8X16:
Jingning Han's avatar
Jingning Han committed
606
607
      for (i = 0; i < num_4x4_w; i += 2)
        t_above[i] = !!*(const uint16_t *)&above[i];
608
609
610
611
612
613
      for (i = 0; i < num_4x4_h; i += 4)
        t_left[i] = !!*(const uint32_t *)&left[i];
      break;
    case TX_16X8:
      for (i = 0; i < num_4x4_w; i += 4)
        t_above[i] = !!*(const uint32_t *)&above[i];
Jingning Han's avatar
Jingning Han committed
614
615
616
      for (i = 0; i < num_4x4_h; i += 2)
        t_left[i] = !!*(const uint16_t *)&left[i];
      break;
617
    case TX_16X32:
Jingning Han's avatar
Jingning Han committed
618
619
      for (i = 0; i < num_4x4_w; i += 4)
        t_above[i] = !!*(const uint32_t *)&above[i];
620
621
      for (i = 0; i < num_4x4_h; i += 8)
        t_left[i] = !!*(const uint64_t *)&left[i];
Jingning Han's avatar
Jingning Han committed
622
      break;
623
    case TX_32X16:
Jingning Han's avatar
Jingning Han committed
624
625
      for (i = 0; i < num_4x4_w; i += 8)
        t_above[i] = !!*(const uint64_t *)&above[i];
626
627
628
      for (i = 0; i < num_4x4_h; i += 4)
        t_left[i] = !!*(const uint32_t *)&left[i];
      break;
clang-format's avatar
clang-format committed
629
    default: assert(0 && "Invalid transform size."); break;
Jingning Han's avatar
Jingning Han committed
630
631
632
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
633
634
635
636
void av1_get_entropy_contexts(BLOCK_SIZE bsize, TX_SIZE tx_size,
                              const struct macroblockd_plane *pd,
                              ENTROPY_CONTEXT t_above[2 * MAX_MIB_SIZE],
                              ENTROPY_CONTEXT t_left[2 * MAX_MIB_SIZE]) {
637
  const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
638
  get_entropy_contexts_plane(plane_bsize, tx_size, pd, t_above, t_left);
639
640
}

641
void av1_mv_pred(const AV1_COMP *cpi, MACROBLOCK *x, uint8_t *ref_y_buffer,
Yaowu Xu's avatar
Yaowu Xu committed
642
                 int ref_y_stride, int ref_frame, BLOCK_SIZE block_size) {
Jingning Han's avatar
Jingning Han committed
643
644
645
646
647
648
649
650
651
  int i;
  int zero_seen = 0;
  int best_index = 0;
  int best_sad = INT_MAX;
  int this_sad = INT_MAX;
  int max_mv = 0;
  int near_same_nearest;
  uint8_t *src_y_ptr = x->plane[0].src.buf;
  uint8_t *ref_y_ptr;
652
653
654
  const int num_mv_refs =
      MAX_MV_REF_CANDIDATES +
      (cpi->sf.adaptive_motion_search && block_size < x->max_partition_size);
Jingning Han's avatar
Jingning Han committed
655
656
657
658
659
660
661

  MV pred_mv[3];
  pred_mv[0] = x->mbmi_ext->ref_mvs[ref_frame][0].as_mv;
  pred_mv[1] = x->mbmi_ext->ref_mvs[ref_frame][1].as_mv;
  pred_mv[2] = x->pred_mv[ref_frame];
  assert(num_mv_refs <= (int)(sizeof(pred_mv) / sizeof(pred_mv[0])));

662
663
  near_same_nearest = x->mbmi_ext->ref_mvs[ref_frame][0].as_int ==
                      x->mbmi_ext->ref_mvs[ref_frame][1].as_int;
Jingning Han's avatar
Jingning Han committed
664
665
666
667
668
  // Get the sad for each candidate reference mv.
  for (i = 0; i < num_mv_refs; ++i) {
    const MV *this_mv = &pred_mv[i];
    int fp_row, fp_col;

669
    if (i == 1 && near_same_nearest) continue;
Jingning Han's avatar
Jingning Han committed
670
671
    fp_row = (this_mv->row + 3 + (this_mv->row >= 0)) >> 3;
    fp_col = (this_mv->col + 3 + (this_mv->col >= 0)) >> 3;
Yaowu Xu's avatar
Yaowu Xu committed
672
    max_mv = AOMMAX(max_mv, AOMMAX(abs(this_mv->row), abs(this_mv->col)) >> 3);
Jingning Han's avatar
Jingning Han committed
673

674
675
    if (fp_row == 0 && fp_col == 0 && zero_seen) continue;
    zero_seen |= (fp_row == 0 && fp_col == 0);
Jingning Han's avatar
Jingning Han committed
676

677
    ref_y_ptr = &ref_y_buffer[ref_y_stride * fp_row + fp_col];
Jingning Han's avatar
Jingning Han committed
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
    // Find sad for current vector.
    this_sad = cpi->fn_ptr[block_size].sdf(src_y_ptr, x->plane[0].src.stride,
                                           ref_y_ptr, ref_y_stride);
    // Note if it is the best so far.
    if (this_sad < best_sad) {
      best_sad = this_sad;
      best_index = i;
    }
  }

  // Note the index of the mv that worked best in the reference list.
  x->mv_best_ref_index[ref_frame] = best_index;
  x->max_mv_context[ref_frame] = max_mv;
  x->pred_mv_sad[ref_frame] = best_sad;
}

Yaowu Xu's avatar
Yaowu Xu committed
694
695
696
697
698
void av1_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) {
Jingning Han's avatar
Jingning Han committed
699
700
701
702
703
704
705
706
707
  int i;

  dst[0].buf = src->y_buffer;
  dst[0].stride = src->y_stride;
  dst[1].buf = src->u_buffer;
  dst[2].buf = src->v_buffer;
  dst[1].stride = dst[2].stride = src->uv_stride;

  for (i = 0; i < MAX_MB_PLANE; ++i) {
708
709
710
    setup_pred_plane(dst + i, dst[i].buf,
                     i ? src->uv_crop_width : src->y_crop_width,
                     i ? src->uv_crop_height : src->y_crop_height,
711
                     dst[i].stride, mi_row, mi_col, i ? scale_uv : scale,
Jingning Han's avatar
Jingning Han committed
712
713
714
715
                     xd->plane[i].subsampling_x, xd->plane[i].subsampling_y);
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
716
717
int av1_raster_block_offset(BLOCK_SIZE plane_bsize, int raster_block,
                            int stride) {
Jingning Han's avatar
Jingning Han committed
718
719
720
721
722
723
  const int bw = b_width_log2_lookup[plane_bsize];
  const int y = 4 * (raster_block >> bw);
  const int x = 4 * (raster_block & ((1 << bw) - 1));
  return y * stride + x;
}

Yaowu Xu's avatar
Yaowu Xu committed
724
725
int16_t *av1_raster_block_offset_int16(BLOCK_SIZE plane_bsize, int raster_block,
                                       int16_t *base) {
726
  const int stride = block_size_wide[plane_bsize];
Yaowu Xu's avatar
Yaowu Xu committed
727
  return base + av1_raster_block_offset(plane_bsize, raster_block, stride);
Jingning Han's avatar
Jingning Han committed
728
729
}

Yaowu Xu's avatar
Yaowu Xu committed
730
731
732
YV12_BUFFER_CONFIG *av1_get_scaled_ref_frame(const AV1_COMP *cpi,
                                             int ref_frame) {
  const AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
733
734
  const int scaled_idx = cpi->scaled_ref_idx[ref_frame - 1];
  const int ref_idx = get_ref_frame_buf_idx(cpi, ref_frame);
735
736
737
  return (scaled_idx != ref_idx && scaled_idx != INVALID_IDX)
             ? &cm->buffer_pool->frame_bufs[scaled_idx].buf
             : NULL;
Jingning Han's avatar
Jingning Han committed
738
739
}

740
#if CONFIG_DUAL_FILTER
741
int av1_get_switchable_rate(const AV1_COMP *cpi, const MACROBLOCKD *xd) {
742
743
744
745
746
747
748
749
750
751
752
753
754
755
  const AV1_COMMON *const cm = &cpi->common;
  if (cm->interp_filter == SWITCHABLE) {
    const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
    int inter_filter_cost = 0;
    int dir;

    for (dir = 0; dir < 2; ++dir) {
      if (has_subpel_mv_component(xd->mi[0], xd, dir) ||
          (mbmi->ref_frame[1] > INTRA_FRAME &&
           has_subpel_mv_component(xd->mi[0], xd, dir + 2))) {
        const int ctx = av1_get_pred_context_switchable_interp(xd, dir);
        inter_filter_cost +=
            cpi->switchable_interp_costs[ctx][mbmi->interp_filter[dir]];
      }
756
    }
757
758
759
    return SWITCHABLE_INTERP_RATE_FACTOR * inter_filter_cost;
  } else {
    return 0;
760
761
762
  }
}
#else
763
int av1_get_switchable_rate(const AV1_COMP *cpi, const MACROBLOCKD *xd) {
764
765
  const AV1_COMMON *const cm = &cpi->common;
  if (cm->interp_filter == SWITCHABLE) {
766
#if CONFIG_EXT_INTERP
767
768
769
770
771
772
773
774
775
776
    if (av1_is_interp_needed(xd))
#endif
    {
      const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
      const int ctx = av1_get_pred_context_switchable_interp(xd);
      return SWITCHABLE_INTERP_RATE_FACTOR *
             cpi->switchable_interp_costs[ctx][mbmi->interp_filter];
    }
  }
  return 0;
Jingning Han's avatar
Jingning Han committed
777
}
778
#endif
Jingning Han's avatar
Jingning Han committed
779

Yaowu Xu's avatar
Yaowu Xu committed
780
void av1_set_rd_speed_thresholds(AV1_COMP *cpi) {
Jingning Han's avatar
Jingning Han committed
781
782
783
784
785
786
787
788
789
790
  int i;
  RD_OPT *const rd = &cpi->rd;
  SPEED_FEATURES *const sf = &cpi->sf;

  // Set baseline threshold values.
  for (i = 0; i < MAX_MODES; ++i)
    rd->thresh_mult[i] = cpi->oxcf.mode == BEST ? -500 : 0;

  if (sf->adaptive_rd_thresh) {
    rd->thresh_mult[THR_NEARESTMV] = 300;
791
792
793
#if CONFIG_EXT_REFS
    rd->thresh_mult[THR_NEARESTL2] = 300;
    rd->thresh_mult[THR_NEARESTL3] = 300;
794
    rd->thresh_mult[THR_NEARESTB] = 300;
795
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
796
    rd->thresh_mult[THR_NEARESTA] = 300;
797
    rd->thresh_mult[THR_NEARESTG] = 300;
Jingning Han's avatar
Jingning Han committed
798
799
  } else {
    rd->thresh_mult[THR_NEARESTMV] = 0;
800
801
802
#if CONFIG_EXT_REFS
    rd->thresh_mult[THR_NEARESTL2] = 0;
    rd->thresh_mult[THR_NEARESTL3] = 0;
803
    rd->thresh_mult[THR_NEARESTB] = 0;
804
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
805
    rd->thresh_mult[THR_NEARESTA] = 0;
806
    rd->thresh_mult[THR_NEARESTG] = 0;
Jingning Han's avatar
Jingning Han committed
807
808
809
810
811
  }

  rd->thresh_mult[THR_DC] += 1000;

  rd->thresh_mult[THR_NEWMV] += 1000;
812
813
814
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_NEWL2] += 1000;
  rd->thresh_mult[THR_NEWL3] += 1000;
815
  rd->thresh_mult[THR_NEWB] += 1000;
816
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
817
818
819
820
  rd->thresh_mult[THR_NEWA] += 1000;
  rd->thresh_mult[THR_NEWG] += 1000;

  rd->thresh_mult[THR_NEARMV] += 1000;
821
822
823
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_NEARL2] += 1000;
  rd->thresh_mult[THR_NEARL3] += 1000;
824
  rd->thresh_mult[THR_NEARB] += 1000;
825
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
826
  rd->thresh_mult[THR_NEARA] += 1000;
827
828
  rd->thresh_mult[THR_NEARG] += 1000;

Yue Chen's avatar
Yue Chen committed
829
830
#if CONFIG_EXT_INTER
  rd->thresh_mult[THR_NEWFROMNEARMV] += 1000;
831
#if CONFIG_EXT_REFS
Yue Chen's avatar
Yue Chen committed
832
833
  rd->thresh_mult[THR_NEWFROMNEARL2] += 1000;
  rd->thresh_mult[THR_NEWFROMNEARL3] += 1000;
834
  rd->thresh_mult[THR_NEWFROMNEARB] += 1000;
835
#endif  // CONFIG_EXT_REFS
Yue Chen's avatar
Yue Chen committed
836
  rd->thresh_mult[THR_NEWFROMNEARA] += 1000;
837
  rd->thresh_mult[THR_NEWFROMNEARG] += 1000;
Yue Chen's avatar
Yue Chen committed
838
839
#endif  // CONFIG_EXT_INTER

840
841
842
843
  rd->thresh_mult[THR_ZEROMV] += 2000;
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_ZEROL2] += 2000;
  rd->thresh_mult[THR_ZEROL3] += 2000;
844
  rd->thresh_mult[THR_ZEROB] += 2000;
845
846
847
#endif  // CONFIG_EXT_REFS
  rd->thresh_mult[THR_ZEROG] += 2000;
  rd->thresh_mult[THR_ZEROA] += 2000;
Jingning Han's avatar
Jingning Han committed
848
849
850

  rd->thresh_mult[THR_TM] += 1000;

851
#if CONFIG_EXT_INTER
852

853
  rd->thresh_mult[THR_COMP_NEAREST_NEARESTLA] += 1000;
854
855
856
857
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_COMP_NEAREST_NEARESTL2A] += 1000;
  rd->thresh_mult[THR_COMP_NEAREST_NEARESTL3A] += 1000;
#endif  // CONFIG_EXT_REFS
858
  rd->thresh_mult[THR_COMP_NEAREST_NEARESTGA] += 1000;
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_COMP_NEAREST_NEARESTLB] += 1000;
  rd->thresh_mult[THR_COMP_NEAREST_NEARESTL2B] += 1000;
  rd->thresh_mult[THR_COMP_NEAREST_NEARESTL3B] += 1000;
  rd->thresh_mult[THR_COMP_NEAREST_NEARESTGB] += 1000;
#endif  // CONFIG_EXT_REFS

#else  // CONFIG_EXT_INTER

  rd->thresh_mult[THR_COMP_NEARESTLA] += 1000;
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_COMP_NEARESTL2A] += 1000;
  rd->thresh_mult[THR_COMP_NEARESTL3A] += 1000;
#endif  // CONFIG_EXT_REFS
  rd->thresh_mult[THR_COMP_NEARESTGA] += 1000;
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_COMP_NEARESTLB] += 1000;
  rd->thresh_mult[THR_COMP_NEARESTL2B] += 1000;
  rd->thresh_mult[THR_COMP_NEARESTL3B] += 1000;
  rd->thresh_mult[THR_COMP_NEARESTGB] += 1000;
#endif  // CONFIG_EXT_REFS

#endif  // CONFIG_EXT_INTER

#if CONFIG_EXT_INTER

885
886
  rd->thresh_mult[THR_COMP_NEAREST_NEARLA] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARESTLA] += 1200;
887
  rd->thresh_mult[THR_COMP_NEAR_NEARLA] += 1200;
888
889
890
891
892
893
894
895
896
897
  rd->thresh_mult[THR_COMP_NEAREST_NEWLA] += 1500;
  rd->thresh_mult[THR_COMP_NEW_NEARESTLA] += 1500;
  rd->thresh_mult[THR_COMP_NEAR_NEWLA] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEARLA] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEWLA] += 2000;
  rd->thresh_mult[THR_COMP_ZERO_ZEROLA] += 2500;

#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_COMP_NEAREST_NEARL2A] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARESTL2A] += 1200;
898
  rd->thresh_mult[THR_COMP_NEAR_NEARL2A] += 1200;
899
900
901
902
903
904
905
906
907
  rd->thresh_mult[THR_COMP_NEAREST_NEWL2A] += 1500;
  rd->thresh_mult[THR_COMP_NEW_NEARESTL2A] += 1500;
  rd->thresh_mult[THR_COMP_NEAR_NEWL2A] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEARL2A] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEWL2A] += 2000;
  rd->thresh_mult[THR_COMP_ZERO_ZEROL2A] += 2500;

  rd->thresh_mult[THR_COMP_NEAREST_NEARL3A] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARESTL3A] += 1200;
908
  rd->thresh_mult[THR_COMP_NEAR_NEARL3A] += 1200;
909
910
911
912
913
914
  rd->thresh_mult[THR_COMP_NEAREST_NEWL3A] += 1500;
  rd->thresh_mult[THR_COMP_NEW_NEARESTL3A] += 1500;
  rd->thresh_mult[THR_COMP_NEAR_NEWL3A] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEARL3A] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEWL3A] += 2000;
  rd->thresh_mult[THR_COMP_ZERO_ZEROL3A] += 2500;
915
#endif  // CONFIG_EXT_REFS
916

917
918
919
920
921
922
923
924
925
  rd->thresh_mult[THR_COMP_NEAREST_NEARGA] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARESTGA] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARGA] += 1200;
  rd->thresh_mult[THR_COMP_NEAREST_NEWGA] += 1500;
  rd->thresh_mult[THR_COMP_NEW_NEARESTGA] += 1500;
  rd->thresh_mult[THR_COMP_NEAR_NEWGA] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEARGA] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEWGA] += 2000;
  rd->thresh_mult[THR_COMP_ZERO_ZEROGA] += 2500;
926

927
928
929
930
931
932
933
934
935
936
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_COMP_NEAREST_NEARLB] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARESTLB] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARLB] += 1200;
  rd->thresh_mult[THR_COMP_NEAREST_NEWLB] += 1500;
  rd->thresh_mult[THR_COMP_NEW_NEARESTLB] += 1500;
  rd->thresh_mult[THR_COMP_NEAR_NEWLB] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEARLB] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEWLB] += 2000;
  rd->thresh_mult[THR_COMP_ZERO_ZEROLB] += 2500;
937

938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
  rd->thresh_mult[THR_COMP_NEAREST_NEARL2B] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARESTL2B] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARL2B] += 1200;
  rd->thresh_mult[THR_COMP_NEAREST_NEWL2B] += 1500;
  rd->thresh_mult[THR_COMP_NEW_NEARESTL2B] += 1500;
  rd->thresh_mult[THR_COMP_NEAR_NEWL2B] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEARL2B] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEWL2B] += 2000;
  rd->thresh_mult[THR_COMP_ZERO_ZEROL2B] += 2500;

  rd->thresh_mult[THR_COMP_NEAREST_NEARL3B] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARESTL3B] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARL3B] += 1200;
  rd->thresh_mult[THR_COMP_NEAREST_NEWL3B] += 1500;
  rd->thresh_mult[THR_COMP_NEW_NEARESTL3B] += 1500;
  rd->thresh_mult[THR_COMP_NEAR_NEWL3B] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEARL3B] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEWL3B] += 2000;
  rd->thresh_mult[THR_COMP_ZERO_ZEROL3B] += 2500;
957
958
959

  rd->thresh_mult[THR_COMP_NEAREST_NEARGB] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARESTGB] += 1200;
960
  rd->thresh_mult[THR_COMP_NEAR_NEARGB] += 1200;
961
962
963
964
965
966
  rd->thresh_mult[THR_COMP_NEAREST_NEWGB] += 1500;
  rd->thresh_mult[THR_COMP_NEW_NEARESTGB] += 1500;
  rd->thresh_mult[THR_COMP_NEAR_NEWGB] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEARGB] += 1700;
  rd->thresh_mult[THR_COMP_NEW_NEWGB] += 2000;
  rd->thresh_mult[THR_COMP_ZERO_ZEROGB] += 2500;
967
#endif  // CONFIG_EXT_REFS
968
969
970

#else  // CONFIG_EXT_INTER

Jingning Han's avatar
Jingning Han committed
971
972
  rd->thresh_mult[THR_COMP_NEARLA] += 1500;
  rd->thresh_mult[THR_COMP_NEWLA] += 2000;
973
974
975
976
977
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_COMP_NEARL2A] += 1500;
  rd->thresh_mult[THR_COMP_NEWL2A] += 2000;
  rd->thresh_mult[THR_COMP_NEARL3A] += 1500;
  rd->thresh_mult[THR_COMP_NEWL3A] += 2000;
978
979
980
981
982
#endif  // CONFIG_EXT_REFS
  rd->thresh_mult[THR_COMP_NEARGA] += 1500;
  rd->thresh_mult[THR_COMP_NEWGA] += 2000;

#if CONFIG_EXT_REFS
983
984
  rd->thresh_mult[THR_COMP_NEARLB] += 1500;
  rd->thresh_mult[THR_COMP_NEWLB] += 2000;
985
986
987
988
989
  rd->thresh_mult[THR_COMP_NEARL2B] += 1500;
  rd->thresh_mult[THR_COMP_NEWL2B] += 2000;
  rd->thresh_mult[THR_COMP_NEARL3B] += 1500;
  rd->thresh_mult[THR_COMP_NEWL3B] += 2000;
  rd->thresh_mult[THR_COMP_NEARGB] += 1500;
990
  rd->thresh_mult[THR_COMP_NEWGB] += 2000;
991
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
992
993

  rd->thresh_mult[THR_COMP_ZEROLA] += 2500;
994
995
996
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_COMP_ZEROL2A] += 2500;
  rd->thresh_mult[THR_COMP_ZEROL3A] += 2500;
997
998
999
1000
#endif  // CONFIG_EXT_REFS
  rd->thresh_mult[THR_COMP_ZEROGA] += 2500;

#if CONFIG_EXT_REFS