vp9_decodframe.c 50.1 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 <assert.h>
#include <stdio.h>
John Koleszar's avatar
John Koleszar committed
13

14
#include "vp9/decoder/vp9_onyxd_int.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
15
#include "vp9/common/vp9_common.h"
16 17 18
#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
19
#include "vp9/common/vp9_entropy.h"
20
#include "vp9/decoder/vp9_decodframe.h"
21
#include "vp9/decoder/vp9_detokenize.h"
22 23 24 25
#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
26
#include "vpx_scale/vpx_scale.h"
27
#include "vp9/common/vp9_setupintrarecon.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
28

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

35
#include "vp9/common/vp9_seg_common.h"
36
#include "vp9/common/vp9_tile_common.h"
37
#include "vp9_rtcd.h"
38

39
// #define DEC_DEBUG
40 41 42 43
#ifdef DEC_DEBUG
int dec_debug = 0;
#endif

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

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

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

74 75 76 77 78 79 80 81 82 83 84 85 86
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) {
87
  if (v > 2 * m)
88
    return v;
89 90

  return v % 2 ? m - (v + 1) / 2 : m + v / 2;
91 92
}

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

100 101
  v = vp9_read_literal(r, l - 1);
  return v < m ?  v : (v << 1) - m + vp9_read_bit(r);
102 103
}

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

125
static int decode_unsigned_max(vp9_reader *r, int max) {
126 127 128
  int data = 0, bit = 0, lmax = max;

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

John Koleszar's avatar
John Koleszar committed
135 136
static int merge_index(int v, int n, int modulus) {
  int max1 = (n - 1 - modulus / 2) / modulus + 1;
137 138 139
  if (v < max1) {
    v = v * modulus + modulus / 2;
  } else {
John Koleszar's avatar
John Koleszar committed
140 141 142 143 144 145 146 147
    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;
148 149
}

John Koleszar's avatar
John Koleszar committed
150 151
static int inv_remap_prob(int v, int m) {
  const int n = 256;
152

153
  v = merge_index(v, n - 1, MODULUS_PARAM);
John Koleszar's avatar
John Koleszar committed
154
  if ((m << 1) <= n) {
155
    return inv_recenter_nonneg(v + 1, m);
John Koleszar's avatar
John Koleszar committed
156
  } else {
157
    return n - 1 - inv_recenter_nonneg(v + 1, n - 1 - m);
John Koleszar's avatar
John Koleszar committed
158
  }
159
}
160

161 162
static vp9_prob read_prob_diff_update(vp9_reader *r, int oldp) {
  int delp = decode_term_subexp(r, SUBEXP_PARAM, 255);
163
  return (vp9_prob)inv_remap_prob(delp, oldp);
164
}
165

166 167
void vp9_init_dequantizer(VP9_COMMON *pc) {
  int q, i;
John Koleszar's avatar
John Koleszar committed
168

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

174
    // AC values
John Koleszar's avatar
John Koleszar committed
175
    for (i = 1; i < 16; i++) {
176
      const int rc = vp9_default_zig_zag1d_4x4[i];
John Koleszar's avatar
John Koleszar committed
177

178 179
      pc->y_dequant[q][rc] = vp9_ac_quant(q, 0);
      pc->uv_dequant[q][rc] = vp9_ac_quant(q, pc->uv_ac_delta_q);
John Koleszar's avatar
John Koleszar committed
180
    }
John Koleszar's avatar
John Koleszar committed
181
  }
John Koleszar's avatar
John Koleszar committed
182 183
}

Dmitry Kovalev's avatar
Dmitry Kovalev committed
184 185 186
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)) {
187 188 189 190
    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
191 192 193 194 195
  } else {
    return base_qindex;
  }
}

196
static void mb_init_dequantizer(VP9_COMMON *pc, MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
197
  int i;
198 199
  const int segment_id = xd->mode_info_context->mbmi.segment_id;
  xd->q_index = get_qindex(xd, segment_id, pc->base_qindex);
John Koleszar's avatar
John Koleszar committed
200

201
  xd->plane[0].dequant = pc->y_dequant[xd->q_index];
202
  for (i = 1; i < MAX_MB_PLANE; i++)
203
    xd->plane[i].dequant = pc->uv_dequant[xd->q_index];
John Koleszar's avatar
John Koleszar committed
204 205
}

206
static void decode_16x16(MACROBLOCKD *xd) {
207
  const TX_TYPE tx_type = get_tx_type_16x16(xd, 0);
208

209 210
  vp9_iht_add_16x16_c(tx_type, xd->plane[0].qcoeff, xd->plane[0].dst.buf,
                      xd->plane[0].dst.stride, xd->plane[0].eobs[0]);
211

212 213
  vp9_idct_add_8x8(xd->plane[1].qcoeff, xd->plane[1].dst.buf,
                   xd->plane[1].dst.stride, xd->plane[1].eobs[0]);
214

215 216
  vp9_idct_add_8x8(xd->plane[2].qcoeff, xd->plane[2].dst.buf,
                   xd->plane[1].dst.stride, xd->plane[2].eobs[0]);
217 218
}

219
static void decode_8x8(MACROBLOCKD *xd) {
220 221
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
  // luma
222
  // if the first one is DCT_DCT assume all the rest are as well
223
  TX_TYPE tx_type = get_tx_type_8x8(xd, 0);
224
  if (tx_type != DCT_DCT || mode == I8X8_PRED) {
225 226 227 228
    int i;
    for (i = 0; i < 4; i++) {
      int ib = vp9_i8x8_block[i];
      int idx = (ib & 0x02) ? (ib + 2) : ib;
229
      int16_t *q  = BLOCK_OFFSET(xd->plane[0].qcoeff, idx, 16);
230 231 232 233
      uint8_t* const dst =
          raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 0, ib,
                                    xd->plane[0].dst.buf,
                                    xd->plane[0].dst.stride);
234
      int stride = xd->plane[0].dst.stride;
235
      if (mode == I8X8_PRED) {
Scott LaVarnway's avatar
Scott LaVarnway committed
236
        int i8x8mode = xd->mode_info_context->bmi[ib].as_mode.first;
237
        vp9_intra8x8_predict(xd, ib, i8x8mode, dst, stride);
238
      }
239
      tx_type = get_tx_type_8x8(xd, ib);
240
      vp9_iht_add_8x8_c(tx_type, q, dst, stride, xd->plane[0].eobs[idx]);
241
    }
242
  } else {
243 244
    vp9_idct_add_y_block_8x8(xd->plane[0].qcoeff, xd->plane[0].dst.buf,
                             xd->plane[0].dst.stride, xd);
245 246
  }

247 248
  // chroma
  if (mode == I8X8_PRED) {
249 250 251
    int i;
    for (i = 0; i < 4; i++) {
      int ib = vp9_i8x8_block[i];
Scott LaVarnway's avatar
Scott LaVarnway committed
252
      int i8x8mode = xd->mode_info_context->bmi[ib].as_mode.first;
253
      uint8_t* dst;
254

255 256 257 258 259
      dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 1, i,
                                      xd->plane[1].dst.buf,
                                      xd->plane[1].dst.stride);
      vp9_intra_uv4x4_predict(xd, 16 + i, i8x8mode,
                              dst, xd->plane[1].dst.stride);
260
      xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
261
                   dst, xd->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
262
                   xd->plane[1].eobs[i]);
263

264 265 266 267 268
      dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 2, i,
                                      xd->plane[2].dst.buf,
                                      xd->plane[1].dst.stride);
      vp9_intra_uv4x4_predict(xd, 20 + i, i8x8mode,
                              dst, xd->plane[1].dst.stride);
269
      xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
270
                   dst, xd->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
271
                   xd->plane[2].eobs[i]);
272
    }
273
  } else if (mode == SPLITMV) {
274 275 276 277
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->plane[1].dst.buf,
        xd->plane[1].dst.stride, xd->plane[1].eobs);
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->plane[2].dst.buf,
        xd->plane[1].dst.stride, xd->plane[2].eobs);
278
  } else {
279 280
    vp9_idct_add_8x8(xd->plane[1].qcoeff, xd->plane[1].dst.buf,
                     xd->plane[1].dst.stride, xd->plane[1].eobs[0]);
281

282 283
    vp9_idct_add_8x8(xd->plane[2].qcoeff, xd->plane[2].dst.buf,
                     xd->plane[1].dst.stride, xd->plane[2].eobs[0]);
284 285 286
  }
}

287
static INLINE void dequant_add_y(MACROBLOCKD *xd, TX_TYPE tx_type, int idx) {
288
  struct macroblockd_plane *const y = &xd->plane[0];
289 290 291
  uint8_t* const dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 0, idx,
                                                 xd->plane[0].dst.buf,
                                                 xd->plane[0].dst.stride);
292
  if (tx_type != DCT_DCT) {
293
    vp9_iht_add_c(tx_type, BLOCK_OFFSET(y->qcoeff, idx, 16),
294
                  dst, xd->plane[0].dst.stride, y->eobs[idx]);
295
  } else {
296 297
    xd->itxm_add(BLOCK_OFFSET(y->qcoeff, idx, 16),
                 dst, xd->plane[0].dst.stride, y->eobs[idx]);
298 299 300
  }
}

301
static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd, vp9_reader *r) {
302
  TX_TYPE tx_type;
303
  int i = 0;
304
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
305 306 307 308 309
  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;
310
      uint8_t* dst;
Scott LaVarnway's avatar
Scott LaVarnway committed
311
      int i8x8mode = xd->mode_info_context->bmi[ib].as_mode.first;
312 313 314 315 316

      dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 0, ib,
                                      xd->plane[0].dst.buf,
                                      xd->plane[0].dst.stride);
      vp9_intra8x8_predict(xd, ib, i8x8mode, dst, xd->plane[0].dst.stride);
317
      for (j = 0; j < 4; j++) {
318
        tx_type = get_tx_type_4x4(xd, ib + iblock[j]);
319
        dequant_add_y(xd, tx_type, ib + iblock[j]);
320
      }
321 322 323 324 325
      dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 1, i,
                                      xd->plane[1].dst.buf,
                                      xd->plane[1].dst.stride);
      vp9_intra_uv4x4_predict(xd, 16 + i, i8x8mode,
                              dst, xd->plane[1].dst.stride);
326
      xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
327
                   dst, xd->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
328
                   xd->plane[1].eobs[i]);
329 330 331 332 333
      dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 2, i,
                                      xd->plane[2].dst.buf,
                                      xd->plane[2].dst.stride);
      vp9_intra_uv4x4_predict(xd, 20 + i, i8x8mode,
                              dst, xd->plane[1].dst.stride);
334
      xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
335
                   dst, xd->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
336
                   xd->plane[2].eobs[i]);
337
    }
338
  } else if (mode == SPLITMV || get_tx_type_4x4(xd, 0) == DCT_DCT) {
339 340 341 342 343 344
    xd->itxm_add_y_block(xd->plane[0].qcoeff, xd->plane[0].dst.buf,
        xd->plane[0].dst.stride, xd);
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->plane[1].dst.buf,
        xd->plane[1].dst.stride, xd->plane[1].eobs);
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->plane[2].dst.buf,
        xd->plane[1].dst.stride, xd->plane[2].eobs);
345
  } else {
346
    for (i = 0; i < 16; i++) {
347
      tx_type = get_tx_type_4x4(xd, i);
348
      dequant_add_y(xd, tx_type, i);
349
    }
350 351 352 353
    xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->plane[1].dst.buf,
                          xd->plane[1].dst.stride, xd->plane[1].eobs);
    xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->plane[2].dst.buf,
                          xd->plane[1].dst.stride, xd->plane[2].eobs);
354 355 356
  }
}

357 358 359 360 361 362 363 364 365 366 367 368
static int txfrm_block_to_raster_block(MACROBLOCKD *xd,
                                       BLOCK_SIZE_TYPE bsize,
                                       int plane, int block,
                                       int ss_txfrm_size) {
  const int bwl = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
  const int txwl = ss_txfrm_size / 2;
  const int tx_cols_lg2 = bwl - txwl;
  const int tx_cols = 1 << tx_cols_lg2;
  const int raster_mb = block >> ss_txfrm_size;
  const int x = (raster_mb & (tx_cols - 1)) << (txwl);
  const int y = raster_mb >> tx_cols_lg2 << (txwl);
  return x + (y << bwl);
369 370
}

371

372 373 374 375 376 377 378 379 380 381 382
static void decode_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
                         int ss_txfrm_size, void *arg) {
  MACROBLOCKD* const xd = arg;
  int16_t* const qcoeff = BLOCK_OFFSET(xd->plane[plane].qcoeff, block, 16);
  const int stride = xd->plane[plane].dst.stride;
  const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
                                                       block, ss_txfrm_size);
  uint8_t* const dst = raster_block_offset_uint8(xd, bsize, plane,
                                                 raster_block,
                                                 xd->plane[plane].dst.buf,
                                                 stride);
383

384
  TX_TYPE tx_type;
385

386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
  switch (ss_txfrm_size / 2) {
    case TX_4X4:
      tx_type = plane == 0 ? get_tx_type_4x4(xd, raster_block) : DCT_DCT;
      if (tx_type == DCT_DCT)
        xd->itxm_add(qcoeff, dst, stride, xd->plane[plane].eobs[block]);
      else
        vp9_iht_add_c(tx_type, qcoeff, dst, stride,
                      xd->plane[plane].eobs[block]);
      break;
    case TX_8X8:
      tx_type = plane == 0 ? get_tx_type_8x8(xd, raster_block) : DCT_DCT;
      vp9_iht_add_8x8_c(tx_type, qcoeff, dst, stride,
                        xd->plane[plane].eobs[block]);
      break;
    case TX_16X16:
      tx_type = plane == 0 ? get_tx_type_16x16(xd, raster_block) : DCT_DCT;
      vp9_iht_add_16x16_c(tx_type, qcoeff, dst, stride,
                          xd->plane[plane].eobs[block]);
      break;
    case TX_32X32:
      vp9_idct_add_32x32(qcoeff, dst, stride, xd->plane[plane].eobs[block]);
      break;
408 409 410
  }
}

411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
static void decode_atom_intra(VP9D_COMP *pbi, MACROBLOCKD *xd,
                              vp9_reader *r,
                              BLOCK_SIZE_TYPE bsize) {
  int i = 0;
  int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
  int bc = 1 << (bwl + bhl);
  int tx_type;

  for (i = 0; i < bc; i++) {
    int b_mode = xd->mode_info_context->bmi[i].as_mode.first;
    uint8_t* dst;
    dst = raster_block_offset_uint8(xd, bsize, 0, i,
                                    xd->plane[0].dst.buf,
                                    xd->plane[0].dst.stride);
#if CONFIG_NEWBINTRAMODES
    xd->mode_info_context->bmi[i].as_mode.context =
        vp9_find_bpred_context(xd, i, dst, xd->plane[0].dst.stride);
    if (!xd->mode_info_context->mbmi.mb_skip_coeff)
      vp9_decode_coefs_4x4(pbi, xd, r, PLANE_TYPE_Y_WITH_DC, i);
#endif
    vp9_intra4x4_predict(xd, i, b_mode, dst, xd->plane[0].dst.stride);
    // TODO(jingning): refactor to use foreach_transformed_block_in_plane_
    tx_type = get_tx_type_4x4(xd, i);
    dequant_add_y(xd, tx_type, i);
  }
#if CONFIG_NEWBINTRAMODES
  if (!xd->mode_info_context->mbmi.mb_skip_coeff)
    vp9_decode_mb_tokens_4x4_uv(pbi, xd, r);
#endif
  foreach_transformed_block_uv(xd, bsize, decode_block, xd);
}

443
static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mi_row, int mi_col,
444
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
445
  const int bwl = mi_width_log2(bsize), bhl = mi_height_log2(bsize);
446
  const int bw = 1 << bwl, bh = 1 << bhl;
447
  int n, eobtotal;
448
  VP9_COMMON *const pc = &pbi->common;
449 450
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
451
  const int mis = pc->mode_info_stride;
452

453
  assert(mbmi->sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
454 455

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

458
  // generate prediction
459
  if (mbmi->ref_frame == INTRA_FRAME) {
460 461
    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
462
  } else {
463
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
464 465
  }

466
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
467
    vp9_reset_sb_tokens_context(xd, bsize);
468
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
469 470
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
471
      mb_init_dequantizer(pc, xd);
Yunqing Wang's avatar
Yunqing Wang committed
472 473

    // dequantization and idct
474
    eobtotal = vp9_decode_tokens(pbi, xd, r, bsize);
Yunqing Wang's avatar
Yunqing Wang committed
475 476 477 478
    if (eobtotal == 0) {  // skip loopfilter
      for (n = 0; n < bw * bh; n++) {
        const int x_idx = n & (bw - 1), y_idx = n >> bwl;

479
        if (mi_col + x_idx < pc->mi_cols && mi_row + y_idx < pc->mi_rows)
Yunqing Wang's avatar
Yunqing Wang committed
480 481 482
          mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
      }
    } else {
483
      foreach_transformed_block(xd, bsize, decode_block, xd);
484
    }
485
  }
486 487
}

488 489
// TODO(jingning): Need to merge SB and MB decoding. The MB decoding currently
// couples special handles on I8x8, B_PRED, and splitmv modes.
490
static void decode_mb(VP9D_COMP *pbi, MACROBLOCKD *xd,
491
                     int mi_row, int mi_col,
492
                     vp9_reader *r) {
John Koleszar's avatar
John Koleszar committed
493
  int eobtotal = 0;
494 495 496
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
  const MB_PREDICTION_MODE mode = mbmi->mode;
  const int tx_size = mbmi->txfm_size;
497

498
  assert(mbmi->sb_type == BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
499

Deb Mukherjee's avatar
Deb Mukherjee committed
500
  //mode = xd->mode_info_context->mbmi.mode;
501
  if (pbi->common.frame_type != KEY_FRAME)
502
    vp9_setup_interp_filters(xd, mbmi->interp_filter, &pbi->common);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
503

504
  // do prediction
505
  if (mbmi->ref_frame == INTRA_FRAME) {
John Koleszar's avatar
John Koleszar committed
506
    if (mode != I8X8_PRED) {
507
      vp9_build_intra_predictors_sbuv_s(xd, BLOCK_SIZE_MB16X16);
Yaowu Xu's avatar
Yaowu Xu committed
508
      if (mode != I4X4_PRED)
509
        vp9_build_intra_predictors_sby_s(xd, BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
510
    }
John Koleszar's avatar
John Koleszar committed
511
  } else {
512
#if 0  // def DEC_DEBUG
513 514 515 516 517
  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
518
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
519 520
  }

521
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
522
    vp9_reset_sb_tokens_context(xd, BLOCK_SIZE_MB16X16);
523
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
524 525
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
526
      mb_init_dequantizer(&pbi->common, xd);
Yunqing Wang's avatar
Yunqing Wang committed
527

528
    if (!vp9_reader_has_error(r)) {
Yunqing Wang's avatar
Yunqing Wang committed
529 530 531
#if CONFIG_NEWBINTRAMODES
    if (mode != I4X4_PRED)
#endif
532
      eobtotal = vp9_decode_tokens(pbi, xd, r, BLOCK_SIZE_MB16X16);
Yunqing Wang's avatar
Yunqing Wang committed
533 534 535 536
    }
  }

  if (eobtotal == 0 &&
537
      mode != I4X4_PRED && mode != I8X8_PRED && mode != SPLITMV &&
538
      !vp9_reader_has_error(r)) {
539
    mbmi->mb_skip_coeff = 1;
Yunqing Wang's avatar
Yunqing Wang committed
540 541 542 543 544 545 546
  } 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) {
547
      decode_16x16(xd);
Yunqing Wang's avatar
Yunqing Wang committed
548
    } else if (tx_size == TX_8X8) {
549
      decode_8x8(xd);
Yunqing Wang's avatar
Yunqing Wang committed
550
    } else {
551 552 553 554 555 556
      if (mbmi->mode == I4X4_PRED)
        // TODO(jingning): we need to move this to decode_atom later and
        // deprecate decode_mb, when SB8X8 is on.
        decode_atom_intra(pbi, xd, r, BLOCK_SIZE_MB16X16);
      else
        decode_4x4(pbi, xd, r);
Yunqing Wang's avatar
Yunqing Wang committed
557
    }
558
  }
Yunqing Wang's avatar
Yunqing Wang committed
559

560 561 562 563
#ifdef DEC_DEBUG
  if (dec_debug) {
    int i, j;
    printf("\n");
564 565 566 567 568 569 570
    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");
571
    printf("final y\n");
John Koleszar's avatar
John Koleszar committed
572
    for (i = 0; i < 16; i++) {
573
      for (j = 0; j < 16; j++)
574
        printf("%3d ", xd->plane[0].dst.buf[i * xd->plane[0].dst.stride + j]);
575
      printf("\n");
John Koleszar's avatar
John Koleszar committed
576
    }
577 578 579 580
    printf("\n");
    printf("final u\n");
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++)
581
        printf("%3d ", xd->plane[1].dst.buf[i * xd->plane[1].dst.stride + j]);
582
      printf("\n");
583
    }
584 585 586 587
    printf("\n");
    printf("final v\n");
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++)
588
        printf("%3d ", xd->plane[2].dst.buf[i * xd->plane[1].dst.stride + j]);
589
      printf("\n");
590
    }
591
    fflush(stdout);
John Koleszar's avatar
John Koleszar committed
592
  }
593
#endif
Yaowu Xu's avatar
Yaowu Xu committed
594
}
John Koleszar's avatar
John Koleszar committed
595

596 597 598 599
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
600 601
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
602
  }
John Koleszar's avatar
John Koleszar committed
603

604
  // Trigger a quantizer update if the delta-q value has changed
605
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
606 607
}

608
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
609 610 611
                        int mi_row, int mi_col) {
  const int bh = 1 << mi_height_log2(bsize);
  const int bw = 1 << mi_width_log2(bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
612 613
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
614
  int i;
John Koleszar's avatar
John Koleszar committed
615

616
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
617
  const YV12_BUFFER_CONFIG *dst_fb = &cm->yv12_fb[cm->new_fb_idx];
618 619 620 621
  const int recon_yoffset =
      (MI_SIZE * mi_row) * dst_fb->y_stride + (MI_SIZE * mi_col);
  const int recon_uvoffset =
      (MI_UV_SIZE * mi_row) * dst_fb->uv_stride + (MI_UV_SIZE * mi_col);
622

623
  xd->mode_info_context = cm->mi + mi_idx;
624
  xd->mode_info_context->mbmi.sb_type = bsize;
625 626
  xd->prev_mode_info_context = cm->prev_mi + mi_idx;

627 628 629 630 631 632
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
        (mi_col * 4 >> (xd->plane[i].subsampling_x + CONFIG_SB8X8));
    xd->plane[i].left_context = cm->left_context[i] +
        (((mi_row * 4 >> CONFIG_SB8X8) & 15) >> xd->plane[i].subsampling_y);
  }
633 634
  xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8);
  xd->left_seg_context  = cm->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
635

636 637
  // 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
638
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
639

640 641 642
  xd->plane[0].dst.buf = dst_fb->y_buffer + recon_yoffset;
  xd->plane[1].dst.buf = dst_fb->u_buffer + recon_uvoffset;
  xd->plane[2].dst.buf = dst_fb->v_buffer + recon_uvoffset;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
643
}
John Koleszar's avatar
John Koleszar committed
644

645
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
646 647
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
648
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
649 650

  if (mbmi->ref_frame > INTRA_FRAME) {
651
    // Select the appropriate reference frame for this MB
652 653 654
    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];
655
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
656
    setup_pre_planes(xd, cfg, NULL, mi_row, mi_col,
657
                     xd->scale_factor, xd->scale_factor_uv);
658
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
659

Ronald S. Bultje's avatar
Ronald S. Bultje committed
660
    if (mbmi->second_ref_frame > INTRA_FRAME) {
661
      // Select the appropriate reference frame for this MB
662 663
      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
664 665
      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];
666
      setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col,
667
                       xd->scale_factor, xd->scale_factor_uv);
668
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
669 670 671
    }
  }
}
John Koleszar's avatar
John Koleszar committed
672

673
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
674 675 676
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

677 678 679
  set_offsets(pbi, bsize, mi_row, mi_col);
  vp9_decode_mb_mode_mv(pbi, xd, mi_row, mi_col, r);
  set_refs(pbi, mi_row, mi_col);
680 681

  // TODO(jingning): merge decode_sb_ and decode_mb_
682
  if (bsize > BLOCK_SIZE_MB16X16) {
683
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
684
  } else {
685
    decode_mb(pbi, xd, mi_row, mi_col, r);
686
  }
687

688
  xd->corrupted |= vp9_reader_has_error(r);
689 690
}

691
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
692
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
693 694
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
695
  int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
696 697 698 699
  int n;
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

700
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
701 702 703
    return;

  if (bsize > BLOCK_SIZE_MB16X16) {
704
    int pl;
705
    // read the partition information
706 707 708
    xd->left_seg_context =
        pc->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3);
    xd->above_seg_context = pc->above_seg_context + (mi_col >> CONFIG_SB8X8);
709
    pl = partition_plane_context(xd, bsize);
710
    partition = treed_read(r, vp9_partition_tree,
711 712
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
713 714 715 716 717
  }

  switch (partition) {
    case PARTITION_NONE:
      subsize = bsize;
718
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
719 720 721 722
      break;
    case PARTITION_HORZ:
      subsize = (bsize == BLOCK_SIZE_SB64X64) ? BLOCK_SIZE_SB64X32 :
                                                BLOCK_SIZE_SB32X16;
723 724 725
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
      if ((mi_row + bs) < pc->mi_rows)
        decode_modes_b(pbi, mi_row + bs, mi_col, r, subsize);
726 727 728 729
      break;
    case PARTITION_VERT:
      subsize = (bsize == BLOCK_SIZE_SB64X64) ? BLOCK_SIZE_SB32X64 :
                                                BLOCK_SIZE_SB16X32;
730 731 732
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
      if ((mi_col + bs) < pc->mi_cols)
        decode_modes_b(pbi, mi_row, mi_col + bs, r, subsize);
733 734 735 736 737 738 739 740 741 742
      break;
    case PARTITION_SPLIT:
      subsize = (bsize == BLOCK_SIZE_SB64X64) ? BLOCK_SIZE_SB32X32 :
                                                BLOCK_SIZE_MB16X16;
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
        if (subsize == BLOCK_SIZE_SB32X32)
          xd->sb_index = n;
        else
          xd->mb_index = n;
743
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
744 745 746 747 748
      }
      break;
    default:
      assert(0);
  }
749 750 751 752
  // update partition context
  if ((partition == PARTITION_SPLIT) && (bsize > BLOCK_SIZE_SB32X32))
    return;

753 754
  xd->left_seg_context = pc->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3);
  xd->above_seg_context = pc->above_seg_context + (mi_col >> CONFIG_SB8X8);
755
  update_partition_context(xd, subsize, bsize);
756 757
}

758
static void setup_token_decoder(VP9D_COMP *pbi,
759 760
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
761
  VP9_COMMON *pc = &pbi->common;
762 763
  const uint8_t *data_end = pbi->source + pbi->source_sz;
  const size_t partition_size = data_end - data;
John Koleszar's avatar
John Koleszar committed
764

Dmitry Kovalev's avatar
Dmitry Kovalev committed
765 766 767
  // Validate the calculated partition length. If the buffer
  // described by the partition can't be fully read, then restrict
  // it to the portion that can be (for EC mode) or throw an error.
768
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
769 770 771 772
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

773
  if (vp9_reader_init(r, data, partition_size))
John Koleszar's avatar
John Koleszar committed
774 775
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
776 777
}

778 779
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
780
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
781

John Koleszar's avatar
John Koleszar committed
782
  if (pc->frame_type == KEY_FRAME) {
783
    vp9_setup_past_independence(pc, xd);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
784
    // All buffers are implicitly updated on key frames.
785
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
Deb Mukherjee's avatar