vp9_encodemb.c 38.4 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5 6
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
7
 *  in the file PATENTS.  All contributing project authors may
8
 *  be found in the AUTHORS file in the root of the source tree.
John Koleszar's avatar
John Koleszar committed
9 10
 */

11 12

#include "./vp9_rtcd.h"
13
#include "./vpx_config.h"
14
#include "./vpx_dsp_rtcd.h"
15 16

#include "vpx_mem/vpx_mem.h"
17
#include "vpx_ports/mem.h"
18 19

#include "vp9/common/vp9_idct.h"
20 21
#include "vp9/common/vp9_reconinter.h"
#include "vp9/common/vp9_reconintra.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
22
#include "vp9/common/vp9_scan.h"
23
#include "vp9/common/vp9_systemdependent.h"
24 25 26

#include "vp9/encoder/vp9_encodemb.h"
#include "vp9/encoder/vp9_quantize.h"
27
#include "vp9/encoder/vp9_rd.h"
28
#include "vp9/encoder/vp9_tokenize.h"
John Koleszar's avatar
John Koleszar committed
29

30 31 32 33 34
struct optimize_ctx {
  ENTROPY_CONTEXT ta[MAX_MB_PLANE][16];
  ENTROPY_CONTEXT tl[MAX_MB_PLANE][16];
};

35
void vp9_subtract_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane) {
36
  struct macroblock_plane *const p = &x->plane[plane];
37 38 39 40
  const struct macroblockd_plane *const pd = &x->e_mbd.plane[plane];
  const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
  const int bw = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
  const int bh = 4 * num_4x4_blocks_high_lookup[plane_bsize];
41

42 43
#if CONFIG_VP9_HIGHBITDEPTH
  if (x->e_mbd.cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
44
    vpx_highbd_subtract_block(bh, bw, p->src_diff, bw, p->src.buf,
45 46
                              p->src.stride, pd->dst.buf, pd->dst.stride,
                              x->e_mbd.bd);
47 48 49
    return;
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH
50
  vpx_subtract_block(bh, bw, p->src_diff, bw, p->src.buf, p->src.stride,
51
                     pd->dst.buf, pd->dst.stride);
Yaowu Xu's avatar
Yaowu Xu committed
52 53
}

54
#define RDTRUNC(RM, DM, R, D) ((128 + (R) * (RM)) & 0xFF)
55

Dmitry Kovalev's avatar
Dmitry Kovalev committed
56
typedef struct vp9_token_state {
57 58
  int           rate;
  int           error;
Daniel Kang's avatar
Daniel Kang committed
59
  int           next;
Yaowu Xu's avatar
Yaowu Xu committed
60
  int16_t       token;
61
  short         qc;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
62
} vp9_token_state;
63

64
// TODO(jimbankoski): experiment to find optimal RD numbers.
Dmitry Kovalev's avatar
Dmitry Kovalev committed
65
static const int plane_rd_mult[PLANE_TYPES] = { 4, 2 };
66

67 68 69 70 71 72 73 74 75 76
#define UPDATE_RD_COST()\
{\
  rd_cost0 = RDCOST(rdmult, rddiv, rate0, error0);\
  rd_cost1 = RDCOST(rdmult, rddiv, rate1, error1);\
  if (rd_cost0 == rd_cost1) {\
    rd_cost0 = RDTRUNC(rdmult, rddiv, rate0, error0);\
    rd_cost1 = RDTRUNC(rdmult, rddiv, rate1, error1);\
  }\
}

77 78
// This function is a place holder for now but may ultimately need
// to scan previous tokens to work out the correct context.
79 80
static int trellis_get_coeff_context(const int16_t *scan,
                                     const int16_t *nb,
81
                                     int idx, int token,
82
                                     uint8_t *token_cache) {
83
  int bak = token_cache[scan[idx]], pt;
84
  token_cache[scan[idx]] = vp9_pt_energy_class[token];
85
  pt = get_coef_context(nb, token_cache, idx + 1);
86
  token_cache[scan[idx]] = bak;
87
  return pt;
88 89
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
90
static int optimize_b(MACROBLOCK *mb, int plane, int block,
Yaowu Xu's avatar
Yaowu Xu committed
91
                      TX_SIZE tx_size, int ctx) {
92
  MACROBLOCKD *const xd = &mb->e_mbd;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
93 94
  struct macroblock_plane *const p = &mb->plane[plane];
  struct macroblockd_plane *const pd = &xd->plane[plane];
95
  const int ref = is_inter_block(&xd->mi[0]->mbmi);
96 97
  vp9_token_state tokens[1025][2];
  unsigned best_index[1025][2];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
98
  uint8_t token_cache[1024];
99 100 101
  const tran_low_t *const coeff = BLOCK_OFFSET(mb->plane[plane].coeff, block);
  tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
  tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
102 103
  const int eob = p->eobs[block];
  const PLANE_TYPE type = pd->plane_type;
104
  const int default_eob = 16 << (tx_size << 1);
105
  const int mul = 1 + (tx_size == TX_32X32);
106
  const int16_t *dequant_ptr = pd->dequant;
107
  const uint8_t *const band_translate = get_band_translate(tx_size);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
108 109 110 111 112 113
  const scan_order *const so = get_scan(xd, tx_size, type, block);
  const int16_t *const scan = so->scan;
  const int16_t *const nb = so->neighbors;
  int next = eob, sz = 0;
  int64_t rdmult = mb->rdmult * plane_rd_mult[type], rddiv = mb->rddiv;
  int64_t rd_cost0, rd_cost1;
114 115 116
  int rate0, rate1, error0, error1;
  int16_t t0, t1;
  EXTRABIT e0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
117
  int best, band, pt, i, final_eob;
118 119 120 121 122
#if CONFIG_VP9_HIGHBITDEPTH
  const int16_t *cat6_high_cost = vp9_get_high_cost_table(xd->bd);
#else
  const int16_t *cat6_high_cost = vp9_get_high_cost_table(8);
#endif
John Koleszar's avatar
John Koleszar committed
123

John Koleszar's avatar
John Koleszar committed
124
  assert((!type && !plane) || (type && plane));
John Koleszar's avatar
John Koleszar committed
125
  assert(eob <= default_eob);
John Koleszar's avatar
John Koleszar committed
126 127

  /* Now set up a Viterbi trellis to evaluate alternative roundings. */
Dmitry Kovalev's avatar
Dmitry Kovalev committed
128
  if (!ref)
John Koleszar's avatar
John Koleszar committed
129
    rdmult = (rdmult * 9) >> 4;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
130

John Koleszar's avatar
John Koleszar committed
131 132 133
  /* Initialize the sentinel node of the trellis. */
  tokens[eob][0].rate = 0;
  tokens[eob][0].error = 0;
134
  tokens[eob][0].next = default_eob;
135
  tokens[eob][0].token = EOB_TOKEN;
John Koleszar's avatar
John Koleszar committed
136
  tokens[eob][0].qc = 0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
137 138
  tokens[eob][1] = tokens[eob][0];

139
  for (i = 0; i < eob; i++)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
140
    token_cache[scan[i]] =
141
        vp9_pt_energy_class[vp9_get_token(qcoeff[scan[i]])];
142

Dmitry Kovalev's avatar
Dmitry Kovalev committed
143
  for (i = eob; i-- > 0;) {
144
    int base_bits, d2, dx;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
145 146
    const int rc = scan[i];
    int x = qcoeff[rc];
John Koleszar's avatar
John Koleszar committed
147 148 149 150 151 152 153 154
    /* Only add a trellis state for non-zero coefficients. */
    if (x) {
      int shortcut = 0;
      error0 = tokens[next][0].error;
      error1 = tokens[next][1].error;
      /* Evaluate the first possibility for this state. */
      rate0 = tokens[next][0].rate;
      rate1 = tokens[next][1].rate;
155
      vp9_get_token_extra(x, &t0, &e0);
John Koleszar's avatar
John Koleszar committed
156
      /* Consider both possible successor states. */
157
      if (next < default_eob) {
158
        band = band_translate[i + 1];
159
        pt = trellis_get_coeff_context(scan, nb, i, t0, token_cache);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
160 161 162 163
        rate0 += mb->token_costs[tx_size][type][ref][band][0][pt]
                                [tokens[next][0].token];
        rate1 += mb->token_costs[tx_size][type][ref][band][0][pt]
                                [tokens[next][1].token];
John Koleszar's avatar
John Koleszar committed
164
      }
165
      UPDATE_RD_COST();
John Koleszar's avatar
John Koleszar committed
166 167
      /* And pick the best. */
      best = rd_cost1 < rd_cost0;
168
      base_bits = vp9_get_cost(t0, e0, cat6_high_cost);
169
      dx = mul * (dqcoeff[rc] - coeff[rc]);
170 171 172 173 174
#if CONFIG_VP9_HIGHBITDEPTH
      if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
        dx >>= xd->bd - 8;
      }
#endif  // CONFIG_VP9_HIGHBITDEPTH
John Koleszar's avatar
John Koleszar committed
175 176 177 178 179 180
      d2 = dx * dx;
      tokens[i][0].rate = base_bits + (best ? rate1 : rate0);
      tokens[i][0].error = d2 + (best ? error1 : error0);
      tokens[i][0].next = next;
      tokens[i][0].token = t0;
      tokens[i][0].qc = x;
181
      best_index[i][0] = best;
182

John Koleszar's avatar
John Koleszar committed
183 184 185 186
      /* Evaluate the second possibility for this state. */
      rate0 = tokens[next][0].rate;
      rate1 = tokens[next][1].rate;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
187 188 189
      if ((abs(x) * dequant_ptr[rc != 0] > abs(coeff[rc]) * mul) &&
          (abs(x) * dequant_ptr[rc != 0] < abs(coeff[rc]) * mul +
                                               dequant_ptr[rc != 0]))
John Koleszar's avatar
John Koleszar committed
190 191 192 193 194 195 196 197 198 199 200 201 202
        shortcut = 1;
      else
        shortcut = 0;

      if (shortcut) {
        sz = -(x < 0);
        x -= 2 * sz + 1;
      }

      /* Consider both possible successor states. */
      if (!x) {
        /* If we reduced this coefficient to zero, check to see if
         *  we need to move the EOB back here.
203
         */
204 205
        t0 = tokens[next][0].token == EOB_TOKEN ? EOB_TOKEN : ZERO_TOKEN;
        t1 = tokens[next][1].token == EOB_TOKEN ? EOB_TOKEN : ZERO_TOKEN;
206
        e0 = 0;
John Koleszar's avatar
John Koleszar committed
207
      } else {
208 209
        vp9_get_token_extra(x, &t0, &e0);
        t1 = t0;
John Koleszar's avatar
John Koleszar committed
210
      }
211
      if (next < default_eob) {
212
        band = band_translate[i + 1];
213
        if (t0 != EOB_TOKEN) {
214
          pt = trellis_get_coeff_context(scan, nb, i, t0, token_cache);
215
          rate0 += mb->token_costs[tx_size][type][ref][band][!x][pt]
216
                                  [tokens[next][0].token];
John Koleszar's avatar
John Koleszar committed
217
        }
218
        if (t1 != EOB_TOKEN) {
219
          pt = trellis_get_coeff_context(scan, nb, i, t1, token_cache);
220
          rate1 += mb->token_costs[tx_size][type][ref][band][!x][pt]
221
                                  [tokens[next][1].token];
John Koleszar's avatar
John Koleszar committed
222 223
        }
      }
John Koleszar's avatar
John Koleszar committed
224

225
      UPDATE_RD_COST();
John Koleszar's avatar
John Koleszar committed
226 227
      /* And pick the best. */
      best = rd_cost1 < rd_cost0;
228
      base_bits = vp9_get_cost(t0, e0, cat6_high_cost);
John Koleszar's avatar
John Koleszar committed
229 230

      if (shortcut) {
231 232 233 234 235 236 237 238 239
#if CONFIG_VP9_HIGHBITDEPTH
        if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
          dx -= ((dequant_ptr[rc != 0] >> (xd->bd - 8)) + sz) ^ sz;
        } else {
          dx -= (dequant_ptr[rc != 0] + sz) ^ sz;
        }
#else
        dx -= (dequant_ptr[rc != 0] + sz) ^ sz;
#endif  // CONFIG_VP9_HIGHBITDEPTH
John Koleszar's avatar
John Koleszar committed
240 241 242 243 244 245 246
        d2 = dx * dx;
      }
      tokens[i][1].rate = base_bits + (best ? rate1 : rate0);
      tokens[i][1].error = d2 + (best ? error1 : error0);
      tokens[i][1].next = next;
      tokens[i][1].token = best ? t1 : t0;
      tokens[i][1].qc = x;
247
      best_index[i][1] = best;
John Koleszar's avatar
John Koleszar committed
248 249
      /* Finally, make this the new head of the trellis. */
      next = i;
250 251 252 253
    } else {
      /* There's no choice to make for a zero coefficient, so we don't
       *  add a new trellis node, but we do need to update the costs.
       */
254
      band = band_translate[i + 1];
John Koleszar's avatar
John Koleszar committed
255 256 257
      t0 = tokens[next][0].token;
      t1 = tokens[next][1].token;
      /* Update the cost of each path if we're past the EOB token. */
258
      if (t0 != EOB_TOKEN) {
259
        tokens[next][0].rate +=
260
            mb->token_costs[tx_size][type][ref][band][1][0][t0];
John Koleszar's avatar
John Koleszar committed
261 262
        tokens[next][0].token = ZERO_TOKEN;
      }
263
      if (t1 != EOB_TOKEN) {
264
        tokens[next][1].rate +=
265
            mb->token_costs[tx_size][type][ref][band][1][0][t1];
John Koleszar's avatar
John Koleszar committed
266 267
        tokens[next][1].token = ZERO_TOKEN;
      }
268
      best_index[i][0] = best_index[i][1] = 0;
John Koleszar's avatar
John Koleszar committed
269
      /* Don't update next, because we didn't add a new node. */
270
    }
John Koleszar's avatar
John Koleszar committed
271 272 273
  }

  /* Now pick the best path through the whole trellis. */
274
  band = band_translate[i + 1];
John Koleszar's avatar
John Koleszar committed
275 276 277 278 279 280
  rate0 = tokens[next][0].rate;
  rate1 = tokens[next][1].rate;
  error0 = tokens[next][0].error;
  error1 = tokens[next][1].error;
  t0 = tokens[next][0].token;
  t1 = tokens[next][1].token;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
281 282
  rate0 += mb->token_costs[tx_size][type][ref][band][0][ctx][t0];
  rate1 += mb->token_costs[tx_size][type][ref][band][0][ctx][t1];
283
  UPDATE_RD_COST();
John Koleszar's avatar
John Koleszar committed
284
  best = rd_cost1 < rd_cost0;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
285
  final_eob = -1;
James Zern's avatar
James Zern committed
286 287
  memset(qcoeff, 0, sizeof(*qcoeff) * (16 << (tx_size * 2)));
  memset(dqcoeff, 0, sizeof(*dqcoeff) * (16 << (tx_size * 2)));
John Koleszar's avatar
John Koleszar committed
288
  for (i = next; i < eob; i = next) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
289 290
    const int x = tokens[i][best].qc;
    const int rc = scan[i];
291
    if (x) {
John Koleszar's avatar
John Koleszar committed
292
      final_eob = i;
293
    }
Dmitry Kovalev's avatar
Dmitry Kovalev committed
294

295 296
    qcoeff[rc] = x;
    dqcoeff[rc] = (x * dequant_ptr[rc != 0]) / mul;
297

John Koleszar's avatar
John Koleszar committed
298
    next = tokens[i][best].next;
299
    best = best_index[i][best];
John Koleszar's avatar
John Koleszar committed
300 301 302
  }
  final_eob++;

303
  mb->plane[plane].eobs[block] = final_eob;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
304
  return final_eob;
305 306
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
307
static INLINE void fdct32x32(int rd_transform,
308 309
                             const int16_t *src, tran_low_t *dst,
                             int src_stride) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
310 311 312 313 314 315
  if (rd_transform)
    vp9_fdct32x32_rd(src, dst, src_stride);
  else
    vp9_fdct32x32(src, dst, src_stride);
}

316
#if CONFIG_VP9_HIGHBITDEPTH
317 318
static INLINE void highbd_fdct32x32(int rd_transform, const int16_t *src,
                                    tran_low_t *dst, int src_stride) {
319
  if (rd_transform)
320
    vp9_highbd_fdct32x32_rd(src, dst, src_stride);
321
  else
322
    vp9_highbd_fdct32x32(src, dst, src_stride);
323
}
324
#endif  // CONFIG_VP9_HIGHBITDEPTH
325

326 327 328 329 330
void vp9_xform_quant_fp(MACROBLOCK *x, int plane, int block,
                        BLOCK_SIZE plane_bsize, TX_SIZE tx_size) {
  MACROBLOCKD *const xd = &x->e_mbd;
  const struct macroblock_plane *const p = &x->plane[plane];
  const struct macroblockd_plane *const pd = &xd->plane[plane];
Jingning Han's avatar
Jingning Han committed
331
  const scan_order *const scan_order = &vp9_default_scan_orders[tx_size];
332 333 334
  tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
  tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
  tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
Jingning Han's avatar
Jingning Han committed
335 336 337 338 339 340 341
  uint16_t *const eob = &p->eobs[block];
  const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
  int i, j;
  const int16_t *src_diff;
  txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &i, &j);
  src_diff = &p->src_diff[4 * (j * diff_stride + i)];

342 343 344 345
#if CONFIG_VP9_HIGHBITDEPTH
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    switch (tx_size) {
      case TX_32X32:
346 347 348 349
        highbd_fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
        vp9_highbd_quantize_fp_32x32(coeff, 1024, x->skip_block, p->zbin,
                                     p->round_fp, p->quant_fp, p->quant_shift,
                                     qcoeff, dqcoeff, pd->dequant,
350
                                     eob, scan_order->scan,
351
                                     scan_order->iscan);
352 353
        break;
      case TX_16X16:
354 355 356
        vp9_highbd_fdct16x16(src_diff, coeff, diff_stride);
        vp9_highbd_quantize_fp(coeff, 256, x->skip_block, p->zbin, p->round_fp,
                               p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
357
                               pd->dequant, eob,
358
                               scan_order->scan, scan_order->iscan);
359 360
        break;
      case TX_8X8:
361 362 363
        vp9_highbd_fdct8x8(src_diff, coeff, diff_stride);
        vp9_highbd_quantize_fp(coeff, 64, x->skip_block, p->zbin, p->round_fp,
                               p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
364
                               pd->dequant, eob,
365
                               scan_order->scan, scan_order->iscan);
366 367 368
        break;
      case TX_4X4:
        x->fwd_txm4x4(src_diff, coeff, diff_stride);
369 370
        vp9_highbd_quantize_fp(coeff, 16, x->skip_block, p->zbin, p->round_fp,
                               p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
371
                               pd->dequant, eob,
372
                               scan_order->scan, scan_order->iscan);
373 374 375 376 377 378 379 380
        break;
      default:
        assert(0);
    }
    return;
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH

Jingning Han's avatar
Jingning Han committed
381 382 383
  switch (tx_size) {
    case TX_32X32:
      fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
384 385
      vp9_quantize_fp_32x32(coeff, 1024, x->skip_block, p->zbin, p->round_fp,
                            p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
386
                            pd->dequant, eob, scan_order->scan,
387
                            scan_order->iscan);
Jingning Han's avatar
Jingning Han committed
388 389 390 391 392
      break;
    case TX_16X16:
      vp9_fdct16x16(src_diff, coeff, diff_stride);
      vp9_quantize_fp(coeff, 256, x->skip_block, p->zbin, p->round_fp,
                      p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
393
                      pd->dequant, eob,
Jingning Han's avatar
Jingning Han committed
394 395 396
                      scan_order->scan, scan_order->iscan);
      break;
    case TX_8X8:
397 398 399
      vp9_fdct8x8_quant(src_diff, diff_stride, coeff, 64,
                        x->skip_block, p->zbin, p->round_fp,
                        p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
400
                        pd->dequant, eob,
401
                        scan_order->scan, scan_order->iscan);
Jingning Han's avatar
Jingning Han committed
402 403 404 405 406
      break;
    case TX_4X4:
      x->fwd_txm4x4(src_diff, coeff, diff_stride);
      vp9_quantize_fp(coeff, 16, x->skip_block, p->zbin, p->round_fp,
                      p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
407
                      pd->dequant, eob,
Jingning Han's avatar
Jingning Han committed
408 409 410 411
                      scan_order->scan, scan_order->iscan);
      break;
    default:
      assert(0);
412
      break;
Jingning Han's avatar
Jingning Han committed
413 414 415 416 417 418 419 420
  }
}

void vp9_xform_quant_dc(MACROBLOCK *x, int plane, int block,
                        BLOCK_SIZE plane_bsize, TX_SIZE tx_size) {
  MACROBLOCKD *const xd = &x->e_mbd;
  const struct macroblock_plane *const p = &x->plane[plane];
  const struct macroblockd_plane *const pd = &xd->plane[plane];
421 422 423
  tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
  tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
  tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
424 425 426 427 428 429 430 431
  uint16_t *const eob = &p->eobs[block];
  const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
  int i, j;
  const int16_t *src_diff;

  txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &i, &j);
  src_diff = &p->src_diff[4 * (j * diff_stride + i)];

432 433 434 435
#if CONFIG_VP9_HIGHBITDEPTH
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    switch (tx_size) {
      case TX_32X32:
436 437 438 439
        vp9_highbd_fdct32x32_1(src_diff, coeff, diff_stride);
        vp9_highbd_quantize_dc_32x32(coeff, x->skip_block, p->round,
                                     p->quant_fp[0], qcoeff, dqcoeff,
                                     pd->dequant[0], eob);
440 441
        break;
      case TX_16X16:
442
        vp9_highbd_fdct16x16_1(src_diff, coeff, diff_stride);
443
        vp9_highbd_quantize_dc(coeff, 256, x->skip_block, p->round,
444 445
                               p->quant_fp[0], qcoeff, dqcoeff,
                               pd->dequant[0], eob);
446 447
        break;
      case TX_8X8:
448
        vp9_highbd_fdct8x8_1(src_diff, coeff, diff_stride);
449
        vp9_highbd_quantize_dc(coeff, 64, x->skip_block, p->round,
450 451
                               p->quant_fp[0], qcoeff, dqcoeff,
                               pd->dequant[0], eob);
452 453 454
        break;
      case TX_4X4:
        x->fwd_txm4x4(src_diff, coeff, diff_stride);
455
        vp9_highbd_quantize_dc(coeff, 16, x->skip_block, p->round,
456 457
                               p->quant_fp[0], qcoeff, dqcoeff,
                               pd->dequant[0], eob);
458 459 460 461 462 463 464 465
        break;
      default:
        assert(0);
    }
    return;
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH

466 467 468 469 470 471 472 473 474
  switch (tx_size) {
    case TX_32X32:
      vp9_fdct32x32_1(src_diff, coeff, diff_stride);
      vp9_quantize_dc_32x32(coeff, x->skip_block, p->round,
                            p->quant_fp[0], qcoeff, dqcoeff,
                            pd->dequant[0], eob);
      break;
    case TX_16X16:
      vp9_fdct16x16_1(src_diff, coeff, diff_stride);
475
      vp9_quantize_dc(coeff, 256, x->skip_block, p->round,
476 477 478 479 480
                     p->quant_fp[0], qcoeff, dqcoeff,
                     pd->dequant[0], eob);
      break;
    case TX_8X8:
      vp9_fdct8x8_1(src_diff, coeff, diff_stride);
481
      vp9_quantize_dc(coeff, 64, x->skip_block, p->round,
482 483 484 485 486
                      p->quant_fp[0], qcoeff, dqcoeff,
                      pd->dequant[0], eob);
      break;
    case TX_4X4:
      x->fwd_txm4x4(src_diff, coeff, diff_stride);
487
      vp9_quantize_dc(coeff, 16, x->skip_block, p->round,
488 489 490 491 492
                      p->quant_fp[0], qcoeff, dqcoeff,
                      pd->dequant[0], eob);
      break;
    default:
      assert(0);
493
      break;
494 495 496
  }
}

497 498 499
void vp9_xform_quant(MACROBLOCK *x, int plane, int block,
                     BLOCK_SIZE plane_bsize, TX_SIZE tx_size) {
  MACROBLOCKD *const xd = &x->e_mbd;
500 501 502
  const struct macroblock_plane *const p = &x->plane[plane];
  const struct macroblockd_plane *const pd = &xd->plane[plane];
  const scan_order *const scan_order = &vp9_default_scan_orders[tx_size];
503 504 505
  tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
  tran_low_t *const qcoeff = BLOCK_OFFSET(p->qcoeff, block);
  tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
506
  uint16_t *const eob = &p->eobs[block];
507 508
  const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
  int i, j;
509
  const int16_t *src_diff;
510 511
  txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &i, &j);
  src_diff = &p->src_diff[4 * (j * diff_stride + i)];
512

513 514 515 516
#if CONFIG_VP9_HIGHBITDEPTH
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
     switch (tx_size) {
      case TX_32X32:
517 518 519
        highbd_fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
        vp9_highbd_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin,
                                    p->round, p->quant, p->quant_shift, qcoeff,
520
                                    dqcoeff, pd->dequant, eob,
521
                                    scan_order->scan, scan_order->iscan);
522 523
        break;
      case TX_16X16:
524 525 526
        vp9_highbd_fdct16x16(src_diff, coeff, diff_stride);
        vp9_highbd_quantize_b(coeff, 256, x->skip_block, p->zbin, p->round,
                              p->quant, p->quant_shift, qcoeff, dqcoeff,
527
                              pd->dequant, eob,
528
                              scan_order->scan, scan_order->iscan);
529 530
        break;
      case TX_8X8:
531 532 533
        vp9_highbd_fdct8x8(src_diff, coeff, diff_stride);
        vp9_highbd_quantize_b(coeff, 64, x->skip_block, p->zbin, p->round,
                              p->quant, p->quant_shift, qcoeff, dqcoeff,
534
                              pd->dequant, eob,
535
                              scan_order->scan, scan_order->iscan);
536 537 538
        break;
      case TX_4X4:
        x->fwd_txm4x4(src_diff, coeff, diff_stride);
539 540
        vp9_highbd_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round,
                              p->quant, p->quant_shift, qcoeff, dqcoeff,
541
                              pd->dequant, eob,
542
                              scan_order->scan, scan_order->iscan);
543 544 545 546 547 548 549 550
        break;
      default:
        assert(0);
    }
    return;
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH

551
  switch (tx_size) {
552
    case TX_32X32:
Dmitry Kovalev's avatar
Dmitry Kovalev committed
553
      fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
554 555
      vp9_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin, p->round,
                           p->quant, p->quant_shift, qcoeff, dqcoeff,
556
                           pd->dequant, eob, scan_order->scan,
557
                           scan_order->iscan);
558 559
      break;
    case TX_16X16:
560
      vp9_fdct16x16(src_diff, coeff, diff_stride);
561 562
      vp9_quantize_b(coeff, 256, x->skip_block, p->zbin, p->round,
                     p->quant, p->quant_shift, qcoeff, dqcoeff,
563
                     pd->dequant, eob,
564
                     scan_order->scan, scan_order->iscan);
565 566
      break;
    case TX_8X8:
567
      vp9_fdct8x8(src_diff, coeff, diff_stride);
568 569
      vp9_quantize_b(coeff, 64, x->skip_block, p->zbin, p->round,
                     p->quant, p->quant_shift, qcoeff, dqcoeff,
570
                     pd->dequant, eob,
571
                     scan_order->scan, scan_order->iscan);
572 573
      break;
    case TX_4X4:
574
      x->fwd_txm4x4(src_diff, coeff, diff_stride);
575 576
      vp9_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round,
                     p->quant, p->quant_shift, qcoeff, dqcoeff,
577
                     pd->dequant, eob,
578
                     scan_order->scan, scan_order->iscan);
579 580 581
      break;
    default:
      assert(0);
582
      break;
John Koleszar's avatar
John Koleszar committed
583
  }
584 585
}

586
static void encode_block(int plane, int block, BLOCK_SIZE plane_bsize,
587
                         TX_SIZE tx_size, void *arg) {
588 589 590
  struct encode_b_args *const args = arg;
  MACROBLOCK *const x = args->x;
  MACROBLOCKD *const xd = &x->e_mbd;
591
  struct optimize_ctx *const ctx = args->ctx;
592
  struct macroblock_plane *const p = &x->plane[plane];
593
  struct macroblockd_plane *const pd = &xd->plane[plane];
594
  tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
595 596
  int i, j;
  uint8_t *dst;
597
  ENTROPY_CONTEXT *a, *l;
598 599
  txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &i, &j);
  dst = &pd->dst.buf[4 * j * pd->dst.stride + 4 * i];
600 601
  a = &ctx->ta[plane][i];
  l = &ctx->tl[plane][j];
602 603 604 605

  // TODO(jingning): per transformed block zero forcing only enabled for
  // luma component. will integrate chroma components as well.
  if (x->zcoeff_blk[tx_size][block] && plane == 0) {
606
    p->eobs[block] = 0;
607
    *a = *l = 0;
608 609 610
    return;
  }

611
  if (!x->skip_recode) {
612 613 614
    if (x->quant_fp) {
      // Encoding process for rtc mode
      if (x->skip_txfm[0] == 1 && plane == 0) {
615 616 617 618
        // skip forward transform
        p->eobs[block] = 0;
        *a = *l = 0;
        return;
619 620
      } else {
        vp9_xform_quant_fp(x, plane, block, plane_bsize, tx_size);
621
      }
622
    } else {
623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
      if (max_txsize_lookup[plane_bsize] == tx_size) {
        int txfm_blk_index = (plane << 2) + (block >> (tx_size << 1));
        if (x->skip_txfm[txfm_blk_index] == 0) {
          // full forward transform and quantization
          vp9_xform_quant(x, plane, block, plane_bsize, tx_size);
        } else if (x->skip_txfm[txfm_blk_index]== 2) {
          // fast path forward transform and quantization
          vp9_xform_quant_dc(x, plane, block, plane_bsize, tx_size);
        } else {
          // skip forward transform
          p->eobs[block] = 0;
          *a = *l = 0;
          return;
        }
      } else {
638
        vp9_xform_quant(x, plane, block, plane_bsize, tx_size);
639
      }
Jingning Han's avatar
Jingning Han committed
640
    }
641
  }
642

643
  if (x->optimize && (!x->skip_recode || !x->skip_optimize)) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
644
    const int ctx = combine_entropy_contexts(*a, *l);
Yaowu Xu's avatar
Yaowu Xu committed
645
    *a = *l = optimize_b(x, plane, block, tx_size, ctx) > 0;
646
  } else {
647
    *a = *l = p->eobs[block] > 0;
648
  }
John Koleszar's avatar
John Koleszar committed
649

Jim Bankoski's avatar
Jim Bankoski committed
650
  if (p->eobs[block])
651
    *(args->skip) = 0;
Jim Bankoski's avatar
Jim Bankoski committed
652

653
  if (x->skip_encode || p->eobs[block] == 0)
654
    return;
655 656 657 658
#if CONFIG_VP9_HIGHBITDEPTH
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    switch (tx_size) {
      case TX_32X32:
659 660
        vp9_highbd_idct32x32_add(dqcoeff, dst, pd->dst.stride,
                                 p->eobs[block], xd->bd);
661 662
        break;
      case TX_16X16:
663 664
        vp9_highbd_idct16x16_add(dqcoeff, dst, pd->dst.stride,
                                 p->eobs[block], xd->bd);
665 666
        break;
      case TX_8X8:
667 668
        vp9_highbd_idct8x8_add(dqcoeff, dst, pd->dst.stride,
                               p->eobs[block], xd->bd);
669 670 671 672 673
        break;
      case TX_4X4:
        // this is like vp9_short_idct4x4 but has a special case around eob<=1
        // which is significant (not just an optimization) for the lossless
        // case.
674 675
        x->highbd_itxm_add(dqcoeff, dst, pd->dst.stride,
                           p->eobs[block], xd->bd);
676 677 678 679 680 681 682
        break;
      default:
        assert(0 && "Invalid transform size");
    }
    return;
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH
683

684
  switch (tx_size) {
685
    case TX_32X32:
686
      vp9_idct32x32_add(dqcoeff, dst, pd->dst.stride, p->eobs[block]);
687 688
      break;
    case TX_16X16:
689
      vp9_idct16x16_add(dqcoeff, dst, pd->dst.stride, p->eobs[block]);
690 691
      break;
    case TX_8X8:
692
      vp9_idct8x8_add(dqcoeff, dst, pd->dst.stride, p->eobs[block]);
693 694
      break;
    case TX_4X4:
695 696 697
      // this is like vp9_short_idct4x4 but has a special case around eob<=1
      // which is significant (not just an optimization) for the lossless
      // case.
698
      x->itxm_add(dqcoeff, dst, pd->dst.stride, p->eobs[block]);
699
      break;
700
    default:
James Zern's avatar
James Zern committed
701
      assert(0 && "Invalid transform size");
702
      break;
703
  }
John Koleszar's avatar
John Koleszar committed
704
}
705

706 707
static void encode_block_pass1(int plane, int block, BLOCK_SIZE plane_bsize,
                               TX_SIZE tx_size, void *arg) {
708
  MACROBLOCK *const x = (MACROBLOCK *)arg;
709
  MACROBLOCKD *const xd = &x->e_mbd;
710
  struct macroblock_plane *const p = &x->plane[plane];
711
  struct macroblockd_plane *const pd = &xd->plane[plane];
712
  tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
713 714 715 716
  int i, j;
  uint8_t *dst;
  txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &i, &j);
  dst = &pd->dst.buf[4 * j * pd->dst.stride + 4 * i];
717

718
  vp9_xform_quant(x, plane, block, plane_bsize, tx_size);
719

720 721 722
  if (p->eobs[block] > 0) {
#if CONFIG_VP9_HIGHBITDEPTH
    if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
723
       x->highbd_itxm_add(dqcoeff, dst, pd->dst.stride, p->eobs[block], xd->bd);
724 725 726
       return;
    }
#endif  // CONFIG_VP9_HIGHBITDEPTH
727
    x->itxm_add(dqcoeff, dst, pd->dst.stride, p->eobs[block]);
728
  }
729 730
}

731
void vp9_encode_sby_pass1(MACROBLOCK *x, BLOCK_SIZE bsize) {
732
  vp9_subtract_plane(x, bsize, 0);
733 734
  vp9_foreach_transformed_block_in_plane(&x->e_mbd, bsize, 0,
                                         encode_block_pass1, x);
735 736
}

737
void vp9_encode_sb(MACROBLOCK *x, BLOCK_SIZE bsize) {
738
  MACROBLOCKD *const xd = &x->e_mbd;
739
  struct optimize_ctx ctx;
740
  MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
741
  struct encode_b_args arg = {x, &ctx, &mbmi->skip};
742
  int plane;
John Koleszar's avatar
John Koleszar committed
743

744 745 746 747 748
  mbmi->skip = 1;

  if (x->skip)
    return;

749 750 751
  for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
    if (!x->skip_recode)
      vp9_subtract_plane(x, bsize, plane);
752

753 754
    if (x->optimize && (!x->skip_recode || !x->skip_optimize)) {
      const struct macroblockd_plane* const pd = &xd->plane[plane];
755
      const TX_SIZE tx_size = plane ? get_uv_tx_size(mbmi, pd) : mbmi->tx_size;
756 757 758
      vp9_get_entropy_contexts(bsize, tx_size, pd,
                               ctx.ta[plane], ctx.tl[plane]);
    }
Scott LaVarnway's avatar
Scott LaVarnway committed
759

760 761 762
    vp9_foreach_transformed_block_in_plane(xd, bsize, plane, encode_block,
                                           &arg);
  }
John Koleszar's avatar
John Koleszar committed
763
}
764

765
void vp9_encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
766
                               TX_SIZE tx_size, void *arg) {
767
  struct encode_b_args* const args = arg;
768 769
  MACROBLOCK *const x = args->x;
  MACROBLOCKD *const xd = &x->e_mbd;
770
  MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
771 772
  struct macroblock_plane *const p = &x->plane[plane];
  struct macroblockd_plane *const pd = &xd->plane[plane];
773 774 775
  tran_low_t *coeff = BLOCK_OFFSET(p->coeff, block);
  tran_low_t *qcoeff = BLOCK_OFFSET(p->qcoeff, block);
  tran_low_t *dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
776
  const scan_order *scan_order;
777
  TX_TYPE tx_type;
778
  PREDICTION_MODE mode;
779
  const int bwl = b_width_log2_lookup[plane_bsize];
780
  const int diff_stride = 4 * (1 << bwl);
781 782
  uint8_t *src, *dst;
  int16_t *src_diff;
783
  uint16_t *eob = &p->eobs[block];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
784 785
  const int src_stride = p->src.stride;
  const int dst_stride = pd->dst.stride;
786 787
  int i, j;
  txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &i, &j);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
788 789
  dst = &pd->dst.buf[4 * (j * dst_stride + i)];
  src = &p->src.buf[4 * (j * src_stride + i)];
790
  src_diff = &p->src_diff[4 * (j * diff_stride + i)];
791

792 793 794 795 796 797 798 799 800 801 802
#if CONFIG_VP9_HIGHBITDEPTH
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    switch (tx_size) {
      case TX_32X32:
        scan_order = &vp9_default_scan_orders[TX_32X32];
        mode = plane == 0 ? mbmi->mode : mbmi->uv_mode;
        vp9_predict_intra_block(xd, block >> 6, bwl, TX_32X32, mode,
                                x->skip_encode ? src : dst,
                                x->skip_encode ? src_stride : dst_stride,
                                dst, dst_stride, i, j, plane);
        if (!x->skip_recode) {
803
          vpx_highbd_subtract_block(32, 32, src_diff, diff_stride,
804 805 806 807
                                    src, src_stride, dst, dst_stride, xd->bd);
          highbd_fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
          vp9_highbd_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin,
                                      p->round, p->quant, p->quant_shift,
808
                                      qcoeff, dqcoeff, pd->dequant, eob,
809
                                      scan_order->scan, scan_order->iscan);
810 811
        }
        if (!x->skip_encode && *eob) {
812
          vp9_highbd_idct32x32_add(dqcoeff, dst, dst_stride, *eob, xd->bd);
813 814 815 816 817 818 819 820 821 822 823
        }
        break;
      case TX_16X16:
        tx_type = get_tx_type(pd->plane_type, xd);
        scan_order = &vp9_scan_orders[TX_16X16][tx_type];
        mode = plane == 0 ? mbmi->mode : mbmi->uv_mode;
        vp9_predict_intra_block(xd, block >> 4, bwl, TX_16X16, mode,
                                x->skip_encode ? src : dst,
                                x->skip_encode ? src_stride : dst_stride,
                                dst, dst_stride, i, j, plane);
        if (!x->skip_recode) {
824
          vpx_highbd_subtract_block(16, 16, src_diff, diff_stride,
825 826 827 828
                                    src, src_stride, dst, dst_stride, xd->bd);
          vp9_highbd_fht16x16(src_diff, coeff, diff_stride, tx_type);
          vp9_highbd_quantize_b(coeff, 256, x->skip_block, p->zbin, p->round,
                                p->quant, p->quant_shift, qcoeff, dqcoeff,
829
                                pd->dequant, eob,
830
                                scan_order->scan, scan_order->iscan);
831 832
        }
        if (!x->skip_encode && *eob) {
833 834
          vp9_highbd_iht16x16_add(tx_type, dqcoeff, dst, dst_stride,
                                  *eob, xd->bd);
835 836 837 838 839 840 841 842 843 844 845
        }
        break;
      case TX_8X8:
        tx_type = get_tx_type(pd->plane_type, xd);
        scan_order = &vp9_scan_orders[TX_8X8][tx_type];
        mode = plane == 0 ? mbmi->mode : mbmi->uv_mode;
        vp9_predict_intra_block(xd, block >> 2, bwl, TX_8X8, mode,
                                x->skip_encode ? src : dst,
                                x->skip_encode ? src_stride : dst_stride,
                                dst, dst_stride, i, j, plane);
        if (!x->skip_recode) {
846
          vpx_highbd_subtract_block(8, 8, src_diff, diff_stride,
847 848 849 850
                                    src, src_stride, dst, dst_stride, xd->bd);
          vp9_highbd_fht8x8(src_diff, coeff, diff_stride, tx_type);
          vp9_highbd_quantize_b(coeff, 64, x->skip_block, p->zbin, p->round,
                                p->quant, p->quant_shift, qcoeff, dqcoeff,
851
                                pd->dequant, eob,
852
                                scan_order->scan, scan_order->iscan);
853 854
        }
        if (!x->skip_encode && *eob) {
855 856
          vp9_highbd_iht8x8_add(tx_type, dqcoeff, dst, dst_stride, *eob,
                                xd->bd);
857 858 859 860 861
        }
        break;
      case TX_4X4:
        tx_type = get_tx_type_4x4(pd->plane_type, xd, block);
        scan_order = &vp9_scan_orders[TX_4X4][tx_type];
862
        mode = plane == 0 ? get_y_mode(xd->mi[0], block) : mbmi->uv_mode;
863 864 865 866 867 868
        vp9_predict_intra_block(xd, block, bwl, TX_4X4, mode,
                                x->skip_encode ? src : dst,
                                x->skip_encode ? src_stride : dst_stride,
                                dst, dst_stride, i, j, plane);

        if (!x->skip_recode) {
869
          vpx_highbd_subtract_block(4, 4, src_diff, diff_stride,
870
                                    src, src_stride, dst, dst_stride, xd->bd);
871
          if (tx_type != DCT_DCT)
872
            vp9_highbd_fht4x4(src_diff, coeff, diff_stride, tx_type);
873 874
          else
            x->fwd_txm4x4(src_diff, coeff, diff_stride);
875 876
          vp9_highbd_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round,
                                p->quant, p->quant_shift, qcoeff, dqcoeff,
877
                                pd->dequant, eob,
878
                                scan_order->scan, scan_order->iscan);
879 880 881
        }

        if (!x->skip_encode && *eob) {
882
          if (tx_type == DCT_DCT) {
883 884 885
            // this is like vp9_short_idct4x4 but has a special case around
            // eob<=1 which is significant (not just an optimization) for the
            // lossless case.
886 887 888 889
            x->highbd_itxm_add(dqcoeff, dst, dst_stride, *eob, xd->bd);
          } else {
            vp9_highbd_iht4x4_16_add(dqcoeff, dst, dst_stride, tx_type, xd->bd);
          }
890 891 892 893 894 895 896 897 898 899 900 901
        }
        break;
      default:
        assert(0);
        return;
    }
    if (*eob)
      *(args->skip) = 0;
    return;
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH