rd.c 45.2 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
#include "av1/encoder/av1_quantize.h"
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/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_SIZES; ++i) {
105
    for (j = 0; j < PALETTE_COLOR_INDEX_CONTEXTS; ++j) {
Yaowu Xu's avatar
Yaowu Xu committed
106
      av1_cost_tokens(cpi->palette_y_color_cost[i][j],
107
108
                      av1_default_palette_y_color_index_prob[i][j],
                      av1_palette_color_index_tree[i]);
Yaowu Xu's avatar
Yaowu Xu committed
109
      av1_cost_tokens(cpi->palette_uv_color_cost[i][j],
110
111
                      av1_default_palette_uv_color_index_prob[i][j],
                      av1_palette_color_index_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
#if CONFIG_EXT_INTRA
hui su's avatar
hui su committed
151
#if CONFIG_INTRA_INTERP
152
  for (i = 0; i < INTRA_FILTERS + 1; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
153
154
    av1_cost_tokens(cpi->intra_filter_cost[i], fc->intra_filter_probs[i],
                    av1_intra_filter_tree);
hui su's avatar
hui su committed
155
#endif  // CONFIG_INTRA_INTERP
156
#endif  // CONFIG_EXT_INTRA
157
158
159
160
#if CONFIG_LOOP_RESTORATION
  av1_cost_tokens(cpi->switchable_restore_cost, fc->switchable_restore_prob,
                  av1_switchable_restore_tree);
#endif  // CONFIG_LOOP_RESTORATION
161
162
163
164
#if CONFIG_GLOBAL_MOTION
  av1_cost_tokens(cpi->gmtype_cost, fc->global_motion_types_prob,
                  av1_global_motion_types_tree);
#endif  // CONFIG_GLOBAL_MOTION
Jingning Han's avatar
Jingning Han committed
165
166
}

Yaowu Xu's avatar
Yaowu Xu committed
167
168
void av1_fill_token_costs(av1_coeff_cost *c,
                          av1_coeff_probs_model (*p)[PLANE_TYPES]) {
Jingning Han's avatar
Jingning Han committed
169
170
  int i, j, k, l;
  TX_SIZE t;
171
  for (t = 0; t < TX_SIZES; ++t)
Jingning Han's avatar
Jingning Han committed
172
173
174
175
    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
176
177
178
179
180
            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
181
182
183
184
185
186
187
188
189
            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
190
#if CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
191
192
193
194
195
196
197
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
198
                            aom_bit_depth_t bit_depth) {
Jingning Han's avatar
Jingning Han committed
199
200
201
202
203
  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
204
    const double q = av1_convert_qindex_to_q(i, bit_depth);
Jingning Han's avatar
Jingning Han committed
205
206
207
208
209
    bit16lut[i] = (int)(0.0418 * q + 2.4107);
    bit4lut[i] = (int)(0.063 * q + 2.742);
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
210
void av1_init_me_luts(void) {
Jingning Han's avatar
Jingning Han committed
211
  init_me_luts_bd(sad_per_bit16lut_8, sad_per_bit4lut_8, QINDEX_RANGE,
Yaowu Xu's avatar
Yaowu Xu committed
212
213
                  AOM_BITS_8);
#if CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
214
  init_me_luts_bd(sad_per_bit16lut_10, sad_per_bit4lut_10, QINDEX_RANGE,
Yaowu Xu's avatar
Yaowu Xu committed
215
                  AOM_BITS_10);
Jingning Han's avatar
Jingning Han committed
216
  init_me_luts_bd(sad_per_bit16lut_12, sad_per_bit4lut_12, QINDEX_RANGE,
Yaowu Xu's avatar
Yaowu Xu committed
217
                  AOM_BITS_12);
Jingning Han's avatar
Jingning Han committed
218
219
220
#endif
}

221
222
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
223
static const int rd_frame_type_factor[FRAME_UPDATE_TYPES] = {
224
  128, 144, 128, 128, 144,
225
#if CONFIG_EXT_REFS
226
227
  // TODO(zoeliu): To adjust further following factor values.
  128, 128, 128
228
229
  // 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
230
231
  ,
  144
232
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
233
234
};

Yaowu Xu's avatar
Yaowu Xu committed
235
236
237
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
238
239
  int64_t rdmult = 0;
  switch (cpi->common.bit_depth) {
Yaowu Xu's avatar
Yaowu Xu committed
240
241
242
    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
243
    default:
Yaowu Xu's avatar
Yaowu Xu committed
244
      assert(0 && "bit_depth should be AOM_BITS_8, AOM_BITS_10 or AOM_BITS_12");
Jingning Han's avatar
Jingning Han committed
245
246
247
248
      return -1;
  }
#else
  int64_t rdmult = 88 * q * q / 24;
Yaowu Xu's avatar
Yaowu Xu committed
249
#endif  // CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
250
251
252
  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
253
    const int boost_index = AOMMIN(15, (cpi->rc.gfu_boost / 100));
Jingning Han's avatar
Jingning Han committed
254
255
256
257

    rdmult = (rdmult * rd_frame_type_factor[frame_type]) >> 7;
    rdmult += ((rdmult * rd_boost_factor[boost_index]) >> 7);
  }
258
  if (rdmult < 1) rdmult = 1;
Jingning Han's avatar
Jingning Han committed
259
260
261
  return (int)rdmult;
}

Yaowu Xu's avatar
Yaowu Xu committed
262
static int compute_rd_thresh_factor(int qindex, aom_bit_depth_t bit_depth) {
Jingning Han's avatar
Jingning Han committed
263
  double q;
Yaowu Xu's avatar
Yaowu Xu committed
264
#if CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
265
  switch (bit_depth) {
Yaowu Xu's avatar
Yaowu Xu committed
266
267
268
    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
269
    default:
Yaowu Xu's avatar
Yaowu Xu committed
270
      assert(0 && "bit_depth should be AOM_BITS_8, AOM_BITS_10 or AOM_BITS_12");
Jingning Han's avatar
Jingning Han committed
271
272
273
      return -1;
  }
#else
274
  (void)bit_depth;
Yaowu Xu's avatar
Yaowu Xu committed
275
276
  q = av1_dc_quant(qindex, 0, AOM_BITS_8) / 4.0;
#endif  // CONFIG_AOM_HIGHBITDEPTH
Jingning Han's avatar
Jingning Han committed
277
  // TODO(debargha): Adjust the function below.
Yaowu Xu's avatar
Yaowu Xu committed
278
  return AOMMAX((int)(pow(q, RD_THRESH_POW) * 5.12), 8);
Jingning Han's avatar
Jingning Han committed
279
280
}

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

Yaowu Xu's avatar
Yaowu Xu committed
306
static void set_block_thresholds(const AV1_COMMON *cm, RD_OPT *rd) {
Jingning Han's avatar
Jingning Han committed
307
308
309
310
  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
311
        clamp(av1_get_qindex(&cm->seg, segment_id, cm->base_qindex) +
312
313
                  cm->y_dc_delta_q,
              0, MAXQ);
Jingning Han's avatar
Jingning Han committed
314
315
316
317
318
319
320
321
    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;

322
323
324
325
326
327
#if CONFIG_CB4X4
      for (i = 0; i < MAX_MODES; ++i)
        rd->threshes[segment_id][bsize][i] = rd->thresh_mult[i] < thresh_max
                                                 ? rd->thresh_mult[i] * t / 4
                                                 : INT_MAX;
#else
Jingning Han's avatar
Jingning Han committed
328
329
      if (bsize >= BLOCK_8X8) {
        for (i = 0; i < MAX_MODES; ++i)
330
331
332
          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
333
334
335
336
337
338
339
      } 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;
      }
340
#endif
Jingning Han's avatar
Jingning Han committed
341
342
343
344
    }
  }
}

345
#if CONFIG_REF_MV
Yaowu Xu's avatar
Yaowu Xu committed
346
347
void av1_set_mvcost(MACROBLOCK *x, MV_REFERENCE_FRAME ref_frame, int ref,
                    int ref_mv_idx) {
348
  MB_MODE_INFO_EXT *mbmi_ext = x->mbmi_ext;
Yaowu Xu's avatar
Yaowu Xu committed
349
350
351
352
  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;
353
354
  x->mvcost = x->mv_cost_stack[nmv_ctx];
  x->nmvjointcost = x->nmv_vec_cost[nmv_ctx];
Jingning Han's avatar
Jingning Han committed
355
356
  x->mvsadcost = x->mvcost;
  x->nmvjointsadcost = x->nmvjointcost;
357
358
359
}
#endif

Yaowu Xu's avatar
Yaowu Xu committed
360
361
void av1_initialize_rd_consts(AV1_COMP *cpi) {
  AV1_COMMON *const cm = &cpi->common;
Jingning Han's avatar
Jingning Han committed
362
363
364
  MACROBLOCK *const x = &cpi->td.mb;
  RD_OPT *const rd = &cpi->rd;
  int i;
Jingning Han's avatar
Jingning Han committed
365
366
367
#if CONFIG_REF_MV
  int nmv_ctx;
#endif
Jingning Han's avatar
Jingning Han committed
368

Yaowu Xu's avatar
Yaowu Xu committed
369
  aom_clear_system_state();
Jingning Han's avatar
Jingning Han committed
370
371

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

374
  set_error_per_bit(x, rd->RDMULT);
Jingning Han's avatar
Jingning Han committed
375
376
377

  set_block_thresholds(cm, rd);

378
#if CONFIG_REF_MV
Jingning Han's avatar
Jingning Han committed
379
  for (nmv_ctx = 0; nmv_ctx < NMV_CONTEXTS; ++nmv_ctx) {
Yaowu Xu's avatar
Yaowu Xu committed
380
    av1_build_nmv_cost_table(
Jingning Han's avatar
Jingning Han committed
381
382
383
384
        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);
385
  }
Jingning Han's avatar
Jingning Han committed
386
387
388
389
390
391
392
393
394
395
  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

396
  if (cpi->oxcf.pass != 1) {
397
    av1_fill_token_costs(x->token_costs, cm->fc->coef_probs);
398
399
400

    if (cpi->sf.partition_search_type != VAR_BASED_PARTITION ||
        cm->frame_type == KEY_FRAME) {
401
402
403
404
405
406
#if CONFIG_UNPOISON_PARTITION_CTX
      cpi->partition_cost[0][PARTITION_NONE] = INT_MAX;
      cpi->partition_cost[0][PARTITION_HORZ] = INT_MAX;
      cpi->partition_cost[0][PARTITION_VERT] = INT_MAX;
      cpi->partition_cost[0][PARTITION_SPLIT] = 0;
#endif
407
#if CONFIG_EXT_PARTITION_TYPES
408
409
410
411
412
      av1_cost_tokens(cpi->partition_cost[CONFIG_UNPOISON_PARTITION_CTX],
                      cm->fc->partition_prob[0], av1_partition_tree);
      for (i = 1; i < PARTITION_CONTEXTS_PRIMARY; ++i)
        av1_cost_tokens(cpi->partition_cost[CONFIG_UNPOISON_PARTITION_CTX + i],
                        cm->fc->partition_prob[i], av1_ext_partition_tree);
413
#else
414
415
416
      for (i = 0; i < PARTITION_CONTEXTS_PRIMARY; ++i)
        av1_cost_tokens(cpi->partition_cost[CONFIG_UNPOISON_PARTITION_CTX + i],
                        cm->fc->partition_prob[i], av1_partition_tree);
417
#endif  // CONFIG_EXT_PARTITION_TYPES
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
#if CONFIG_UNPOISON_PARTITION_CTX
      for (; i < PARTITION_CONTEXTS_PRIMARY + PARTITION_BLOCK_SIZES; ++i) {
        aom_prob p = cm->fc->partition_prob[i][PARTITION_VERT];
        assert(p > 0);
        cpi->partition_cost[1 + i][PARTITION_NONE] = INT_MAX;
        cpi->partition_cost[1 + i][PARTITION_HORZ] = INT_MAX;
        cpi->partition_cost[1 + i][PARTITION_VERT] = av1_cost_bit(p, 0);
        cpi->partition_cost[1 + i][PARTITION_SPLIT] = av1_cost_bit(p, 1);
      }
      for (; i < PARTITION_CONTEXTS_PRIMARY + 2 * PARTITION_BLOCK_SIZES; ++i) {
        aom_prob p = cm->fc->partition_prob[i][PARTITION_HORZ];
        assert(p > 0);
        cpi->partition_cost[1 + i][PARTITION_NONE] = INT_MAX;
        cpi->partition_cost[1 + i][PARTITION_HORZ] = av1_cost_bit(p, 0);
        cpi->partition_cost[1 + i][PARTITION_VERT] = INT_MAX;
        cpi->partition_cost[1 + i][PARTITION_SPLIT] = av1_cost_bit(p, 1);
      }
#endif
436
437
438
    }

    fill_mode_costs(cpi);
439

440
    if (!frame_is_intra_only(cm)) {
441
#if CONFIG_REF_MV
442
      for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i) {
Yaowu Xu's avatar
Yaowu Xu committed
443
444
        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);
445
      }
446

447
      for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i) {
Yaowu Xu's avatar
Yaowu Xu committed
448
449
        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);
450
      }
Jingning Han's avatar
Jingning Han committed
451

452
      for (i = 0; i < REFMV_MODE_CONTEXTS; ++i) {
Yaowu Xu's avatar
Yaowu Xu committed
453
454
        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);
455
      }
456

457
      for (i = 0; i < DRL_MODE_CONTEXTS; ++i) {
Yaowu Xu's avatar
Yaowu Xu committed
458
459
        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);
460
      }
Yue Chen's avatar
Yue Chen committed
461
#if CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
462
463
      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
464
#endif  // CONFIG_EXT_INTER
465
#else
466
      for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
467
468
        av1_cost_tokens((int *)cpi->inter_mode_cost[i],
                        cm->fc->inter_mode_probs[i], av1_inter_mode_tree);
469
#endif  // CONFIG_REF_MV
470
#if CONFIG_EXT_INTER
471
      for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
472
473
474
        av1_cost_tokens((int *)cpi->inter_compound_mode_cost[i],
                        cm->fc->inter_compound_mode_probs[i],
                        av1_inter_compound_mode_tree);
475
      for (i = 0; i < BLOCK_SIZE_GROUPS; ++i)
Yaowu Xu's avatar
Yaowu Xu committed
476
477
478
        av1_cost_tokens((int *)cpi->interintra_mode_cost[i],
                        cm->fc->interintra_mode_prob[i],
                        av1_interintra_mode_tree);
479
#endif  // CONFIG_EXT_INTER
Yue Chen's avatar
Yue Chen committed
480
#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
481
      for (i = BLOCK_8X8; i < BLOCK_SIZES; i++) {
Yue Chen's avatar
Yue Chen committed
482
483
        av1_cost_tokens((int *)cpi->motion_mode_cost[i],
                        cm->fc->motion_mode_prob[i], av1_motion_mode_tree);
484
      }
Yue Chen's avatar
Yue Chen committed
485
486
487
488
489
490
#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
491
#endif  // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
492
    }
Jingning Han's avatar
Jingning Han committed
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
  }
}

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[] = {
510
511
512
513
514
515
516
517
518
    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
519
520
521
522
523
524
525
526
527
  };
  // 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[] = {
528
529
530
531
532
533
534
535
536
    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
537
538
  };
  static const int xsq_iq_q10[] = {
539
540
541
542
543
544
545
546
547
548
549
550
    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
551
552
553
554
555
556
557
558
559
560
561
  };
  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
562
563
564
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
565
566
567
568
569
570
571
572
573
574
575
576
577
578
  // 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
579
    const int xsq_q10 = (int)AOMMIN(xsq_q10_64, MAX_XSQ_Q10);
Jingning Han's avatar
Jingning Han committed
580
    model_rd_norm(xsq_q10, &r_q10, &d_q10);
Yaowu Xu's avatar
Yaowu Xu committed
581
    *rate = ROUND_POWER_OF_TWO(r_q10 << n_log2, 10 - AV1_PROB_COST_SHIFT);
Jingning Han's avatar
Jingning Han committed
582
583
584
585
    *dist = (var * (int64_t)d_q10 + 512) >> 10;
  }
}

586
587
588
589
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]) {
590
591
  const int num_4x4_w = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
  const int num_4x4_h = block_size_high[plane_bsize] >> tx_size_high_log2[0];
Jingning Han's avatar
Jingning Han committed
592
593
594
595
  const ENTROPY_CONTEXT *const above = pd->above_context;
  const ENTROPY_CONTEXT *const left = pd->left_context;

  int i;
596

597
#if CONFIG_CB4X4
598
  switch (tx_size) {
599
    case TX_2X2:
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
      memcpy(t_above, above, sizeof(ENTROPY_CONTEXT) * num_4x4_w);
      memcpy(t_left, left, sizeof(ENTROPY_CONTEXT) * num_4x4_h);
      break;
    case TX_4X4:
      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_8X8:
      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_16X16:
      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;
    case TX_32X32:
      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)
        t_left[i] =
            !!(*(const uint64_t *)&left[i] | *(const uint64_t *)&left[i + 8]);
      break;
    case TX_4X8:
      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 += 4)
        t_left[i] = !!*(const uint32_t *)&left[i];
      break;
    case TX_8X4:
      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 += 2)
        t_left[i] = !!*(const uint16_t *)&left[i];
      break;
    case TX_8X16:
      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 += 8)
        t_left[i] = !!*(const uint64_t *)&left[i];
      break;
    case TX_16X8:
      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 += 4)
        t_left[i] = !!*(const uint32_t *)&left[i];
      break;
    case TX_16X32:
      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 += 16)
        t_left[i] =
            !!(*(const uint64_t *)&left[i] | *(const uint64_t *)&left[i + 8]);
      break;
    case TX_32X16:
      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 += 8)
        t_left[i] = !!*(const uint64_t *)&left[i];
666
      break;
667
668
669
670

    default: assert(0 && "Invalid transform size."); break;
  }
  return;
671
#endif
672
673

  switch (tx_size) {
Jingning Han's avatar
Jingning Han committed
674
675
676
677
    case TX_4X4:
      memcpy(t_above, above, sizeof(ENTROPY_CONTEXT) * num_4x4_w);
      memcpy(t_left, left, sizeof(ENTROPY_CONTEXT) * num_4x4_h);
      break;
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
    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;
696
697
698
699
700
701
#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)
702
703
        t_left[i] =
            !!(*(const uint64_t *)&left[i] | *(const uint64_t *)&left[i + 8]);
704
705
      break;
#endif  // CONFIG_TX64X64
706
707
708
709
710
711
712
713
714
715
    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;
716
    case TX_8X16:
Jingning Han's avatar
Jingning Han committed
717
718
      for (i = 0; i < num_4x4_w; i += 2)
        t_above[i] = !!*(const uint16_t *)&above[i];
719
720
721
722
723
724
      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
725
726
727
      for (i = 0; i < num_4x4_h; i += 2)
        t_left[i] = !!*(const uint16_t *)&left[i];
      break;
728
    case TX_16X32:
Jingning Han's avatar
Jingning Han committed
729
730
      for (i = 0; i < num_4x4_w; i += 4)
        t_above[i] = !!*(const uint32_t *)&above[i];
731
732
      for (i = 0; i < num_4x4_h; i += 8)
        t_left[i] = !!*(const uint64_t *)&left[i];
Jingning Han's avatar
Jingning Han committed
733
      break;
734
    case TX_32X16:
Jingning Han's avatar
Jingning Han committed
735
736
      for (i = 0; i < num_4x4_w; i += 8)
        t_above[i] = !!*(const uint64_t *)&above[i];
737
738
739
      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
740
    default: assert(0 && "Invalid transform size."); break;
Jingning Han's avatar
Jingning Han committed
741
742
743
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
744
745
746
747
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]) {
748
  const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
749
  get_entropy_contexts_plane(plane_bsize, tx_size, pd, t_above, t_left);
750
751
}

752
void av1_mv_pred(const AV1_COMP *cpi, MACROBLOCK *x, uint8_t *ref_y_buffer,
Yaowu Xu's avatar
Yaowu Xu committed
753
                 int ref_y_stride, int ref_frame, BLOCK_SIZE block_size) {
Jingning Han's avatar
Jingning Han committed
754
755
756
757
758
759
760
761
762
  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;
763
764
765
  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
766
767
768
769
770
771
772

  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])));

773
774
  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
775
776
777
778
779
  // 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;

780
    if (i == 1 && near_same_nearest) continue;
Jingning Han's avatar
Jingning Han committed
781
782
    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
783
    max_mv = AOMMAX(max_mv, AOMMAX(abs(this_mv->row), abs(this_mv->col)) >> 3);
Jingning Han's avatar
Jingning Han committed
784

785
786
    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
787

788
    ref_y_ptr = &ref_y_buffer[ref_y_stride * fp_row + fp_col];
Jingning Han's avatar
Jingning Han committed
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
    // 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
805
806
807
808
809
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
810
811
812
813
814
815
816
817
818
  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) {
819
820
821
    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,
822
                     dst[i].stride, mi_row, mi_col, i ? scale_uv : scale,
Jingning Han's avatar
Jingning Han committed
823
824
825
826
                     xd->plane[i].subsampling_x, xd->plane[i].subsampling_y);
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
827
828
int av1_raster_block_offset(BLOCK_SIZE plane_bsize, int raster_block,
                            int stride) {
Jingning Han's avatar
Jingning Han committed
829
830
831
832
833
834
  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
835
836
int16_t *av1_raster_block_offset_int16(BLOCK_SIZE plane_bsize, int raster_block,
                                       int16_t *base) {
837
  const int stride = block_size_wide[plane_bsize];
Yaowu Xu's avatar
Yaowu Xu committed
838
  return base + av1_raster_block_offset(plane_bsize, raster_block, stride);
Jingning Han's avatar
Jingning Han committed
839
840
}

Yaowu Xu's avatar
Yaowu Xu committed
841
842
843
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
844
845
  const int scaled_idx = cpi->scaled_ref_idx[ref_frame - 1];
  const int ref_idx = get_ref_frame_buf_idx(cpi, ref_frame);
846
847
848
  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
849
850
}

851
#if CONFIG_DUAL_FILTER
852
int av1_get_switchable_rate(const AV1_COMP *cpi, const MACROBLOCKD *xd) {
853
854
855
856
857
858
859
860
861
862
863
864
865
866
  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]];
      }
867
    }
868
869
870
    return SWITCHABLE_INTERP_RATE_FACTOR * inter_filter_cost;
  } else {
    return 0;
871
872
873
  }
}
#else
874
int av1_get_switchable_rate(const AV1_COMP *cpi, const MACROBLOCKD *xd) {
875
876
  const AV1_COMMON *const cm = &cpi->common;
  if (cm->interp_filter == SWITCHABLE) {
877
878
879
880
    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];
881
882
  }
  return 0;
Jingning Han's avatar
Jingning Han committed
883
}
884
#endif
Jingning Han's avatar
Jingning Han committed
885

Yaowu Xu's avatar
Yaowu Xu committed
886
void av1_set_rd_speed_thresholds(AV1_COMP *cpi) {
Jingning Han's avatar
Jingning Han committed
887
888
889
890
891
892
893
894
895
896
  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;
897
898
899
#if CONFIG_EXT_REFS
    rd->thresh_mult[THR_NEARESTL2] = 300;
    rd->thresh_mult[THR_NEARESTL3] = 300;
900
    rd->thresh_mult[THR_NEARESTB] = 300;
901
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
902
    rd->thresh_mult[THR_NEARESTA] = 300;
903
    rd->thresh_mult[THR_NEARESTG] = 300;
Jingning Han's avatar
Jingning Han committed
904
905
  } else {
    rd->thresh_mult[THR_NEARESTMV] = 0;
906
907
908
#if CONFIG_EXT_REFS
    rd->thresh_mult[THR_NEARESTL2] = 0;
    rd->thresh_mult[THR_NEARESTL3] = 0;
909
    rd->thresh_mult[THR_NEARESTB] = 0;
910
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
911
    rd->thresh_mult[THR_NEARESTA] = 0;
912
    rd->thresh_mult[THR_NEARESTG] = 0;
Jingning Han's avatar
Jingning Han committed
913
914
915
916
917
  }

  rd->thresh_mult[THR_DC] += 1000;

  rd->thresh_mult[THR_NEWMV] += 1000;
918
919
920
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_NEWL2] += 1000;
  rd->thresh_mult[THR_NEWL3] += 1000;
921
  rd->thresh_mult[THR_NEWB] += 1000;
922
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
923
924
925
926
  rd->thresh_mult[THR_NEWA] += 1000;
  rd->thresh_mult[THR_NEWG] += 1000;

  rd->thresh_mult[THR_NEARMV] += 1000;
927
928
929
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_NEARL2] += 1000;
  rd->thresh_mult[THR_NEARL3] += 1000;
930
  rd->thresh_mult[THR_NEARB] += 1000;
931
#endif  // CONFIG_EXT_REFS
Jingning Han's avatar
Jingning Han committed
932
  rd->thresh_mult[THR_NEARA] += 1000;
933
934
  rd->thresh_mult[THR_NEARG] += 1000;

Yue Chen's avatar
Yue Chen committed
935
936
#if CONFIG_EXT_INTER
  rd->thresh_mult[THR_NEWFROMNEARMV] += 1000;
937
#if CONFIG_EXT_REFS
Yue Chen's avatar
Yue Chen committed
938
939
  rd->thresh_mult[THR_NEWFROMNEARL2] += 1000;
  rd->thresh_mult[THR_NEWFROMNEARL3] += 1000;
940
  rd->thresh_mult[THR_NEWFROMNEARB] += 1000;
941
#endif  // CONFIG_EXT_REFS
Yue Chen's avatar
Yue Chen committed
942
  rd->thresh_mult[THR_NEWFROMNEARA] += 1000;
943
  rd->thresh_mult[THR_NEWFROMNEARG] += 1000;
Yue Chen's avatar
Yue Chen committed
944
945
#endif  // CONFIG_EXT_INTER

946
947
948
949
  rd->thresh_mult[THR_ZEROMV] += 2000;
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_ZEROL2] += 2000;
  rd->thresh_mult[THR_ZEROL3] += 2000;
950
  rd->thresh_mult[THR_ZEROB] += 2000;
951
952
953
#endif  // CONFIG_EXT_REFS
  rd->thresh_mult[THR_ZEROG] += 2000;
  rd->thresh_mult[THR_ZEROA] += 2000;
Jingning Han's avatar
Jingning Han committed
954
955
956

  rd->thresh_mult[THR_TM] += 1000;

957
#if CONFIG_EXT_INTER
958

959
  rd->thresh_mult[THR_COMP_NEAREST_NEARESTLA] += 1000;
960
961
962
963
#if CONFIG_EXT_REFS
  rd->thresh_mult[THR_COMP_NEAREST_NEARESTL2A] += 1000;
  rd->thresh_mult[THR_COMP_NEAREST_NEARESTL3A] += 1000;
#endif  // CONFIG_EXT_REFS
964
  rd->thresh_mult[THR_COMP_NEAREST_NEARESTGA] += 1000;
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
#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

991
992
  rd->thresh_mult[THR_COMP_NEAREST_NEARLA] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARESTLA] += 1200;
993
  rd->thresh_mult[THR_COMP_NEAR_NEARLA] += 1200;
994
995
996
997
998
999
1000
1001
1002
1003
  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;
1004
  rd->thresh_mult[THR_COMP_NEAR_NEARL2A] += 1200;
1005
1006
1007
1008
1009
1010
1011
1012
1013
  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;
1014
  rd->thresh_mult[THR_COMP_NEAR_NEARL3A] += 1200;
1015
1016
1017
1018
1019
1020
  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;
1021
#endif  // CONFIG_EXT_REFS
1022

1023
1024
1025
1026
1027
1028
1029
1030
1031
  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;
1032

1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
#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;
1043

1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
  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;
1063
1064
1065

  rd->thresh_mult[THR_COMP_NEAREST_NEARGB] += 1200;
  rd->thresh_mult[THR_COMP_NEAR_NEARESTGB] += 1200;
1066
  rd->thresh_mult[THR_COMP_NEAR_NEARGB] += 1200;
1067
1068
1069
1070
1071
1072
  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;
1073
#endif  // CONFIG_EXT_REFS
1074
1075
1076

#else  // CONFIG_EXT_INTER

Jingning Han's avatar
Jingning Han committed
1077
1078
  rd->thresh_mult