vp9_decodframe.c 53.7 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
// #define DEC_DEBUG
41 42 43 44
#ifdef DEC_DEBUG
int dec_debug = 0;
#endif

45 46 47 48 49 50 51 52 53
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
54 55
static int read_is_valid(const uint8_t *start, size_t len,
                         const uint8_t *end) {
56 57 58
  return start + len > start && start + len <= end;
}

59 60 61 62 63 64 65 66 67 68 69 70 71 72
static void setup_txfm_mode(VP9_COMMON *pc, int lossless, vp9_reader *r) {
  if (lossless) {
    pc->txfm_mode = ONLY_4X4;
  } else {
    pc->txfm_mode = vp9_read_literal(r, 2);
    if (pc->txfm_mode == ALLOW_32X32)
      pc->txfm_mode += vp9_read_bit(r);

    if (pc->txfm_mode == TX_MODE_SELECT) {
      pc->prob_tx[0] = vp9_read_prob(r);
      pc->prob_tx[1] = vp9_read_prob(r);
      pc->prob_tx[2] = vp9_read_prob(r);
    }
  }
73 74
}

75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
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);
}

96
static int decode_uniform(vp9_reader *r, int n) {
97 98 99 100 101 102
  int v;
  const int l = get_unsigned_bits(n);
  const int m = (1 << l) - n;
  if (!l)
    return 0;

103 104
  v = vp9_read_literal(r, l - 1);
  return v < m ?  v : (v << 1) - m + vp9_read_bit(r);
105 106
}

107
static int decode_term_subexp(vp9_reader *r, int k, int num_syms) {
108 109 110 111 112
  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) {
113
      word = decode_uniform(r, num_syms - mk) + mk;
114 115
      break;
    } else {
116
      if (vp9_read_bit(r)) {
117 118 119
        i++;
        mk += a;
      } else {
120
        word = vp9_read_literal(r, b) + mk;
121 122 123 124 125 126 127
        break;
      }
    }
  }
  return word;
}

128
static int decode_unsigned_max(vp9_reader *r, int max) {
129 130 131
  int data = 0, bit = 0, lmax = max;

  while (lmax) {
132
    data |= vp9_read_bit(r) << bit++;
133 134 135 136 137
    lmax >>= 1;
  }
  return data > max ? max : data;
}

John Koleszar's avatar
John Koleszar committed
138 139 140 141 142 143 144 145 146 147 148 149
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;
150 151
}

John Koleszar's avatar
John Koleszar committed
152 153 154
static int inv_remap_prob(int v, int m) {
  const int n = 256;
  const int modulus = MODULUS_PARAM;
155

John Koleszar's avatar
John Koleszar committed
156 157
  v = merge_index(v, n - 1, modulus);
  if ((m << 1) <= n) {
158
    return inv_recenter_nonneg(v + 1, m);
John Koleszar's avatar
John Koleszar committed
159
  } else {
160
    return n - 1 - inv_recenter_nonneg(v + 1, n - 1 - m);
John Koleszar's avatar
John Koleszar committed
161
  }
162
}
163

164 165
static vp9_prob read_prob_diff_update(vp9_reader *r, int oldp) {
  int delp = decode_term_subexp(r, SUBEXP_PARAM, 255);
166
  return (vp9_prob)inv_remap_prob(delp, oldp);
167
}
168

169
void vp9_init_de_quantizer(VP9D_COMP *pbi) {
John Koleszar's avatar
John Koleszar committed
170
  int i;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
171
  int q;
172
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
173

Dmitry Kovalev's avatar
Dmitry Kovalev committed
174
  for (q = 0; q < QINDEX_RANGE; q++) {
175
    // DC value
176 177
    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
178

179
    // AC values
John Koleszar's avatar
John Koleszar committed
180
    for (i = 1; i < 16; i++) {
181
      const int rc = vp9_default_zig_zag1d_4x4[i];
John Koleszar's avatar
John Koleszar committed
182

Dmitry Kovalev's avatar
Dmitry Kovalev committed
183
      pc->y_dequant[q][rc] = (int16_t)vp9_ac_yquant(q);
184
      pc->uv_dequant[q][rc] = (int16_t)vp9_ac_uv_quant(q, pc->uv_ac_delta_q);
John Koleszar's avatar
John Koleszar committed
185
    }
John Koleszar's avatar
John Koleszar committed
186
  }
John Koleszar's avatar
John Koleszar committed
187 188
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
189 190 191
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)) {
192 193 194 195
    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
196 197 198 199 200 201
  } else {
    return base_qindex;
  }
}

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
204
  VP9_COMMON *const pc = &pbi->common;
205 206
  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
207
  mb->q_index = qindex;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
208

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

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
215
  if (mb->lossless) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
216
    assert(qindex == 0);
Yaowu Xu's avatar
Yaowu Xu committed
217 218
    mb->inv_txm4x4_1      = vp9_short_iwalsh4x4_1;
    mb->inv_txm4x4        = vp9_short_iwalsh4x4;
219 220 221
    mb->itxm_add          = vp9_idct_add_lossless_c;
    mb->itxm_add_y_block  = vp9_idct_add_y_block_lossless_c;
    mb->itxm_add_uv_block = vp9_idct_add_uv_block_lossless_c;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
222
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
223 224
    mb->inv_txm4x4_1      = vp9_short_idct4x4_1;
    mb->inv_txm4x4        = vp9_short_idct4x4;
225 226 227
    mb->itxm_add          = vp9_idct_add;
    mb->itxm_add_y_block  = vp9_idct_add_y_block;
    mb->itxm_add_uv_block = vp9_idct_add_uv_block;
John Koleszar's avatar
John Koleszar committed
228
  }
John Koleszar's avatar
John Koleszar committed
229 230
}

231
static void decode_16x16(MACROBLOCKD *xd) {
232
  const TX_TYPE tx_type = get_tx_type_16x16(xd, 0);
233

234 235
  vp9_iht_add_16x16_c(tx_type, xd->plane[0].qcoeff, xd->plane[0].dst.buf,
                      xd->plane[0].dst.stride, xd->plane[0].eobs[0]);
236

237 238
  vp9_idct_add_8x8(xd->plane[1].qcoeff, xd->plane[1].dst.buf,
                   xd->plane[1].dst.stride, xd->plane[1].eobs[0]);
239

240 241
  vp9_idct_add_8x8(xd->plane[2].qcoeff, xd->plane[2].dst.buf,
                   xd->plane[1].dst.stride, xd->plane[2].eobs[0]);
242 243
}

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

270 271
  // chroma
  if (mode == I8X8_PRED) {
272 273 274 275 276
    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;
277

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

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

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

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


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

392 393 394 395
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;
396 397 398
  int n;

  for (n = 0; n < y_count; n++) {
399 400
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> bwl;
401
    const int y_offset = (y_idx * 32) * mb->plane[0].dst.stride + (x_idx * 32);
402 403 404 405
    vp9_idct_add_32x32(BLOCK_OFFSET(mb->plane[0].qcoeff, n, 1024),
                       mb->plane[0].dst.buf + y_offset,
                       mb->plane[0].dst.stride,
                       mb->plane[0].eobs[n * 64]);
406 407 408 409 410 411 412 413 414 415 416
  }
}

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);
417 418
     const int uv_offset = (y_idx * 32) * mb->plane[1].dst.stride +
         (x_idx * 32);
419 420 421 422 423 424 425 426
     vp9_idct_add_32x32(BLOCK_OFFSET(mb->plane[1].qcoeff, n, 1024),
                        mb->plane[1].dst.buf + uv_offset,
                        mb->plane[1].dst.stride,
                        mb->plane[1].eobs[n * 64]);
     vp9_idct_add_32x32(BLOCK_OFFSET(mb->plane[2].qcoeff, n, 1024),
                        mb->plane[2].dst.buf + uv_offset,
                        mb->plane[1].dst.stride,
                        mb->plane[2].eobs[n * 64]);
427 428 429 430 431 432 433 434 435 436 437 438
  }
}

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;
439
    const int y_offset = (y_idx * 16) * mb->plane[0].dst.stride + (x_idx * 16);
440
    const TX_TYPE tx_type = get_tx_type_16x16(mb,
441
                                (y_idx * (4 * bw) + x_idx) * 4);
442 443 444
    vp9_iht_add_16x16_c(tx_type, BLOCK_OFFSET(mb->plane[0].qcoeff, n, 256),
                        mb->plane[0].dst.buf + y_offset,
                        mb->plane[0].dst.stride, mb->plane[0].eobs[n * 16]);
445
  }
446 447 448 449 450 451 452 453 454
}

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);
455 456

  for (n = 0; n < uv_count; n++) {
457 458
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
459
    const int uv_offset = (y_idx * 16) * mb->plane[1].dst.stride + (x_idx * 16);
460 461 462 463 464 465
    vp9_idct_add_16x16(BLOCK_OFFSET(mb->plane[1].qcoeff, n, 256),
                       mb->plane[1].dst.buf + uv_offset,
                       mb->plane[1].dst.stride, mb->plane[1].eobs[n * 16]);
    vp9_idct_add_16x16(BLOCK_OFFSET(mb->plane[2].qcoeff, n, 256),
                       mb->plane[2].dst.buf + uv_offset,
                       mb->plane[1].dst.stride, mb->plane[2].eobs[n * 16]);
466 467 468
  }
}

469 470 471 472
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;
473 474 475 476
  int n;

  // luma
  for (n = 0; n < y_count; n++) {
477 478
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> bwl;
479
    const int y_offset = (y_idx * 8) * xd->plane[0].dst.stride + (x_idx * 8);
480
    const TX_TYPE tx_type = get_tx_type_8x8(xd,
481
                                            (y_idx * (2 * bw) + x_idx) * 2);
482

483 484 485
    vp9_iht_add_8x8_c(tx_type, BLOCK_OFFSET(xd->plane[0].qcoeff, n, 64),
                      xd->plane[0].dst.buf + y_offset, xd->plane[0].dst.stride,
                      xd->plane[0].eobs[n * 4]);
486
  }
487 488 489 490 491 492 493
}

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;
494 495 496

  // chroma
  for (n = 0; n < uv_count; n++) {
497 498
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
499
    const int uv_offset = (y_idx * 8) * xd->plane[1].dst.stride + (x_idx * 8);
500 501 502 503 504 505
    vp9_idct_add_8x8(BLOCK_OFFSET(xd->plane[1].qcoeff, n, 64),
                     xd->plane[1].dst.buf + uv_offset, xd->plane[1].dst.stride,
                     xd->plane[1].eobs[n * 4]);
    vp9_idct_add_8x8(BLOCK_OFFSET(xd->plane[2].qcoeff, n, 64),
                     xd->plane[2].dst.buf + uv_offset, xd->plane[1].dst.stride,
                     xd->plane[2].eobs[n * 4]);
506 507 508
  }
}

509 510 511 512
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;
513 514 515
  int n;

  for (n = 0; n < y_count; n++) {
516 517
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> bwl;
518
    const int y_offset = (y_idx * 4) * xd->plane[0].dst.stride + (x_idx * 4);
519
    const TX_TYPE tx_type = get_tx_type_4x4(xd, n);
520
    if (tx_type == DCT_DCT) {
521
      xd->itxm_add(BLOCK_OFFSET(xd->plane[0].qcoeff, n, 16),
522
                   xd->plane[0].dst.buf + y_offset, xd->plane[0].dst.stride,
John Koleszar's avatar
John Koleszar committed
523
                   xd->plane[0].eobs[n]);
524
    } else {
525 526 527
      vp9_iht_add_c(tx_type, BLOCK_OFFSET(xd->plane[0].qcoeff, n, 16),
                    xd->plane[0].dst.buf + y_offset, xd->plane[0].dst.stride,
                    xd->plane[0].eobs[n]);
528 529
    }
  }
530 531 532 533 534 535 536
}

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;
537 538

  for (n = 0; n < uv_count; n++) {
539 540
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
541
    const int uv_offset = (y_idx * 4) * xd->plane[1].dst.stride + (x_idx * 4);
542
    xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, n, 16),
543 544
        xd->plane[1].dst.buf + uv_offset, xd->plane[1].dst.stride,
        xd->plane[1].eobs[n]);
545
    xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, n, 16),
546 547
        xd->plane[2].dst.buf + uv_offset, xd->plane[1].dst.stride,
        xd->plane[2].eobs[n]);
548 549 550
  }
}

551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
// 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,
570
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
571 572
  const int bwl = mb_width_log2(bsize), bhl = mb_height_log2(bsize);
  const int bw = 1 << bwl, bh = 1 << bhl;
573
  int n, eobtotal;
574
  VP9_COMMON *const pc = &pbi->common;
575
  MODE_INFO *mi = xd->mode_info_context;
576
  const int mis = pc->mode_info_stride;
577

578
  assert(mi->mbmi.sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
579 580

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

583
  // generate prediction
584 585 586
  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
587
  } else {
588
    vp9_build_inter_predictors_sb(xd, mb_row, mb_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
589 590
  }

Yunqing Wang's avatar
Yunqing Wang committed
591 592
  if (mi->mbmi.mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, bsize);
593
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
594 595 596 597 598
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(pbi, xd);

    // dequantization and idct
599
    eobtotal = vp9_decode_tokens(pbi, xd, r, bsize, xd->block[0].dequant);
Yunqing Wang's avatar
Yunqing Wang committed
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624
    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);
      }
625
    }
626
  }
627 628
}

629 630
// TODO(jingning): Need to merge SB and MB decoding. The MB decoding currently
// couples special handles on I8x8, B_PRED, and splitmv modes.
631 632
static void decode_mb(VP9D_COMP *pbi, MACROBLOCKD *xd,
                     int mb_row, int mb_col,
633
                     vp9_reader *r) {
John Koleszar's avatar
John Koleszar committed
634
  int eobtotal = 0;
635 636
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
  const int tx_size = xd->mode_info_context->mbmi.txfm_size;
637

638
  assert(xd->mode_info_context->mbmi.sb_type == BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
639

Deb Mukherjee's avatar
Deb Mukherjee committed
640
  //mode = xd->mode_info_context->mbmi.mode;
641
  if (pbi->common.frame_type != KEY_FRAME)
642
    vp9_setup_interp_filters(xd, xd->mode_info_context->mbmi.interp_filter,
643
                             &pbi->common);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
644

645
  // do prediction
John Koleszar's avatar
John Koleszar committed
646 647
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
    if (mode != I8X8_PRED) {
648
      vp9_build_intra_predictors_sbuv_s(xd, BLOCK_SIZE_MB16X16);
Yaowu Xu's avatar
Yaowu Xu committed
649
      if (mode != I4X4_PRED)
650
        vp9_build_intra_predictors_sby_s(xd, BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
651
    }
John Koleszar's avatar
John Koleszar committed
652
  } else {
653
#if 0  // def DEC_DEBUG
654 655 656 657 658
  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
659
    vp9_build_inter_predictors_sb(xd, mb_row, mb_col, BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
660 661
  }

Yunqing Wang's avatar
Yunqing Wang committed
662 663
  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, BLOCK_SIZE_MB16X16);
664
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
665 666 667 668
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(pbi, xd);

669
    if (!vp9_reader_has_error(r)) {
Yunqing Wang's avatar
Yunqing Wang committed
670 671 672
#if CONFIG_NEWBINTRAMODES
    if (mode != I4X4_PRED)
#endif
673 674
      eobtotal = vp9_decode_tokens(pbi, xd, r, BLOCK_SIZE_MB16X16,
                                   xd->block[0].dequant);
Yunqing Wang's avatar
Yunqing Wang committed
675 676 677 678 679 680 681
    }
  }

  if (eobtotal == 0 &&
      mode != I4X4_PRED &&
      mode != SPLITMV &&
      mode != I8X8_PRED &&
682
      !vp9_reader_has_error(r)) {
Yunqing Wang's avatar
Yunqing Wang committed
683 684 685 686 687 688 689 690
    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) {
691
      decode_16x16(xd);
Yunqing Wang's avatar
Yunqing Wang committed
692
    } else if (tx_size == TX_8X8) {
693
      decode_8x8(xd);
Yunqing Wang's avatar
Yunqing Wang committed
694
    } else {
695
      decode_4x4(pbi, xd, r);
Yunqing Wang's avatar
Yunqing Wang committed
696
    }
697
  }
Yunqing Wang's avatar
Yunqing Wang committed
698

699 700 701 702
#ifdef DEC_DEBUG
  if (dec_debug) {
    int i, j;
    printf("\n");
703 704 705 706 707 708 709
    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");
710
    printf("final y\n");
John Koleszar's avatar
John Koleszar committed
711
    for (i = 0; i < 16; i++) {
712
      for (j = 0; j < 16; j++)
713
        printf("%3d ", xd->plane[0].dst.buf[i * xd->plane[0].dst.stride + j]);
714
      printf("\n");
John Koleszar's avatar
John Koleszar committed
715
    }
716 717 718 719
    printf("\n");
    printf("final u\n");
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++)
720
        printf("%3d ", xd->plane[1].dst.buf[i * xd->plane[1].dst.stride + j]);
721
      printf("\n");
722
    }
723 724 725 726
    printf("\n");
    printf("final v\n");
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++)
727
        printf("%3d ", xd->plane[2].dst.buf[i * xd->plane[1].dst.stride + j]);
728
      printf("\n");
729
    }
730
    fflush(stdout);
John Koleszar's avatar
John Koleszar committed
731
  }
732
#endif
Yaowu Xu's avatar
Yaowu Xu committed
733
}
John Koleszar's avatar
John Koleszar committed
734

735 736 737 738
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
739 740
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
741
  }
John Koleszar's avatar
John Koleszar committed
742

743
  // Trigger a quantizer update if the delta-q value has changed
744
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
745 746
}

747
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
748
                        int mb_row, int mb_col) {
749 750
  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
751 752
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
753

754 755 756 757 758 759
  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;
760
  xd->mode_info_context->mbmi.sb_type = bsize;
761 762 763
  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;
764 765
  xd->above_seg_context = cm->above_seg_context + mb_col;
  xd->left_seg_context  = cm->left_seg_context + (mb_row & 3);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
766

767 768
  // 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
769
  set_mb_row_col(cm, xd, mb_row, bh, mb_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
770

771 772 773
  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
774
}
John Koleszar's avatar
John Koleszar committed
775

776
static void set_refs(VP9D_COMP *pbi, int mb_row, int mb_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
777 778
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
779
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
780 781

  if (mbmi->ref_frame > INTRA_FRAME) {
782
    // Select the appropriate reference frame for this MB
783 784 785
    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];
786
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
787 788
    setup_pre_planes(xd, cfg, NULL, mb_row, mb_col,
                     xd->scale_factor, xd->scale_factor_uv);
789
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
790

Ronald S. Bultje's avatar
Ronald S. Bultje committed
791
    if (mbmi->second_ref_frame > INTRA_FRAME) {
792
      // Select the appropriate reference frame for this MB
793 794
      const int second_fb_idx = cm->