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

13
#include "vp9/decoder/vp9_onyxd_int.h"
14
#include "vp9/common/vp9_common.h"
15 16 17
#include "vp9/common/vp9_header.h"
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_reconinter.h"
18
#include "vp9/common/vp9_entropy.h"
19
#include "vp9/decoder/vp9_decodframe.h"
20
#include "vp9/decoder/vp9_detokenize.h"
21 22 23 24
#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
25
#include "vpx_scale/vpx_scale.h"
26

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

33
#include "vp9/common/vp9_seg_common.h"
34
#include "vp9/common/vp9_tile_common.h"
35
#include "vp9_rtcd.h"
36

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

172
    // AC values
173 174
    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
175
  }
John Koleszar's avatar
John Koleszar committed
176 177
}

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

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

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

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

215
  TX_TYPE tx_type;
216

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

242 243 244 245 246 247 248 249 250 251
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;
252 253 254 255

    uint8_t* dst = raster_block_offset_uint8(xd, bsize, 0, i,
                                             xd->plane[0].dst.buf,
                                             xd->plane[0].dst.stride);
256

257
    vp9_intra4x4_predict(xd, i, bsize, b_mode, dst, xd->plane[0].dst.stride);
258 259
    // TODO(jingning): refactor to use foreach_transformed_block_in_plane_
    tx_type = get_tx_type_4x4(xd, i);
260
    dequant_add_y(xd, tx_type, i, bsize);
261
  }
262

263 264 265
  foreach_transformed_block_uv(xd, bsize, decode_block, xd);
}

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 296 297
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)) {
      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);
}

298
static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mi_row, int mi_col,
299
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
300
  const int bwl = mi_width_log2(bsize), bhl = mi_height_log2(bsize);
301
  const int bw = 1 << bwl, bh = 1 << bhl;
302
  int n, eobtotal;
303
  VP9_COMMON *const pc = &pbi->common;
304 305
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
306
  const int mis = pc->mode_info_stride;
307

308
  assert(mbmi->sb_type == bsize);
309 310

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

313
  // generate prediction
314
  if (mbmi->ref_frame == INTRA_FRAME) {
315 316
    vp9_build_intra_predictors_sby_s(xd, bsize);
    vp9_build_intra_predictors_sbuv_s(xd, bsize);
317
  } else {
318
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
319 320
  }

321
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
322
    vp9_reset_sb_tokens_context(xd, bsize);
323
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
324 325
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
326
      mb_init_dequantizer(pc, xd);
Yunqing Wang's avatar
Yunqing Wang committed
327 328

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

334
        if (mi_col + x_idx < pc->mi_cols && mi_row + y_idx < pc->mi_rows)
Yunqing Wang's avatar
Yunqing Wang committed
335 336 337
          mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
      }
    } else {
338
      foreach_transformed_block(xd, bsize, decode_block, xd);
339
    }
340
  }
341 342
}

343 344 345 346
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
347 348
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
349
  }
John Koleszar's avatar
John Koleszar committed
350

351
  // Trigger a quantizer update if the delta-q value has changed
352
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
353 354
}

355
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
356 357 358
                        int mi_row, int mi_col) {
  const int bh = 1 << mi_height_log2(bsize);
  const int bw = 1 << mi_width_log2(bsize);
359 360
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
361
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
362
  int i;
363

364
  xd->mode_info_context = cm->mi + mi_idx;
365
  xd->mode_info_context->mbmi.sb_type = bsize;
366 367
  xd->prev_mode_info_context = cm->prev_mi + mi_idx;

368 369
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
370
        (mi_col * 2 >> xd->plane[i].subsampling_x);
371
    xd->plane[i].left_context = cm->left_context[i] +
372
        (((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
373
  }
374 375
  xd->above_seg_context = cm->above_seg_context + mi_col;
  xd->left_seg_context  = cm->left_seg_context + (mi_row & MI_MASK);
376

377 378
  // 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
379
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
380

381
  setup_dst_planes(xd, &cm->yv12_fb[cm->new_fb_idx], mi_row, mi_col);
382
}
John Koleszar's avatar
John Koleszar committed
383

384
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
385 386
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
387
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
388 389

  if (mbmi->ref_frame > INTRA_FRAME) {
390
    // Select the appropriate reference frame for this MB
391 392 393
    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];
394
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
395
    setup_pre_planes(xd, cfg, NULL, mi_row, mi_col,
396
                     xd->scale_factor, xd->scale_factor_uv);
397
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
398

399
    if (mbmi->second_ref_frame > INTRA_FRAME) {
400
      // Select the appropriate reference frame for this MB
401 402
      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];
403 404
      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];
405
      setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col,
406
                       xd->scale_factor, xd->scale_factor_uv);
407
      xd->corrupted |= second_cfg->corrupted;
408 409 410
    }
  }
}
John Koleszar's avatar
John Koleszar committed
411

412
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
413 414 415
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

416 417 418
  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);
419

420 421 422 423
  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);
424
  else
425
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
426

427
  xd->corrupted |= vp9_reader_has_error(r);
428 429
}

430
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
431
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
432 433
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
434
  int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
435 436 437 438
  int n;
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

439
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
440 441
    return;

442
  if (bsize > BLOCK_SIZE_SB8X8) {
443
    int pl;
444
    // read the partition information
445 446
    xd->left_seg_context = pc->left_seg_context + (mi_row & MI_MASK);
    xd->above_seg_context = pc->above_seg_context + mi_col;
447
    pl = partition_plane_context(xd, bsize);
448
    partition = treed_read(r, vp9_partition_tree,
449 450
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
451 452
  }

453
  subsize = get_subsize(bsize, partition);
454 455
  switch (partition) {
    case PARTITION_NONE:
456
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
457 458
      break;
    case PARTITION_HORZ:
459
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
460
      if (mi_row + bs < pc->mi_rows)
461
        decode_modes_b(pbi, mi_row + bs, mi_col, r, subsize);
462 463
      break;
    case PARTITION_VERT:
464
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
465
      if (mi_col + bs < pc->mi_cols)
466
        decode_modes_b(pbi, mi_row, mi_col + bs, r, subsize);
467 468 469 470 471 472
      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;
473 474 475 476
        else if (subsize == BLOCK_SIZE_MB16X16)
          xd->mb_index = n;
        else
          xd->b_index = n;
477
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
478 479 480 481 482
      }
      break;
    default:
      assert(0);
  }
483
  // update partition context
484
  if ((partition == PARTITION_SPLIT) && (bsize > BLOCK_SIZE_MB16X16))
485 486
    return;

487 488
  xd->left_seg_context = pc->left_seg_context + (mi_row & MI_MASK);
  xd->above_seg_context = pc->above_seg_context + mi_col;
489
  update_partition_context(xd, subsize, bsize);
490 491
}

492
static void setup_token_decoder(VP9D_COMP *pbi,
493 494
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
495
  VP9_COMMON *pc = &pbi->common;
496 497
  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
498

Dmitry Kovalev's avatar
Dmitry Kovalev committed
499 500 501
  // 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.
502
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
503 504 505 506
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

507
  if (vp9_reader_init(r, data, partition_size))
John Koleszar's avatar
John Koleszar committed
508 509
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
510 511
}

512 513
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
514
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
515

John Koleszar's avatar
John Koleszar committed
516
  if (pc->frame_type == KEY_FRAME) {
517
    vp9_setup_past_independence(pc, xd);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
518
    // All buffers are implicitly updated on key frames.
519
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
520 521 522
  } else if (pc->error_resilient_mode) {
    vp9_setup_past_independence(pc, xd);
  }
John Koleszar's avatar
John Koleszar committed
523

John Koleszar's avatar
John Koleszar committed
524
  xd->mode_info_context = pc->mi;
525
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
526 527 528
  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
529 530
}

531 532 533
static void read_coef_probs_common(vp9_coeff_probs *coef_probs,
                                   TX_SIZE tx_size,
                                   vp9_reader *r) {
534 535 536 537 538 539
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
  const int entropy_nodes_update = UNCONSTRAINED_UPDATE_NODES;
#else
  const int entropy_nodes_update = ENTROPY_NODES;
#endif

540
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
541

542
  if (vp9_read_bit(r)) {
543
    for (i = 0; i < BLOCK_TYPES; i++) {
544 545 546
      for (j = 0; j < REF_TYPES; j++) {
        for (k = 0; k < COEF_BANDS; k++) {
          for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
547
            const int mstart = 0;
548 549
            if (l >= 3 && k == 0)
              continue;
550 551

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

554 555
              if (vp9_read(r, vp9_coef_update_prob[m])) {
                *p = read_prob_diff_update(r, *p);
556
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
557
                if (m == UNCONSTRAINED_NODES - 1)
558 559
                  vp9_get_model_distribution(*p, coef_probs[i][j][k][l], i, j);
#endif
560
              }
561 562 563
            }
          }
        }
564 565
      }
    }
566
  }
567
}
568

569 570 571
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
572

573
  read_coef_probs_common(fc->coef_probs_4x4, TX_4X4, r);
574

575
  if (mode > ONLY_4X4)
576
    read_coef_probs_common(fc->coef_probs_8x8, TX_8X8, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
577

578
  if (mode > ALLOW_8X8)
579
    read_coef_probs_common(fc->coef_probs_16x16, TX_16X16, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
580

581
  if (mode > ALLOW_16X16)
582
    read_coef_probs_common(fc->coef_probs_32x32, TX_32X32, r);
583 584
}

585
static void setup_segmentation(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
586 587
  int i, j;

588 589
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;
590 591 592
#if CONFIG_IMPLICIT_SEGMENTATION
  xd->allow_implicit_segment_update = 0;
#endif
593

594
  xd->segmentation_enabled = vp9_read_bit(r);
595 596 597 598 599
  if (!xd->segmentation_enabled)
    return;

  // Segmentation map update
  xd->update_mb_segmentation_map = vp9_read_bit(r);
600 601 602
#if CONFIG_IMPLICIT_SEGMENTATION
    xd->allow_implicit_segment_update = vp9_read_bit(r);
#endif
603
  if (xd->update_mb_segmentation_map) {
604
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
605 606 607 608 609 610 611 612 613 614 615
      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;
616
    }
617
  }
618

619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634
  // 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);
635
        }
636
        vp9_set_segdata(xd, i, j, data);
637 638 639 640 641
      }
    }
  }
}

642 643 644 645 646
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
647 648 649
    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;
650 651 652 653 654 655 656
  } else {
    int i;
    for (i = 0; i < PREDICTION_PROBS; ++i)
      if (vp9_read_bit(r))
        pc->ref_pred_probs[i] = vp9_read_prob(r);
  }
}
657

658
static void setup_loopfilter(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
659
  pc->filter_type = (LOOPFILTER_TYPE) vp9_read_bit(r);
660 661
  pc->filter_level = vp9_read_literal(r, 6);
  pc->sharpness_level = vp9_read_literal(r, 3);
662 663

#if CONFIG_LOOP_DERING
664 665
  if (vp9_read_bit(r))
    pc->dering_enabled = 1 + vp9_read_literal(r, 4);
666 667 668 669 670 671 672 673
  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;

674
  xd->mode_ref_lf_delta_enabled = vp9_read_bit(r);
675
  if (xd->mode_ref_lf_delta_enabled) {
676
    xd->mode_ref_lf_delta_update = vp9_read_bit(r);
677
    if (xd->mode_ref_lf_delta_update) {
678 679
      int i;

680
      for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
681
        if (vp9_read_bit(r)) {
682 683
          const int value = vp9_read_literal(r, 6);
          xd->ref_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
684 685 686 687
        }
      }

      for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
688
        if (vp9_read_bit(r)) {
689 690
          const int value = vp9_read_literal(r, 6);
          xd->mode_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
691 692 693 694 695 696
        }
      }
    }
  }
}

697 698 699 700 701
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);
702 703 704
  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))
705
    vp9_init_dequantizer(pc);
706

707
  mb_init_dequantizer(pc, &pbi->mb);  // MB level dequantizer setup
708 709
}

710 711 712 713 714
static INTERPOLATIONFILTERTYPE read_mcomp_filter_type(vp9_reader *r) {
  return vp9_read_bit(r) ? SWITCHABLE
                         : vp9_read_literal(r, 2);
}

715 716 717 718
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) {
719 720 721 722 723 724 725 726 727 728 729
    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;
730 731 732 733 734 735 736 737
    data += 4;
  } else {
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Failed to read frame size");
  }
  return data;
}

738
static const uint8_t *setup_frame_size(VP9D_COMP *pbi, int scaling_active,
739 740
                                       const uint8_t *data,
                                       const uint8_t *data_end) {
741 742
  // 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.
743 744 745 746 747
  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;
748

749 750
  if (scaling_active)
    data = read_frame_size(pc, data, data_end, &display_width, &display_height);
751

752
  data = read_frame_size(pc, data, data_end, &width, &height);
753

754
  if (pc->width != width || pc->height != height) {
755
    if (!pbi->initial_width || !pbi->initial_height) {
756
      if (vp9_alloc_frame_buffers(pc, width, height))
757 758
        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate frame buffers");
759 760 761 762 763 764
        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");
765

766 767 768
      if (height > pbi->initial_height)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame height too large");
769 770
    }

771 772 773 774
    pc->width = width;
    pc->height = height;
    pc->display_width = scaling_active ? display_width : width;
    pc->display_height = scaling_active ? display_height : height;
775

776
    vp9_update_frame_size(pc);
777 778 779 780 781
  }

  return data;
}

782
static void update_frame_context(FRAME_CONTEXT *fc) {
783 784 785 786 787 788 789 790 791
  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);
792
  vp9_copy(fc->pre_partition_prob, fc->partition_prob);
793 794 795 796 797 798 799 800 801 802 803 804 805 806
  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);
807
  vp9_zero(fc->partition_counts);
808
}
809

810 811
static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
  VP9_COMMON *const pc = &pbi->common;
812
  int mi_row, mi_col;
813

814
  for (mi_row = pc->cur_tile_mi_row_start;
815
       mi_row < pc->cur_tile_mi_row_end; mi_row += 8) {
816
    // For a SB there are 2 left contexts, each pertaining to a MB row within
817
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
818
    vpx_memset(pc->left_seg_context, 0, sizeof(pc->left_seg_context));
819
    for (mi_col = pc->cur_tile_mi_col_start;
820
         mi_col < pc->cur_tile_mi_col_end; mi_col += 8)
821
      decode_modes_sb(pbi, mi_row, mi_col, r, BLOCK_SIZE_SB64X64);
822 823 824
  }
}

825 826
static void decode_tiles(VP9D_COMP *pbi,
                         const uint8_t *data, int first_partition_size,
827
                         vp9_reader *header_bc, vp9_reader *residual_bc) {
828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
  VP9_COMMON *const pc = &pbi->common;

  const uint8_t *data_ptr = data + first_partition_size;
  int tile_row, tile_col, delta_log2_tiles;

  vp9_get_tile_n_bits(pc, &pc->log2_tile_columns, &delta_log2_tiles);
  while (delta_log2_tiles--) {
    if (vp9_read_bit(header_bc)) {
      pc->log2_tile_columns++;
    } else {
      break;
    }
  }
  pc->log2_tile_rows = vp9_read_bit(header_bc);
  if (pc->log2_tile_rows)
    pc->log2_tile_rows += vp9_read_bit(header_bc);
  pc->tile_columns = 1 << pc->log2_tile_columns;
  pc->tile_rows    = 1 << pc->log2_tile_rows;

847 848
  // Note: this memset assumes above_context[0], [1] and [2]
  // are allocated as part of the same buffer.
849 850
  vpx_memset(pc->above_context[0], 0, sizeof(ENTROPY_CONTEXT) * 2 *
                                      MAX_MB_PLANE * mi_cols_aligned_to_sb(pc));
851 852

  vpx_memset(pc->above_seg_context, 0, sizeof(PARTITION_CONTEXT) *
853
                                       mi_cols_aligned_to_sb(pc));
854 855 856 857

  if (pbi->oxcf.inv_tile_order) {
    const int n_cols = pc->tile_columns;
    const uint8_t *data_ptr2[4][1 << 6];
858
    vp9_reader bc_bak = {0};
859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881

    // pre-initialize the offsets, we're going to read in inverse order
    data_ptr2[0][0] = data_ptr;
    for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
      if (tile_row) {
        const int size = read_le32(data_ptr2[tile_row - 1][n_cols - 1]);
        data_ptr2[tile_row - 1][n_cols - 1] += 4;
        data_ptr2[tile_row][0] = data_ptr2[tile_row - 1][n_cols - 1] + size;
      }

      for (tile_col = 1; tile_col < n_cols; tile_col++) {
        const int size = read_le32(data_ptr2[tile_row][tile_col - 1]);
        data_ptr2[tile_row][tile_col - 1] += 4;
        data_ptr2[tile_row][tile_col] =
            data_ptr2[tile_row][tile_col - 1] + size;
      }
    }

    for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
      vp9_get_tile_row_offsets(pc, tile_row);
      for (tile_col = n_cols - 1; tile_col >= 0; tile_col--) {
        vp9_get_tile_col_offsets(pc, tile_col);
        setup_token_decoder(pbi, data_ptr2[tile_row][tile_col], residual_bc);
882
        decode_tile(pbi, residual_bc);
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899
        if (tile_row == pc->tile_rows - 1 && tile_col == n_cols - 1)
          bc_bak = *residual_bc;
      }
    }
    *residual_bc = bc_bak;
  } else {
    int has_more;

    for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
      vp9_get_tile_row_offsets(pc, tile_row);
      for (tile_col = 0; tile_col < pc->tile_columns; tile_col++) {
        vp9_get_tile_col_offsets(pc, tile_col);

        has_more = tile_col < pc->tile_columns - 1 ||
                   tile_row < pc->tile_rows - 1;

        setup_token_decoder(pbi, data_ptr + (has_more ? 4 : 0), residual_bc);
900
        decode_tile(pbi, residual_bc);
901 902 903 904 905 906 907 908 909 910

        if (has_more) {
          const int size = read_le32(data_ptr);
          data_ptr += 4 + size;
        }
      }
    }
  }
}

911
int vp9_decode_frame(VP9D_COMP *pbi, const uint8_t **p_data_end) {
912
  vp9_reader header_bc, residual_bc;
913
  VP9_COMMON *const pc = &pbi->common;
914
  MACROBLOCKD *const xd  = &pbi->mb;
915
  const uint8_t *data = pbi->source;
916
  const uint8_t *data_end = data + pbi->source_sz;
917
  size_t first_partition_size = 0;
918
  YV12_BUFFER_CONFIG *new_fb = &pc->yv12_fb[pc->new_fb_idx];
919
  int i;
John Koleszar's avatar
John Koleszar committed
920

921
  xd->corrupted = 0;  // start with no corruption of current frame
922
  new_fb->corrupted = 0;
John Koleszar's avatar
John Koleszar committed
923 924

  if (data_end - data < 3) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
925
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, "Truncated packet");
John Koleszar's avatar
John Koleszar committed
926
  } else {
927
    int scaling_active;
John Koleszar's avatar
John Koleszar committed
928 929 930 931
    pc->last_frame_type = pc->frame_type;
    pc->frame_type = (FRAME_TYPE)(data[0] & 1);
    pc->version = (data[0] >> 1) & 7;
    pc->show_frame = (data[0] >> 4) & 1;
932
    scaling_active = (data[0] >> 5) & 1;
933
    first_partition_size = read_le16(data + 1);
John Koleszar's avatar
John Koleszar committed
934

935
    if (!read_is_valid(data, first_partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
936 937 938 939 940
      vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                         "Truncated packet or corrupt partition 0 length");

    data += 3;

941
    vp9_setup_version(pc);
Yaowu Xu's avatar
Yaowu Xu committed
942

John Koleszar's avatar
John Koleszar committed
943
    if (pc->frame_type == KEY_FRAME) {
944 945
      // When error concealment is enabled we should only check the sync
      // code if we have enough bits available
John Koleszar's avatar
John Koleszar committed
946 947 948 949 950
      if (data + 3 < data_end) {
        if (data[0] != 0x9d || data[1] != 0x01 || data[2] != 0x2a)
          vpx_internal_error(&pc->error, VPX_CODEC_UNSUP_BITSTREAM,
                             "Invalid frame sync code");
      }
951 952
      data += 3;
    }
953

954
    data = setup_frame_size(pbi, scaling_active, data, data_end);
John Koleszar's avatar
John Koleszar committed
955
  }
John Koleszar's avatar
John Koleszar committed
956

John Koleszar's avatar
John Koleszar committed
957
  if ((!pbi->decoded_key_frame && pc->frame_type != KEY_FRAME) ||
958
      pc->width == 0 || pc->height == 0) {
John Koleszar's avatar
John Koleszar committed
959 960
    return -1;
  }
961

John Koleszar's avatar
John Koleszar committed
962
  init_frame(pbi);
John Koleszar's avatar
John Koleszar committed
963

964
  // Reset the frame pointers to the current frame size
965
  vp8_yv12_realloc_frame_buffer(new_fb, pc->width, pc->height,
966 967
                                VP9BORDERINPIXELS);

968
  if (vp9_reader_init(&header_bc, data, first_partition_size))
John Koleszar's avatar
John Koleszar committed
969 970
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder 0");
John Koleszar's avatar
John Koleszar committed
971

972 973
  pc->clr_type = (YUV_TYPE)vp9_read_bit(&header_bc);
  pc->clamp_type = (CLAMP_TYPE)vp9_read_bit(&header_bc);
974
  pc->error_resilient_mode = vp9_read_bit(&header_bc);
Paul Wilkins's avatar
Paul Wilkins committed
975

976
  xd->lossless = vp9_read_bit(&header_bc);
977 978 979 980 981 982 983 984 985 986 987 988 989
  if (xd->lossless) {
    xd->inv_txm4x4_1      = vp9_short_iwalsh4x4_1;
    xd->inv_txm4x4        = vp9_short_iwalsh4x4;
    xd->itxm_add          = vp9_idct_add_lossless_c;
    xd->itxm_add_y_block  = vp9_idct_add_y_block_lossless_c;
    xd->itxm_add_uv_block = vp9_idct_add_uv_block_lossless_c;
  } else {
    xd->inv_txm4x4_1      = vp9_short_idct4x4_1;
    xd->inv_txm4x4        = vp9_short_idct4x4;
    xd->itxm_add          = vp9_idct_add;
    xd->itxm_add_y_block  = vp9_idct_add_y_block;
    xd->itxm_add_uv_block = vp9_idct_add_uv_block;
  }
990

991
  setup_loopfilter(pc, xd, &header_bc);
John Koleszar's avatar
John Koleszar committed
992

993
  setup_quantization(pbi, &header_bc);
John Koleszar's avatar
John Koleszar committed
994

995 996 997
  // Determine if the golden frame or ARF buffer should be updated and how.
  // For all non key frames the GF and ARF refresh flags and sign bias
  // flags must be set explicitly.
998
  if (pc->frame_type == KEY_FRAME) {
999 1000
    for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i)
      pc->active_ref_idx[i] = pc->new_fb_idx;
1001
  } else {
1002
    // Should the GF or ARF be updated from the current frame
1003
    pbi->refresh_frame_flags = vp9_read_literal(&header_bc, NUM_REF_FRAMES);
John Koleszar's avatar
John Koleszar committed
1004

1005
    // Select active reference frames and calculate scaling factors
1006
    for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i) {
1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
      const int ref = vp9_read_literal(&header_bc, NUM_REF_FRAMES_LG2);
      const int mapped_ref = pc->ref_frame_map[ref];
      YV12_BUFFER_CONFIG *const fb = &pc->yv12_fb[mapped_ref];
      struct scale_factors *const sf = &pc->active_ref_scale[i];

      pc->active_ref_idx[i] = mapped_ref;
      if (mapped_ref >= NUM_YV12_BUFFERS)
        memset(sf, 0, sizeof(*sf));
      else
        vp9_setup_scale_factors_for_frame(sf, fb, pc->width, pc->height);
1017 1018
    }

1019 1020 1021 1022 1023
    // Read the sign bias for each reference frame buffer.
    for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i) {
      pc->ref_frame_sign_bias[i + 1] = vp9_read_bit(&header_bc);
    }

1024
    xd->allow_high_precision_mv = vp9_read_bit(&header_bc);
1025
    pc->mcomp_filter_type = read_mcomp_filter_type(&header_bc);
1026

1027
    // To enable choice of different interpolation filters
1028
    vp9_setup_interp_filters(xd, pc->mcomp_filter_type, pc);
John Koleszar's avatar
John Koleszar committed
1029 1030
  }

1031
  if (!pc->error_resilient_mode) {
1032
    pc->refresh_frame_context = vp9_read_bit(&header_bc);
1033 1034
    pc->frame_parallel_decoding_mode = vp9_read_bit(&header_bc);
  } else {
1035
    pc->refresh_frame_context = 0;
1036 1037
    pc->frame_parallel_decoding_mode = 1;
  }
1038

1039
  pc->frame_context_idx = vp9_read_literal(&header_bc, NUM_FRAME_CONTEXTS_LG2);
1040
  pc->fc = pc->frame_contexts[pc->frame_context_idx];
John Koleszar's avatar
John Koleszar committed
1041

1042 1043 1044 1045
  setup_segmentation(pc, xd, &header_bc);

  setup_pred_probs(pc, &header_bc);

1046
  setup_txfm_mode(pc, xd->lossless, &header_bc);
1047

1048 1049 1050
  // Read inter mode probability context updates
  if (pc->frame_type != KEY_FRAME) {
    int i, j;
Dmitry Kovalev's avatar
Dmitry Kovalev committed
1051 1052 1053
    for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
      for (j = 0; j < 4; ++j)
        if (vp9_read(&header_bc, 252))
1054
          pc->fc.vp9_mode_contexts[i][j] = vp9_read_prob(&header_bc);
1055
  }
1056
#if CONFIG_MODELCOEFPROB
1057
  if (pc->frame_type == KEY_FRAME)
1058
    vp9_default_coef_probs(pc);
1059
#endif
1060

1061
  update_frame_context(&pc->fc);
1062 1063

  read_coef_probs(pbi, &header_bc);
Yaowu Xu's avatar
Yaowu Xu committed
1064

1065
  // Initialize xd pointers. Any reference should do for xd->pre, so use 0.
1066 1067
  setup_pre_planes(xd, &pc->yv12_fb[pc->active_ref_idx[0]], NULL,
                   0, 0, NULL, NULL);
1068
  setup_dst_planes(xd, new_fb, 0, 0);
John Koleszar's avatar
John Koleszar committed
1069

John Koleszar's avatar
John Koleszar committed
1070 1071 1072
  // Create the segmentation map structure and set to 0
  if (!pc->last_frame_seg_map)
    CHECK_MEM_ERROR(pc->last_frame_seg_map,
1073
                    vpx_calloc((pc->mi_rows * pc->mi_cols), 1));
1074

1075
  vp9_setup_block_dptrs(xd);
John Koleszar's avatar
John Koleszar committed
1076

Dmitry Kovalev's avatar
Dmitry Kovalev committed
1077
  // clear out the coeff buffer
1078 1079
  for (i = 0; i < MAX_MB_PLANE; ++i)
    vp9_zero(xd->plane[i].qcoeff);
John Koleszar's avatar
John Koleszar committed
1080

1081
  vp9_decode_mode_mvs_init(pbi, &header_bc);
John Koleszar's avatar
John Koleszar committed
1082

1083
  decode_tiles(pbi, data, first_partition_size, &header_bc, &residual_bc);
John Koleszar's avatar
John Koleszar committed
1084

1085 1086
  pc->last_width = pc->width;
  pc->last_height = pc->height;
1087

1088
  new_fb->corrupted = vp9_reader_has_error(&header_bc) | xd->corrupted;
John Koleszar's avatar
John Koleszar committed
1089 1090

  if (!pbi->decoded_key_frame) {
1091
    if (pc->frame_type == KEY_FRAME && !new_fb->corrupted)
John Koleszar's avatar
John Koleszar committed
1092 1093
      pbi->decoded_key_frame = 1;
    else
1094
      vpx_inte