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

13 14 15 16 17 18
#include "./vp9_rtcd.h"
#include "vpx_mem/vpx_mem.h"
#include "vpx_scale/vpx_scale.h"

#include "vp9/common/vp9_extend.h"
#include "vp9/common/vp9_modecont.h"
Ronald S. Bultje's avatar
Ronald S. Bultje committed
19
#include "vp9/common/vp9_common.h"
20 21
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_reconinter.h"
Yaowu Xu's avatar
Yaowu Xu committed
22
#include "vp9/common/vp9_entropy.h"
23 24 25 26
#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"
27 28
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_tile_common.h"
29 30

#include "vp9/decoder/vp9_dboolhuff.h"
31 32 33 34 35
#include "vp9/decoder/vp9_decodframe.h"
#include "vp9/decoder/vp9_detokenize.h"
#include "vp9/decoder/vp9_decodemv.h"
#include "vp9/decoder/vp9_onyxd_int.h"
#include "vp9/decoder/vp9_read_bit_buffer.h"
36

37

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

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

57 58 59 60 61 62 63 64 65 66 67 68 69 70
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);
    }
  }
71 72
}

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

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

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

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

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

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

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

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

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

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

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

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

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

173
    // AC values
174 175
    pc->y_dequant[q][1] = vp9_ac_quant(q, 0);
    pc->uv_dequant[q][1] = vp9_ac_quant(q, pc->uv_ac_delta_q);
John Koleszar's avatar
John Koleszar committed
176
  }
John Koleszar's avatar
John Koleszar committed
177 178
}

179
static void mb_init_dequantizer(VP9_COMMON *pc, MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
180
  int i;
181
  const int segment_id = xd->mode_info_context->mbmi.segment_id;
182
  xd->q_index = vp9_get_qindex(xd, segment_id, pc->base_qindex);
John Koleszar's avatar
John Koleszar committed
183

184
  xd->plane[0].dequant = pc->y_dequant[xd->q_index];
185
  for (i = 1; i < MAX_MB_PLANE; i++)
186
    xd->plane[i].dequant = pc->uv_dequant[xd->q_index];
John Koleszar's avatar
John Koleszar committed
187 188
}

189 190
static INLINE void dequant_add_y(MACROBLOCKD *xd, TX_TYPE tx_type, int idx,
                                 BLOCK_SIZE_TYPE bsize) {
191
  struct macroblockd_plane *const y = &xd->plane[0];
192
  uint8_t* const dst = raster_block_offset_uint8(xd, bsize, 0, idx,
193 194
                                                 xd->plane[0].dst.buf,
                                                 xd->plane[0].dst.stride);
195
  if (tx_type != DCT_DCT) {
196
    vp9_iht_add_c(tx_type, BLOCK_OFFSET(y->qcoeff, idx, 16),
197
                  dst, xd->plane[0].dst.stride, y->eobs[idx]);
198
  } else {
199 200
    xd->itxm_add(BLOCK_OFFSET(y->qcoeff, idx, 16),
                 dst, xd->plane[0].dst.stride, y->eobs[idx]);
201 202 203
  }
}

204 205 206 207 208 209 210 211 212 213 214
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);
215

216
  TX_TYPE tx_type;
217

218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
  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;
240 241 242
  }
}

243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
static void decode_block_intra(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);
  const TX_SIZE tx_size = (TX_SIZE)(ss_txfrm_size / 2);
  TX_TYPE tx_type;
  int mode, b_mode;
  int plane_b_size;
  int tx_ib = raster_block >> tx_size;
  mode = plane == 0? xd->mode_info_context->mbmi.mode:
                     xd->mode_info_context->mbmi.uv_mode;

  if (bsize <= BLOCK_SIZE_SB8X8 && mode == I4X4_PRED && plane == 0)
    b_mode = xd->mode_info_context->bmi[raster_block].as_mode.first;
  else
    b_mode = mode;

  plane_b_size = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
  vp9_predict_intra_block(xd, tx_ib, plane_b_size, tx_size,
                          b_mode, dst, xd->plane[plane].dst.stride);

  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;
  }
}

296 297 298 299 300
static void decode_atom(VP9D_COMP *pbi, MACROBLOCKD *xd,
                        int mi_row, int mi_col,
                        vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;

Yaowu Xu's avatar
Yaowu Xu committed
301 302
  assert(mbmi->ref_frame != INTRA_FRAME);

303 304 305 306
  if (pbi->common.frame_type != KEY_FRAME)
    vp9_setup_interp_filters(xd, mbmi->interp_filter, &pbi->common);

  // prediction
Yaowu Xu's avatar
Yaowu Xu committed
307
  vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
308 309 310 311 312 313 314 315 316 317 318 319

  if (mbmi->mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, bsize);
  } else {
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(&pbi->common, xd);

    if (!vp9_reader_has_error(r)) {
      vp9_decode_tokens(pbi, xd, r, bsize);
    }
  }
Yaowu Xu's avatar
Yaowu Xu committed
320
  foreach_transformed_block(xd, bsize, decode_block, xd);
321 322
}

323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
static void decode_sb_intra(VP9D_COMP *pbi, MACROBLOCKD *xd,
                          int mi_row, int mi_col,
                          vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
  if (mbmi->mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, bsize);
  } else {
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(&pbi->common, xd);

    if (!vp9_reader_has_error(r)) {
      vp9_decode_tokens(pbi, xd, r, bsize);
    }
  }

  foreach_transformed_block(xd, bsize, decode_block_intra, xd);
}


343
static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mi_row, int mi_col,
344
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
345
  const int bwl = mi_width_log2(bsize), bhl = mi_height_log2(bsize);
346
  const int bw = 1 << bwl, bh = 1 << bhl;
347
  int n, eobtotal;
348
  VP9_COMMON *const pc = &pbi->common;
349 350
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
351
  const int mis = pc->mode_info_stride;
352

353
  assert(mbmi->sb_type == bsize);
Yaowu Xu's avatar
Yaowu Xu committed
354
  assert(mbmi->ref_frame != INTRA_FRAME);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
355 356

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

359
  // generate prediction
Yaowu Xu's avatar
Yaowu Xu committed
360
  vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
361

362
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
363
    vp9_reset_sb_tokens_context(xd, bsize);
364
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
365 366
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
367
      mb_init_dequantizer(pc, xd);
Yunqing Wang's avatar
Yunqing Wang committed
368 369

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

375
        if (mi_col + x_idx < pc->mi_cols && mi_row + y_idx < pc->mi_rows)
Yunqing Wang's avatar
Yunqing Wang committed
376 377 378
          mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
      }
    } else {
379
      foreach_transformed_block(xd, bsize, decode_block, xd);
380
    }
381
  }
382 383
}

384 385 386 387
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
388 389
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
390
  }
John Koleszar's avatar
John Koleszar committed
391

392
  // Trigger a quantizer update if the delta-q value has changed
393
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
394 395
}

396
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
397 398 399
                        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
400 401
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
402
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
403
  int i;
404

405
  xd->mode_info_context = cm->mi + mi_idx;
406
  xd->mode_info_context->mbmi.sb_type = bsize;
407 408
  xd->prev_mode_info_context = cm->prev_mi + mi_idx;

409 410
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
Jingning Han's avatar
Jingning Han committed
411
        (mi_col * 2 >> xd->plane[i].subsampling_x);
412
    xd->plane[i].left_context = cm->left_context[i] +
Jingning Han's avatar
Jingning Han committed
413
        (((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
414
  }
415 416
  xd->above_seg_context = cm->above_seg_context + mi_col;
  xd->left_seg_context  = cm->left_seg_context + (mi_row & MI_MASK);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
417

418 419
  // 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
420
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
421

422
  setup_dst_planes(xd, &cm->yv12_fb[cm->new_fb_idx], mi_row, mi_col);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
423
}
John Koleszar's avatar
John Koleszar committed
424

425
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
426 427
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
428
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
429 430

  if (mbmi->ref_frame > INTRA_FRAME) {
431
    // Select the appropriate reference frame for this MB
432 433 434
    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];
435
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
436
    setup_pre_planes(xd, cfg, NULL, mi_row, mi_col,
437
                     xd->scale_factor, xd->scale_factor_uv);
438
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
439

Ronald S. Bultje's avatar
Ronald S. Bultje committed
440
    if (mbmi->second_ref_frame > INTRA_FRAME) {
441
      // Select the appropriate reference frame for this MB
442 443
      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
444 445
      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];
446
      setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col,
447
                       xd->scale_factor, xd->scale_factor_uv);
448
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
449 450 451
    }
  }
}
John Koleszar's avatar
John Koleszar committed
452

453
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
454 455 456
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

457 458 459
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index > 0)
      return;
460 461 462
  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);
463

464
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
465 466
    decode_sb_intra(pbi, xd, mi_row, mi_col, r, (bsize < BLOCK_SIZE_SB8X8) ?
                                     BLOCK_SIZE_SB8X8 : bsize);
467
  else if (bsize < BLOCK_SIZE_SB8X8)
468
    decode_atom(pbi, xd, mi_row, mi_col, r, BLOCK_SIZE_SB8X8);
469
  else
470
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
471

472
  xd->corrupted |= vp9_reader_has_error(r);
473 474
}

475
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
476
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
477 478
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
479
  int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
480 481 482 483
  int n;
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

484
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
485 486
    return;

487 488 489 490 491
  if (bsize < BLOCK_SIZE_SB8X8)
    if (xd->ab_index != 0)
      return;

  if (bsize >= BLOCK_SIZE_SB8X8) {
492
    int pl;
493
    // read the partition information
494 495
    xd->left_seg_context = pc->left_seg_context + (mi_row & MI_MASK);
    xd->above_seg_context = pc->above_seg_context + mi_col;
496
    pl = partition_plane_context(xd, bsize);
497
    partition = treed_read(r, vp9_partition_tree,
498 499
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
500 501
  }

502
  subsize = get_subsize(bsize, partition);
503
  *(get_sb_index(xd, subsize)) = 0;
504

505 506
  switch (partition) {
    case PARTITION_NONE:
507
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
508 509
      break;
    case PARTITION_HORZ:
510
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
511
      *(get_sb_index(xd, subsize)) = 1;
512
      if (mi_row + bs < pc->mi_rows)
513
        decode_modes_b(pbi, mi_row + bs, mi_col, r, subsize);
514 515
      break;
    case PARTITION_VERT:
516
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
517
      *(get_sb_index(xd, subsize)) = 1;
518
      if (mi_col + bs < pc->mi_cols)
519
        decode_modes_b(pbi, mi_row, mi_col + bs, r, subsize);
520 521 522 523
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
524
        *(get_sb_index(xd, subsize)) = n;
525
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
526 527 528 529 530
      }
      break;
    default:
      assert(0);
  }
531
  // update partition context
532 533
  if (bsize >= BLOCK_SIZE_SB8X8 &&
      (bsize == BLOCK_SIZE_SB8X8 || partition != PARTITION_SPLIT)) {
534 535 536
    set_partition_seg_context(pc, xd, mi_row, mi_col);
    update_partition_context(xd, subsize, bsize);
  }
537 538
}

539
static void setup_token_decoder(VP9D_COMP *pbi,
540 541
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
542
  VP9_COMMON *pc = &pbi->common;
543 544
  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
545

Dmitry Kovalev's avatar
Dmitry Kovalev committed
546 547 548
  // 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.
549
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
550 551 552 553
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

554
  if (vp9_reader_init(r, data, partition_size))
John Koleszar's avatar
John Koleszar committed
555 556
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
557 558
}

559 560
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
561
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
562

John Koleszar's avatar
John Koleszar committed
563
  if (pc->frame_type == KEY_FRAME) {
564
    vp9_setup_past_independence(pc, xd);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
565
    // All buffers are implicitly updated on key frames.
566
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
567 568 569
  } else if (pc->error_resilient_mode) {
    vp9_setup_past_independence(pc, xd);
  }
John Koleszar's avatar
John Koleszar committed
570

John Koleszar's avatar
John Koleszar committed
571
  xd->mode_info_context = pc->mi;
572
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
573 574 575
  xd->frame_type = pc->frame_type;
  xd->mode_info_context->mbmi.mode = DC_PRED;
  xd->mode_info_stride = pc->mode_info_stride;
John Koleszar's avatar
John Koleszar committed
576 577
}

578 579 580 581 582
static void read_coef_probs_common(
    vp9_coeff_probs_model *coef_probs,
    TX_SIZE tx_size,
    vp9_reader *r) {
  const int entropy_nodes_update = UNCONSTRAINED_NODES;
583

584
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
585

586
  if (vp9_read_bit(r)) {
587
    for (i = 0; i < BLOCK_TYPES; i++) {
588 589 590
      for (j = 0; j < REF_TYPES; j++) {
        for (k = 0; k < COEF_BANDS; k++) {
          for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
591
            const int mstart = 0;
592 593
            if (l >= 3 && k == 0)
              continue;
594 595

            for (m = mstart; m < entropy_nodes_update; m++) {
596 597
              vp9_prob *const p = coef_probs[i][j][k][l] + m;

598 599
              if (vp9_read(r, vp9_coef_update_prob[m])) {
                *p = read_prob_diff_update(r, *p);
600
              }
601 602 603
            }
          }
        }
604 605
      }
    }
606
  }
607
}
608

609 610 611
static void read_coef_probs(VP9D_COMP *pbi, vp9_reader *r) {
  const TXFM_MODE mode = pbi->common.txfm_mode;
  FRAME_CONTEXT *const fc = &pbi->common.fc;
Daniel Kang's avatar
Daniel Kang committed
612

613
  read_coef_probs_common(fc->coef_probs_4x4, TX_4X4, r);
614

615
  if (mode > ONLY_4X4)
616
    read_coef_probs_common(fc->coef_probs_8x8, TX_8X8, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
617

618
  if (mode > ALLOW_8X8)
619
    read_coef_probs_common(fc->coef_probs_16x16, TX_16X16, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
620

621
  if (mode > ALLOW_16X16)
622
    read_coef_probs_common(fc->coef_probs_32x32, TX_32X32, r);
623 624
}

625
static void setup_segmentation(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
626 627
  int i, j;

628 629
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;
630 631 632
#if CONFIG_IMPLICIT_SEGMENTATION
  xd->allow_implicit_segment_update = 0;
#endif
633

634
  xd->segmentation_enabled = vp9_read_bit(r);
635 636 637 638 639
  if (!xd->segmentation_enabled)
    return;

  // Segmentation map update
  xd->update_mb_segmentation_map = vp9_read_bit(r);
640 641 642
#if CONFIG_IMPLICIT_SEGMENTATION
    xd->allow_implicit_segment_update = vp9_read_bit(r);
#endif
643
  if (xd->update_mb_segmentation_map) {
644
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
645 646 647 648 649 650 651 652 653 654 655
      xd->mb_segment_tree_probs[i] = vp9_read_bit(r) ? vp9_read_prob(r)
                                                     : MAX_PROB;

    pc->temporal_update = vp9_read_bit(r);
    if (pc->temporal_update) {
      for (i = 0; i < PREDICTION_PROBS; i++)
        pc->segment_pred_probs[i] = vp9_read_bit(r) ? vp9_read_prob(r)
                                                    : MAX_PROB;
    } else {
      for (i = 0; i < PREDICTION_PROBS; i++)
        pc->segment_pred_probs[i] = MAX_PROB;
656
    }
657
  }
658

659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
  // Segmentation data update
  xd->update_mb_segmentation_data = vp9_read_bit(r);
  if (xd->update_mb_segmentation_data) {
    xd->mb_segment_abs_delta = vp9_read_bit(r);

    vp9_clearall_segfeatures(xd);

    for (i = 0; i < MAX_MB_SEGMENTS; i++) {
      for (j = 0; j < SEG_LVL_MAX; j++) {
        int data = 0;
        const int feature_enabled = vp9_read_bit(r);
        if (feature_enabled) {
          vp9_enable_segfeature(xd, i, j);
          data = decode_unsigned_max(r, vp9_seg_feature_data_max(j));
          if (vp9_is_segfeature_signed(j))
            data = vp9_read_and_apply_sign(r, data);
675
        }
676
        vp9_set_segdata(xd, i, j, data);
677 678 679 680 681
      }
    }
  }
}

682 683 684 685 686
static void setup_pred_probs(VP9_COMMON *pc, vp9_reader *r) {
  // Read common prediction model status flag probability updates for the
  // reference frame
  if (pc->frame_type == KEY_FRAME) {
    // Set the prediction probabilities to defaults
687 688 689
    pc->ref_pred_probs[0] = DEFAULT_PRED_PROB_0;
    pc->ref_pred_probs[1] = DEFAULT_PRED_PROB_1;
    pc->ref_pred_probs[2] = DEFAULT_PRED_PROB_2;
690 691 692 693 694 695 696
  } else {
    int i;
    for (i = 0; i < PREDICTION_PROBS; ++i)
      if (vp9_read_bit(r))
        pc->ref_pred_probs[i] = vp9_read_prob(r);
  }
}
697

698
static void setup_loopfilter(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
699 700
  pc->filter_level = vp9_read_literal(r, 6);
  pc->sharpness_level = vp9_read_literal(r, 3);
701 702 703 704 705

  // Read in loop filter deltas applied at the MB level based on mode or ref
  // frame.
  xd->mode_ref_lf_delta_update = 0;

706
  xd->mode_ref_lf_delta_enabled = vp9_read_bit(r);
707
  if (xd->mode_ref_lf_delta_enabled) {
708
    xd->mode_ref_lf_delta_update = vp9_read_bit(r);
709
    if (xd->mode_ref_lf_delta_update) {
710 711
      int i;

712
      for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
713
        if (vp9_read_bit(r)) {
714 715
          const int value = vp9_read_literal(r, 6);
          xd->ref_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
716 717 718 719
        }
      }

      for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
720
        if (vp9_read_bit(r)) {
721 722
          const int value = vp9_read_literal(r, 6);
          xd->mode_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
723 724 725 726 727 728
        }
      }
    }
  }
}

729 730 731 732 733
static void setup_quantization(VP9D_COMP *pbi, vp9_reader *r) {
  // Read the default quantizers
  VP9_COMMON *const pc = &pbi->common;

  pc->base_qindex = vp9_read_literal(r, QINDEX_BITS);
734 735 736
  if (get_delta_q(r, &pc->y_dc_delta_q) |
      get_delta_q(r, &pc->uv_dc_delta_q) |
      get_delta_q(r, &pc->uv_ac_delta_q))
737
    vp9_init_dequantizer(pc);
738

739
  mb_init_dequantizer(pc, &pbi->mb);  // MB level dequantizer setup
740 741
}

742 743 744 745 746
static INTERPOLATIONFILTERTYPE read_mcomp_filter_type(vp9_reader *r) {
  return vp9_read_bit(r) ? SWITCHABLE
                         : vp9_read_literal(r, 2);
}

747 748 749 750 751 752 753 754 755 756 757 758 759 760
static void read_frame_size(VP9_COMMON *cm,
                            struct vp9_read_bit_buffer *rb,
                            int *width, int *height) {
  const int w = vp9_rb_read_literal(rb, 16);
  const int h = vp9_rb_read_literal(rb, 16);
  if (w <= 0)
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Invalid frame width");

  if (h <= 0)
    vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
                       "Invalid frame height");
  *width = w;
  *height = h;
761 762
}

763 764
static void setup_frame_size(VP9D_COMP *pbi, int scaling_active,
                             struct vp9_read_bit_buffer *rb) {
765 766
  // If error concealment is enabled we should only parse the new size
  // if we have enough data. Otherwise we will end up with the wrong size.
767 768 769 770 771
  VP9_COMMON *const pc = &pbi->common;
  int display_width = pc->display_width;
  int display_height = pc->display_height;
  int width = pc->width;
  int height = pc->height;
772

773
  if (scaling_active)
774
    read_frame_size(pc, rb, &display_width, &display_height);
775

776
  read_frame_size(pc, rb, &width, &height);
777

778
  if (pc->width != width || pc->height != height) {
779
    if (!pbi->initial_width || !pbi->initial_height) {
780
      if (vp9_alloc_frame_buffers(pc, width, height))
781 782
        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate frame buffers");
783 784 785 786 787 788
        pbi->initial_width = width;
        pbi->initial_height = height;
    } else {
      if (width > pbi->initial_width)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame width too large");
789

790 791 792
      if (height > pbi->initial_height)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame height too large");
793 794
    }

795 796 797 798
    pc->width = width;
    pc->height = height;
    pc->display_width = scaling_active ? display_width : width;
    pc->display_height = scaling_active ? display_height : height;
799

800
    vp9_update_frame_size(pc);
801 802 803
  }
}

804
static void update_frame_context(FRAME_CONTEXT *fc) {
805 806 807 808
  vp9_copy(fc->pre_coef_probs_4x4, fc->coef_probs_4x4);
  vp9_copy(fc->pre_coef_probs_8x8, fc->coef_probs_8x8);
  vp9_copy(fc->pre_coef_probs_16x16, fc->coef_probs_16x16);
  vp9_copy(fc->pre_coef_probs_32x32, fc->coef_probs_32x32);
809
  vp9_copy(fc->pre_y_mode_prob, fc->y_mode_prob);
810
  vp9_copy(fc->pre_uv_mode_prob, fc->uv_mode_prob);
811
  vp9_copy(fc->pre_partition_prob, fc->partition_prob);
812 813 814 815 816 817 818
  fc->pre_nmvc = fc->nmvc;

  vp9_zero(fc->coef_counts_4x4);
  vp9_zero(fc->coef_counts_8x8);
  vp9_zero(fc->coef_counts_16x16);
  vp9_zero(fc->coef_counts_32x32);
  vp9_zero(fc->eob_branch_counts);
819
  vp9_zero(fc->y_mode_counts);
820 821 822
  vp9_zero(fc->uv_mode_counts);
  vp9_zero(fc->NMVcount);
  vp9_zero(fc->mv_ref_ct);
823
  vp9_zero(fc->partition_counts);
824
}
825

826 827
static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
  VP9_COMMON *const pc = &pbi->common;
828
  int mi_row, mi