vp9_decodframe.c 36.7 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
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;

Ronald S. Bultje's avatar
Ronald S. Bultje committed
262 263
  if (xd->mode_info_context->mbmi.sb_type < BLOCK_SIZE_SB8X8 && plane == 0) {
    assert(bsize == BLOCK_SIZE_SB8X8);
264
    b_mode = xd->mode_info_context->bmi[raster_block].as_mode.first;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
265
  } else {
266
    b_mode = mode;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
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

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

298 299 300 301 302
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
303 304
  assert(mbmi->ref_frame != INTRA_FRAME);

305 306 307 308
  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
309
  vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
310 311 312 313 314 315 316 317 318 319 320 321

  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
322
  foreach_transformed_block(xd, bsize, decode_block, xd);
323 324
}

325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
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);
}


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

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

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

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

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

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

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

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

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

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

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

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

411 412
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
Jingning Han's avatar
Jingning Han committed
413
        (mi_col * 2 >> xd->plane[i].subsampling_x);
414
    xd->plane[i].left_context = cm->left_context[i] +
Jingning Han's avatar
Jingning Han committed
415
        (((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
416
  }
417 418
  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
419

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

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

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

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

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

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

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

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

474
  xd->corrupted |= vp9_reader_has_error(r);
475 476
}

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

486
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
487 488
    return;

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

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

504
  subsize = get_subsize(bsize, partition);
505
  *(get_sb_index(xd, subsize)) = 0;
506

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

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

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

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

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

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

John Koleszar's avatar
John Koleszar committed
573
  xd->mode_info_context = pc->mi;
574
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
575 576 577
  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
578 579
}

580 581
static void read_coef_probs_common(FRAME_CONTEXT *fc, TX_SIZE tx_size,
                                   vp9_reader *r) {
582
  const int entropy_nodes_update = UNCONSTRAINED_NODES;
583
  vp9_coeff_probs_model *coef_probs = fc->coef_probs[tx_size];
584

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

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

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

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

610 611 612
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
613

614
  read_coef_probs_common(fc, TX_4X4, r);
615

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

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

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

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

629 630 631
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;

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

  // Segmentation map update
  xd->update_mb_segmentation_map = vp9_read_bit(r);
  if (xd->update_mb_segmentation_map) {
639
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
640 641 642 643 644 645 646 647 648 649 650
      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;
651
    }
652
  }
653

654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669
  // 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);
670
        }
671
        vp9_set_segdata(xd, i, j, data);
672 673 674 675 676
      }
    }
  }
}

677 678 679 680 681
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
682 683 684
    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;
685 686 687 688 689 690 691
  } else {
    int i;
    for (i = 0; i < PREDICTION_PROBS; ++i)
      if (vp9_read_bit(r))
        pc->ref_pred_probs[i] = vp9_read_prob(r);
  }
}
692

693
static void setup_loopfilter(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
694 695
  pc->filter_level = vp9_read_literal(r, 6);
  pc->sharpness_level = vp9_read_literal(r, 3);
696 697 698 699 700

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

701
  xd->mode_ref_lf_delta_enabled = vp9_read_bit(r);
702
  if (xd->mode_ref_lf_delta_enabled) {
703
    xd->mode_ref_lf_delta_update = vp9_read_bit(r);
704
    if (xd->mode_ref_lf_delta_update) {
705 706
      int i;

707
      for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
708
        if (vp9_read_bit(r)) {
709 710
          const int value = vp9_read_literal(r, 6);
          xd->ref_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
711 712 713 714
        }
      }

      for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
715
        if (vp9_read_bit(r)) {
716 717
          const int value = vp9_read_literal(r, 6);
          xd->mode_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
718 719 720 721 722 723
        }
      }
    }
  }
}

724 725 726 727 728
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);
729 730 731
  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))
732
    vp9_init_dequantizer(pc);
733

734
  mb_init_dequantizer(pc, &pbi->mb);  // MB level dequantizer setup
735 736
}

737 738 739 740 741
static INTERPOLATIONFILTERTYPE read_mcomp_filter_type(vp9_reader *r) {
  return vp9_read_bit(r) ? SWITCHABLE
                         : vp9_read_literal(r, 2);
}

742 743 744 745 746 747 748 749 750 751 752 753 754 755
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;
756 757
}

758 759
static void setup_frame_size(VP9D_COMP *pbi, int scaling_active,
                             struct vp9_read_bit_buffer *rb) {
760 761
  // 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.
762 763 764 765 766
  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;
767

768
  if (scaling_active)
769
    read_frame_size(pc, rb, &display_width, &display_height);
770

771
  read_frame_size(pc, rb, &width, &height);
772

773
  if (pc->width != width || pc->height != height) {
774
    if (!pbi->initial_width || !pbi->initial_height) {
775
      if (vp9_alloc_frame_buffers(pc, width, height))
776 777
        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate frame buffers");
778 779 780 781 782 783
        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");
784

785 786 787
      if (height > pbi->initial_height)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame height too large");
788 789
    }

790 791 792 793
    pc->width = width;
    pc->height = height;
    pc->display_width = scaling_active ? display_width : width;
    pc->display_height = scaling_active ? display_height : height;
794

795
    vp9_update_frame_size(pc);
796 797 798
  }
}

799
static void update_frame_context(FRAME_CONTEXT *fc) {
800
  vp9_copy(fc->pre_coef_probs, fc->coef_probs);
801
  vp9_copy(fc->pre_y_mode_prob, fc->y_mode_prob);
802
  vp9_copy(fc->pre_uv_mode_prob, fc->uv_mode_prob);
803
  vp9_copy(fc->pre_partition_prob, fc->partition_prob);
804 805
  fc->pre_nmvc = fc->nmvc;

806
  vp9_zero(fc->coef_counts);
807
  vp9_zero(fc->eob_branch_counts);
808
  vp9_zero(fc->y_mode_counts);
809 810 811
  vp9_zero(fc->uv_mode_counts);
  vp9_zero(fc->NMVcount);
  vp9_zero(fc->mv_ref_ct);
812
  vp9_zero(fc->partition_counts);
813
}
814