vp9_decodframe.c 50.2 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
void vp9_init_de_quantizer(VP9D_COMP *pbi) {
John Koleszar's avatar
John Koleszar committed
167
  int i;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
168
  int q;
169
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
170

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

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

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

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

198
static void mb_init_dequantizer(VP9_COMMON *pc, MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
199
  int i;
200 201
  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
202

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

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

211 212
  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]);
213

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

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

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

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

257 258 259 260 261
      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);
262
      xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
263
                   dst, xd->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
264
                   xd->plane[1].eobs[i]);
265

266 267 268 269 270
      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);
271
      xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
272
                   dst, xd->plane[1].dst.stride,
John Koleszar's avatar
John Koleszar committed
273
                   xd->plane[2].eobs[i]);
274
    }
275
  } else if (mode == SPLITMV) {
276 277 278 279
    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);
280
  } else {
281 282
    vp9_idct_add_8x8(xd->plane[1].qcoeff, xd->plane[1].dst.buf,
                     xd->plane[1].dst.stride, xd->plane[1].eobs[0]);
283

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

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

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

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

359 360 361 362 363 364 365 366 367 368 369 370
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);
371 372
}

373

374 375 376 377 378 379 380 381 382 383 384
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);
385

386
  TX_TYPE tx_type;
387

388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
  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;
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 443 444
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);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

  if (eobtotal == 0 &&
539
      mode != I4X4_PRED && mode != I8X8_PRED && mode != SPLITMV &&
540
      !vp9_reader_has_error(r)) {
541
    mbmi->mb_skip_coeff = 1;
Yunqing Wang's avatar
Yunqing Wang committed
542 543 544 545 546 547 548
  } 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) {
549
      decode_16x16(xd);
Yunqing Wang's avatar
Yunqing Wang committed
550
    } else if (tx_size == TX_8X8) {
551
      decode_8x8(xd);
Yunqing Wang's avatar
Yunqing Wang committed
552
    } else {
553 554 555 556 557 558
      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
559
    }
560
  }
Yunqing Wang's avatar
Yunqing Wang committed
561

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

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

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

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

610
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
611 612 613
                        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
614 615
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
616
  int i;
John Koleszar's avatar
John Koleszar committed
617

618
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
619
  const YV12_BUFFER_CONFIG *dst_fb = &cm->yv12_fb[cm->new_fb_idx];
620 621 622 623
  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);
624

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

629 630 631 632 633 634
  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);
  }
635 636
  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
637

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

642 643 644
  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
645
}
John Koleszar's avatar
John Koleszar committed
646

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

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

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

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

679 680 681
  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);
682 683

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

690
  xd->corrupted |= vp9_reader_has_error(r);
691 692
}

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

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

  if (bsize > BLOCK_SIZE_MB16X16) {
706
    int pl;
707
    // read the partition information
708 709 710
    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);
711
    pl = partition_plane_context(xd, bsize);
712
    partition = treed_read(r, vp9_partition_tree,
713 714
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
715 716 717 718 719
  }

  switch (partition) {
    case PARTITION_NONE:
      subsize = bsize;
720
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
721 722 723 724
      break;
    case PARTITION_HORZ:
      subsize = (bsize == BLOCK_SIZE_SB64X64) ? BLOCK_SIZE_SB64X32 :
                                                BLOCK_SIZE_SB32X16;
725 726 727
      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);
728 729 730 731
      break;
    case PARTITION_VERT:
      subsize = (bsize == BLOCK_SIZE_SB64X64) ? BLOCK_SIZE_SB32X64 :
                                                BLOCK_SIZE_SB16X32;
732 733 734
      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);
735 736 737 738 739 740 741 742 743 744
      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;
745
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
746 747 748 749 750
      }
      break;
    default:
      assert(0);
  }
751 752 753 754
  // update partition context
  if ((partition == PARTITION_SPLIT) && (bsize > BLOCK_SIZE_SB32X32))
    return;

755 756
  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);
757
  update_partition_context(xd, subsize, bsize);
758 759
}

760
static void setup_token_decoder(VP9D_COMP *pbi,
761 762
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
763
  VP9_COMMON *pc = &pbi->common;
764 765
  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
766

Dmitry Kovalev's avatar
Dmitry Kovalev committed
767 768 769
  // 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.
770
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
771 772 773 774
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

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

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