vp9_decodframe.c 57.6 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;
}

John Koleszar's avatar
John Koleszar committed
68 69 70 71 72 73 74 75 76 77 78 79
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;
80 81
}

John Koleszar's avatar
John Koleszar committed
82 83 84
static int inv_remap_prob(int v, int m) {
  const int n = 256;
  const int modulus = MODULUS_PARAM;
85

John Koleszar's avatar
John Koleszar committed
86 87
  v = merge_index(v, n - 1, modulus);
  if ((m << 1) <= n) {
88
    return vp9_inv_recenter_nonneg(v + 1, m);
John Koleszar's avatar
John Koleszar committed
89
  } else {
90
    return n - 1 - vp9_inv_recenter_nonneg(v + 1, n - 1 - m);
John Koleszar's avatar
John Koleszar committed
91
  }
92
}
93

94
static vp9_prob read_prob_diff_update(vp9_reader *const bc, int oldp) {
95
  int delp = vp9_decode_term_subexp(bc, SUBEXP_PARAM, 255);
96
  return (vp9_prob)inv_remap_prob(delp, oldp);
97
}
98

99
void vp9_init_de_quantizer(VP9D_COMP *pbi) {
John Koleszar's avatar
John Koleszar committed
100
  int i;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
101
  int q;
102
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
103

Dmitry Kovalev's avatar
Dmitry Kovalev committed
104
  for (q = 0; q < QINDEX_RANGE; q++) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
105 106
    pc->y_dequant[q][0] = (int16_t)vp9_dc_quant(q, pc->y1dc_delta_q);
    pc->uv_dequant[q][0] = (int16_t)vp9_dc_uv_quant(q, pc->uvdc_delta_q);
John Koleszar's avatar
John Koleszar committed
107 108 109

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
112 113
      pc->y_dequant[q][rc] = (int16_t)vp9_ac_yquant(q);
      pc->uv_dequant[q][rc] = (int16_t)vp9_ac_uv_quant(q, pc->uvac_delta_q);
John Koleszar's avatar
John Koleszar committed
114
    }
John Koleszar's avatar
John Koleszar committed
115
  }
John Koleszar's avatar
John Koleszar committed
116 117
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
118 119 120
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)) {
121 122 123 124
    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
125 126 127 128 129 130
  } else {
    return base_qindex;
  }
}

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
133
  VP9_COMMON *const pc = &pbi->common;
134 135
  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
136
  mb->q_index = qindex;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
137

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

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
144
  if (mb->lossless) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
145
    assert(qindex == 0);
Yaowu Xu's avatar
Yaowu Xu committed
146 147
    mb->inv_txm4x4_1      = vp9_short_iwalsh4x4_1;
    mb->inv_txm4x4        = vp9_short_iwalsh4x4;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
148 149 150 151
    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
152 153
    mb->inv_txm4x4_1      = vp9_short_idct4x4_1;
    mb->inv_txm4x4        = vp9_short_idct4x4;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
154 155 156
    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
157
  }
John Koleszar's avatar
John Koleszar committed
158 159
}

160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
#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

186 187
static void decode_16x16(VP9D_COMP *pbi, MACROBLOCKD *xd,
                         BOOL_DECODER* const bc) {
188
  const TX_TYPE tx_type = get_tx_type_16x16(xd, 0);
189

190 191 192
  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]);
193 194

  vp9_dequant_idct_add_8x8(xd->plane[1].qcoeff, xd->block[16].dequant,
195
                           xd->dst.u_buffer, xd->dst.uv_stride,
196
                           xd->plane[1].eobs[0]);
197

Dmitry Kovalev's avatar
Dmitry Kovalev committed
198
  vp9_dequant_idct_add_8x8(xd->plane[2].qcoeff, xd->block[20].dequant,
199
                           xd->dst.v_buffer, xd->dst.uv_stride,
200
                           xd->plane[2].eobs[0]);
201 202 203 204
}

static void decode_8x8(VP9D_COMP *pbi, MACROBLOCKD *xd,
                       BOOL_DECODER* const bc) {
205 206
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
  // luma
207
  // if the first one is DCT_DCT assume all the rest are as well
208
  TX_TYPE tx_type = get_tx_type_8x8(xd, 0);
209
  if (tx_type != DCT_DCT || mode == I8X8_PRED) {
210 211 212 213
    int i;
    for (i = 0; i < 4; i++) {
      int ib = vp9_i8x8_block[i];
      int idx = (ib & 0x02) ? (ib + 2) : ib;
214
      int16_t *q  = BLOCK_OFFSET(xd->plane[0].qcoeff, idx, 16);
215 216
      int16_t *dq = xd->block[0].dequant;
      uint8_t *dst = *(xd->block[ib].base_dst) + xd->block[ib].dst;
217
      int stride = xd->dst.y_stride;
218
      if (mode == I8X8_PRED) {
219
        BLOCKD *b = &xd->block[ib];
220
        int i8x8mode = b->bmi.as_mode.first;
221
        vp9_intra8x8_predict(xd, b, i8x8mode, dst, stride);
222
      }
223
      tx_type = get_tx_type_8x8(xd, ib);
224 225
      vp9_dequant_iht_add_8x8_c(tx_type, q, dq, dst, stride,
                                xd->plane[0].eobs[idx]);
226
    }
227
  } else {
228
    vp9_dequant_idct_add_y_block_8x8(xd->plane[0].qcoeff,
229 230
                                     xd->block[0].dequant, xd->dst.y_buffer,
                                     xd->dst.y_stride, xd);
231 232
  }

233 234
  // chroma
  if (mode == I8X8_PRED) {
235 236 237 238 239
    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;
240

241
      b = &xd->block[16 + i];
242 243
      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                              b->dst_stride);
244
      xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
245
                   b->dequant, *(b->base_dst) + b->dst, b->dst_stride,
John Koleszar's avatar
John Koleszar committed
246
                   xd->plane[1].eobs[i]);
247

248
      b = &xd->block[20 + i];
249 250
      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                              b->dst_stride);
251
      xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
252
                   b->dequant, *(b->base_dst) + b->dst, b->dst_stride,
John Koleszar's avatar
John Koleszar committed
253
                   xd->plane[2].eobs[i]);
254
    }
255
  } else if (mode == SPLITMV) {
256
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
257
         xd->dst.u_buffer, xd->dst.uv_stride, xd->plane[1].eobs);
258
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
259
         xd->dst.v_buffer, xd->dst.uv_stride, xd->plane[2].eobs);
260
  } else {
261
    vp9_dequant_idct_add_8x8(xd->plane[1].qcoeff, xd->block[16].dequant,
262
                             xd->dst.u_buffer, xd->dst.uv_stride,
263
                             xd->plane[1].eobs[0]);
264 265

    vp9_dequant_idct_add_8x8(xd->plane[2].qcoeff, xd->block[16].dequant,
266
                             xd->dst.v_buffer, xd->dst.uv_stride,
267
                             xd->plane[2].eobs[0]);
268 269 270
  }
}

271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
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]);
  }
}


287 288 289
static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd,
                       BOOL_DECODER* const bc) {
  TX_TYPE tx_type;
290
  int i = 0;
291
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
292 293 294 295 296
  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
297 298
      BLOCKD *b = &xd->block[ib];
      int i8x8mode = b->bmi.as_mode.first;
299 300
      vp9_intra8x8_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                           b->dst_stride);
301
      for (j = 0; j < 4; j++) {
302
        tx_type = get_tx_type_4x4(xd, ib + iblock[j]);
303
        dequant_add_y(xd, tx_type, ib + iblock[j]);
304 305
      }
      b = &xd->block[16 + i];
306 307
      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                              b->dst_stride);
308
      xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
309
                   b->dequant, *(b->base_dst) + b->dst, b->dst_stride,
John Koleszar's avatar
John Koleszar committed
310
                   xd->plane[1].eobs[i]);
311
      b = &xd->block[20 + i];
312 313
      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
                              b->dst_stride);
314
      xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
315
                   b->dequant, *(b->base_dst) + b->dst, b->dst_stride,
John Koleszar's avatar
John Koleszar committed
316
                   xd->plane[2].eobs[i]);
317
    }
Yaowu Xu's avatar
Yaowu Xu committed
318
  } else if (mode == I4X4_PRED) {
319 320
    for (i = 0; i < 16; i++) {
      BLOCKD *b = &xd->block[i];
Dmitry Kovalev's avatar
Dmitry Kovalev committed
321
      int b_mode = xd->mode_info_context->bmi[i].as_mode.first;
322 323
#if CONFIG_NEWBINTRAMODES
      xd->mode_info_context->bmi[i].as_mode.context = b->bmi.as_mode.context =
324
          vp9_find_bpred_context(xd, b);
325 326
      if (!xd->mode_info_context->mbmi.mb_skip_coeff)
        vp9_decode_coefs_4x4(pbi, xd, bc, PLANE_TYPE_Y_WITH_DC, i);
327
#endif
328 329
      vp9_intra4x4_predict(xd, b, b_mode, *(b->base_dst) + b->dst,
                           b->dst_stride);
330
      tx_type = get_tx_type_4x4(xd, i);
331
      dequant_add_y(xd, tx_type, i);
332
    }
333 334 335 336
#if CONFIG_NEWBINTRAMODES
    if (!xd->mode_info_context->mbmi.mb_skip_coeff)
      vp9_decode_mb_tokens_4x4_uv(pbi, xd, bc);
#endif
337
    vp9_build_intra_predictors_sbuv_s(xd, BLOCK_SIZE_MB16X16);
338
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
339
         xd->dst.u_buffer, xd->dst.uv_stride, xd->plane[1].eobs);
340
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
341
         xd->dst.v_buffer, xd->dst.uv_stride, xd->plane[2].eobs);
342
  } else if (mode == SPLITMV || get_tx_type_4x4(xd, 0) == DCT_DCT) {
343
    xd->itxm_add_y_block(xd->plane[0].qcoeff,
344
                          xd->block[0].dequant,
345
                          xd->dst.y_buffer, xd->dst.y_stride, xd);
346
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
347
         xd->dst.u_buffer, xd->dst.uv_stride, xd->plane[1].eobs);
348
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
349
         xd->dst.v_buffer, xd->dst.uv_stride, xd->plane[2].eobs);
350
  } else {
351
    for (i = 0; i < 16; i++) {
352
      tx_type = get_tx_type_4x4(xd, i);
353
      dequant_add_y(xd, tx_type, i);
354
    }
355
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
356 357
                          xd->dst.u_buffer, xd->dst.uv_stride,
                          xd->plane[1].eobs);
358
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
359 360
                          xd->dst.v_buffer, xd->dst.uv_stride,
                          xd->plane[2].eobs);
361 362 363
  }
}

364 365 366 367
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;
368 369 370
  int n;

  for (n = 0; n < y_count; n++) {
371 372 373 374 375
    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 ,
376
                               mb->dst.y_buffer + y_offset, mb->dst.y_stride,
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
                               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,
393
                                mb->dst.uv_stride, mb->plane[1].eobs[n * 64]);
394 395 396
     vp9_dequant_idct_add_32x32(BLOCK_OFFSET(mb->plane[2].qcoeff, n, 1024),
                                mb->block[20].dequant,
                                mb->dst.v_buffer + uv_offset,
397
                                mb->dst.uv_stride, mb->plane[2].eobs[n * 64]);
398 399 400 401 402 403 404 405 406 407 408 409
  }
}

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;
410
    const int y_offset = (y_idx * 16) * mb->dst.y_stride + (x_idx * 16);
411
    const TX_TYPE tx_type = get_tx_type_16x16(mb,
412
                                (y_idx * (4 * bw) + x_idx) * 4);
413 414 415 416 417 418
    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]);
419
  }
420 421 422 423 424 425 426 427 428
}

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);
429 430

  for (n = 0; n < uv_count; n++) {
431 432
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
433
    const int uv_offset = (y_idx * 16) * mb->dst.uv_stride + (x_idx * 16);
434
    vp9_dequant_idct_add_16x16(BLOCK_OFFSET(mb->plane[1].qcoeff, n, 256),
435
                               mb->block[16].dequant,
436
                               mb->dst.u_buffer + uv_offset, mb->dst.uv_stride,
John Koleszar's avatar
John Koleszar committed
437
                               mb->plane[1].eobs[n * 16]);
438
    vp9_dequant_idct_add_16x16(BLOCK_OFFSET(mb->plane[2].qcoeff, n, 256),
439
                               mb->block[20].dequant,
440
                               mb->dst.v_buffer + uv_offset, mb->dst.uv_stride,
John Koleszar's avatar
John Koleszar committed
441
                               mb->plane[2].eobs[n * 16]);
442 443 444
  }
}

445 446 447 448
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;
449 450 451 452
  int n;

  // luma
  for (n = 0; n < y_count; n++) {
453 454
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> bwl;
455 456
    const int y_offset = (y_idx * 8) * xd->dst.y_stride + (x_idx * 8);
    const TX_TYPE tx_type = get_tx_type_8x8(xd,
457
                                            (y_idx * (2 * bw) + x_idx) * 2);
458 459 460 461 462 463

    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]);
464
  }
465 466 467 468 469 470 471
}

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;
472 473 474

  // chroma
  for (n = 0; n < uv_count; n++) {
475 476
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
477
    const int uv_offset = (y_idx * 8) * xd->dst.uv_stride + (x_idx * 8);
478 479 480 481 482 483 484 485
    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]);
486 487 488
  }
}

489 490 491 492
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;
493 494 495
  int n;

  for (n = 0; n < y_count; n++) {
496 497
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> bwl;
498
    const int y_offset = (y_idx * 4) * xd->dst.y_stride + (x_idx * 4);
499
    const TX_TYPE tx_type = get_tx_type_4x4(xd, n);
500
    if (tx_type == DCT_DCT) {
501 502
      xd->itxm_add(BLOCK_OFFSET(xd->plane[0].qcoeff, n, 16),
                   xd->block[0].dequant,
503
                   xd->dst.y_buffer + y_offset, xd->dst.y_stride,
John Koleszar's avatar
John Koleszar committed
504
                   xd->plane[0].eobs[n]);
505
    } else {
506 507
      vp9_dequant_iht_add_c(tx_type,
                            BLOCK_OFFSET(xd->plane[0].qcoeff, n, 16),
508 509
                            xd->block[0].dequant, xd->dst.y_buffer + y_offset,
                            xd->dst.y_stride, xd->plane[0].eobs[n]);
510 511
    }
  }
512 513 514 515 516 517 518
}

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;
519 520

  for (n = 0; n < uv_count; n++) {
521 522
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
523 524 525
    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,
526
        xd->dst.u_buffer + uv_offset, xd->dst.uv_stride, xd->plane[1].eobs[n]);
527 528
    xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, n, 16),
        xd->block[20].dequant,
529
        xd->dst.v_buffer + uv_offset, xd->dst.uv_stride, xd->plane[2].eobs[n]);
530 531 532
  }
}

533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
// 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,
                      BOOL_DECODER* const bc, BLOCK_SIZE_TYPE bsize) {
  const int bwl = mb_width_log2(bsize), bhl = mb_height_log2(bsize);
  const int bw = 1 << bwl, bh = 1 << bhl;
555
  int n, eobtotal;
556
  VP9_COMMON *const pc = &pbi->common;
557
  MODE_INFO *mi = xd->mode_info_context;
558
  const int mis = pc->mode_info_stride;
559

560
  assert(mi->mbmi.sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
561 562

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

565
  // generate prediction
566 567 568
  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
569
  } else {
570
    vp9_build_inter_predictors_sb(xd, mb_row, mb_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
571 572
  }

Yunqing Wang's avatar
Yunqing Wang committed
573 574 575 576 577
  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
578
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(pbi, xd);

    // dequantization and idct
    eobtotal = vp9_decode_tokens(pbi, xd, bc, bsize);
    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);
      }
610
    }
611
  }
Yunqing Wang's avatar
Yunqing Wang committed
612

613 614 615
#if CONFIG_CODE_NONZEROCOUNT
  propagate_nzcs(&pbi->common, xd);
#endif
616 617
}

618 619
// TODO(jingning): Need to merge SB and MB decoding. The MB decoding currently
// couples special handles on I8x8, B_PRED, and splitmv modes.
620 621 622
static void decode_mb(VP9D_COMP *pbi, MACROBLOCKD *xd,
                     int mb_row, int mb_col,
                     BOOL_DECODER* const bc) {
John Koleszar's avatar
John Koleszar committed
623
  int eobtotal = 0;
624 625
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
  const int tx_size = xd->mode_info_context->mbmi.txfm_size;
626

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

Deb Mukherjee's avatar
Deb Mukherjee committed
629
  //mode = xd->mode_info_context->mbmi.mode;
630
  if (pbi->common.frame_type != KEY_FRAME)
631
    vp9_setup_interp_filters(xd, xd->mode_info_context->mbmi.interp_filter,
632
                             &pbi->common);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
633

634
  // do prediction
John Koleszar's avatar
John Koleszar committed
635 636
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
    if (mode != I8X8_PRED) {
637
      vp9_build_intra_predictors_sbuv_s(xd, BLOCK_SIZE_MB16X16);
Yaowu Xu's avatar
Yaowu Xu committed
638
      if (mode != I4X4_PRED)
639
        vp9_build_intra_predictors_sby_s(xd, BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
640
    }
John Koleszar's avatar
John Koleszar committed
641
  } else {
642
#if 0  // def DEC_DEBUG
643 644 645 646 647
  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
648
    vp9_build_inter_predictors_mb_s(xd, mb_row, mb_col);
John Koleszar's avatar
John Koleszar committed
649 650
  }

Yunqing Wang's avatar
Yunqing Wang committed
651 652
  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, BLOCK_SIZE_MB16X16);
653
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(pbi, xd);

    if (!bool_error(bc)) {
#if CONFIG_NEWBINTRAMODES
    if (mode != I4X4_PRED)
#endif
      eobtotal = vp9_decode_tokens(pbi, xd, bc, BLOCK_SIZE_MB16X16);
    }
  }

  if (eobtotal == 0 &&
      mode != I4X4_PRED &&
      mode != SPLITMV &&
      mode != I8X8_PRED &&
      !bool_error(bc)) {
    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) {
      decode_16x16(pbi, xd, bc);
    } else if (tx_size == TX_8X8) {
      decode_8x8(pbi, xd, bc);
    } else {
      decode_4x4(pbi, xd, bc);
    }
685
  }
Yunqing Wang's avatar
Yunqing Wang committed
686

687 688 689 690
#ifdef DEC_DEBUG
  if (dec_debug) {
    int i, j;
    printf("\n");
691 692 693 694 695 696 697
    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");
698
    printf("final y\n");
John Koleszar's avatar
John Koleszar committed
699
    for (i = 0; i < 16; i++) {
700 701 702
      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
703
    }
704 705 706 707 708 709
    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");
710
    }
711 712 713 714 715 716
    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");
717
    }
718
    fflush(stdout);
John Koleszar's avatar
John Koleszar committed
719
  }
720
#endif
Yaowu Xu's avatar
Yaowu Xu committed
721
}
John Koleszar's avatar
John Koleszar committed
722

723 724 725 726
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
727 728
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
729
  }
John Koleszar's avatar
John Koleszar committed
730

731
  // Trigger a quantizer update if the delta-q value has changed
732
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
733 734 735 736 737 738 739
}

#ifdef PACKET_TESTING
#include <stdio.h>
FILE *vpxlog = 0;
#endif

740
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
741
                        int mb_row, int mb_col) {
742 743
  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
744 745
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
746

747 748 749 750 751 752
  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;
753
  xd->mode_info_context->mbmi.sb_type = bsize;
754 755 756
  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
757

758 759
  // 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
760 761
  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
762

763 764 765
  xd->dst.y_buffer = dst_fb->y_buffer + recon_yoffset;
  xd->dst.u_buffer = dst_fb->u_buffer + recon_uvoffset;
  xd->dst.v_buffer = dst_fb->v_buffer + recon_uvoffset;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
766
}
John Koleszar's avatar
John Koleszar committed
767

768
static void set_refs(VP9D_COMP *pbi, int mb_row, int mb_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
769 770
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
771
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
772 773

  if (mbmi->ref_frame > INTRA_FRAME) {
774
    // Select the appropriate reference frame for this MB
775 776 777
    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];
778
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
779
    setup_pred_block(&xd->pre, cfg, mb_row, mb_col,
780
                     &xd->scale_factor[0], &xd->scale_factor_uv[0]);
781
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
782

Ronald S. Bultje's avatar
Ronald S. Bultje committed
783
    if (mbmi->second_ref_frame > INTRA_FRAME) {
784
      // Select the appropriate reference frame for this MB
785 786
      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
787 788
      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];
789
      setup_pred_block(&xd->second_pre, second_cfg, mb_row, mb_col,
790
                       &xd->scale_factor[1], &xd->scale_factor_uv[1]);
791
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
792 793 794
    }