vp9_decodframe.c 57.9 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 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
#if CONFIG_CODE_NONZEROCOUNT
static void propagate_nzcs(VP9_COMMON *cm, MACROBLOCKD *xd) {
  MODE_INFO *m = xd->mode_info_context;
  BLOCK_SIZE_TYPE sb_type = m->mbmi.sb_type;
  const int mis = cm->mode_info_stride;
  int n;
  if (sb_type == BLOCK_SIZE_SB64X64) {
    for (n = 0; n < 16; ++n) {
      int i = n >> 2;
      int j = n & 3;
      if (i == 0 && j == 0) continue;
      vpx_memcpy((m + j + mis * i)->mbmi.nzcs, m->mbmi.nzcs,
                 384 * sizeof(m->mbmi.nzcs[0]));
    }
  } else if (sb_type == BLOCK_SIZE_SB32X32) {
    for (n = 0; n < 4; ++n) {
      int i = n >> 1;
      int j = n & 1;
      if (i == 0 && j == 0) continue;
      vpx_memcpy((m + j + mis * i)->mbmi.nzcs, m->mbmi.nzcs,
                 384 * sizeof(m->mbmi.nzcs[0]));
    }
  }
}
#endif

249
static void decode_16x16(MACROBLOCKD *xd) {
250
  const TX_TYPE tx_type = get_tx_type_16x16(xd, 0);
251

252 253 254
  vp9_dequant_iht_add_16x16_c(tx_type, xd->plane[0].qcoeff,
                              xd->block[0].dequant, xd->dst.y_buffer,
                              xd->dst.y_stride, xd->plane[0].eobs[0]);
255 256

  vp9_dequant_idct_add_8x8(xd->plane[1].qcoeff, xd->block[16].dequant,
257
                           xd->dst.u_buffer, xd->dst.uv_stride,
258
                           xd->plane[1].eobs[0]);
259

Dmitry Kovalev's avatar
Dmitry Kovalev committed
260
  vp9_dequant_idct_add_8x8(xd->plane[2].qcoeff, xd->block[20].dequant,
261
                           xd->dst.v_buffer, xd->dst.uv_stride,
262
                           xd->plane[2].eobs[0]);
263 264
}

265
static void decode_8x8(MACROBLOCKD *xd) {
266 267
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
  // luma
268
  // if the first one is DCT_DCT assume all the rest are as well
269
  TX_TYPE tx_type = get_tx_type_8x8(xd, 0);
270
  if (tx_type != DCT_DCT || mode == I8X8_PRED) {
271 272 273 274
    int i;
    for (i = 0; i < 4; i++) {
      int ib = vp9_i8x8_block[i];
      int idx = (ib & 0x02) ? (ib + 2) : ib;
275
      int16_t *q  = BLOCK_OFFSET(xd->plane[0].qcoeff, idx, 16);
276 277
      int16_t *dq = xd->block[0].dequant;
      uint8_t *dst = *(xd->block[ib].base_dst) + xd->block[ib].dst;
278
      int stride = xd->dst.y_stride;
279
      if (mode == I8X8_PRED) {
280
        BLOCKD *b = &xd->block[ib];
281
        int i8x8mode = b->bmi.as_mode.first;
282
        vp9_intra8x8_predict(xd, b, i8x8mode, dst, stride);
283
      }
284
      tx_type = get_tx_type_8x8(xd, ib);
285 286
      vp9_dequant_iht_add_8x8_c(tx_type, q, dq, dst, stride,
                                xd->plane[0].eobs[idx]);
287
    }
288
  } else {
289
    vp9_dequant_idct_add_y_block_8x8(xd->plane[0].qcoeff,
290 291
                                     xd->block[0].dequant, xd->dst.y_buffer,
                                     xd->dst.y_stride, xd);
292 293
  }

294 295
  // chroma
  if (mode == I8X8_PRED) {
296 297 298 299 300
    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;
301

302
      b = &xd->block[16 + i];
303 304
      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                              b->dst_stride);
305
      xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
306
                   b->dequant, *(b->base_dst) + b->dst, b->dst_stride,
John Koleszar's avatar
John Koleszar committed
307
                   xd->plane[1].eobs[i]);
308

309
      b = &xd->block[20 + i];
310 311
      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                              b->dst_stride);
312
      xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
313
                   b->dequant, *(b->base_dst) + b->dst, b->dst_stride,
John Koleszar's avatar
John Koleszar committed
314
                   xd->plane[2].eobs[i]);
315
    }
316
  } else if (mode == SPLITMV) {
317
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
318
         xd->dst.u_buffer, xd->dst.uv_stride, xd->plane[1].eobs);
319
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
320
         xd->dst.v_buffer, xd->dst.uv_stride, xd->plane[2].eobs);
321
  } else {
322
    vp9_dequant_idct_add_8x8(xd->plane[1].qcoeff, xd->block[16].dequant,
323
                             xd->dst.u_buffer, xd->dst.uv_stride,
324
                             xd->plane[1].eobs[0]);
325 326

    vp9_dequant_idct_add_8x8(xd->plane[2].qcoeff, xd->block[16].dequant,
327
                             xd->dst.v_buffer, xd->dst.uv_stride,
328
                             xd->plane[2].eobs[0]);
329 330 331
  }
}

332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
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]);
  }
}


348
static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd, vp9_reader *r) {
349
  TX_TYPE tx_type;
350
  int i = 0;
351
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
352 353 354 355 356
  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
357 358
      BLOCKD *b = &xd->block[ib];
      int i8x8mode = b->bmi.as_mode.first;
359 360
      vp9_intra8x8_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                           b->dst_stride);
361
      for (j = 0; j < 4; j++) {
362
        tx_type = get_tx_type_4x4(xd, ib + iblock[j]);
363
        dequant_add_y(xd, tx_type, ib + iblock[j]);
364 365
      }
      b = &xd->block[16 + i];
366 367
      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                              b->dst_stride);
368
      xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
369
                   b->dequant, *(b->base_dst) + b->dst, b->dst_stride,
John Koleszar's avatar
John Koleszar committed
370
                   xd->plane[1].eobs[i]);
371
      b = &xd->block[20 + i];
372 373
      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                              b->dst_stride);
374
      xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
375
                   b->dequant, *(b->base_dst) + b->dst, b->dst_stride,
John Koleszar's avatar
John Koleszar committed
376
                   xd->plane[2].eobs[i]);
377
    }
Yaowu Xu's avatar
Yaowu Xu committed
378
  } else if (mode == I4X4_PRED) {
379 380
    for (i = 0; i < 16; i++) {
      BLOCKD *b = &xd->block[i];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
381
      int b_mode = xd->mode_info_context->bmi[i].as_mode.first;
382 383
#if CONFIG_NEWBINTRAMODES
      xd->mode_info_context->bmi[i].as_mode.context = b->bmi.as_mode.context =
384
          vp9_find_bpred_context(xd, b);
385
      if (!xd->mode_info_context->mbmi.mb_skip_coeff)
386
        vp9_decode_coefs_4x4(pbi, xd, r, PLANE_TYPE_Y_WITH_DC, i);
387
#endif
388 389
      vp9_intra4x4_predict(xd, b, b_mode, *(b->base_dst) + b->dst,
                           b->dst_stride);
390
      tx_type = get_tx_type_4x4(xd, i);
391
      dequant_add_y(xd, tx_type, i);
392
    }
393 394
#if CONFIG_NEWBINTRAMODES
    if (!xd->mode_info_context->mbmi.mb_skip_coeff)
395
      vp9_decode_mb_tokens_4x4_uv(pbi, xd, r);
396
#endif
397
    vp9_build_intra_predictors_sbuv_s(xd, BLOCK_SIZE_MB16X16);
398
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
399
         xd->dst.u_buffer, xd->dst.uv_stride, xd->plane[1].eobs);
400
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
401
         xd->dst.v_buffer, xd->dst.uv_stride, xd->plane[2].eobs);
402
  } else if (mode == SPLITMV || get_tx_type_4x4(xd, 0) == DCT_DCT) {
403
    xd->itxm_add_y_block(xd->plane[0].qcoeff,
404
                          xd->block[0].dequant,
405
                          xd->dst.y_buffer, xd->dst.y_stride, xd);
406
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
407
         xd->dst.u_buffer, xd->dst.uv_stride, xd->plane[1].eobs);
408
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
409
         xd->dst.v_buffer, xd->dst.uv_stride, xd->plane[2].eobs);
410
  } else {
411
    for (i = 0; i < 16; i++) {
412
      tx_type = get_tx_type_4x4(xd, i);
413
      dequant_add_y(xd, tx_type, i);
414
    }
415
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
416 417
                          xd->dst.u_buffer, xd->dst.uv_stride,
                          xd->plane[1].eobs);
418
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
419 420
                          xd->dst.v_buffer, xd->dst.uv_stride,
                          xd->plane[2].eobs);
421 422 423
  }
}

424 425 426 427
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;
428 429 430
  int n;

  for (n = 0; n < y_count; n++) {
431 432 433 434 435
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> bwl;
    const int y_offset = (y_idx * 32) * mb->dst.y_stride + (x_idx * 32);
    vp9_dequant_idct_add_32x32(BLOCK_OFFSET(mb->plane[0].qcoeff, n, 1024),
                               mb->block[0].dequant ,
436
                               mb->dst.y_buffer + y_offset, mb->dst.y_stride,
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
                               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);
     const int uv_offset = (y_idx * 32) * mb->dst.uv_stride + (x_idx * 32);
     vp9_dequant_idct_add_32x32(BLOCK_OFFSET(mb->plane[1].qcoeff, n, 1024),
                                mb->block[16].dequant,
                                mb->dst.u_buffer + uv_offset,
453
                                mb->dst.uv_stride, mb->plane[1].eobs[n * 64]);
454 455 456
     vp9_dequant_idct_add_32x32(BLOCK_OFFSET(mb->plane[2].qcoeff, n, 1024),
                                mb->block[20].dequant,
                                mb->dst.v_buffer + uv_offset,
457
                                mb->dst.uv_stride, mb->plane[2].eobs[n * 64]);
458 459 460 461 462 463 464 465 466 467 468 469
  }
}

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;
470
    const int y_offset = (y_idx * 16) * mb->dst.y_stride + (x_idx * 16);
471
    const TX_TYPE tx_type = get_tx_type_16x16(mb,
472
                                (y_idx * (4 * bw) + x_idx) * 4);
473 474 475 476 477 478
    vp9_dequant_iht_add_16x16_c(tx_type,
                                BLOCK_OFFSET(mb->plane[0].qcoeff, n, 256),
                                mb->block[0].dequant,
                                mb->dst.y_buffer + y_offset,
                                mb->dst.y_stride,
                                mb->plane[0].eobs[n * 16]);
479
  }
480 481 482 483 484 485 486 487 488
}

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);
489 490

  for (n = 0; n < uv_count; n++) {
491 492
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
493
    const int uv_offset = (y_idx * 16) * mb->dst.uv_stride + (x_idx * 16);
494
    vp9_dequant_idct_add_16x16(BLOCK_OFFSET(mb->plane[1].qcoeff, n, 256),
495
                               mb->block[16].dequant,
496
                               mb->dst.u_buffer + uv_offset, mb->dst.uv_stride,
John Koleszar's avatar
John Koleszar committed
497
                               mb->plane[1].eobs[n * 16]);
498
    vp9_dequant_idct_add_16x16(BLOCK_OFFSET(mb->plane[2].qcoeff, n, 256),
499
                               mb->block[20].dequant,
500
                               mb->dst.v_buffer + uv_offset, mb->dst.uv_stride,
John Koleszar's avatar
John Koleszar committed
501
                               mb->plane[2].eobs[n * 16]);
502 503 504
  }
}

505 506 507 508
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;
509 510 511 512
  int n;

  // luma
  for (n = 0; n < y_count; n++) {
513 514
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> bwl;
515 516
    const int y_offset = (y_idx * 8) * xd->dst.y_stride + (x_idx * 8);
    const TX_TYPE tx_type = get_tx_type_8x8(xd,
517
                                            (y_idx * (2 * bw) + x_idx) * 2);
518 519 520 521 522 523

    vp9_dequant_iht_add_8x8_c(tx_type,
                              BLOCK_OFFSET(xd->plane[0].qcoeff, n, 64),
                              xd->block[0].dequant,
                              xd->dst.y_buffer + y_offset, xd->dst.y_stride,
                              xd->plane[0].eobs[n * 4]);
524
  }
525 526 527 528 529 530 531
}

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;
532 533 534

  // chroma
  for (n = 0; n < uv_count; n++) {
535 536
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
537
    const int uv_offset = (y_idx * 8) * xd->dst.uv_stride + (x_idx * 8);
538 539 540 541 542 543 544 545
    vp9_dequant_idct_add_8x8(BLOCK_OFFSET(xd->plane[1].qcoeff, n, 64),
                             xd->block[16].dequant,
                             xd->dst.u_buffer + uv_offset, xd->dst.uv_stride,
                             xd->plane[1].eobs[n * 4]);
    vp9_dequant_idct_add_8x8(BLOCK_OFFSET(xd->plane[2].qcoeff, n, 64),
                             xd->block[20].dequant,
                             xd->dst.v_buffer + uv_offset, xd->dst.uv_stride,
                             xd->plane[2].eobs[n * 4]);
546 547 548
  }
}

549 550 551 552
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;
553 554 555
  int n;

  for (n = 0; n < y_count; n++) {
556 557
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> bwl;
558
    const int y_offset = (y_idx * 4) * xd->dst.y_stride + (x_idx * 4);
559
    const TX_TYPE tx_type = get_tx_type_4x4(xd, n);
560
    if (tx_type == DCT_DCT) {
561 562
      xd->itxm_add(BLOCK_OFFSET(xd->plane[0].qcoeff, n, 16),
                   xd->block[0].dequant,
563
                   xd->dst.y_buffer + y_offset, xd->dst.y_stride,
John Koleszar's avatar
John Koleszar committed
564
                   xd->plane[0].eobs[n]);
565
    } else {
566 567
      vp9_dequant_iht_add_c(tx_type,
                            BLOCK_OFFSET(xd->plane[0].qcoeff, n, 16),
568 569
                            xd->block[0].dequant, xd->dst.y_buffer + y_offset,
                            xd->dst.y_stride, xd->plane[0].eobs[n]);
570 571
    }
  }
572 573 574 575 576 577 578
}

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;
579 580

  for (n = 0; n < uv_count; n++) {
581 582
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
583 584 585
    const int uv_offset = (y_idx * 4) * xd->dst.uv_stride + (x_idx * 4);
    xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, n, 16),
        xd->block[16].dequant,
586
        xd->dst.u_buffer + uv_offset, xd->dst.uv_stride, xd->plane[1].eobs[n]);
587 588
    xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, n, 16),
        xd->block[20].dequant,
589
        xd->dst.v_buffer + uv_offset, xd->dst.uv_stride, xd->plane[2].eobs[n]);
590 591 592
  }
}

593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
// 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,
612
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
613 614
  const int bwl = mb_width_log2(bsize), bhl = mb_height_log2(bsize);
  const int bw = 1 << bwl, bh = 1 << bhl;
615
  int n, eobtotal;
616
  VP9_COMMON *const pc = &pbi->common;
617
  MODE_INFO *mi = xd->mode_info_context;
618
  const int mis = pc->mode_info_stride;
619

620
  assert(mi->mbmi.sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
621 622

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

625
  // generate prediction
626 627 628
  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
629
  } else {
630
    vp9_build_inter_predictors_sb(xd, mb_row, mb_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
631 632
  }

Yunqing Wang's avatar
Yunqing Wang committed
633 634 635 636 637
  if (mi->mbmi.mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, bsize);
#if CONFIG_CODE_NONZEROCOUNT
    vpx_memset(mi->mbmi.nzcs, 0, 384 * sizeof(mi->mbmi.nzcs[0]));
#endif
638
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
639 640 641 642 643
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(pbi, xd);

    // dequantization and idct
644
    eobtotal = vp9_decode_tokens(pbi, xd, r, bsize);
Yunqing Wang's avatar
Yunqing Wang committed
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
    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);
      }
670
    }
671
  }
Yunqing Wang's avatar
Yunqing Wang committed
672

673 674 675
#if CONFIG_CODE_NONZEROCOUNT
  propagate_nzcs(&pbi->common, xd);
#endif
676 677
}

678 679
// TODO(jingning): Need to merge SB and MB decoding. The MB decoding currently
// couples special handles on I8x8, B_PRED, and splitmv modes.
680 681
static void decode_mb(VP9D_COMP *pbi, MACROBLOCKD *xd,
                     int mb_row, int mb_col,
682
                     vp9_reader *r) {
John Koleszar's avatar
John Koleszar committed
683
  int eobtotal = 0;
684 685
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
  const int tx_size = xd->mode_info_context->mbmi.txfm_size;
686

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

Deb Mukherjee's avatar
Deb Mukherjee committed
689
  //mode = xd->mode_info_context->mbmi.mode;
690
  if (pbi->common.frame_type != KEY_FRAME)
691
    vp9_setup_interp_filters(xd, xd->mode_info_context->mbmi.interp_filter,
692
                             &pbi->common);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
693

694
  // do prediction
John Koleszar's avatar
John Koleszar committed
695 696
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
    if (mode != I8X8_PRED) {
697
      vp9_build_intra_predictors_sbuv_s(xd, BLOCK_SIZE_MB16X16);
Yaowu Xu's avatar
Yaowu Xu committed
698
      if (mode != I4X4_PRED)
699
        vp9_build_intra_predictors_sby_s(xd, BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
700
    }
John Koleszar's avatar
John Koleszar committed
701
  } else {
702
#if 0  // def DEC_DEBUG
703 704 705 706 707
  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
708
    vp9_build_inter_predictors_mb(xd, mb_row, mb_col);
John Koleszar's avatar
John Koleszar committed
709 710
  }

Yunqing Wang's avatar
Yunqing Wang committed
711 712
  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, BLOCK_SIZE_MB16X16);
713
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
714 715 716 717
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(pbi, xd);

718
    if (!vp9_reader_has_error(r)) {
Yunqing Wang's avatar
Yunqing Wang committed
719 720 721
#if CONFIG_NEWBINTRAMODES
    if (mode != I4X4_PRED)
#endif
722
      eobtotal = vp9_decode_tokens(pbi, xd, r, BLOCK_SIZE_MB16X16);
Yunqing Wang's avatar
Yunqing Wang committed
723 724 725 726 727 728 729
    }
  }

  if (eobtotal == 0 &&
      mode != I4X4_PRED &&
      mode != SPLITMV &&
      mode != I8X8_PRED &&
730
      !vp9_reader_has_error(r)) {
Yunqing Wang's avatar
Yunqing Wang committed
731 732 733 734 735 736 737 738
    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) {
739
      decode_16x16(xd);
Yunqing Wang's avatar
Yunqing Wang committed
740
    } else if (tx_size == TX_8X8) {
741
      decode_8x8(xd);
Yunqing Wang's avatar
Yunqing Wang committed
742
    } else {
743
      decode_4x4(pbi, xd, r);
Yunqing Wang's avatar
Yunqing Wang committed
744
    }
745
  }
Yunqing Wang's avatar
Yunqing Wang committed
746

747 748 749 750
#ifdef DEC_DEBUG
  if (dec_debug) {
    int i, j;
    printf("\n");
751 752 753 754 755 756 757
    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");
758
    printf("final y\n");
John Koleszar's avatar
John Koleszar committed
759
    for (i = 0; i < 16; i++) {
760 761 762
      for (j = 0; j < 16; j++)
        printf("%3d ", xd->dst.y_buffer[i * xd->dst.y_stride + j]);
      printf("\n");
John Koleszar's avatar
John Koleszar committed
763
    }
764 765 766 767 768 769
    printf("\n");
    printf("final u\n");
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++)
        printf("%3d ", xd->dst.u_buffer[i * xd->dst.uv_stride + j]);
      printf("\n");
770
    }
771 772 773 774 775 776
    printf("\n");
    printf("final v\n");
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++)
        printf("%3d ", xd->dst.v_buffer[i * xd->dst.uv_stride + j]);
      printf("\n");
777
    }
778
    fflush(stdout);
John Koleszar's avatar
John Koleszar committed
779
  }
780
#endif
Yaowu Xu's avatar
Yaowu Xu committed
781
}
John Koleszar's avatar
John Koleszar committed
782

783 784 785 786
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
787 788
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
789
  }
John Koleszar's avatar
John Koleszar committed
790