vp9_decodframe.c 55.8 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/decoder/vp9_onyxd_int.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
13
#include "vp9/common/vp9_common.h"
14
15
16
#include "vp9/common/vp9_header.h"
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_reconinter.h"
Yaowu Xu's avatar
Yaowu Xu committed
17
#include "vp9/common/vp9_entropy.h"
18
#include "vp9/decoder/vp9_decodframe.h"
19
#include "vp9/decoder/vp9_detokenize.h"
20
21
22
23
#include "vp9/common/vp9_invtrans.h"
#include "vp9/common/vp9_alloccommon.h"
#include "vp9/common/vp9_entropymode.h"
#include "vp9/common/vp9_quant_common.h"
Johann's avatar
Johann committed
24
#include "vpx_scale/vpx_scale.h"
25
#include "vp9/common/vp9_setupintrarecon.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
26

27
#include "vp9/decoder/vp9_decodemv.h"
28
29
#include "vp9/common/vp9_extend.h"
#include "vp9/common/vp9_modecont.h"
John Koleszar's avatar
John Koleszar committed
30
#include "vpx_mem/vpx_mem.h"
31
#include "vp9/decoder/vp9_dboolhuff.h"
John Koleszar's avatar
John Koleszar committed
32

33
#include "vp9/common/vp9_seg_common.h"
34
#include "vp9/common/vp9_tile_common.h"
35
#include "vp9_rtcd.h"
36

John Koleszar's avatar
John Koleszar committed
37
38
39
#include <assert.h>
#include <stdio.h>

40
41
#define COEFCOUNT_TESTING

42
// #define DEC_DEBUG
43
44
45
46
#ifdef DEC_DEBUG
int dec_debug = 0;
#endif

47
48
49
50
51
52
53
54
55
static int read_le16(const uint8_t *p) {
  return (p[1] << 8) | p[0];
}

static int read_le32(const uint8_t *p) {
  return (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
}

// len == 0 is not allowed
56
57
static int read_is_valid(const uint8_t *start, size_t len,
                         const uint8_t *end) {
58
59
60
  return start + len > start && start + len <= end;
}

61
62
63
64
65
66
67
static TXFM_MODE read_txfm_mode(vp9_reader *r) {
  TXFM_MODE mode = vp9_read_literal(r, 2);
  if (mode == ALLOW_32X32)
    mode += vp9_read_bit(r);
  return mode;
}

68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
static int get_unsigned_bits(unsigned int num_values) {
  int cat = 0;
  if (num_values <= 1)
    return 0;
  num_values--;
  while (num_values > 0) {
    cat++;
    num_values >>= 1;
  }
  return cat;
}

static int inv_recenter_nonneg(int v, int m) {
  if (v > (m << 1))
    return v;
  else if ((v & 1) == 0)
    return (v >> 1) + m;
  else
    return m - ((v + 1) >> 1);
}

89
static int decode_uniform(vp9_reader *r, int n) {
90
91
92
93
94
95
  int v;
  const int l = get_unsigned_bits(n);
  const int m = (1 << l) - n;
  if (!l)
    return 0;

96
97
  v = vp9_read_literal(r, l - 1);
  return v < m ?  v : (v << 1) - m + vp9_read_bit(r);
98
99
}

100
static int decode_term_subexp(vp9_reader *r, int k, int num_syms) {
101
102
103
104
105
  int i = 0, mk = 0, word;
  while (1) {
    const int b = i ? k + i - 1 : k;
    const int a = 1 << b;
    if (num_syms <= mk + 3 * a) {
106
      word = decode_uniform(r, num_syms - mk) + mk;
107
108
      break;
    } else {
109
      if (vp9_read_bit(r)) {
110
111
112
        i++;
        mk += a;
      } else {
113
        word = vp9_read_literal(r, b) + mk;
114
115
116
117
118
119
120
        break;
      }
    }
  }
  return word;
}

121
static int decode_unsigned_max(vp9_reader *r, int max) {
122
123
124
  int data = 0, bit = 0, lmax = max;

  while (lmax) {
125
    data |= vp9_read_bit(r) << bit++;
126
127
128
129
130
    lmax >>= 1;
  }
  return data > max ? max : data;
}

John Koleszar's avatar
John Koleszar committed
131
132
133
134
135
136
137
138
139
140
141
142
static int merge_index(int v, int n, int modulus) {
  int max1 = (n - 1 - modulus / 2) / modulus + 1;
  if (v < max1) v = v * modulus + modulus / 2;
  else {
    int w;
    v -= max1;
    w = v;
    v += (v + modulus - modulus / 2) / modulus;
    while (v % modulus == modulus / 2 ||
           w != v - (v + modulus - modulus / 2) / modulus) v++;
  }
  return v;
143
144
}

John Koleszar's avatar
John Koleszar committed
145
146
147
static int inv_remap_prob(int v, int m) {
  const int n = 256;
  const int modulus = MODULUS_PARAM;
148

John Koleszar's avatar
John Koleszar committed
149
150
  v = merge_index(v, n - 1, modulus);
  if ((m << 1) <= n) {
151
    return inv_recenter_nonneg(v + 1, m);
John Koleszar's avatar
John Koleszar committed
152
  } else {
153
    return n - 1 - inv_recenter_nonneg(v + 1, n - 1 - m);
John Koleszar's avatar
John Koleszar committed
154
  }
155
}
156

157
158
static vp9_prob read_prob_diff_update(vp9_reader *r, int oldp) {
  int delp = decode_term_subexp(r, SUBEXP_PARAM, 255);
159
  return (vp9_prob)inv_remap_prob(delp, oldp);
160
}
161

162
void vp9_init_de_quantizer(VP9D_COMP *pbi) {
John Koleszar's avatar
John Koleszar committed
163
  int i;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
164
  int q;
165
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
166

Dmitry Kovalev's avatar
Dmitry Kovalev committed
167
  for (q = 0; q < QINDEX_RANGE; q++) {
168
169
    pc->y_dequant[q][0] = (int16_t)vp9_dc_quant(q, pc->y_dc_delta_q);
    pc->uv_dequant[q][0] = (int16_t)vp9_dc_uv_quant(q, pc->uv_dc_delta_q);
John Koleszar's avatar
John Koleszar committed
170
171
172

    /* all the ac values =; */
    for (i = 1; i < 16; i++) {
173
      const int rc = vp9_default_zig_zag1d_4x4[i];
John Koleszar's avatar
John Koleszar committed
174

Dmitry Kovalev's avatar
Dmitry Kovalev committed
175
      pc->y_dequant[q][rc] = (int16_t)vp9_ac_yquant(q);
176
      pc->uv_dequant[q][rc] = (int16_t)vp9_ac_uv_quant(q, pc->uv_ac_delta_q);
John Koleszar's avatar
John Koleszar committed
177
    }
John Koleszar's avatar
John Koleszar committed
178
  }
John Koleszar's avatar
John Koleszar committed
179
180
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
181
182
183
static int get_qindex(MACROBLOCKD *mb, int segment_id, int base_qindex) {
  // Set the Q baseline allowing for any segment level adjustment
  if (vp9_segfeature_active(mb, segment_id, SEG_LVL_ALT_Q)) {
184
185
186
187
    const int data = vp9_get_segdata(mb, segment_id, SEG_LVL_ALT_Q);
    return mb->mb_segment_abs_delta == SEGMENT_ABSDATA ?
               data :  // Abs value
               clamp(base_qindex + data, 0, MAXQ);  // Delta value
Dmitry Kovalev's avatar
Dmitry Kovalev committed
188
189
190
191
192
193
  } else {
    return base_qindex;
  }
}

static void mb_init_dequantizer(VP9D_COMP *pbi, MACROBLOCKD *mb) {
John Koleszar's avatar
John Koleszar committed
194
195
  int i;

Dmitry Kovalev's avatar
Dmitry Kovalev committed
196
  VP9_COMMON *const pc = &pbi->common;
197
198
  const int segment_id = mb->mode_info_context->mbmi.segment_id;
  const int qindex = get_qindex(mb, segment_id, pc->base_qindex);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
199
  mb->q_index = qindex;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
200

Dmitry Kovalev's avatar
Dmitry Kovalev committed
201
  for (i = 0; i < 16; i++)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
202
    mb->block[i].dequant = pc->y_dequant[qindex];
John Koleszar's avatar
John Koleszar committed
203

Dmitry Kovalev's avatar
Dmitry Kovalev committed
204
  for (i = 16; i < 24; i++)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
205
    mb->block[i].dequant = pc->uv_dequant[qindex];
John Koleszar's avatar
John Koleszar committed
206

Dmitry Kovalev's avatar
Dmitry Kovalev committed
207
  if (mb->lossless) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
208
    assert(qindex == 0);
Yaowu Xu's avatar
Yaowu Xu committed
209
210
    mb->inv_txm4x4_1      = vp9_short_iwalsh4x4_1;
    mb->inv_txm4x4        = vp9_short_iwalsh4x4;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
211
212
213
214
    mb->itxm_add          = vp9_dequant_idct_add_lossless_c;
    mb->itxm_add_y_block  = vp9_dequant_idct_add_y_block_lossless_c;
    mb->itxm_add_uv_block = vp9_dequant_idct_add_uv_block_lossless_c;
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
215
216
    mb->inv_txm4x4_1      = vp9_short_idct4x4_1;
    mb->inv_txm4x4        = vp9_short_idct4x4;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
217
218
219
    mb->itxm_add          = vp9_dequant_idct_add;
    mb->itxm_add_y_block  = vp9_dequant_idct_add_y_block;
    mb->itxm_add_uv_block = vp9_dequant_idct_add_uv_block;
John Koleszar's avatar
John Koleszar committed
220
  }
John Koleszar's avatar
John Koleszar committed
221
222
}

223
static void decode_16x16(MACROBLOCKD *xd) {
224
  const TX_TYPE tx_type = get_tx_type_16x16(xd, 0);
225

226
  vp9_dequant_iht_add_16x16_c(tx_type, xd->plane[0].qcoeff,
227
228
                              xd->block[0].dequant, xd->plane[0].dst.buf,
                              xd->plane[0].dst.stride, xd->plane[0].eobs[0]);
229
230

  vp9_dequant_idct_add_8x8(xd->plane[1].qcoeff, xd->block[16].dequant,
231
                           xd->plane[1].dst.buf, xd->plane[1].dst.stride,
232
                           xd->plane[1].eobs[0]);
233

Dmitry Kovalev's avatar
Dmitry Kovalev committed
234
  vp9_dequant_idct_add_8x8(xd->plane[2].qcoeff, xd->block[20].dequant,
235
                           xd->plane[2].dst.buf, xd->plane[1].dst.stride,
236
                           xd->plane[2].eobs[0]);
237
238
}

239
static void decode_8x8(MACROBLOCKD *xd) {
240
241
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
  // luma
242
  // if the first one is DCT_DCT assume all the rest are as well
243
  TX_TYPE tx_type = get_tx_type_8x8(xd, 0);
244
  if (tx_type != DCT_DCT || mode == I8X8_PRED) {
245
246
247
248
    int i;
    for (i = 0; i < 4; i++) {
      int ib = vp9_i8x8_block[i];
      int idx = (ib & 0x02) ? (ib + 2) : ib;
249
      int16_t *q  = BLOCK_OFFSET(xd->plane[0].qcoeff, idx, 16);
250
251
      int16_t *dq = xd->block[0].dequant;
      uint8_t *dst = *(xd->block[ib].base_dst) + xd->block[ib].dst;
252
      int stride = xd->plane[0].dst.stride;
253
      if (mode == I8X8_PRED) {
254
        BLOCKD *b = &xd->block[ib];
255
        int i8x8mode = b->bmi.as_mode.first;
256
        vp9_intra8x8_predict(xd, b, i8x8mode, dst, stride);
257
      }
258
      tx_type = get_tx_type_8x8(xd, ib);
259
260
      vp9_dequant_iht_add_8x8_c(tx_type, q, dq, dst, stride,
                                xd->plane[0].eobs[idx]);
261
    }
262
  } else {
263
    vp9_dequant_idct_add_y_block_8x8(xd->plane[0].qcoeff,
264
265
                                     xd->block[0].dequant, xd->plane[0].dst.buf,
                                     xd->plane[0].dst.stride, xd);
266
267
  }

268
269
  // chroma
  if (mode == I8X8_PRED) {
270
271
272
273
274
    int i;
    for (i = 0; i < 4; i++) {
      int ib = vp9_i8x8_block[i];
      BLOCKD *b = &xd->block[ib];
      int i8x8mode = b->bmi.as_mode.first;
275

276
      b = &xd->block[16 + i];
277
278
      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                              b->dst_stride);
279
      xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
280
                   b->dequant, *(b->base_dst) + b->dst, b->dst_stride,
John Koleszar's avatar
John Koleszar committed
281
                   xd->plane[1].eobs[i]);
282

283
      b = &xd->block[20 + i];
284
285
      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                              b->dst_stride);
286
      xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
287
                   b->dequant, *(b->base_dst) + b->dst, b->dst_stride,
John Koleszar's avatar
John Koleszar committed
288
                   xd->plane[2].eobs[i]);
289
    }
290
  } else if (mode == SPLITMV) {
291
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
292
         xd->plane[1].dst.buf, xd->plane[1].dst.stride, xd->plane[1].eobs);
293
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
294
         xd->plane[2].dst.buf, xd->plane[1].dst.stride, xd->plane[2].eobs);
295
  } else {
296
    vp9_dequant_idct_add_8x8(xd->plane[1].qcoeff, xd->block[16].dequant,
297
                             xd->plane[1].dst.buf, xd->plane[1].dst.stride,
298
                             xd->plane[1].eobs[0]);
299
300

    vp9_dequant_idct_add_8x8(xd->plane[2].qcoeff, xd->block[16].dequant,
301
                             xd->plane[2].dst.buf, xd->plane[1].dst.stride,
302
                             xd->plane[2].eobs[0]);
303
304
305
  }
}

306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
static INLINE void dequant_add_y(MACROBLOCKD *xd, TX_TYPE tx_type, int idx) {
  BLOCKD *const b = &xd->block[idx];
  struct mb_plane *const y = &xd->plane[0];
  if (tx_type != DCT_DCT) {
    vp9_dequant_iht_add_c(tx_type,
                          BLOCK_OFFSET(y->qcoeff, idx, 16),
                          b->dequant, *(b->base_dst) + b->dst,
                          b->dst_stride, y->eobs[idx]);
  } else {
    xd->itxm_add(BLOCK_OFFSET(y->qcoeff, idx, 16),
                 b->dequant, *(b->base_dst) + b->dst,
                 b->dst_stride, y->eobs[idx]);
  }
}


322
static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd, vp9_reader *r) {
323
  TX_TYPE tx_type;
324
  int i = 0;
325
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
326
327
328
329
330
  if (mode == I8X8_PRED) {
    for (i = 0; i < 4; i++) {
      int ib = vp9_i8x8_block[i];
      const int iblock[4] = {0, 1, 4, 5};
      int j;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
331
332
      BLOCKD *b = &xd->block[ib];
      int i8x8mode = b->bmi.as_mode.first;
333
334
      vp9_intra8x8_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                           b->dst_stride);
335
      for (j = 0; j < 4; j++) {
336
        tx_type = get_tx_type_4x4(xd, ib + iblock[j]);
337
        dequant_add_y(xd, tx_type, ib + iblock[j]);
338
339
      }
      b = &xd->block[16 + i];
340
341
      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                              b->dst_stride);
342
      xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
343
                   b->dequant, *(b->base_dst) + b->dst, b->dst_stride,
John Koleszar's avatar
John Koleszar committed
344
                   xd->plane[1].eobs[i]);
345
      b = &xd->block[20 + i];
346
347
      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                              b->dst_stride);
348
      xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
349
                   b->dequant, *(b->base_dst) + b->dst, b->dst_stride,
John Koleszar's avatar
John Koleszar committed
350
                   xd->plane[2].eobs[i]);
351
    }
Yaowu Xu's avatar
Yaowu Xu committed
352
  } else if (mode == I4X4_PRED) {
353
354
    for (i = 0; i < 16; i++) {
      BLOCKD *b = &xd->block[i];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
355
      int b_mode = xd->mode_info_context->bmi[i].as_mode.first;
356
357
#if CONFIG_NEWBINTRAMODES
      xd->mode_info_context->bmi[i].as_mode.context = b->bmi.as_mode.context =
358
          vp9_find_bpred_context(xd, b);
359
      if (!xd->mode_info_context->mbmi.mb_skip_coeff)
360
        vp9_decode_coefs_4x4(pbi, xd, r, PLANE_TYPE_Y_WITH_DC, i);
361
#endif
362
363
      vp9_intra4x4_predict(xd, b, b_mode, *(b->base_dst) + b->dst,
                           b->dst_stride);
364
      tx_type = get_tx_type_4x4(xd, i);
365
      dequant_add_y(xd, tx_type, i);
366
    }
367
368
#if CONFIG_NEWBINTRAMODES
    if (!xd->mode_info_context->mbmi.mb_skip_coeff)
369
      vp9_decode_mb_tokens_4x4_uv(pbi, xd, r);
370
#endif
371
    vp9_build_intra_predictors_sbuv_s(xd, BLOCK_SIZE_MB16X16);
372
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
373
         xd->plane[1].dst.buf, xd->plane[1].dst.stride, xd->plane[1].eobs);
374
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
375
         xd->plane[2].dst.buf, xd->plane[1].dst.stride, xd->plane[2].eobs);
376
  } else if (mode == SPLITMV || get_tx_type_4x4(xd, 0) == DCT_DCT) {
377
    xd->itxm_add_y_block(xd->plane[0].qcoeff,
378
                          xd->block[0].dequant,
379
                          xd->plane[0].dst.buf, xd->plane[0].dst.stride, xd);
380
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
381
         xd->plane[1].dst.buf, xd->plane[1].dst.stride, xd->plane[1].eobs);
382
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
383
         xd->plane[2].dst.buf, xd->plane[1].dst.stride, xd->plane[2].eobs);
384
  } else {
385
    for (i = 0; i < 16; i++) {
386
      tx_type = get_tx_type_4x4(xd, i);
387
      dequant_add_y(xd, tx_type, i);
388
    }
389
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
390
                          xd->plane[1].dst.buf, xd->plane[1].dst.stride,
391
                          xd->plane[1].eobs);
392
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
393
                          xd->plane[2].dst.buf, xd->plane[1].dst.stride,
394
                          xd->plane[2].eobs);
395
396
397
  }
}

398
399
400
401
static INLINE void decode_sby_32x32(MACROBLOCKD *mb, BLOCK_SIZE_TYPE bsize) {
  const int bwl = mb_width_log2(bsize) - 1, bw = 1 << bwl;
  const int bhl = mb_height_log2(bsize) - 1, bh = 1 << bhl;
  const int y_count = bw * bh;
402
403
404
  int n;

  for (n = 0; n < y_count; n++) {
405
406
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> bwl;
407
    const int y_offset = (y_idx * 32) * mb->plane[0].dst.stride + (x_idx * 32);
408
409
    vp9_dequant_idct_add_32x32(BLOCK_OFFSET(mb->plane[0].qcoeff, n, 1024),
                               mb->block[0].dequant ,
410
411
                               mb->plane[0].dst.buf + y_offset,
                               mb->plane[0].dst.stride,
412
413
414
415
416
417
418
419
420
421
422
423
                               mb->plane[0].eobs[n * 64]);
  }
}

static INLINE void decode_sbuv_32x32(MACROBLOCKD *mb, BLOCK_SIZE_TYPE bsize) {
  const int bwl = mb_width_log2(bsize) - 1, bw = (1 << bwl) / 2;
  const int bhl = mb_height_log2(bsize) - 1, bh = (1 << bhl) / 2;
  const int uv_count = bw * bh;
  int n;
  for (n = 0; n < uv_count; n++) {
     const int x_idx = n & (bw - 1);
     const int y_idx = n >> (bwl - 1);
424
425
     const int uv_offset = (y_idx * 32) * mb->plane[1].dst.stride +
         (x_idx * 32);
426
427
     vp9_dequant_idct_add_32x32(BLOCK_OFFSET(mb->plane[1].qcoeff, n, 1024),
                                mb->block[16].dequant,
428
429
430
                                mb->plane[1].dst.buf + uv_offset,
                                mb->plane[1].dst.stride,
                                mb->plane[1].eobs[n * 64]);
431
432
     vp9_dequant_idct_add_32x32(BLOCK_OFFSET(mb->plane[2].qcoeff, n, 1024),
                                mb->block[20].dequant,
433
434
435
                                mb->plane[2].dst.buf + uv_offset,
                                mb->plane[1].dst.stride,
                                mb->plane[2].eobs[n * 64]);
436
437
438
439
440
441
442
443
444
445
446
447
  }
}

static INLINE void decode_sby_16x16(MACROBLOCKD *mb, BLOCK_SIZE_TYPE bsize) {
  const int bwl = mb_width_log2(bsize), bw = 1 << bwl;
  const int bhl = mb_height_log2(bsize), bh = 1 << bhl;
  const int y_count = bw * bh;
  int n;

  for (n = 0; n < y_count; n++) {
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> bwl;
448
    const int y_offset = (y_idx * 16) * mb->plane[0].dst.stride + (x_idx * 16);
449
    const TX_TYPE tx_type = get_tx_type_16x16(mb,
450
                                (y_idx * (4 * bw) + x_idx) * 4);
451
452
453
    vp9_dequant_iht_add_16x16_c(tx_type,
                                BLOCK_OFFSET(mb->plane[0].qcoeff, n, 256),
                                mb->block[0].dequant,
454
455
                                mb->plane[0].dst.buf + y_offset,
                                mb->plane[0].dst.stride,
456
                                mb->plane[0].eobs[n * 16]);
457
  }
458
459
460
461
462
463
464
465
466
}

static INLINE void decode_sbuv_16x16(MACROBLOCKD *mb, BLOCK_SIZE_TYPE bsize) {
  const int bwl = mb_width_log2(bsize), bw = (1 << bwl) / 2;
  const int bhl = mb_height_log2(bsize), bh = (1 << bhl) / 2;
  const int uv_count = bw * bh;
  int n;

  assert(bsize >= BLOCK_SIZE_SB32X32);
467
468

  for (n = 0; n < uv_count; n++) {
469
470
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
471
    const int uv_offset = (y_idx * 16) * mb->plane[1].dst.stride + (x_idx * 16);
472
    vp9_dequant_idct_add_16x16(BLOCK_OFFSET(mb->plane[1].qcoeff, n, 256),
473
                               mb->block[16].dequant,
474
475
                               mb->plane[1].dst.buf + uv_offset,
                               mb->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
476
                               mb->plane[1].eobs[n * 16]);
477
    vp9_dequant_idct_add_16x16(BLOCK_OFFSET(mb->plane[2].qcoeff, n, 256),
478
                               mb->block[20].dequant,
479
480
                               mb->plane[2].dst.buf + uv_offset,
                               mb->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
481
                               mb->plane[2].eobs[n * 16]);
482
483
484
  }
}

485
486
487
488
static INLINE void decode_sby_8x8(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
  const int bwl = mb_width_log2(bsize)  + 1, bw = 1 << bwl;
  const int bhl = mb_height_log2(bsize) + 1, bh = 1 << bhl;
  const int y_count = bw * bh;
489
490
491
492
  int n;

  // luma
  for (n = 0; n < y_count; n++) {
493
494
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> bwl;
495
    const int y_offset = (y_idx * 8) * xd->plane[0].dst.stride + (x_idx * 8);
496
    const TX_TYPE tx_type = get_tx_type_8x8(xd,
497
                                            (y_idx * (2 * bw) + x_idx) * 2);
498
499
500
501

    vp9_dequant_iht_add_8x8_c(tx_type,
                              BLOCK_OFFSET(xd->plane[0].qcoeff, n, 64),
                              xd->block[0].dequant,
502
503
                              xd->plane[0].dst.buf + y_offset,
                              xd->plane[0].dst.stride,
504
                              xd->plane[0].eobs[n * 4]);
505
  }
506
507
508
509
510
511
512
}

static INLINE void decode_sbuv_8x8(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
  const int bwl = mb_width_log2(bsize)  + 1, bw = 1 << (bwl - 1);
  const int bhl = mb_height_log2(bsize) + 1, bh = 1 << (bhl - 1);
  const int uv_count = bw * bh;
  int n;
513
514
515

  // chroma
  for (n = 0; n < uv_count; n++) {
516
517
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
518
    const int uv_offset = (y_idx * 8) * xd->plane[1].dst.stride + (x_idx * 8);
519
520
    vp9_dequant_idct_add_8x8(BLOCK_OFFSET(xd->plane[1].qcoeff, n, 64),
                             xd->block[16].dequant,
521
522
                             xd->plane[1].dst.buf + uv_offset,
                             xd->plane[1].dst.stride,
523
524
525
                             xd->plane[1].eobs[n * 4]);
    vp9_dequant_idct_add_8x8(BLOCK_OFFSET(xd->plane[2].qcoeff, n, 64),
                             xd->block[20].dequant,
526
527
                             xd->plane[2].dst.buf + uv_offset,
                             xd->plane[1].dst.stride,
528
                             xd->plane[2].eobs[n * 4]);
529
530
531
  }
}

532
533
534
535
static INLINE void decode_sby_4x4(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
  const int bwl = mb_width_log2(bsize)  + 2, bw = 1 << bwl;
  const int bhl = mb_height_log2(bsize) + 2, bh = 1 << bhl;
  const int y_count = bw * bh;
536
537
538
  int n;

  for (n = 0; n < y_count; n++) {
539
540
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> bwl;
541
    const int y_offset = (y_idx * 4) * xd->plane[0].dst.stride + (x_idx * 4);
542
    const TX_TYPE tx_type = get_tx_type_4x4(xd, n);
543
    if (tx_type == DCT_DCT) {
544
545
      xd->itxm_add(BLOCK_OFFSET(xd->plane[0].qcoeff, n, 16),
                   xd->block[0].dequant,
546
                   xd->plane[0].dst.buf + y_offset, xd->plane[0].dst.stride,
John Koleszar's avatar
John Koleszar committed
547
                   xd->plane[0].eobs[n]);
548
    } else {
549
550
      vp9_dequant_iht_add_c(tx_type,
                            BLOCK_OFFSET(xd->plane[0].qcoeff, n, 16),
551
552
553
                            xd->block[0].dequant,
                            xd->plane[0].dst.buf + y_offset,
                            xd->plane[0].dst.stride, xd->plane[0].eobs[n]);
554
555
    }
  }
556
557
558
559
560
561
562
}

static INLINE void decode_sbuv_4x4(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
  const int bwl = mb_width_log2(bsize)  + 2, bw = 1 << (bwl - 1);
  const int bhl = mb_height_log2(bsize) + 2, bh = 1 << (bhl - 1);
  const int uv_count = bw * bh;
  int n;
563
564

  for (n = 0; n < uv_count; n++) {
565
566
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
567
    const int uv_offset = (y_idx * 4) * xd->plane[1].dst.stride + (x_idx * 4);
568
569
    xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, n, 16),
        xd->block[16].dequant,
570
571
        xd->plane[1].dst.buf + uv_offset, xd->plane[1].dst.stride,
        xd->plane[1].eobs[n]);
572
573
    xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, n, 16),
        xd->block[20].dequant,
574
575
        xd->plane[2].dst.buf + uv_offset, xd->plane[1].dst.stride,
        xd->plane[2].eobs[n]);
576
577
578
  }
}

579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
// TODO(jingning): combine luma and chroma dequantization and inverse
// transform into a single function looping over planes.
static void decode_sb_32x32(MACROBLOCKD *mb, BLOCK_SIZE_TYPE bsize) {
  decode_sby_32x32(mb, bsize);
  if (bsize == BLOCK_SIZE_SB64X64)
    decode_sbuv_32x32(mb, bsize);
  else
    decode_sbuv_16x16(mb, bsize);
}

static void decode_sb_16x16(MACROBLOCKD *mb, BLOCK_SIZE_TYPE bsize) {
  decode_sby_16x16(mb, bsize);
  if (bsize >= BLOCK_SIZE_SB32X32)
    decode_sbuv_16x16(mb, bsize);
  else
    decode_sbuv_8x8(mb, bsize);
}

static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mb_row, int mb_col,
598
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
599
600
  const int bwl = mb_width_log2(bsize), bhl = mb_height_log2(bsize);
  const int bw = 1 << bwl, bh = 1 << bhl;
601
  int n, eobtotal;
602
  VP9_COMMON *const pc = &pbi->common;
603
  MODE_INFO *mi = xd->mode_info_context;
604
  const int mis = pc->mode_info_stride;
605

606
  assert(mi->mbmi.sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
607
608

  if (pbi->common.frame_type != KEY_FRAME)
609
    vp9_setup_interp_filters(xd, mi->mbmi.interp_filter, pc);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
610

611
  // generate prediction
612
613
614
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
    vp9_build_intra_predictors_sby_s(xd, bsize);
    vp9_build_intra_predictors_sbuv_s(xd, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
615
  } else {
616
    vp9_build_inter_predictors_sb(xd, mb_row, mb_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
617
618
  }

Yunqing Wang's avatar
Yunqing Wang committed
619
620
  if (mi->mbmi.mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, bsize);
621
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
622
623
624
625
626
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(pbi, xd);

    // dequantization and idct
627
    eobtotal = vp9_decode_tokens(pbi, xd, r, bsize);
Yunqing Wang's avatar
Yunqing Wang committed
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
    if (eobtotal == 0) {  // skip loopfilter
      for (n = 0; n < bw * bh; n++) {
        const int x_idx = n & (bw - 1), y_idx = n >> bwl;

        if (mb_col + x_idx < pc->mb_cols && mb_row + y_idx < pc->mb_rows)
          mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
      }
    } else {
      switch (xd->mode_info_context->mbmi.txfm_size) {
        case TX_32X32:
          decode_sb_32x32(xd, bsize);
          break;
        case TX_16X16:
          decode_sb_16x16(xd, bsize);
          break;
        case TX_8X8:
          decode_sby_8x8(xd, bsize);
          decode_sbuv_8x8(xd, bsize);
          break;
        case TX_4X4:
          decode_sby_4x4(xd, bsize);
          decode_sbuv_4x4(xd, bsize);
          break;
        default: assert(0);
      }
653
    }
654
  }
655
656
}

657
658
// TODO(jingning): Need to merge SB and MB decoding. The MB decoding currently
// couples special handles on I8x8, B_PRED, and splitmv modes.
659
660
static void decode_mb(VP9D_COMP *pbi, MACROBLOCKD *xd,
                     int mb_row, int mb_col,
661
                     vp9_reader *r) {
John Koleszar's avatar
John Koleszar committed
662
  int eobtotal = 0;
663
664
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
  const int tx_size = xd->mode_info_context->mbmi.txfm_size;
665

Ronald S. Bultje's avatar
Ronald S. Bultje committed
666
  assert(!xd->mode_info_context->mbmi.sb_type);
John Koleszar's avatar
John Koleszar committed
667

Deb Mukherjee's avatar
Deb Mukherjee committed
668
  //mode = xd->mode_info_context->mbmi.mode;
669
  if (pbi->common.frame_type != KEY_FRAME)
670
    vp9_setup_interp_filters(xd, xd->mode_info_context->mbmi.interp_filter,
671
                             &pbi->common);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
672

673
  // do prediction
John Koleszar's avatar
John Koleszar committed
674
675
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
    if (mode != I8X8_PRED) {
676
      vp9_build_intra_predictors_sbuv_s(xd, BLOCK_SIZE_MB16X16);
Yaowu Xu's avatar
Yaowu Xu committed
677
      if (mode != I4X4_PRED)
678
        vp9_build_intra_predictors_sby_s(xd, BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
679
    }
John Koleszar's avatar
John Koleszar committed
680
  } else {
681
#if 0  // def DEC_DEBUG
682
683
684
685
686
  if (dec_debug)
    printf("Decoding mb:  %d %d interp %d\n",
           xd->mode_info_context->mbmi.mode, tx_size,
           xd->mode_info_context->mbmi.interp_filter);
#endif
687
    vp9_build_inter_predictors_sb(xd, mb_row, mb_col, BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
688
689
  }

Yunqing Wang's avatar
Yunqing Wang committed
690
691
  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, BLOCK_SIZE_MB16X16);
692
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
693
694
695
696
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(pbi, xd);

697
    if (!vp9_reader_has_error(r)) {
Yunqing Wang's avatar
Yunqing Wang committed
698
699
700
#if CONFIG_NEWBINTRAMODES
    if (mode != I4X4_PRED)
#endif
701
      eobtotal = vp9_decode_tokens(pbi, xd, r, BLOCK_SIZE_MB16X16);
Yunqing Wang's avatar
Yunqing Wang committed
702
703
704
705
706
707
708
    }
  }

  if (eobtotal == 0 &&
      mode != I4X4_PRED &&
      mode != SPLITMV &&
      mode != I8X8_PRED &&
709
      !vp9_reader_has_error(r)) {
Yunqing Wang's avatar
Yunqing Wang committed
710
711
712
713
714
715
716
717
    xd->mode_info_context->mbmi.mb_skip_coeff = 1;
  } else {
#if 0  // def DEC_DEBUG
  if (dec_debug)
    printf("Decoding mb:  %d %d\n", xd->mode_info_context->mbmi.mode, tx_size);
#endif

    if (tx_size == TX_16X16) {
718
      decode_16x16(xd);
Yunqing Wang's avatar
Yunqing Wang committed
719
    } else if (tx_size == TX_8X8) {
720
      decode_8x8(xd);
Yunqing Wang's avatar
Yunqing Wang committed
721
    } else {
722
      decode_4x4(pbi, xd, r);
Yunqing Wang's avatar
Yunqing Wang committed
723
    }
724
  }
Yunqing Wang's avatar
Yunqing Wang committed
725

726
727
728
729
#ifdef DEC_DEBUG
  if (dec_debug) {
    int i, j;
    printf("\n");
730
731
732
733
734
735
736
    printf("predictor y\n");
    for (i = 0; i < 16; i++) {
      for (j = 0; j < 16; j++)
        printf("%3d ", xd->predictor[i * 16 + j]);
      printf("\n");
    }
    printf("\n");
737
    printf("final y\n");
John Koleszar's avatar
John Koleszar committed
738
    for (i = 0; i < 16; i++) {
739
      for (j = 0; j < 16; j++)
740
        printf("%3d ", xd->plane[0].dst.buf[i * xd->plane[0].dst.stride + j]);
741
      printf("\n");
John Koleszar's avatar
John Koleszar committed
742
    }
743
744
745
746
    printf("\n");
    printf("final u\n");
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++)
747
        printf("%3d ", xd->plane[1].dst.buf[i * xd->plane[1].dst.stride + j]);
748
      printf("\n");
749
    }
750
751
752
753
    printf("\n");
    printf("final v\n");
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++)
754
        printf("%3d ", xd->plane[2].dst.buf[i * xd->plane[1].dst.stride + j]);
755
      printf("\n");
756
    }
757
    fflush(stdout);
John Koleszar's avatar
John Koleszar committed
758
  }
759
#endif
Yaowu Xu's avatar
Yaowu Xu committed
760
}
John Koleszar's avatar
John Koleszar committed
761

762
763
764
765
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
766
767
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
768
  }
John Koleszar's avatar
John Koleszar committed
769

770
  // Trigger a quantizer update if the delta-q value has changed
771
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
772
773
}

774
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
775
                        int mb_row, int mb_col) {
776
777
  const int bh = 1 << mb_height_log2(bsize);
  const int bw = 1 << mb_width_log2(bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
778
779
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
780

781
782
783
784
785
786
  const int mb_idx = mb_row * cm->mode_info_stride + mb_col;
  const YV12_BUFFER_CONFIG *dst_fb = &cm->yv12_fb[cm->new_fb_idx];
  const int recon_yoffset = (16 * mb_row) * dst_fb->y_stride + (16 * mb_col);
  const int recon_uvoffset = (8 * mb_row) * dst_fb->uv_stride + (8 * mb_col);

  xd->mode_info_context = cm->mi + mb_idx;
787
  xd->mode_info_context->mbmi.sb_type = bsize;
788
789
790
  xd->prev_mode_info_context = cm->prev_mi + mb_idx;
  xd->above_context = cm->above_context + mb_col;
  xd->left_context = cm->left_context + mb_row % 4;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
791

792
793
  // Distance of Mb to the various image edges. These are specified to 8th pel
  // as they are always compared to values that are in 1/8th pel units
794
795
  set_mb_row(cm, xd, mb_row, bh);
  set_mb_col(cm, xd, mb_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
796

797
798
799
  xd->plane[0].dst.buf = dst_fb->y_buffer + recon_yoffset;
  xd->plane[1].dst.buf = dst_fb->u_buffer + recon_uvoffset;
  xd->plane[2].dst.buf = dst_fb->v_buffer + recon_uvoffset;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
800
}
John Koleszar's avatar
John Koleszar committed
801

802
static void set_refs(VP9D_COMP *pbi, int mb_row, int mb_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
803
804
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
805
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
806
807

  if (mbmi->ref_frame > INTRA_FRAME) {
808
    // Select the appropriate reference frame for this MB
809
810
811
    const int fb_idx = cm->active_ref_idx[mbmi->ref_frame - 1];
    const YV12_BUFFER_CONFIG *cfg = &cm->yv12_fb[fb_idx];
    xd->scale_factor[0]    = cm->active_ref_scale[mbmi->ref_frame - 1];
812
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
813
814
    setup_pre_planes(xd, cfg, NULL, mb_row, mb_col,
                     xd->scale_factor, xd->scale_factor_uv);
815
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
816

Ronald S. Bultje's avatar
Ronald S. Bultje committed
817
    if (mbmi->second_ref_frame > INTRA_FRAME) {
818
      // Select the appropriate reference frame for this MB
819
820
      const int second_fb_idx = cm->active_ref_idx[mbmi->second_ref_frame - 1];
      const YV12_BUFFER_CONFIG *second_cfg = &cm->yv12_fb[second_fb_idx];
Yunqing Wang's avatar
Yunqing Wang committed
821
822
      xd->scale_factor[1]    = cm->active_ref_scale[mbmi->second_ref_frame - 1];
      xd->scale_factor_uv[1] = cm->active_ref_scale[mbmi->second_ref_frame - 1];
823
824
      setup_pre_planes(xd, NULL, second_cfg, mb_row, mb_col,
                       xd->scale_factor, xd->scale_factor_uv);
825
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
826
827
828
    }
  }
}
John Koleszar's avatar
John Koleszar committed
829

830
831
832
833
834
835
836
837
838
839
840
841
842
843
static void decode_modes_b(VP9D_COMP *pbi, int mb_row, int mb_col,
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

  set_offsets(pbi, bsize, mb_row, mb_col);
  vp9_decode_mb_mode_mv(pbi, xd, mb_row, mb_col, r);
  set_refs(pbi, mb_row, mb_col);

  // TODO(jingning): merge decode_sb_ and decode_mb_
  if (bsize > BLOCK_SIZE_MB16X16)
    decode_sb(pbi, xd, mb_row, mb_col, r, bsize);
  else
    decode_mb(pbi, xd, mb_row, mb_col, r);

844
  xd->corrupted |= vp9_reader_has_error(r);
845
846
847
848
}

static void decode_modes_sb(VP9D_COMP *pbi, int mb_row, int mb_col,
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
849
850
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882