vp9_decodframe.c 38.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 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
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);
257

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

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

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

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

309
  assert(mbmi->sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
310 311

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

314
  // generate prediction
315
  if (mbmi->ref_frame == INTRA_FRAME) {
316 317
    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
318
  } else {
319
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
320 321
  }

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

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

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

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

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

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

356
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
357 358 359
                        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
360 361
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
362
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
363
  int i;
364

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

369 370
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
Jingning Han's avatar
Jingning Han committed
371
        (mi_col * 2 >> xd->plane[i].subsampling_x);
372
    xd->plane[i].left_context = cm->left_context[i] +
Jingning Han's avatar
Jingning Han committed
373
        (((mi_row * 2) & 15) >> xd->plane[i].subsampling_y);
374
  }
Jingning Han's avatar
Jingning Han committed
375 376
  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
377

378 379
  // 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
380
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
381

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

385
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
386 387
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
388
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
389 390

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

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

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

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

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

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

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

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

443
  if (bsize > BLOCK_SIZE_SB8X8) {
444
    int pl;
445
    // read the partition information
446
    xd->left_seg_context =
Jingning Han's avatar
Jingning Han committed
447 448
        pc->left_seg_context + ((mi_row >> 1) & 3);
    xd->above_seg_context = pc->above_seg_context + (mi_col >> 1);
449
    pl = partition_plane_context(xd, bsize);
450
    partition = treed_read(r, vp9_partition_tree,
451 452
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
453 454
  }

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

Jingning Han's avatar
Jingning Han committed
489 490
  xd->left_seg_context = pc->left_seg_context + ((mi_row >> 1) & 3);
  xd->above_seg_context = pc->above_seg_context + (mi_col >> 1);
491
  update_partition_context(xd, subsize, bsize);
492 493
}

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

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

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

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

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

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

533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
#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);
572
  if (cm->txfm_mode > ONLY_4X4)
573 574 575 576 577 578 579 580
    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

581 582 583
static void read_coef_probs_common(vp9_coeff_probs *coef_probs,
                                   TX_SIZE tx_size,
                                   vp9_reader *r) {
584 585 586 587 588 589
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
  const int entropy_nodes_update = UNCONSTRAINED_UPDATE_NODES;
#else
  const int entropy_nodes_update = ENTROPY_NODES;
#endif

590
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
591

592
  if (vp9_read_bit(r)) {
593
    for (i = 0; i < BLOCK_TYPES; i++) {
594 595 596
      for (j = 0; j < REF_TYPES; j++) {
        for (k = 0; k < COEF_BANDS; k++) {
          for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
597
            const int mstart = 0;
598 599
            if (l >= 3 && k == 0)
              continue;
600 601

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

604 605
              if (vp9_read(r, vp9_coef_update_prob[m])) {
                *p = read_prob_diff_update(r, *p);
606
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
607
                if (m == UNCONSTRAINED_NODES - 1)
608 609
                  vp9_get_model_distribution(*p, coef_probs[i][j][k][l], i, j);
#endif
610
              }
611 612 613
            }
          }
        }
614 615
      }
    }
616
  }
617
}
618

619 620 621
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
622

623
  read_coef_probs_common(fc->coef_probs_4x4, TX_4X4, r);
624

625
  if (mode > ONLY_4X4)
626
    read_coef_probs_common(fc->coef_probs_8x8, TX_8X8, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
627

628
  if (mode > ALLOW_8X8)
629
    read_coef_probs_common(fc->coef_probs_16x16, TX_16X16, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
630

631
  if (mode > ALLOW_16X16)
632
    read_coef_probs_common(fc->coef_probs_32x32, TX_32X32, r);
633 634
}

635
static void setup_segmentation(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
636 637
  int i, j;

638 639
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;
640 641 642
#if CONFIG_IMPLICIT_SEGMENTATION
  xd->allow_implicit_segment_update = 0;
#endif
643

644
  xd->segmentation_enabled = vp9_read_bit(r);
645 646 647 648 649
  if (!xd->segmentation_enabled)
    return;

  // Segmentation map update
  xd->update_mb_segmentation_map = vp9_read_bit(r);
650 651 652
#if CONFIG_IMPLICIT_SEGMENTATION
    xd->allow_implicit_segment_update = vp9_read_bit(r);
#endif
653
  if (xd->update_mb_segmentation_map) {
654
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
655 656 657 658 659 660 661 662 663 664 665
      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;
666
    }
667
  }
668

669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
  // 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);
685
        }
686
        vp9_set_segdata(xd, i, j, data);
687 688 689 690 691
      }
    }
  }
}

692 693 694 695 696
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
697 698 699
    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;
700 701 702 703 704 705 706
  } else {
    int i;
    for (i = 0; i < PREDICTION_PROBS; ++i)
      if (vp9_read_bit(r))
        pc->ref_pred_probs[i] = vp9_read_prob(r);
  }
}
707

708
static void setup_loopfilter(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
709
  pc->filter_type = (LOOPFILTER_TYPE) vp9_read_bit(r);
710 711
  pc->filter_level = vp9_read_literal(r, 6);
  pc->sharpness_level = vp9_read_literal(r, 3);
712 713

#if CONFIG_LOOP_DERING
714 715
  if (vp9_read_bit(r))
    pc->dering_enabled = 1 + vp9_read_literal(r, 4);
716 717 718 719 720 721 722 723
  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;

724
  xd->mode_ref_lf_delta_enabled = vp9_read_bit(r);
725
  if (xd->mode_ref_lf_delta_enabled) {
726
    xd->mode_ref_lf_delta_update = vp9_read_bit(r);
727
    if (xd->mode_ref_lf_delta_update) {
728 729
      int i;

730
      for (i = 0; i < MAX_REF_LF_DELTAS; i++) {
731
        if (vp9_read_bit(r)) {
732 733
          const int value = vp9_read_literal(r, 6);
          xd->ref_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
734 735 736 737
        }
      }

      for (i = 0; i < MAX_MODE_LF_DELTAS; i++) {
738
        if (vp9_read_bit(r)) {
739 740
          const int value = vp9_read_literal(r, 6);
          xd->mode_lf_deltas[i] = vp9_read_and_apply_sign(r, value);
741 742 743 744 745 746
        }
      }
    }
  }
}

747 748 749 750 751
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);
752 753 754
  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))
755
    vp9_init_dequantizer(pc);
756

757
  mb_init_dequantizer(pc, &pbi->mb);  // MB level dequantizer setup
758 759
}

760 761 762 763 764
static INTERPOLATIONFILTERTYPE read_mcomp_filter_type(vp9_reader *r) {
  return vp9_read_bit(r) ? SWITCHABLE
                         : vp9_read_literal(r, 2);
}

765 766 767 768
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) {
769 770 771 772 773 774 775 776 777 778 779
    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;
780 781 782 783 784 785 786 787
    data += 4;
  } else {
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Failed to read frame size");
  }
  return data;
}

788
static const uint8_t *setup_frame_size(VP9D_COMP *pbi, int scaling_active,
789 790
                                       const uint8_t *data,
                                       const uint8_t *data_end) {
791 792
  // 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.
793 794 795 796 797
  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;
798

799 800
  if (scaling_active)
    data = read_frame_size(pc, data, data_end, &display_width, &display_height);
801

802
  data = read_frame_size(pc, data, data_end, &width, &height);
803

804
  if (pc->width != width || pc->height != height) {
805
    if (!pbi->initial_width || !pbi->initial_height) {
806
      if (vp9_alloc_frame_buffers(pc, width, height))
807 808
        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate frame buffers");
809 810 811 812 813 814
        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");
815

816 817 818
      if (height > pbi->initial_height)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Frame height too large");
819 820
    }

821 822 823 824
    pc->width = width;
    pc->height = height;
    pc->display_width = scaling_active ? display_width : width;
    pc->display_height = scaling_active ? display_height : height;
825

826
    vp9_update_frame_size(pc);
827 828 829 830 831
  }

  return data;
}

832
static void update_frame_context(FRAME_CONTEXT *fc) {
833 834 835 836 837 838 839 840 841
  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);
842
  vp9_copy(fc->pre_partition_prob, fc->partition_prob);
843 844 845 846 847 848 849 850 851 852 853 854 855 856
  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);
857
  vp9_zero(fc->partition_counts);
858 859 860 861 862 863

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

864 865 866 867 868 869 870 871 872 873 874
#if CONFIG_CODE_ZEROGROUP
  vp9_copy(fc->pre_zpc_probs_4x4, fc->zpc_probs_4x4);
  vp9_copy(fc->pre_zpc_probs_8x8, fc->zpc_probs_8x8);
  vp9_copy(fc->pre_zpc_probs_16x16, fc->zpc_probs_16x16);
  vp9_copy(fc->pre_zpc_probs_32x32, fc->zpc_probs_32x32);

  vp9_zero(fc->zpc_counts_4x4);
  vp9_zero(fc->zpc_counts_8x8);
  vp9_zero(fc->zpc_counts_16x16);
  vp9_zero(fc->zpc_counts_32x32);
#endif
875
}
876

877 878
static void decode_tile(VP9D_COMP *pbi, vp9_reader *r) {
  VP9_COMMON *const pc = &pbi->common;