vp9_decodframe.c 45.9 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"
27
#include "vp9/common/vp9_setupintrarecon.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
28

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

35
#include "vp9/common/vp9_seg_common.h"
36
#include "vp9/common/vp9_tile_common.h"
37
#include "vp9_rtcd.h"
38

39
// #define DEC_DEBUG
40 41 42 43
#ifdef DEC_DEBUG
int dec_debug = 0;
#endif

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

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

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

  return v % 2 ? m - (v + 1) / 2 : m + v / 2;
91 92
}

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

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

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

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

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

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

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

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

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

166 167
void vp9_init_dequantizer(VP9_COMMON *pc) {
  int q, i;
John Koleszar's avatar
John Koleszar committed
168

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

174
    // AC values
John Koleszar's avatar
John Koleszar committed
175
    for (i = 1; i < 16; i++) {
176
      const int rc = vp9_default_zig_zag1d_4x4[i];
John Koleszar's avatar
John Koleszar committed
177

178 179
      pc->y_dequant[q][rc] = vp9_ac_quant(q, 0);
      pc->uv_dequant[q][rc] = vp9_ac_quant(q, pc->uv_ac_delta_q);
John Koleszar's avatar
John Koleszar committed
180
    }
John Koleszar's avatar
John Koleszar committed
181
  }
John Koleszar's avatar
John Koleszar committed
182 183
}

184
static void mb_init_dequantizer(VP9_COMMON *pc, MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
185
  int i;
186
  const int segment_id = xd->mode_info_context->mbmi.segment_id;
187
  xd->q_index = vp9_get_qindex(xd, segment_id, pc->base_qindex);
John Koleszar's avatar
John Koleszar committed
188

189
  xd->plane[0].dequant = pc->y_dequant[xd->q_index];
190
  for (i = 1; i < MAX_MB_PLANE; i++)
191
    xd->plane[i].dequant = pc->uv_dequant[xd->q_index];
John Koleszar's avatar
John Koleszar committed
192 193
}

194
#if !CONFIG_SB8X8
195
static void decode_8x8(MACROBLOCKD *xd) {
196 197
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
  // luma
198
  // if the first one is DCT_DCT assume all the rest are as well
199
  TX_TYPE tx_type = get_tx_type_8x8(xd, 0);
200 201 202 203 204 205 206
  int i;
  assert(mode == I8X8_PRED);
  for (i = 0; i < 4; i++) {
    int ib = vp9_i8x8_block[i];
    int idx = (ib & 0x02) ? (ib + 2) : ib;
    int16_t *q  = BLOCK_OFFSET(xd->plane[0].qcoeff, idx, 16);
    uint8_t* const dst =
207 208 209
          raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 0, ib,
                                    xd->plane[0].dst.buf,
                                    xd->plane[0].dst.stride);
210 211 212 213
    int stride = xd->plane[0].dst.stride;
    if (mode == I8X8_PRED) {
      int i8x8mode = xd->mode_info_context->bmi[ib].as_mode.first;
      vp9_intra8x8_predict(xd, ib, i8x8mode, dst, stride);
214
    }
215 216
    tx_type = get_tx_type_8x8(xd, ib);
    vp9_iht_add_8x8_c(tx_type, q, dst, stride, xd->plane[0].eobs[idx]);
217 218
  }

219
  // chroma
220 221 222 223
  for (i = 0; i < 4; i++) {
    int ib = vp9_i8x8_block[i];
    int i8x8mode = xd->mode_info_context->bmi[ib].as_mode.first;
    uint8_t* dst;
224

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
    dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 1, i,
                                    xd->plane[1].dst.buf,
                                    xd->plane[1].dst.stride);
    vp9_intra_uv4x4_predict(xd, 16 + i, i8x8mode,
                            dst, xd->plane[1].dst.stride);
    xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
                 dst, xd->plane[1].dst.stride,
                 xd->plane[1].eobs[i]);

    dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 2, i,
                                    xd->plane[2].dst.buf,
                                    xd->plane[1].dst.stride);
    vp9_intra_uv4x4_predict(xd, 20 + i, i8x8mode,
                            dst, xd->plane[1].dst.stride);
    xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
                 dst, xd->plane[1].dst.stride,
                 xd->plane[2].eobs[i]);
242 243
  }
}
244
#endif
245

246
static INLINE void dequant_add_y(MACROBLOCKD *xd, TX_TYPE tx_type, int idx) {
247
  struct macroblockd_plane *const y = &xd->plane[0];
248 249 250
  uint8_t* const dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 0, idx,
                                                 xd->plane[0].dst.buf,
                                                 xd->plane[0].dst.stride);
251
  if (tx_type != DCT_DCT) {
252
    vp9_iht_add_c(tx_type, BLOCK_OFFSET(y->qcoeff, idx, 16),
253
                  dst, xd->plane[0].dst.stride, y->eobs[idx]);
254
  } else {
255 256
    xd->itxm_add(BLOCK_OFFSET(y->qcoeff, idx, 16),
                 dst, xd->plane[0].dst.stride, y->eobs[idx]);
257 258 259
  }
}

260
#if !CONFIG_SB8X8
261
static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd, vp9_reader *r) {
262
  TX_TYPE tx_type;
263
  int i = 0;
264
  const MB_PREDICTION_MODE mode = xd->mode_info_context->mbmi.mode;
265 266 267 268 269 270 271
  assert(mode == I8X8_PRED);
  for (i = 0; i < 4; i++) {
    int ib = vp9_i8x8_block[i];
    const int iblock[4] = {0, 1, 4, 5};
    int j;
    uint8_t* dst;
    int i8x8mode = xd->mode_info_context->bmi[ib].as_mode.first;
272

273 274 275 276 277 278 279
    dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 0, ib,
                                    xd->plane[0].dst.buf,
                                    xd->plane[0].dst.stride);
    vp9_intra8x8_predict(xd, ib, i8x8mode, dst, xd->plane[0].dst.stride);
    for (j = 0; j < 4; j++) {
      tx_type = get_tx_type_4x4(xd, ib + iblock[j]);
      dequant_add_y(xd, tx_type, ib + iblock[j]);
280
    }
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
    dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 1, i,
                                    xd->plane[1].dst.buf,
                                    xd->plane[1].dst.stride);
    vp9_intra_uv4x4_predict(xd, 16 + i, i8x8mode,
                            dst, xd->plane[1].dst.stride);
    xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
                 dst, xd->plane[1].dst.stride,
                 xd->plane[1].eobs[i]);
    dst = raster_block_offset_uint8(xd, BLOCK_SIZE_MB16X16, 2, i,
                                    xd->plane[2].dst.buf,
                                    xd->plane[2].dst.stride);
    vp9_intra_uv4x4_predict(xd, 20 + i, i8x8mode,
                            dst, xd->plane[1].dst.stride);
    xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
                 dst, xd->plane[1].dst.stride,
                 xd->plane[2].eobs[i]);
297 298
  }
}
299
#endif
300

301 302 303 304 305 306 307 308 309 310 311
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);
312

313
  TX_TYPE tx_type;
314

315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
  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;
337 338 339
  }
}

340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
static void decode_atom_intra(VP9D_COMP *pbi, MACROBLOCKD *xd,
                              vp9_reader *r,
                              BLOCK_SIZE_TYPE bsize) {
  int i = 0;
  int bwl = b_width_log2(bsize), bhl = b_height_log2(bsize);
  int bc = 1 << (bwl + bhl);
  int tx_type;

  for (i = 0; i < bc; i++) {
    int b_mode = xd->mode_info_context->bmi[i].as_mode.first;
    uint8_t* dst;
    dst = raster_block_offset_uint8(xd, bsize, 0, i,
                                    xd->plane[0].dst.buf,
                                    xd->plane[0].dst.stride);
#if CONFIG_NEWBINTRAMODES
    xd->mode_info_context->bmi[i].as_mode.context =
        vp9_find_bpred_context(xd, i, dst, xd->plane[0].dst.stride);
    if (!xd->mode_info_context->mbmi.mb_skip_coeff)
      vp9_decode_coefs_4x4(pbi, xd, r, PLANE_TYPE_Y_WITH_DC, i);
#endif
    vp9_intra4x4_predict(xd, i, b_mode, dst, xd->plane[0].dst.stride);
    // TODO(jingning): refactor to use foreach_transformed_block_in_plane_
    tx_type = get_tx_type_4x4(xd, i);
    dequant_add_y(xd, tx_type, i);
  }
#if CONFIG_NEWBINTRAMODES
  if (!xd->mode_info_context->mbmi.mb_skip_coeff)
    vp9_decode_mb_tokens_4x4_uv(pbi, xd, r);
#endif
  foreach_transformed_block_uv(xd, bsize, decode_block, xd);
}

372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
static void decode_atom(VP9D_COMP *pbi, MACROBLOCKD *xd,
                        int mi_row, int mi_col,
                        vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;

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

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

  if (mbmi->mb_skip_coeff) {
    vp9_reset_sb_tokens_context(xd, bsize);
  } else {
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
      mb_init_dequantizer(&pbi->common, xd);

    if (!vp9_reader_has_error(r)) {
#if CONFIG_NEWBINTRAMODES
    if (mbmi->mode != I4X4_PRED)
#endif
      vp9_decode_tokens(pbi, xd, r, bsize);
    }
  }

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

407
static void decode_sb(VP9D_COMP *pbi, MACROBLOCKD *xd, int mi_row, int mi_col,
408
                      vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
409
  const int bwl = mi_width_log2(bsize), bhl = mi_height_log2(bsize);
410
  const int bw = 1 << bwl, bh = 1 << bhl;
411
  int n, eobtotal;
412
  VP9_COMMON *const pc = &pbi->common;
413 414
  MODE_INFO *const mi = xd->mode_info_context;
  MB_MODE_INFO *const mbmi = &mi->mbmi;
415
  const int mis = pc->mode_info_stride;
416

417
  assert(mbmi->sb_type == bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
418 419

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

422
  // generate prediction
423
  if (mbmi->ref_frame == INTRA_FRAME) {
424 425
    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
426
  } else {
427
    vp9_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
428 429
  }

430
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
431
    vp9_reset_sb_tokens_context(xd, bsize);
432
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
433 434
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
435
      mb_init_dequantizer(pc, xd);
Yunqing Wang's avatar
Yunqing Wang committed
436 437

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

443
        if (mi_col + x_idx < pc->mi_cols && mi_row + y_idx < pc->mi_rows)
Yunqing Wang's avatar
Yunqing Wang committed
444 445 446
          mi[y_idx * mis + x_idx].mbmi.mb_skip_coeff = 1;
      }
    } else {
447
      foreach_transformed_block(xd, bsize, decode_block, xd);
448
    }
449
  }
450 451
}

452
#if !CONFIG_SB8X8
453 454
// TODO(jingning): This only performs I8X8_PRED decoding process, which will be
// automatically covered by decode_sb, when SB8X8 is on.
455
static void decode_mb(VP9D_COMP *pbi, MACROBLOCKD *xd,
456
                     int mi_row, int mi_col,
457
                     vp9_reader *r) {
458 459
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
  const int tx_size = mbmi->txfm_size;
460

461
  assert(mbmi->sb_type == BLOCK_SIZE_MB16X16);
John Koleszar's avatar
John Koleszar committed
462

463
  if (mbmi->mb_skip_coeff) {
Yunqing Wang's avatar
Yunqing Wang committed
464
    vp9_reset_sb_tokens_context(xd, BLOCK_SIZE_MB16X16);
465
  } else {
Yunqing Wang's avatar
Yunqing Wang committed
466 467
    // re-initialize macroblock dequantizer before detokenization
    if (xd->segmentation_enabled)
468
      mb_init_dequantizer(&pbi->common, xd);
Yunqing Wang's avatar
Yunqing Wang committed
469

470 471
    if (!vp9_reader_has_error(r))
      vp9_decode_tokens(pbi, xd, r, BLOCK_SIZE_MB16X16);
Yunqing Wang's avatar
Yunqing Wang committed
472 473
  }

474 475 476 477
  if (tx_size == TX_8X8)
    decode_8x8(xd);
  else
    decode_4x4(pbi, xd, r);
Yaowu Xu's avatar
Yaowu Xu committed
478
}
479
#endif
John Koleszar's avatar
John Koleszar committed
480

481 482 483 484
static int get_delta_q(vp9_reader *r, int *dq) {
  const int old_value = *dq;

  if (vp9_read_bit(r)) {  // Update bit
485 486
    const int value = vp9_read_literal(r, 4);
    *dq = vp9_read_and_apply_sign(r, value);
John Koleszar's avatar
John Koleszar committed
487
  }
John Koleszar's avatar
John Koleszar committed
488

489
  // Trigger a quantizer update if the delta-q value has changed
490
  return old_value != *dq;
John Koleszar's avatar
John Koleszar committed
491 492
}

493
static void set_offsets(VP9D_COMP *pbi, BLOCK_SIZE_TYPE bsize,
494 495 496
                        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
497 498
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
499
  int i;
John Koleszar's avatar
John Koleszar committed
500

501
  const int mi_idx = mi_row * cm->mode_info_stride + mi_col;
502
  const YV12_BUFFER_CONFIG *dst_fb = &cm->yv12_fb[cm->new_fb_idx];
503 504 505 506
  const int recon_yoffset =
      (MI_SIZE * mi_row) * dst_fb->y_stride + (MI_SIZE * mi_col);
  const int recon_uvoffset =
      (MI_UV_SIZE * mi_row) * dst_fb->uv_stride + (MI_UV_SIZE * mi_col);
507

508
  xd->mode_info_context = cm->mi + mi_idx;
509
  xd->mode_info_context->mbmi.sb_type = bsize;
510 511
  xd->prev_mode_info_context = cm->prev_mi + mi_idx;

512 513 514 515 516 517
  for (i = 0; i < MAX_MB_PLANE; i++) {
    xd->plane[i].above_context = cm->above_context[i] +
        (mi_col * 4 >> (xd->plane[i].subsampling_x + CONFIG_SB8X8));
    xd->plane[i].left_context = cm->left_context[i] +
        (((mi_row * 4 >> CONFIG_SB8X8) & 15) >> xd->plane[i].subsampling_y);
  }
518 519
  xd->above_seg_context = cm->above_seg_context + (mi_col >> CONFIG_SB8X8);
  xd->left_seg_context  = cm->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
520

521 522
  // 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
523
  set_mi_row_col(cm, xd, mi_row, bh, mi_col, bw);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
524

525 526 527
  xd->plane[0].dst.buf = dst_fb->y_buffer + recon_yoffset;
  xd->plane[1].dst.buf = dst_fb->u_buffer + recon_uvoffset;
  xd->plane[2].dst.buf = dst_fb->v_buffer + recon_uvoffset;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
528
}
John Koleszar's avatar
John Koleszar committed
529

530
static void set_refs(VP9D_COMP *pbi, int mi_row, int mi_col) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
531 532
  VP9_COMMON *const cm = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
533
  MB_MODE_INFO *const mbmi = &xd->mode_info_context->mbmi;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
534 535

  if (mbmi->ref_frame > INTRA_FRAME) {
536
    // Select the appropriate reference frame for this MB
537 538 539
    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];
540
    xd->scale_factor_uv[0] = cm->active_ref_scale[mbmi->ref_frame - 1];
541
    setup_pre_planes(xd, cfg, NULL, mi_row, mi_col,
542
                     xd->scale_factor, xd->scale_factor_uv);
543
    xd->corrupted |= cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
544

Ronald S. Bultje's avatar
Ronald S. Bultje committed
545
    if (mbmi->second_ref_frame > INTRA_FRAME) {
546
      // Select the appropriate reference frame for this MB
547 548
      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
549 550
      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];
551
      setup_pre_planes(xd, NULL, second_cfg, mi_row, mi_col,
552
                       xd->scale_factor, xd->scale_factor_uv);
553
      xd->corrupted |= second_cfg->corrupted;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
554 555 556
    }
  }
}
John Koleszar's avatar
John Koleszar committed
557

558
static void decode_modes_b(VP9D_COMP *pbi, int mi_row, int mi_col,
559 560 561
                           vp9_reader *r, BLOCK_SIZE_TYPE bsize) {
  MACROBLOCKD *const xd = &pbi->mb;

562 563 564
  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);
565

566
#if CONFIG_SB8X8
567 568 569 570
  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);
571
  else
572
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
573
#else
574
  // TODO(jingning): merge decode_sb_ and decode_mb_
575
  if (bsize > BLOCK_SIZE_MB16X16) {
576
    decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
577
  } else {
578 579 580 581 582 583 584
    // TODO(jingning): In transition of separating functionalities of decode_mb
    // into decode_sb and decode_atom. Will remove decode_mb and clean this up
    // when SB8X8 is on.
    if (xd->mode_info_context->mbmi.mode == I4X4_PRED ||
        (xd->mode_info_context->mbmi.mode == SPLITMV &&
         xd->mode_info_context->mbmi.partitioning == PARTITIONING_4X4))
      decode_atom(pbi, xd, mi_row, mi_col, r, bsize);
585 586
    else if (xd->mode_info_context->mbmi.mode != I8X8_PRED)
      decode_sb(pbi, xd, mi_row, mi_col, r, bsize);
587
    else
588 589
      // TODO(jingning): decode_mb still carries deocding process of I8X8_PRED.
      // This will be covered by decode_sb when SB8X8 is on.
590
      decode_mb(pbi, xd, mi_row, mi_col, r);
591
  }
592
#endif
593

594
  xd->corrupted |= vp9_reader_has_error(r);
595 596
}

597
static void decode_modes_sb(VP9D_COMP *pbi, int mi_row, int mi_col,
598
                            vp9_reader* r, BLOCK_SIZE_TYPE bsize) {
599 600
  VP9_COMMON *const pc = &pbi->common;
  MACROBLOCKD *const xd = &pbi->mb;
601
  int bsl = mi_width_log2(bsize), bs = (1 << bsl) / 2;
602 603 604 605
  int n;
  PARTITION_TYPE partition = PARTITION_NONE;
  BLOCK_SIZE_TYPE subsize;

606
  if (mi_row >= pc->mi_rows || mi_col >= pc->mi_cols)
607 608
    return;

609 610 611
#if CONFIG_SB8X8
  if (bsize > BLOCK_SIZE_SB8X8) {
#else
612
  if (bsize > BLOCK_SIZE_MB16X16) {
613
#endif
614
    int pl;
615
    // read the partition information
616 617 618
    xd->left_seg_context =
        pc->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3);
    xd->above_seg_context = pc->above_seg_context + (mi_col >> CONFIG_SB8X8);
619
    pl = partition_plane_context(xd, bsize);
620
    partition = treed_read(r, vp9_partition_tree,
621 622
                           pc->fc.partition_prob[pl]);
    pc->fc.partition_counts[pl][partition]++;
623 624
  }

625
  subsize = get_subsize(bsize, partition);
626 627
  switch (partition) {
    case PARTITION_NONE:
628
      decode_modes_b(pbi, mi_row, mi_col, r, subsize);
629 630
      break;
    case PARTITION_HORZ:
631 632 633
      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);
634 635
      break;
    case PARTITION_VERT:
636 637 638
      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);
639 640 641 642 643 644
      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;
645 646 647 648 649 650
#if CONFIG_SB8X8
        else if (subsize == BLOCK_SIZE_MB16X16)
          xd->mb_index = n;
        else
          xd->b_index = n;
#else
651 652
        else
          xd->mb_index = n;
653
#endif
654
        decode_modes_sb(pbi, mi_row + j * bs, mi_col + i * bs, r, subsize);
655 656 657 658 659
      }
      break;
    default:
      assert(0);
  }
660
  // update partition context
661 662 663
#if CONFIG_SB8X8
  if ((partition == PARTITION_SPLIT) && (bsize > BLOCK_SIZE_MB16X16))
#else
664
  if ((partition == PARTITION_SPLIT) && (bsize > BLOCK_SIZE_SB32X32))
665
#endif
666 667
    return;

668 669
  xd->left_seg_context = pc->left_seg_context + ((mi_row >> CONFIG_SB8X8) & 3);
  xd->above_seg_context = pc->above_seg_context + (mi_col >> CONFIG_SB8X8);
670
  update_partition_context(xd, subsize, bsize);
671 672
}

673
static void setup_token_decoder(VP9D_COMP *pbi,
674 675
                                const uint8_t *data,
                                vp9_reader *r) {
Dmitry Kovalev's avatar
Dmitry Kovalev committed
676
  VP9_COMMON *pc = &pbi->common;
677 678
  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
679

Dmitry Kovalev's avatar
Dmitry Kovalev committed
680 681 682
  // 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.
683
  if (!read_is_valid(data, partition_size, data_end))
John Koleszar's avatar
John Koleszar committed
684 685 686 687
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);

688
  if (vp9_reader_init(r, data, partition_size))
John Koleszar's avatar
John Koleszar committed
689 690
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
691 692
}

693 694
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
695
  MACROBLOCKD *const xd = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
696

John Koleszar's avatar
John Koleszar committed
697
  if (pc->frame_type == KEY_FRAME) {
698
    vp9_setup_past_independence(pc, xd);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
699
    // All buffers are implicitly updated on key frames.
700
    pbi->refresh_frame_flags = (1 << NUM_REF_FRAMES) - 1;
701 702 703
  } else if (pc->error_resilient_mode) {
    vp9_setup_past_independence(pc, xd);
  }
John Koleszar's avatar
John Koleszar committed
704

John Koleszar's avatar
John Koleszar committed
705
  xd->mode_info_context = pc->mi;
706
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
707 708 709
  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
710 711
}

712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750
#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);
751
  if (cm->txfm_mode > ONLY_4X4)
752 753 754 755 756 757 758 759
    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

760 761 762
static void read_coef_probs_common(vp9_coeff_probs *coef_probs,
                                   TX_SIZE tx_size,
                                   vp9_reader *r) {
763 764 765 766 767 768
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
  const int entropy_nodes_update = UNCONSTRAINED_UPDATE_NODES;
#else
  const int entropy_nodes_update = ENTROPY_NODES;
#endif

769
  int i, j, k, l, m;
John Koleszar's avatar
John Koleszar committed
770

771
  if (vp9_read_bit(r)) {
772
    for (i = 0; i < BLOCK_TYPES; i++) {
773 774 775
      for (j = 0; j < REF_TYPES; j++) {
        for (k = 0; k < COEF_BANDS; k++) {
          for (l = 0; l < PREV_COEF_CONTEXTS; l++) {
776
            const int mstart = 0;
777 778
            if (l >= 3 && k == 0)
              continue;
779 780

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

783 784
              if (vp9_read(r, vp9_coef_update_prob[m])) {
                *p = read_prob_diff_update(r, *p);
785
#if CONFIG_MODELCOEFPROB && MODEL_BASED_UPDATE
786
                if (m == UNCONSTRAINED_NODES - 1)
787 788
                  vp9_get_model_distribution(*p, coef_probs[i][j][k][l], i, j);
#endif
789
              }
790 791 792
            }
          }
        }
793 794
      }
    }
795
  }
796
}
797

798 799 800
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
801

802
  read_coef_probs_common(fc->coef_probs_4x4, TX_4X4, r);
803

804
  if (mode > ONLY_4X4)
805
    read_coef_probs_common(fc->coef_probs_8x8, TX_8X8, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
806

807
  if (mode > ALLOW_8X8)
808
    read_coef_probs_common(fc->coef_probs_16x16, TX_16X16, r);
Dmitry Kovalev's avatar
Dmitry Kovalev committed
809

810
  if (mode > ALLOW_16X16)
811
    read_coef_probs_common(fc->coef_probs_32x32, TX_32X32, r);
812 813
}

814
static void setup_segmentation(VP9_COMMON *pc, MACROBLOCKD *xd, vp9_reader *r) {
815 816
  int i, j;

817 818
  xd->update_mb_segmentation_map = 0;
  xd->update_mb_segmentation_data = 0;
819 820 821
#if CONFIG_IMPLICIT_SEGMENTATION
  xd->allow_implicit_segment_update = 0;
#endif
822

823
  xd->segmentation_enabled = vp9_read_bit(r);
824 825 826 827 828
  if (!xd->segmentation_enabled)
    return;

  // Segmentation map update
  xd->update_mb_segmentation_map = vp9_read_bit(r);
829 830 831
#if CONFIG_IMPLICIT_SEGMENTATION
    xd->allow_implicit_segment_update = vp9_read_bit(r);
#endif
832
  if (xd->update_mb_segmentation_map) {
833
    for (i = 0; i < MB_SEG_TREE_PROBS; i++)
834 835 836 837 838 839 840 841 842 843 844
      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;
845
    }
846
  }
847

848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
  // 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);
864
        }
865
        vp9_set_segdata(xd, i, j, data);
Dmitry Kovalev's avatar