encodemb.c 48.4 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */


#include "./vp10_rtcd.h"
#include "./vpx_config.h"
#include "./vpx_dsp_rtcd.h"

#include "vpx_dsp/quantize.h"
#include "vpx_mem/vpx_mem.h"
#include "vpx_ports/mem.h"

20
21
22
23
#include "vp10/common/idct.h"
#include "vp10/common/reconinter.h"
#include "vp10/common/reconintra.h"
#include "vp10/common/scan.h"
Jingning Han's avatar
Jingning Han committed
24

25
#include "vp10/encoder/encodemb.h"
Angie Chiang's avatar
Angie Chiang committed
26
#include "vp10/encoder/hybrid_fwd_txfm.h"
Angie Chiang's avatar
Angie Chiang committed
27
#include "vp10/encoder/quantize.h"
28
29
#include "vp10/encoder/rd.h"
#include "vp10/encoder/tokenize.h"
Jingning Han's avatar
Jingning Han committed
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

void vp10_subtract_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane) {
  struct macroblock_plane *const p = &x->plane[plane];
  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];

#if CONFIG_VP9_HIGHBITDEPTH
  if (x->e_mbd.cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    vpx_highbd_subtract_block(bh, bw, p->src_diff, bw, p->src.buf,
                              p->src.stride, pd->dst.buf, pd->dst.stride,
                              x->e_mbd.bd);
    return;
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH
  vpx_subtract_block(bh, bw, p->src_diff, bw, p->src.buf, p->src.stride,
                     pd->dst.buf, pd->dst.stride);
}

typedef struct vp10_token_state {
  int           rate;
52
  int64_t       error;
Jingning Han's avatar
Jingning Han committed
53
54
  int           next;
  int16_t       token;
55
  tran_low_t    qc;
56
  tran_low_t    dqc;
Jingning Han's avatar
Jingning Han committed
57
58
} vp10_token_state;

59
60
61
62
// These numbers are empirically obtained.
static const int plane_rd_mult[REF_TYPES][PLANE_TYPES] = {
    {10, 6}, {8, 5},
};
Jingning Han's avatar
Jingning Han committed
63
64
65
66
67
68
69

#define UPDATE_RD_COST()\
{\
  rd_cost0 = RDCOST(rdmult, rddiv, rate0, error0);\
  rd_cost1 = RDCOST(rdmult, rddiv, rate1, error1);\
}

70
71
72
73
74
75
76
77
78
79
80
81
82
83
static const int16_t band_count_table[TX_SIZES][8] = {
  { 1, 2, 3, 4,  3,   16 - 13, 0 },
  { 1, 2, 3, 4, 11,   64 - 21, 0 },
  { 1, 2, 3, 4, 11,  256 - 21, 0 },
  { 1, 2, 3, 4, 11, 1024 - 21, 0 },
};

static const int16_t band_cum_count_table[TX_SIZES][8] = {
  { 0, 1, 3, 6, 10, 13, 16, 0 },
  { 0, 1, 3, 6, 10, 21, 64, 0 },
  { 0, 1, 3, 6, 10, 21, 256, 0 },
  { 0, 1, 3, 6, 10, 21, 1024, 0 },
};

84
85
int vp10_optimize_b(MACROBLOCK *mb, int plane, int block,
                    TX_SIZE tx_size, int ctx) {
Jingning Han's avatar
Jingning Han committed
86
87
88
89
  MACROBLOCKD *const xd = &mb->e_mbd;
  struct macroblock_plane *const p = &mb->plane[plane];
  struct macroblockd_plane *const pd = &xd->plane[plane];
  const int ref = is_inter_block(&xd->mi[0]->mbmi);
90
91
  vp10_token_state tokens[MAX_TX_SQUARE + 1][2];
  unsigned best_index[MAX_TX_SQUARE + 1][2];
92
  uint8_t token_cache[MAX_TX_SQUARE];
Jingning Han's avatar
Jingning Han committed
93
94
95
96
97
98
  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);
  const int eob = p->eobs[block];
  const PLANE_TYPE type = pd->plane_type;
  const int default_eob = 16 << (tx_size << 1);
99
100
  const int16_t* const dequant_ptr = pd->dequant;
  const uint8_t* const band_translate = get_band_translate(tx_size);
hui su's avatar
hui su committed
101
  TX_TYPE tx_type = get_tx_type(type, xd, block, tx_size);
102
  const scan_order* const so =
103
      get_scan(tx_size, tx_type, is_inter_block(&xd->mi[0]->mbmi));
104
105
  const int16_t* const scan = so->scan;
  const int16_t* const nb = so->neighbors;
106
#if CONFIG_NEW_QUANT
107
108
  int dq = get_dq_profile_from_ctx(ctx);
  const dequant_val_type_nuq *dequant_val = pd->dequant_val_nuq[dq];
109
#endif  // CONFIG_NEW_QUANT
110
111
  const int shift = get_tx_scale(xd, tx_type, tx_size);
  const int dq_step[2] = { dequant_ptr[0] >> shift, dequant_ptr[1] >> shift };
Jingning Han's avatar
Jingning Han committed
112
  int next = eob, sz = 0;
hui su's avatar
hui su committed
113
114
  const int64_t rdmult = (mb->rdmult * plane_rd_mult[ref][type]) >> 1;
  const int64_t rddiv = mb->rddiv;
Jingning Han's avatar
Jingning Han committed
115
  int64_t rd_cost0, rd_cost1;
116
117
  int rate0, rate1;
  int64_t error0, error1;
Jingning Han's avatar
Jingning Han committed
118
  int16_t t0, t1;
119
120
121
  int best, band = (eob < default_eob) ?
      band_translate[eob] : band_translate[eob - 1];
  int pt, i, final_eob;
Jingning Han's avatar
Jingning Han committed
122
#if CONFIG_VP9_HIGHBITDEPTH
123
  const int *cat6_high_cost = vp10_get_high_cost_table(xd->bd);
Jingning Han's avatar
Jingning Han committed
124
#else
125
  const int *cat6_high_cost = vp10_get_high_cost_table(8);
Jingning Han's avatar
Jingning Han committed
126
#endif
127
128
  unsigned int (*token_costs)[2][COEFF_CONTEXTS][ENTROPY_TOKENS] =
                   mb->token_costs[tx_size][type][ref];
129
130
  const int16_t *band_counts = &band_count_table[tx_size][band];
  int16_t band_left = eob - band_cum_count_table[tx_size][band] + 1;
131
132
  int shortcut = 0;
  int next_shortcut = 0;
133
134

  token_costs += band;
Jingning Han's avatar
Jingning Han committed
135
136
137

  assert((!type && !plane) || (type && plane));
  assert(eob <= default_eob);
138

Jingning Han's avatar
Jingning Han committed
139
140
141
142
143
144
145
146
147
  /* Now set up a Viterbi trellis to evaluate alternative roundings. */
  /* Initialize the sentinel node of the trellis. */
  tokens[eob][0].rate = 0;
  tokens[eob][0].error = 0;
  tokens[eob][0].next = default_eob;
  tokens[eob][0].token = EOB_TOKEN;
  tokens[eob][0].qc = 0;
  tokens[eob][1] = tokens[eob][0];

148
149
  for (i = 0; i < eob; i++) {
    const int rc = scan[i];
150
151
152
    tokens[i][0].rate = vp10_get_token_cost(qcoeff[rc], &t0, cat6_high_cost);
    tokens[i][0].token = t0;
    token_cache[rc] = vp10_pt_energy_class[t0];
153
  }
Jingning Han's avatar
Jingning Han committed
154
155

  for (i = eob; i-- > 0;) {
156
157
    int base_bits, dx;
    int64_t d2;
Jingning Han's avatar
Jingning Han committed
158
159
    const int rc = scan[i];
    int x = qcoeff[rc];
160
    next_shortcut = shortcut;
161

Jingning Han's avatar
Jingning Han committed
162
    /* Only add a trellis state for non-zero coefficients. */
163
    if (UNLIKELY(x)) {
Jingning Han's avatar
Jingning Han committed
164
165
166
167
168
      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;
169

170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
      if (next_shortcut) {
        /* Consider both possible successor states. */
        if (next < default_eob) {
          pt = get_coef_context(nb, token_cache, i + 1);
          rate0 += (*token_costs)[0][pt][tokens[next][0].token];
          rate1 += (*token_costs)[0][pt][tokens[next][1].token];
        }
        UPDATE_RD_COST();
        /* And pick the best. */
        best = rd_cost1 < rd_cost0;
      } else {
        if (next < default_eob) {
          pt = get_coef_context(nb, token_cache, i + 1);
          rate0 += (*token_costs)[0][pt][tokens[next][0].token];
        }
        best = 0;
Jingning Han's avatar
Jingning Han committed
186
      }
187
188

      dx = (dqcoeff[rc] - coeff[rc]) * (1 << shift);
Jingning Han's avatar
Jingning Han committed
189
190
191
192
193
#if CONFIG_VP9_HIGHBITDEPTH
      if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
        dx >>= xd->bd - 8;
      }
#endif  // CONFIG_VP9_HIGHBITDEPTH
194
      d2 = (int64_t)dx * dx;
195
      tokens[i][0].rate += (best ? rate1 : rate0);
Jingning Han's avatar
Jingning Han committed
196
197
198
      tokens[i][0].error = d2 + (best ? error1 : error0);
      tokens[i][0].next = next;
      tokens[i][0].qc = x;
199
      tokens[i][0].dqc = dqcoeff[rc];
Jingning Han's avatar
Jingning Han committed
200
201
202
203
204
205
      best_index[i][0] = best;

      /* Evaluate the second possibility for this state. */
      rate0 = tokens[next][0].rate;
      rate1 = tokens[next][1].rate;

206
      // The threshold of 3 is empirically obtained.
207
      if (UNLIKELY(abs(x) > 3)) {
208
209
        shortcut = 0;
      } else {
210
#if CONFIG_NEW_QUANT
211
        shortcut = (
212
            (vp10_dequant_abscoeff_nuq(
213
214
                abs(x), dequant_ptr[rc != 0],
                dequant_val[band_translate[i]]) > (abs(coeff[rc]) << shift)) &&
215
            (vp10_dequant_abscoeff_nuq(
216
217
                abs(x) - 1, dequant_ptr[rc != 0],
                dequant_val[band_translate[i]]) < (abs(coeff[rc]) << shift)));
218
#else   // CONFIG_NEW_QUANT
219
220
221
222
223
224
        if ((abs(x) * dequant_ptr[rc != 0] > (abs(coeff[rc]) << shift)) &&
            (abs(x) * dequant_ptr[rc != 0] < (abs(coeff[rc]) << shift) +
              dequant_ptr[rc != 0]))
          shortcut = 1;
        else
          shortcut = 0;
225
#endif   // CONFIG_NEW_QUANT
226
      }
Jingning Han's avatar
Jingning Han committed
227
228
229
230

      if (shortcut) {
        sz = -(x < 0);
        x -= 2 * sz + 1;
231
232
233
234
      } else {
        tokens[i][1] = tokens[i][0];
        best_index[i][1] = best_index[i][0];
        next = i;
235

236
        if (UNLIKELY(!(--band_left))) {
237
238
239
240
          --band_counts;
          band_left = *band_counts;
          --token_costs;
        }
241
        continue;
Jingning Han's avatar
Jingning Han committed
242
243
244
245
246
247
248
249
250
      }

      /* 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.
         */
        t0 = tokens[next][0].token == EOB_TOKEN ? EOB_TOKEN : ZERO_TOKEN;
        t1 = tokens[next][1].token == EOB_TOKEN ? EOB_TOKEN : ZERO_TOKEN;
251
        base_bits = 0;
Jingning Han's avatar
Jingning Han committed
252
      } else {
253
        base_bits = vp10_get_token_cost(x, &t0, cat6_high_cost);
Jingning Han's avatar
Jingning Han committed
254
255
        t1 = t0;
      }
256
257

      if (next_shortcut) {
258
        if (LIKELY(next < default_eob)) {
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
          if (t0 != EOB_TOKEN) {
            token_cache[rc] = vp10_pt_energy_class[t0];
            pt = get_coef_context(nb, token_cache, i + 1);
            rate0 += (*token_costs)[!x][pt][tokens[next][0].token];
          }
          if (t1 != EOB_TOKEN) {
            token_cache[rc] = vp10_pt_energy_class[t1];
            pt = get_coef_context(nb, token_cache, i + 1);
            rate1 += (*token_costs)[!x][pt][tokens[next][1].token];
          }
        }

        UPDATE_RD_COST();
        /* And pick the best. */
        best = rd_cost1 < rd_cost0;
      } else {
        // The two states in next stage are identical.
        if (next < default_eob && t0 != EOB_TOKEN) {
Jingning Han's avatar
Jingning Han committed
277
278
          token_cache[rc] = vp10_pt_energy_class[t0];
          pt = get_coef_context(nb, token_cache, i + 1);
279
          rate0 += (*token_costs)[!x][pt][tokens[next][0].token];
Jingning Han's avatar
Jingning Han committed
280
        }
281
        best = 0;
Jingning Han's avatar
Jingning Han committed
282
283
      }

284
#if CONFIG_NEW_QUANT
285
      dx = vp10_dequant_coeff_nuq(
hui su's avatar
hui su committed
286
287
          x, dequant_ptr[rc != 0],
          dequant_val[band_translate[i]]) - (coeff[rc] << shift);
288
#if CONFIG_VP9_HIGHBITDEPTH
hui su's avatar
hui su committed
289
290
291
      if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
        dx >>= xd->bd - 8;
      }
292
293
#endif  // CONFIG_VP9_HIGHBITDEPTH
#else   // CONFIG_NEW_QUANT
Jingning Han's avatar
Jingning Han committed
294
#if CONFIG_VP9_HIGHBITDEPTH
hui su's avatar
hui su committed
295
296
297
      if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
        dx -= ((dequant_ptr[rc != 0] >> (xd->bd - 8)) + sz) ^ sz;
      } else {
Jingning Han's avatar
Jingning Han committed
298
        dx -= (dequant_ptr[rc != 0] + sz) ^ sz;
hui su's avatar
hui su committed
299
300
301
      }
#else
      dx -= (dequant_ptr[rc != 0] + sz) ^ sz;
Jingning Han's avatar
Jingning Han committed
302
#endif  // CONFIG_VP9_HIGHBITDEPTH
303
#endif  // CONFIG_NEW_QUANT
304
      d2 = (int64_t)dx * dx;
hui su's avatar
hui su committed
305

Jingning Han's avatar
Jingning Han committed
306
307
308
309
310
      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;
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328

      if (x) {
        tran_low_t offset = dq_step[rc != 0];
        // The 32x32 transform coefficient uses half quantization step size.
        // Account for the rounding difference in the dequantized coefficeint
        // value when the quantization index is dropped from an even number
        // to an odd number.
        if (shift & x)
          offset += (dequant_ptr[rc != 0] & 0x01);

        if (sz == 0)
          tokens[i][1].dqc = dqcoeff[rc] - offset;
        else
          tokens[i][1].dqc = dqcoeff[rc] + offset;
      } else {
        tokens[i][1].dqc = 0;
      }

Jingning Han's avatar
Jingning Han committed
329
330
331
332
333
334
335
336
337
      best_index[i][1] = best;
      /* Finally, make this the new head of the trellis. */
      next = i;
    } 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.
       */
      t0 = tokens[next][0].token;
      t1 = tokens[next][1].token;
338
      pt = get_coef_context(nb, token_cache, i + 1);
Jingning Han's avatar
Jingning Han committed
339
340
      /* Update the cost of each path if we're past the EOB token. */
      if (t0 != EOB_TOKEN) {
341
        tokens[next][0].rate += (*token_costs)[1][pt][t0];
Jingning Han's avatar
Jingning Han committed
342
343
344
        tokens[next][0].token = ZERO_TOKEN;
      }
      if (t1 != EOB_TOKEN) {
345
        tokens[next][1].rate += (*token_costs)[1][pt][t1];
Jingning Han's avatar
Jingning Han committed
346
347
348
        tokens[next][1].token = ZERO_TOKEN;
      }
      best_index[i][0] = best_index[i][1] = 0;
349
      shortcut = (tokens[next][0].rate != tokens[next][1].rate);
Jingning Han's avatar
Jingning Han committed
350
351
      /* Don't update next, because we didn't add a new node. */
    }
352

353
    if (UNLIKELY(!(--band_left))) {
354
355
356
357
      --band_counts;
      band_left = *band_counts;
      --token_costs;
    }
Jingning Han's avatar
Jingning Han committed
358
359
360
361
362
363
364
365
366
  }

  /* Now pick the best path through the whole trellis. */
  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;
367
368
  rate0 += (*token_costs)[0][ctx][t0];
  rate1 += (*token_costs)[0][ctx][t1];
Jingning Han's avatar
Jingning Han committed
369
370
  UPDATE_RD_COST();
  best = rd_cost1 < rd_cost0;
371

Jingning Han's avatar
Jingning Han committed
372
  final_eob = -1;
373

Jingning Han's avatar
Jingning Han committed
374
375
376
  for (i = next; i < eob; i = next) {
    const int x = tokens[i][best].qc;
    const int rc = scan[i];
377
378

    if (x) final_eob = i;
Jingning Han's avatar
Jingning Han committed
379
    qcoeff[rc] = x;
380
381
    dqcoeff[rc] = tokens[i][best].dqc;

382
#if CONFIG_NEW_QUANT
383
384
    dqcoeff[rc] = vp10_dequant_abscoeff_nuq(abs(x), dequant_ptr[rc != 0],
                                            dequant_val[band_translate[i]]);
385
386
387
    if (shift) dqcoeff[rc] = ROUND_POWER_OF_TWO(dqcoeff[rc], shift);
    if (x < 0) dqcoeff[rc] = -dqcoeff[rc];
#endif  // CONFIG_NEW_QUANT
Jingning Han's avatar
Jingning Han committed
388
389
390
391
392
393
394

    next = tokens[i][best].next;
    best = best_index[i][best];
  }
  final_eob++;

  mb->plane[plane].eobs[block] = final_eob;
395
  assert(final_eob <= default_eob);
Jingning Han's avatar
Jingning Han committed
396
397
398
  return final_eob;
}

399
#if CONFIG_VP9_HIGHBITDEPTH
Angie Chiang's avatar
Angie Chiang committed
400
401
typedef enum QUANT_FUNC {
  QUANT_FUNC_LOWBD = 0,
402
403
  QUANT_FUNC_HIGHBD = 1,
  QUANT_FUNC_LAST = 2
Angie Chiang's avatar
Angie Chiang committed
404
405
} QUANT_FUNC;

406
407
static VP10_QUANT_FACADE
    quant_func_list[VP10_XFORM_QUANT_LAST][QUANT_FUNC_LAST] = {
408
409
410
411
        {vp10_quantize_fp_facade, vp10_highbd_quantize_fp_facade},
        {vp10_quantize_b_facade, vp10_highbd_quantize_b_facade},
        {vp10_quantize_dc_facade, vp10_highbd_quantize_dc_facade},
        {NULL, NULL}};
412

Angie Chiang's avatar
Angie Chiang committed
413
414
415
#else
typedef enum QUANT_FUNC {
  QUANT_FUNC_LOWBD = 0,
416
  QUANT_FUNC_LAST = 1
Angie Chiang's avatar
Angie Chiang committed
417
} QUANT_FUNC;
Angie Chiang's avatar
Angie Chiang committed
418

419
420
static VP10_QUANT_FACADE
    quant_func_list[VP10_XFORM_QUANT_LAST][QUANT_FUNC_LAST] = {
421
422
423
424
        {vp10_quantize_fp_facade},
        {vp10_quantize_b_facade},
        {vp10_quantize_dc_facade},
        {NULL}};
Angie Chiang's avatar
Angie Chiang committed
425
#endif
426

427
428
429
static FWD_TXFM_OPT fwd_txfm_opt_list[VP10_XFORM_QUANT_LAST] = {
    FWD_TXFM_OPT_NORMAL, FWD_TXFM_OPT_NORMAL, FWD_TXFM_OPT_DC,
    FWD_TXFM_OPT_NORMAL};
430

Angie Chiang's avatar
Angie Chiang committed
431
432
433
void vp10_xform_quant(MACROBLOCK *x, int plane, int block, int blk_row,
                      int blk_col, BLOCK_SIZE plane_bsize, TX_SIZE tx_size,
                      VP10_XFORM_QUANT xform_quant_idx) {
Jingning Han's avatar
Jingning Han committed
434
435
436
  MACROBLOCKD *const xd = &x->e_mbd;
  const struct macroblock_plane *const p = &x->plane[plane];
  const struct macroblockd_plane *const pd = &xd->plane[plane];
hui su's avatar
hui su committed
437
  PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
hui su's avatar
hui su committed
438
  TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size);
439
440
  const scan_order *const scan_order =
      get_scan(tx_size, tx_type, is_inter_block(&xd->mi[0]->mbmi));
Jingning Han's avatar
Jingning Han committed
441
442
443
444
445
446
  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);
  uint16_t *const eob = &p->eobs[block];
  const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
  const int16_t *src_diff;
Angie Chiang's avatar
Angie Chiang committed
447
448
  const int tx1d_size = get_tx1d_size(tx_size);
  const int tx2d_size = tx1d_size * tx1d_size;
Angie Chiang's avatar
Angie Chiang committed
449
450

  FWD_TXFM_PARAM fwd_txfm_param;
451
452
453
  QUANT_PARAM qparam;

  fwd_txfm_param.tx_type = tx_type;
Angie Chiang's avatar
Angie Chiang committed
454
  fwd_txfm_param.tx_size = tx_size;
455
  fwd_txfm_param.fwd_txfm_opt = fwd_txfm_opt_list[xform_quant_idx];
Angie Chiang's avatar
Angie Chiang committed
456
457
458
  fwd_txfm_param.rd_transform = x->use_lp32x32fdct;
  fwd_txfm_param.lossless = xd->lossless[xd->mi[0]->mbmi.segment_id];

459
  src_diff = &p->src_diff[4 * (blk_row * diff_stride + blk_col)];
Jingning Han's avatar
Jingning Han committed
460

461
  qparam.log_scale = get_tx_scale(xd, tx_type, tx_size);
Jingning Han's avatar
Jingning Han committed
462
#if CONFIG_VP9_HIGHBITDEPTH
463
  fwd_txfm_param.bd = xd->bd;
Jingning Han's avatar
Jingning Han committed
464
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
Angie Chiang's avatar
Angie Chiang committed
465
    highbd_fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param);
466
467
468
469
    if (xform_quant_idx != VP10_XFORM_QUANT_SKIP_QUANT) {
      if (x->skip_block) {
        vp10_quantize_skip(tx2d_size, qcoeff, dqcoeff, eob);
      } else {
470
471
472
        quant_func_list[xform_quant_idx][QUANT_FUNC_HIGHBD](
            coeff, tx2d_size, p, qcoeff, pd, dqcoeff, eob,
            scan_order, &qparam);
473
474
475
476
477
478
479
480
      }
    }
    return;
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH

  fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param);
  if (xform_quant_idx != VP10_XFORM_QUANT_SKIP_QUANT) {
Angie Chiang's avatar
Angie Chiang committed
481
482
483
    if (x->skip_block) {
      vp10_quantize_skip(tx2d_size, qcoeff, dqcoeff, eob);
    } else {
484
485
486
      quant_func_list[xform_quant_idx][QUANT_FUNC_LOWBD](
          coeff, tx2d_size, p, qcoeff, pd, dqcoeff, eob,
          scan_order, &qparam);
Jingning Han's avatar
Jingning Han committed
487
488
489
490
    }
  }
}

491
492
493
#if CONFIG_NEW_QUANT
void vp10_xform_quant_nuq(MACROBLOCK *x, int plane, int block, int blk_row,
                          int blk_col, BLOCK_SIZE plane_bsize,
494
                          TX_SIZE tx_size, int ctx) {
495
496
497
498
499
500
501
502
503
504
  MACROBLOCKD *const xd = &x->e_mbd;
  const struct macroblock_plane *const p = &x->plane[plane];
  const struct macroblockd_plane *const pd = &xd->plane[plane];
  PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
  TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size);
  const scan_order *const scan_order =
      get_scan(tx_size, tx_type, is_inter_block(&xd->mi[0]->mbmi));
  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);
505
  int dq = get_dq_profile_from_ctx(ctx);
506
507
508
509
510
511
512
513
514
  uint16_t *const eob = &p->eobs[block];
  const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
  const int16_t *src_diff;
  const uint8_t* band = get_band_translate(tx_size);

  FWD_TXFM_PARAM fwd_txfm_param;

  fwd_txfm_param.tx_type = tx_type;
  fwd_txfm_param.tx_size = tx_size;
515
  fwd_txfm_param.fwd_txfm_opt = fwd_txfm_opt_list[VP10_XFORM_QUANT_FP];
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
  fwd_txfm_param.rd_transform = x->use_lp32x32fdct;
  fwd_txfm_param.lossless = xd->lossless[xd->mi[0]->mbmi.segment_id];

  src_diff = &p->src_diff[4 * (blk_row * diff_stride + blk_col)];

// TODO(sarahparker) add all of these new quant quantize functions
// to quant_func_list, just trying to get this expr to work for now
#if CONFIG_VP9_HIGHBITDEPTH
  fwd_txfm_param.bd = xd->bd;
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    highbd_fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param);
    switch (tx_size) {
      case TX_32X32:
        highbd_quantize_32x32_nuq(coeff, 1024, x->skip_block,
                                  p->quant, p->quant_shift, pd->dequant,
                                  (const cuml_bins_type_nuq *)
532
                                      p->cuml_bins_nuq[dq],
533
                                  (const dequant_val_type_nuq *)
534
                                      pd->dequant_val_nuq[dq],
535
536
537
538
539
540
                                  qcoeff, dqcoeff, eob,
                                  scan_order->scan, band);
        break;
      case TX_16X16:
        highbd_quantize_nuq(coeff, 256, x->skip_block,
                            p->quant, p->quant_shift, pd->dequant,
541
                            (const cuml_bins_type_nuq *)p->cuml_bins_nuq[dq],
542
                            (const dequant_val_type_nuq *)
543
                                pd->dequant_val_nuq[dq],
544
545
546
547
548
549
                            qcoeff, dqcoeff, eob,
                            scan_order->scan, band);
        break;
      case TX_8X8:
        highbd_quantize_nuq(coeff, 64, x->skip_block,
                            p->quant, p->quant_shift, pd->dequant,
550
                            (const cuml_bins_type_nuq *)p->cuml_bins_nuq[dq],
551
                            (const dequant_val_type_nuq *)
552
                                pd->dequant_val_nuq[dq],
553
554
555
556
557
558
                            qcoeff, dqcoeff, eob,
                            scan_order->scan, band);
        break;
      case TX_4X4:
        highbd_quantize_nuq(coeff, 16, x->skip_block,
                            p->quant, p->quant_shift, pd->dequant,
559
                            (const cuml_bins_type_nuq *)p->cuml_bins_nuq[dq],
560
                            (const dequant_val_type_nuq *)
561
                                pd->dequant_val_nuq[dq],
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
                            qcoeff, dqcoeff, eob,
                            scan_order->scan, band);
        break;
      default:
        assert(0);
    }
    return;
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH

  fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param);
  switch (tx_size) {
    case TX_32X32:
      quantize_32x32_nuq(coeff, 1024, x->skip_block,
                         p->quant, p->quant_shift, pd->dequant,
577
                         (const cuml_bins_type_nuq *)p->cuml_bins_nuq[dq],
578
                         (const dequant_val_type_nuq *)
579
                         pd->dequant_val_nuq[dq],
580
581
582
583
584
585
                         qcoeff, dqcoeff, eob,
                         scan_order->scan, band);
      break;
    case TX_16X16:
      quantize_nuq(coeff, 256, x->skip_block,
                   p->quant, p->quant_shift, pd->dequant,
586
587
                   (const cuml_bins_type_nuq *)p->cuml_bins_nuq[dq],
                   (const dequant_val_type_nuq *)pd->dequant_val_nuq[dq],
588
589
590
591
592
593
                   qcoeff, dqcoeff, eob,
                   scan_order->scan, band);
      break;
    case TX_8X8:
      quantize_nuq(coeff, 64, x->skip_block,
                   p->quant, p->quant_shift, pd->dequant,
594
595
                   (const cuml_bins_type_nuq *)p->cuml_bins_nuq[dq],
                   (const dequant_val_type_nuq *)pd->dequant_val_nuq[dq],
596
597
598
599
600
601
                   qcoeff, dqcoeff, eob,
                   scan_order->scan, band);
      break;
    case TX_4X4:
      quantize_nuq(coeff, 16, x->skip_block,
                   p->quant, p->quant_shift, pd->dequant,
602
603
                   (const cuml_bins_type_nuq *)p->cuml_bins_nuq[dq],
                   (const dequant_val_type_nuq *)pd->dequant_val_nuq[dq],
604
605
606
607
608
609
610
611
612
613
614
                   qcoeff, dqcoeff, eob,
                   scan_order->scan, band);
      break;
    default:
      assert(0);
      break;
  }
}

void vp10_xform_quant_fp_nuq(MACROBLOCK *x, int plane, int block, int blk_row,
                             int blk_col, BLOCK_SIZE plane_bsize,
615
                             TX_SIZE tx_size, int ctx) {
616
617
618
  MACROBLOCKD *const xd = &x->e_mbd;
  const struct macroblock_plane *const p = &x->plane[plane];
  const struct macroblockd_plane *const pd = &xd->plane[plane];
619
  int dq = get_dq_profile_from_ctx(ctx);
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
  PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
  TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size);
  const scan_order *const scan_order =
      get_scan(tx_size, tx_type, is_inter_block(&xd->mi[0]->mbmi));
  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);
  uint16_t *const eob = &p->eobs[block];
  const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
  const int16_t *src_diff;
  const uint8_t* band = get_band_translate(tx_size);

  FWD_TXFM_PARAM fwd_txfm_param;

  fwd_txfm_param.tx_type = tx_type;
  fwd_txfm_param.tx_size = tx_size;
  fwd_txfm_param.fwd_txfm_opt = fwd_txfm_opt_list[VP10_XFORM_QUANT_FP];
  fwd_txfm_param.rd_transform = x->use_lp32x32fdct;
  fwd_txfm_param.lossless = xd->lossless[xd->mi[0]->mbmi.segment_id];

  src_diff = &p->src_diff[4 * (blk_row * diff_stride + blk_col)];

// TODO(sarahparker) add all of these new quant quantize functions
// to quant_func_list, just trying to get this expr to work for now
#if CONFIG_VP9_HIGHBITDEPTH
  fwd_txfm_param.bd = xd->bd;
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    highbd_fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param);
    switch (tx_size) {
      case TX_32X32:
        highbd_quantize_32x32_fp_nuq(coeff, 1024, x->skip_block,
                                     p->quant_fp, pd->dequant,
                                     (const cuml_bins_type_nuq *)
653
                                         p->cuml_bins_nuq[dq],
654
                                     (const dequant_val_type_nuq *)
655
                                         pd->dequant_val_nuq[dq],
656
657
658
659
660
661
662
                                     qcoeff, dqcoeff, eob,
                                     scan_order->scan, band);
        break;
      case TX_16X16:
        highbd_quantize_fp_nuq(coeff, 256, x->skip_block,
                               p->quant_fp, pd->dequant,
                               (const cuml_bins_type_nuq *)
663
                                  p->cuml_bins_nuq[dq],
664
                               (const dequant_val_type_nuq *)
665
                                   pd->dequant_val_nuq[dq],
666
667
668
669
670
671
672
                               qcoeff, dqcoeff, eob,
                               scan_order->scan, band);
        break;
      case TX_8X8:
        highbd_quantize_fp_nuq(coeff, 64, x->skip_block,
                               p->quant_fp, pd->dequant,
                               (const cuml_bins_type_nuq *)
673
                                  p->cuml_bins_nuq[dq],
674
                               (const dequant_val_type_nuq *)
675
                                   pd->dequant_val_nuq[dq],
676
677
678
679
680
681
682
                               qcoeff, dqcoeff, eob,
                               scan_order->scan, band);
        break;
      case TX_4X4:
        highbd_quantize_fp_nuq(coeff, 16, x->skip_block,
                               p->quant_fp, pd->dequant,
                               (const cuml_bins_type_nuq *)
683
                                   p->cuml_bins_nuq[dq],
684
                               (const dequant_val_type_nuq *)
685
                                   pd->dequant_val_nuq[dq],
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
                               qcoeff, dqcoeff, eob,
                               scan_order->scan, band);
        break;
      default:
        assert(0);
    }
    return;
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH

  fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param);
  switch (tx_size) {
    case TX_32X32:
      quantize_32x32_fp_nuq(coeff, 1024, x->skip_block,
                            p->quant_fp, pd->dequant,
                            (const cuml_bins_type_nuq *)
702
                                p->cuml_bins_nuq[dq],
703
                            (const dequant_val_type_nuq *)
704
                                pd->dequant_val_nuq[dq],
705
706
707
708
709
710
711
                            qcoeff, dqcoeff, eob,
                            scan_order->scan, band);
      break;
    case TX_16X16:
      quantize_fp_nuq(coeff, 256, x->skip_block,
                      p->quant_fp, pd->dequant,
                      (const cuml_bins_type_nuq *)
712
                          p->cuml_bins_nuq[dq],
713
                      (const dequant_val_type_nuq *)
714
                          pd->dequant_val_nuq[dq],
715
716
717
718
719
720
721
                      qcoeff, dqcoeff, eob,
                      scan_order->scan, band);
      break;
    case TX_8X8:
      quantize_fp_nuq(coeff, 64, x->skip_block,
                      p->quant_fp, pd->dequant,
                      (const cuml_bins_type_nuq *)
722
                          p->cuml_bins_nuq[dq],
723
                      (const dequant_val_type_nuq *)
724
                          pd->dequant_val_nuq[dq],
725
726
727
728
729
730
731
                      qcoeff, dqcoeff, eob,
                      scan_order->scan, band);
      break;
    case TX_4X4:
      quantize_fp_nuq(coeff, 16, x->skip_block,
                      p->quant_fp, pd->dequant,
                      (const cuml_bins_type_nuq *)
732
                          p->cuml_bins_nuq[dq],
733
                      (const dequant_val_type_nuq *)
734
                          pd->dequant_val_nuq[dq],
735
736
737
738
739
740
741
742
743
744
745
                      qcoeff, dqcoeff, eob,
                      scan_order->scan, band);
      break;
    default:
      assert(0);
      break;
  }
}

void vp10_xform_quant_dc_nuq(MACROBLOCK *x, int plane, int block, int blk_row,
                             int blk_col, BLOCK_SIZE plane_bsize,
746
                             TX_SIZE tx_size, int ctx) {
747
748
749
750
751
752
753
754
755
756
757
  MACROBLOCKD *const xd = &x->e_mbd;
  const struct macroblock_plane *const p = &x->plane[plane];
  const struct macroblockd_plane *const pd = &xd->plane[plane];
  PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
  TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size);
  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);
  uint16_t *const eob = &p->eobs[block];
  const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
  const int16_t *src_diff;
758
  int dq = get_dq_profile_from_ctx(ctx);
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780

  FWD_TXFM_PARAM fwd_txfm_param;

  fwd_txfm_param.tx_type = tx_type;
  fwd_txfm_param.tx_size = tx_size;
  fwd_txfm_param.fwd_txfm_opt = fwd_txfm_opt_list[VP10_XFORM_QUANT_DC];
  fwd_txfm_param.rd_transform = x->use_lp32x32fdct;
  fwd_txfm_param.lossless = xd->lossless[xd->mi[0]->mbmi.segment_id];

  src_diff = &p->src_diff[4 * (blk_row * diff_stride + blk_col)];

// TODO(sarahparker) add all of these new quant quantize functions
// to quant_func_list, just trying to get this expr to work for now
#if CONFIG_VP9_HIGHBITDEPTH
  fwd_txfm_param.bd = xd->bd;
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    highbd_fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param);
    switch (tx_size) {
      case TX_32X32:
        highbd_quantize_dc_32x32_nuq(coeff, 1024, x->skip_block,
                                     p->quant[0], p->quant_shift[0],
                                     pd->dequant[0],
781
782
                                     p->cuml_bins_nuq[dq][0],
                                     pd->dequant_val_nuq[dq][0],
783
784
785
786
787
788
                                     qcoeff, dqcoeff, eob);
        break;
      case TX_16X16:
        highbd_quantize_dc_nuq(coeff, 256, x->skip_block,
                               p->quant[0], p->quant_shift[0],
                               pd->dequant[0],
789
790
                               p->cuml_bins_nuq[dq][0],
                               pd->dequant_val_nuq[dq][0],
791
792
793
794
795
796
                               qcoeff, dqcoeff, eob);
        break;
      case TX_8X8:
        highbd_quantize_dc_nuq(coeff, 64, x->skip_block,
                               p->quant[0], p->quant_shift[0],
                               pd->dequant[0],
797
798
                               p->cuml_bins_nuq[dq][0],
                               pd->dequant_val_nuq[dq][0],
799
800
801
802
803
804
                               qcoeff, dqcoeff, eob);
        break;
      case TX_4X4:
        highbd_quantize_dc_nuq(coeff, 16, x->skip_block,
                               p->quant[0], p->quant_shift[0],
                               pd->dequant[0],
805
806
                               p->cuml_bins_nuq[dq][0],
                               pd->dequant_val_nuq[dq][0],
807
808
809
810
811
812
813
814
815
816
817
818
819
820
                               qcoeff, dqcoeff, eob);
        break;
      default:
        assert(0);
    }
    return;
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH

  fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param);
  switch (tx_size) {
    case TX_32X32:
      quantize_dc_32x32_nuq(coeff, 1024, x->skip_block,
                            p->quant[0], p->quant_shift[0], pd->dequant[0],
821
822
                            p->cuml_bins_nuq[dq][0],
                            pd->dequant_val_nuq[dq][0],
823
824
825
826
827
                            qcoeff, dqcoeff, eob);
      break;
    case TX_16X16:
      quantize_dc_nuq(coeff, 256, x->skip_block,
                      p->quant[0], p->quant_shift[0], pd->dequant[0],
828
829
                      p->cuml_bins_nuq[dq][0],
                      pd->dequant_val_nuq[dq][0],
830
831
832
833
834
                      qcoeff, dqcoeff, eob);
      break;
    case TX_8X8:
      quantize_dc_nuq(coeff, 64, x->skip_block,
                      p->quant[0], p->quant_shift[0], pd->dequant[0],
835
836
                      p->cuml_bins_nuq[dq][0],
                      pd->dequant_val_nuq[dq][0],
837
838
839
840
841
                      qcoeff, dqcoeff, eob);
      break;
    case TX_4X4:
      quantize_dc_nuq(coeff, 16, x->skip_block,
                      p->quant[0], p->quant_shift[0], pd->dequant[0],
842
843
                      p->cuml_bins_nuq[dq][0],
                      pd->dequant_val_nuq[dq][0],
844
845
846
847
848
849
850
851
852
853
                      qcoeff, dqcoeff, eob);
      break;
    default:
      assert(0);
      break;
  }
}

void vp10_xform_quant_dc_fp_nuq(MACROBLOCK *x, int plane, int block,
                                int blk_row, int blk_col,
854
855
                                BLOCK_SIZE plane_bsize, TX_SIZE tx_size,
                                int ctx) {
856
857
858
859
860
861
862
863
864
865
866
  MACROBLOCKD *const xd = &x->e_mbd;
  const struct macroblock_plane *const p = &x->plane[plane];
  const struct macroblockd_plane *const pd = &xd->plane[plane];
  PLANE_TYPE plane_type = (plane == 0) ? PLANE_TYPE_Y : PLANE_TYPE_UV;
  TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size);
  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);
  uint16_t *const eob = &p->eobs[block];
  const int diff_stride = 4 * num_4x4_blocks_wide_lookup[plane_bsize];
  const int16_t *src_diff;
867
  int dq = get_dq_profile_from_ctx(ctx);
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888

  FWD_TXFM_PARAM fwd_txfm_param;

  fwd_txfm_param.tx_type = tx_type;
  fwd_txfm_param.tx_size = tx_size;
  fwd_txfm_param.fwd_txfm_opt = fwd_txfm_opt_list[VP10_XFORM_QUANT_DC];
  fwd_txfm_param.rd_transform = x->use_lp32x32fdct;
  fwd_txfm_param.lossless = xd->lossless[xd->mi[0]->mbmi.segment_id];

  src_diff = &p->src_diff[4 * (blk_row * diff_stride + blk_col)];

// TODO(sarahparker) add all of these new quant quantize functions
// to quant_func_list, just trying to get this expr to work for now
#if CONFIG_VP9_HIGHBITDEPTH
  fwd_txfm_param.bd = xd->bd;
  if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
    highbd_fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param);
    switch (tx_size) {
      case TX_32X32:
        highbd_quantize_dc_32x32_fp_nuq(coeff, 1024, x->skip_block,
                                        p->quant_fp[0], pd->dequant[0],
889
890
                                        p->cuml_bins_nuq[dq][0],
                                        pd->dequant_val_nuq[dq][0],
891
892
893
894
895
                                        qcoeff, dqcoeff, eob);
        break;
      case TX_16X16:
        highbd_quantize_dc_fp_nuq(coeff, 256, x->skip_block,
                                  p->quant_fp[0], pd->dequant[0],
896
897
                                  p->cuml_bins_nuq[dq][0],
                                  pd->dequant_val_nuq[dq][0],
898
899
900
901
902
                                  qcoeff, dqcoeff, eob);
        break;
      case TX_8X8:
        highbd_quantize_dc_fp_nuq(coeff, 64, x->skip_block,
                                  p->quant_fp[0], pd->dequant[0],
903
904
                                  p->cuml_bins_nuq[dq][0],
                                  pd->dequant_val_nuq[dq][0],
905
906
907
908
909
                                  qcoeff, dqcoeff, eob);
        break;
      case TX_4X4:
        highbd_quantize_dc_fp_nuq(coeff, 16, x->skip_block,
                                  p->quant_fp[0], pd->dequant[0],
910
911
                                  p->cuml_bins_nuq[dq][0],
                                  pd->dequant_val_nuq[dq][0],
912
913
914
915
916
917
918
919
920
921
922
923
924
925
                                  qcoeff, dqcoeff, eob);
        break;
      default:
        assert(0);
    }
    return;
  }
#endif  // CONFIG_VP9_HIGHBITDEPTH

  fwd_txfm(src_diff, coeff, diff_stride, &fwd_txfm_param);
  switch (tx_size) {
    case TX_32X32:
      quantize_dc_32x32_fp_nuq(coeff, 1024, x->skip_block,
                               p->quant_fp[0], pd->dequant[0],
926
927
                               p->cuml_bins_nuq[dq][0],
                               pd->dequant_val_nuq[dq][0],
928
929
930
931
932
                               qcoeff, dqcoeff, eob);
      break;
    case TX_16X16:
      quantize_dc_fp_nuq(coeff, 256, x->skip_block,
                         p->quant_fp[0], pd->dequant[0],
933
934
                         p->cuml_bins_nuq[dq][0],
                         pd->dequant_val_nuq[dq][0],
935
936
937
938
939
940
                         qcoeff, dqcoeff, eob);

      break;
    case TX_8X8:
      quantize_dc_fp_nuq(coeff, 64, x->skip_block,
                         p->quant_fp[0], pd->dequant[0],
941
942
                         p->cuml_bins_nuq[dq][0],
                         pd->dequant_val_nuq[dq][0],
943
944
945
946
947
                         qcoeff, dqcoeff, eob);
      break;
    case TX_4X4:
      quantize_dc_fp_nuq(coeff, 16, x->skip_block,
                         p->quant_fp[0], pd->dequant[0],
948
949
                         p->cuml_bins_nuq[dq][0],
                         pd->dequant_val_nuq[dq][0],
950
951
952
953
954
955
956
957
958
                         qcoeff, dqcoeff, eob);
      break;
    default:
      assert(0);
      break;
  }
}
#endif  // CONFIG_NEW_QUANT

959
960
static void encode_block(int plane, int block, int blk_row, int blk_col,
                         BLOCK_SIZE plane_bsize,
Jingning Han's avatar
Jingning Han committed
961
962
963
964
                         TX_SIZE tx_size, void *arg) {
  struct encode_b_args *const args = arg;
  MACROBLOCK *const x = args->x;
  MACROBLOCKD *const xd = &x->e_mbd;
965
  int ctx;
Jingning Han's avatar
Jingning Han committed
966
967
968
969
970
  struct macroblock_plane *const p = &x->plane[plane];
  struct macroblockd_plane *const pd = &xd->plane[plane];
  tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
  uint8_t *dst;
  ENTROPY_CONTEXT *a, *l;
Angie Chiang's avatar
Angie Chiang committed
971
  INV_TXFM_PARAM inv_txfm_param;
972
973
#if CONFIG_VAR_TX
  int i;
974
  const int bwl = b_width_log2_lookup[plane_bsize];
975
#endif
976
  dst = &pd->dst.buf[4 * blk_row * pd->dst.stride + 4 * blk_col];
977
978
  a = &args->ta[blk_col];
  l = &args->tl[blk_row];
979
980
981
982
983
#if CONFIG_VAR_TX
  ctx = get_entropy_context(tx_size, a, l);
#else
  ctx = combine_entropy_contexts(*a, *l);
#endif
Jingning Han's avatar
Jingning Han committed
984

Alex Converse's avatar
Alex Converse committed
985
#if CONFIG_VAR_TX
986
987
988
  // Assert not magic number (uninitialised).
  assert(x->blk_skip[plane][(blk_row << bwl) + blk_col] != 234);

989
  if (x->blk_skip[plane][(blk_row << bwl) + blk_col] == 0) {
990
#else
991
  {
992
#endif
993
#if CONFIG_NEW_QUANT
Geza Lore's avatar
Geza Lore committed
994
995
    vp10_xform_quant_fp_nuq(x, plane, block, blk_row, blk_col, plane_bsize,
                            tx_size, ctx);
996
#else
Geza Lore's avatar
Geza Lore committed
997
998
    vp10_xform_quant(x, plane, block, blk_row, blk_col, plane_bsize,
                     tx_size, VP10_XFORM_QUANT_FP);
999
#endif  // CONFIG_NEW_QUANT
Jingning Han's avatar
Jingning Han committed
1000
  }
For faster browsing, not all history is shown. View entire blame