vp9_decodframe.c 58.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 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 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
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);
}

static int decode_uniform(BOOL_DECODER *br, int n) {
  int v;
  const int l = get_unsigned_bits(n);
  const int m = (1 << l) - n;
  if (!l)
    return 0;

  v = vp9_read_literal(br, l - 1);
  return v < m ?  v : (v << 1) - m + vp9_read_bit(br);
}

static int decode_term_subexp(BOOL_DECODER *br, int k, int num_syms) {
  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) {
      word = decode_uniform(br, num_syms - mk) + mk;
      break;
    } else {
      if (vp9_read_bit(br)) {
        i++;
        mk += a;
      } else {
        word = vp9_read_literal(br, b) + mk;
        break;
      }
    }
  }
  return word;
}

static int decode_unsigned_max(BOOL_DECODER *br, int max) {
  int data = 0, bit = 0, lmax = max;

  while (lmax) {
    data |= vp9_read_bit(br) << bit++;
    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
static vp9_prob read_prob_diff_update(vp9_reader *const bc, int oldp) {
158
  int delp = decode_term_subexp(bc, 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 250
static void decode_16x16(VP9D_COMP *pbi, MACROBLOCKD *xd,
                         BOOL_DECODER* const bc) {
251
  const TX_TYPE tx_type = get_tx_type_16x16(xd, 0);
252

253 254 255
  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]);
256 257

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

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

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

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

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

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
    }
318
  } else if (mode == SPLITMV) {
319
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
320
         xd->dst.u_buffer, xd->dst.uv_stride, xd->plane[1].eobs);
321
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
322
         xd->dst.v_buffer, xd->dst.uv_stride, xd->plane[2].eobs);
323
  } else {
324
    vp9_dequant_idct_add_8x8(xd->plane[1].qcoeff, xd->block[16].dequant,
325
                             xd->dst.u_buffer, xd->dst.uv_stride,
326
                             xd->plane[1].eobs[0]);
327 328

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

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


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

427 428 429 430
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;
431 432 433
  int n;

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

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;
473
    const int y_offset = (y_idx * 16) * mb->dst.y_stride + (x_idx * 16);
474
    const TX_TYPE tx_type = get_tx_type_16x16(mb,
475
                                (y_idx * (4 * bw) + x_idx) * 4);
476 477 478 479 480 481
    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]);
482
  }
483 484 485 486 487 488 489 490 491
}

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);
492 493

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

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

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

    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]);
527
  }
528 529 530 531 532 533 534
}

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;
535 536 537

  // chroma
  for (n = 0; n < uv_count; n++) {
538 539
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
540
    const int uv_offset = (y_idx * 8) * xd->dst.uv_stride + (x_idx * 8);
541 542 543 544 545 546 547 548
    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]);
549 550 551
  }
}

552 553 554 555
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;
556 557 558
  int n;

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

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;
582 583

  for (n = 0; n < uv_count; n++) {
584 585
    const int x_idx = n & (bw - 1);
    const int y_idx = n >> (bwl - 1);
586 587 588
    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,
589
        xd->dst.u_buffer + uv_offset, xd->dst.uv_stride, xd->plane[1].eobs[n]);
590 591
    xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, n, 16),
        xd->block[20].dequant,
592
        xd->dst.v_buffer + uv_offset, xd->dst.uv_stride, xd->plane[2].eobs[n]);
593 594 595
  }
}

596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
// 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;
618
  int n, eobtotal;
619
  VP9_COMMON *const pc = &pbi->common;
620
  MODE_INFO *mi = xd->mode_info_context;
621
  const int mis = pc->mode_info_stride;
622

623
  assert(mi->mbmi.sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
624 625

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

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

Yunqing Wang's avatar
Yunqing Wang committed
636 637 638 639 640
  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
641
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
642 643 644 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 670 671 672
    // 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);
      }
673
    }
674
  }
Yunqing Wang's avatar
Yunqing Wang committed
675

676 677 678
#if CONFIG_CODE_NONZEROCOUNT
  propagate_nzcs(&pbi->common, xd);
#endif
679 680
}

681 682
// TODO(jingning): Need to merge SB and MB decoding. The MB decoding currently
// couples special handles on I8x8, B_PRED, and splitmv modes.
683 684 685
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
686
  int eobtotal = 0;
687 688
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
  const int tx_size = xd->mode_info_context->mbmi.txfm_size;
689

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

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

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

Yunqing Wang's avatar
Yunqing Wang committed
714 715
  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, BLOCK_SIZE_MB16X16);
716
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
    // 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);
    }
748
  }
Yunqing Wang's avatar
Yunqing Wang committed
749

750 751 752 753
#ifdef DEC_DEBUG
  if (dec_debug) {
    int i, j;
    printf("\n");
754 755 756 757 758 759 760
    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");
761
    printf("final y\n");
John Koleszar's avatar
John Koleszar committed
762
    for (i = 0; i < 16; i++) {
763 764 765
      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
766
    }
767 768 769 770 771 772
    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");
773
    }
774 775 776 777 778 779
    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");
780
    }
781
    fflush(stdout);
John Koleszar's avatar
John Koleszar committed
782
  }
783
#endif
Yaowu Xu's avatar
Yaowu Xu committed
784
}
John Koleszar's avatar
John Koleszar committed
785

786 787 788 789
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

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

794
  // Trigger a quantizer update if the delta-q value has changed
795
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
796 797 798 799 800 801 802
}

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

803
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
804
                        int mb_row, int mb_col) {
805 806
  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
807 808
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
809

810 811 812 813 814 815
  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;
816
  xd->mode_info_context->mbmi.sb_type = bsize;
817 818 819
  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
820

821 822
  // 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
823 824
  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
825

826 827 828
  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
829
}
John Koleszar's avatar
John Koleszar committed
830

831
static void set_refs(VP9D_COMP *pbi, int mb_row, int mb_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
832 833
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
834
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
835 836

  if (mbmi->ref_frame > INTRA_FRAME) {
837
    // Select the appropriate reference frame for this MB
838 839 840
    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];
841
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
842
    setup_pred_block(&xd->pre, cfg, mb_row, mb_col,
843
                     &xd->scale_factor[0], &xd->scale_factor_uv[0]);
844
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
845

Ronald S. Bultje's avatar
Ronald S. Bultje committed
846
    if (mbmi->second_ref_frame > INTRA_FRAME) {
847
      // Select the appropriate reference frame for this MB
848 849
      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
850 851
      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];
852
      setup_pred_block(&xd->second_pre, second_cfg, mb_row, mb_col,
853
                       &xd->scale_factor[1], &xd->scale_factor_uv[1]);
854
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
855 856 857
    }
  }
}