vp9_decodframe.c 39.5 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"
Scott LaVarnway's avatar
Scott LaVarnway committed
27

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

34
#include "vp9/common/vp9_seg_common.h"
35
#include "vp9/common/vp9_tile_common.h"
36
#include "vp9_rtcd.h"
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
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
263
    vp9_intra4x4_predict(xd, i, bsize, b_mode, dst, xd->plane[0].dst.stride);
264 265
    // TODO(jingning): refactor to use foreach_transformed_block_in_plane_
    tx_type = get_tx_type_4x4(xd, i);
266
    dequant_add_y(xd, tx_type, i, bsize);
267 268 269 270 271 272 273 274
  }
#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);
}

275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
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;

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

  // prediction
  if (mbmi->ref_frame == INTRA_FRAME)
    vp9_build_intra_predictors_sbuv_s(xd, bsize);
  else
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);

  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)) {
#if CONFIG_NEWBINTRAMODES
    if (mbmi->mode != I4X4_PRED)
#endif
      vp9_decode_tokens(pbi, xd, r, bsize);
    }
  }

  if (mbmi->ref_frame == INTRA_FRAME)
    decode_atom_intra(pbi, xd, r, bsize);
  else
    foreach_transformed_block(xd, bsize, decode_block, xd);
}

310
static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mi_row, int mi_col,
311
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
312
  const int bwl = mi_width_log2(bsize), bhl = mi_height_log2(bsize);
313
  const int bw = 1 << bwl, bh = 1 << bhl;
314
  int n, eobtotal;
315
  VP9_COMMON *const pc = &pbi->common;
316 317
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
318
  const int mis = pc->mode_info_stride;
319

320
  assert(mbmi->sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
321 322

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

325
  // generate prediction
326
  if (mbmi->ref_frame == INTRA_FRAME) {
327 328
    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
329
  } else {
330
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
331 332
  }

333
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
334
    vp9_reset_sb_tokens_context(xd, bsize);
335
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
336 337
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
338
      mb_init_dequantizer(pc, xd);
Yunqing Wang's avatar
Yunqing Wang committed
339 340

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

346
        if (mi_col + x_idx < pc->mi_cols && mi_row + y_idx < pc->mi_rows)
Yunqing Wang's avatar
Yunqing Wang committed
347 348 349
          mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
      }
    } else {
350
      foreach_transformed_block(xd, bsize, decode_block, xd);
351
    }
352
  }
353 354
}

355 356 357 358
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
359 360
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
361
  }
John Koleszar's avatar
John Koleszar committed
362

363
  // Trigger a quantizer update if the delta-q value has changed
364
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
365 366
}

367
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
368 369 370
                        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
371 372
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
373
  int i;
John Koleszar's avatar
John Koleszar committed
374

375
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
376
  const YV12_BUFFER_CONFIG *dst_fb = &cm->yv12_fb[cm->new_fb_idx];
377 378 379 380
  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);
381

382
  xd->mode_info_context = cm->mi + mi_idx;
383
  xd->mode_info_context->mbmi.sb_type = bsize;
384 385
  xd->prev_mode_info_context = cm->prev_mi + mi_idx;

386 387
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
Jingning Han's avatar
Jingning Han committed
388
        (mi_col * 2 >> xd->plane[i].subsampling_x);
389
    xd->plane[i].left_context = cm->left_context[i] +
Jingning Han's avatar
Jingning Han committed
390
        (((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
391
  }
Jingning Han's avatar
Jingning Han committed
392 393
  xd->above_seg_context = cm->above_seg_context + (mi_col >> 1);
  xd->left_seg_context  = cm->left_seg_context + ((mi_row >> 1) & 3);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
394

395 396
  // 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
397
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
398

399 400 401
  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
402
}
John Koleszar's avatar
John Koleszar committed
403

404
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
405 406
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
407
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
408 409

  if (mbmi->ref_frame > INTRA_FRAME) {
410
    // Select the appropriate reference frame for this MB
411 412 413
    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];
414
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
415
    setup_pre_planes(xd, cfg, NULL, mi_row, mi_col,
416
                     xd->scale_factor, xd->scale_factor_uv);
417
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
418

Ronald S. Bultje's avatar
Ronald S. Bultje committed
419
    if (mbmi->second_ref_frame > INTRA_FRAME) {
420
      // Select the appropriate reference frame for this MB
421 422
      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
423 424
      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];
425
      setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col,
426
                       xd->scale_factor, xd->scale_factor_uv);
427
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
428 429 430
    }
  }
}
John Koleszar's avatar
John Koleszar committed
431

432
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
433 434 435
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

436 437 438
  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);
439

440 441 442 443
  if (bsize == BLOCK_SIZE_SB8X8 &&
      (xd->mode_info_context->mbmi.mode == SPLITMV ||
       xd->mode_info_context->mbmi.mode == I4X4_PRED))
    decode_atom(pbi, xd, mi_row, mi_col, r, bsize);
444
  else
445
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
446

447
  xd->corrupted |= vp9_reader_has_error(r);
448 449
}

450
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
451
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
452 453
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
454
  int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
455 456 457 458
  int n;
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

459
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
460 461
    return;

462
  if (bsize > BLOCK_SIZE_SB8X8) {
463
    int pl;
464
    // read the partition information
465
    xd->left_seg_context =
Jingning Han's avatar
Jingning Han committed
466 467
        pc->left_seg_context + ((mi_row >> 1) & 3);
    xd->above_seg_context = pc->above_seg_context + (mi_col >> 1);
468
    pl = partition_plane_context(xd, bsize);
469
    partition = treed_read(r, vp9_partition_tree,
470 471
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
472 473
  }

474
  subsize = get_subsize(bsize, partition);
475 476
  switch (partition) {
    case PARTITION_NONE:
477
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
478 479
      break;
    case PARTITION_HORZ:
480 481 482
      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);
483 484
      break;
    case PARTITION_VERT:
485 486 487
      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);
488 489 490 491 492 493
      break;
    case PARTITION_SPLIT:
      for (n = 0; n < 4; n++) {
        int j = n >> 1, i = n & 0x01;
        if (subsize == BLOCK_SIZE_SB32X32)
          xd->sb_index = n;
494 495 496 497
        else if (subsize == BLOCK_SIZE_MB16X16)
          xd->mb_index = n;
        else
          xd->b_index = n;
498
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
499 500 501 502 503
      }
      break;
    default:
      assert(0);
  }
504
  // update partition context
505
  if ((partition == PARTITION_SPLIT) && (bsize > BLOCK_SIZE_MB16X16))
506 507
    return;

Jingning Han's avatar
Jingning Han committed
508 509
  xd->left_seg_context = pc->left_seg_context + ((mi_row >> 1) & 3);
  xd->above_seg_context = pc->above_seg_context + (mi_col >> 1);
510
  update_partition_context(xd, subsize, bsize);
511 512
}

513
static void setup_token_decoder(VP9D_COMP *pbi,
514 515
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
516
  VP9_COMMON *pc = &pbi->common;
517 518
  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
519

Dmitry Kovalev's avatar
Dmitry Kovalev committed
520 521 522
  // 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.
523
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
524 525 526 527
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

528
  if (vp9_reader_init(r, data, partition_size))
John Koleszar's avatar
John Koleszar committed
529 530
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
531 532
}

533 534
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
535
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
536

John Koleszar's avatar
John Koleszar committed
537
  if (pc->frame_type == KEY_FRAME) {
538
    vp9_setup_past_independence(pc, xd);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
539
    // All buffers are implicitly updated on key frames.
540
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
541 542 543
  } else if (pc->error_resilient_mode) {
    vp9_setup_past_independence(pc, xd);
  }
John Koleszar's avatar
John Koleszar committed
544

John Koleszar's avatar
John Koleszar committed
545
  xd->mode_info_context = pc->mi;
546
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
547 548 549
  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
550 551
}

552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
#if CONFIG_CODE_ZEROGROUP
static void read_zpc_probs_common(VP9_COMMON *cm,
                                  vp9_reader* bc,
                                  TX_SIZE tx_size) {
  int r, b, p, n;
  vp9_zpc_probs *zpc_probs;
  vp9_prob upd = ZPC_UPDATE_PROB;
  if (!get_zpc_used(tx_size)) return;
  if (!vp9_read_bit(bc)) return;

  if (tx_size == TX_32X32) {
    zpc_probs = &cm->fc.zpc_probs_32x32;
  } else if (tx_size == TX_16X16) {
    zpc_probs = &cm->fc.zpc_probs_16x16;
  } else if (tx_size == TX_8X8) {
    zpc_probs = &cm->fc.zpc_probs_8x8;
  } else {
    zpc_probs = &cm->fc.zpc_probs_4x4;
  }
  for (r = 0; r < REF_TYPES; ++r) {
    for (b = 0; b < ZPC_BANDS; ++b) {
      for (p = 0; p < ZPC_PTOKS; ++p) {
        for (n = 0; n < ZPC_NODES; ++n) {
          vp9_prob *q = &(*zpc_probs)[r][b][p][n];
#if USE_ZPC_EXTRA == 0
          if (n == 1) continue;
#endif
          if (vp9_read(bc, upd)) {
            *q = read_prob_diff_update(bc, *q);
          }
        }
      }
    }
  }
}

static void read_zpc_probs(VP9_COMMON *cm,
                           vp9_reader* bc) {
  read_zpc_probs_common(cm, bc, TX_4X4);
591
  if (cm->txfm_mode > ONLY_4X4)
592 593 594 595 596 597 598 599
    read_zpc_probs_common(cm, bc, TX_8X8);
  if (cm->txfm_mode > ALLOW_8X8)
    read_zpc_probs_common(cm, bc, TX_16X16);
  if (cm->txfm_mode > ALLOW_16X16)
    read_zpc_probs_common(cm, bc, TX_32X32);
}
#endif  // CONFIG_CODE_ZEROGROUP

600 601 602
static void read_coef_probs_common(vp9_coeff_probs *coef_probs,
                                   TX_SIZE tx_size,
                                   vp9_reader *r) {
603 604 605 606 607 608
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
  const int entropy_nodes_update = UNCONSTRAINED_UPDATE_NODES;
#else
  const int entropy_nodes_update = ENTROPY_NODES;
#endif

609
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
610

611
  if (vp9_read_bit(r)) {
612
    for (i = 0; i < BLOCK_TYPES; i++) {
613 614 615
      for (j = 0; j < REF_TYPES; j++) {
        for (k = 0; k < COEF_BANDS; k++) {
          for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
616
            const int mstart = 0;
617 618
            if (l >= 3 && k == 0)
              continue;
619 620

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

623 624
              if (vp9_read(r, vp9_coef_update_prob[m])) {
                *p = read_prob_diff_update(r, *p);
625
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
626
                if (m == UNCONSTRAINED_NODES - 1)
627 628
                  vp9_get_model_distribution(*p, coef_probs[i][j][k][l], i, j);
#endif
629
              }
630 631 632
            }
          }
        }
633 634
      }
    }
635
  }
636
}
637

638 639 640
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
641

642
  read_coef_probs_common(fc->coef_probs_4x4, TX_4X4, r);
643

644
  if (mode > ONLY_4X4)
645
    read_coef_probs_common(fc->coef_probs_8x8, TX_8X8, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
646

647
  if (mode > ALLOW_8X8)
648
    read_coef_probs_common(fc->coef_probs_16x16, TX_16X16, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
649

650
  if (mode > ALLOW_16X16)
651
    read_coef_probs_common(fc->coef_probs_32x32, TX_32X32, r);
652 653
}

654
static void setup_segmentation(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
655 656
  int i, j;

657 658
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;
659 660 661
#if CONFIG_IMPLICIT_SEGMENTATION
  xd->allow_implicit_segment_update = 0;
#endif
662

663
  xd->segmentation_enabled = vp9_read_bit(r);
664 665 666 667 668
  if (!xd->segmentation_enabled)
    return;

  // Segmentation map update
  xd->update_mb_segmentation_map = vp9_read_bit(r);
669 670 671
#if CONFIG_IMPLICIT_SEGMENTATION
    xd->allow_implicit_segment_update = vp9_read_bit(r);
#endif
672
  if (xd->update_mb_segmentation_map) {
673
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
674 675 676 677 678 679 680 681 682 683 684
      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;
685
    }
686
  }
687

688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
  // 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);
704
        }
705
        vp9_set_segdata(xd, i, j, data);
706 707 708 709 710
      }
    }
  }
}

711 712 713 714 715
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
716 717 718
    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;
719 720 721 722 723 724 725
  } else {
    int i;
    for (i = 0; i < PREDICTION_PROBS; ++i)
      if (vp9_read_bit(r))
        pc->ref_pred_probs[i] = vp9_read_prob(r);
  }
}
726

727
static void setup_loopfilter(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
728
  pc->filter_type = (LOOPFILTER_TYPE) vp9_read_bit(r);
729 730
  pc->filter_level = vp9_read_literal(r, 6);
  pc->sharpness_level = vp9_read_literal(r, 3);
731 732

#if CONFIG_LOOP_DERING
733 734
  if (vp9_read_bit(r))
    pc->dering_enabled = 1 + vp9_read_literal(r, 4);
735 736 737 738 739 740 741 742
  else
    pc->dering_enabled = 0;
#endif

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

743
  xd->mode_ref_lf_delta_enabled = vp9_read_bit(r);
744
  if (xd->mode_ref_lf_delta_enabled) {
745
    xd->mode_ref_lf_delta_update = vp9_read_bit(r);
746
    if (xd->mode_ref_lf_delta_update) {
747 748
      int i;

749
      for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
750
        if (vp9_read_bit(r)) {
751 752
          const int value = vp9_read_literal(r, 6);
          xd->ref_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
753 754 755 756
        }
      }

      for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
757
        if (vp9_read_bit(r)) {
758 759
          const int value = vp9_read_literal(r, 6);
          xd->mode_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
760 761 762 763 764 765
        }
      }
    }
  }
}

766 767 768 769 770
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);
771 772 773
  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))
774
    vp9_init_dequantizer(pc);
775

776
  mb_init_dequantizer(pc, &pbi->mb);  // MB level dequantizer setup
777 778
}

779 780 781 782 783
static INTERPOLATIONFILTERTYPE read_mcomp_filter_type(vp9_reader *r) {
  return vp9_read_bit(r) ? SWITCHABLE
                         : vp9_read_literal(r, 2);
}

784 785 786 787
static const uint8_t *read_frame_size(VP9_COMMON *const pc, const uint8_t *data,
                                      const uint8_t *data_end,
                                      int *width, int *height) {
  if (data + 4 < data_end) {
788 789 790 791 792 793 794 795 796 797 798
    const int w = read_le16(data);
    const int h = read_le16(data + 2);
    if (w <= 0)
      vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                         "Invalid frame width");

    if (h <= 0)
      vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                         "Invalid frame height");
    *width = w;
    *height = h;
799 800 801 802 803 804 805 806
    data += 4;
  } else {
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Failed to read frame size");
  }
  return data;
}

807
static const uint8_t *setup_frame_size(VP9D_COMP *pbi, int scaling_active,
808 809
                                       const uint8_t *data,
                                       const uint8_t *data_end) {
810 811
  // 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.
812 813 814 815 816
  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;
817

818 819
  if (scaling_active)
    data = read_frame_size(pc, data, data_end, &display_width, &display_height);
820

821
  data = read_frame_size(pc, data, data_end, &width, &height);
822

823
  if (pc->width != width || pc->height != height) {
824
    if (!pbi->initial_width || !pbi->initial_height) {
825
      if (vp9_alloc_frame_buffers(pc, width, height))
826 827
        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate frame buffers");
828 829 830 831 832 833
        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");
834

835 836 837
      if (height > pbi->initial_height)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame height too large");
838 839
    }

840 841 842 843
    pc->width = width;
    pc->height = height;
    pc->display_width = scaling_active ? display_width : width;
    pc->display_height = scaling_active ? display_height : height;
844

845
    vp9_update_frame_size(pc);
846 847 848 849 850
  }

  return data;
}

851
static void update_frame_context(FRAME_CONTEXT *fc) {
852 853 854 855 856 857 858 859 860
  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);
  vp9_copy(fc->pre_ymode_prob, fc->ymode_prob);
  vp9_copy(fc->pre_sb_ymode_prob, fc->sb_ymode_prob);
  vp9_copy(fc->pre_uv_mode_prob, fc->uv_mode_prob);
  vp9_copy(fc->pre_bmode_prob, fc->bmode_prob);
  vp9_copy(fc->pre_sub_mv_ref_prob, fc->sub_mv_ref_prob);
861
  vp9_copy(fc->pre_partition_prob, fc->partition_prob);
862 863 864 865 866 867 868 869 870 871 872 873 874 875
  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);
  vp9_zero(fc->ymode_counts);
  vp9_zero(fc->sb_ymode_counts);
  vp9_zero(fc->uv_mode_counts);
  vp9_zero(fc->bmode_counts);
  vp9_zero(fc->sub_mv_ref_counts);
  vp9_zero(fc->NMVcount);
  vp9_zero(fc->mv_ref_ct);
876
  vp9_zero(fc->partition_counts);
877 878 879 880 881 882

#if CONFIG_COMP_INTERINTRA_PRED
  fc->pre_interintra_prob = fc->interintra_prob;
  vp9_zero(fc->interintra_counts);
#endif

883 884 885 886 887 888 889 890 891 892