vp9_decodframe.c 36.6 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
static void read_coef_probs_common(vp9_coeff_probs *coef_probs,
                                   TX_SIZE tx_size,
                                   vp9_reader *r) {
536 537 538 539 540 541
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
  const int entropy_nodes_update = UNCONSTRAINED_UPDATE_NODES;
#else
  const int entropy_nodes_update = ENTROPY_NODES;
#endif

542
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
543

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

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

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

571 572 573
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
574

575
  read_coef_probs_common(fc->coef_probs_4x4, TX_4X4, r);
576

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

751 752
  if (scaling_active)
    data = read_frame_size(pc, data, data_end, &display_width, &display_height);
753

754
  data = read_frame_size(pc, data, data_end, &width, &height);
755

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

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

773 774 775 776
    pc->width = width;
    pc->height = height;
    pc->display_width = scaling_active ? display_width : width;
    pc->display_height = scaling_active ? display_height : height;
777

778
    vp9_update_frame_size(pc);
779 780 781 782 783
  }

  return data;
}

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

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

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

828 829
static void decode_tiles(VP9D_COMP *pbi,
                         const uint8_t *data, int first_partition_size,
830
                         vp9_reader *header_bc, vp9_reader *residual_bc) {
831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
  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;