vp9_decodframe.c 49.2 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 13 14 15 16 17 18 19 20 21 22
#include "vp9_onyxd_int.h"
#include "vp9/common/vp9_header.h"
#include "vp9/common/vp9_reconintra.h"
#include "vp9/common/vp9_reconintra4x4.h"
#include "vp9/common/vp9_reconinter.h"
#include "vp9/decoder/vp9_decodframe.h"
#include "vp9_detokenize.h"
#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"
23
#include "vpx_scale/vpxscale.h"
24
#include "vp9/common/vp9_setupintrarecon.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
25

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

32 33
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_entropy.h"
34
#include "vp9_rtcd.h"
35

John Koleszar's avatar
John Koleszar committed
36 37 38
#include <assert.h>
#include <stdio.h>

39

40 41
#define COEFCOUNT_TESTING

John Koleszar's avatar
John Koleszar committed
42 43 44 45 46 47 48 49 50 51 52 53
static int merge_index(int v, int n, int modulus) {
  int max1 = (n - 1 - modulus / 2) / modulus + 1;
  if (v < max1) v = v * modulus + modulus / 2;
  else {
    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;
54 55
}

John Koleszar's avatar
John Koleszar committed
56 57 58
static int inv_remap_prob(int v, int m) {
  const int n = 256;
  const int modulus = MODULUS_PARAM;
59
  int i;
John Koleszar's avatar
John Koleszar committed
60 61
  v = merge_index(v, n - 1, modulus);
  if ((m << 1) <= n) {
62
    i = vp9_inv_recenter_nonneg(v + 1, m);
John Koleszar's avatar
John Koleszar committed
63
  } else {
64
    i = n - 1 - vp9_inv_recenter_nonneg(v + 1, n - 1 - m);
John Koleszar's avatar
John Koleszar committed
65 66
  }
  return i;
67
}
68

69
static vp9_prob read_prob_diff_update(vp9_reader *const bc, int oldp) {
70
  int delp = vp9_decode_term_subexp(bc, SUBEXP_PARAM, 255);
71
  return (vp9_prob)inv_remap_prob(delp, oldp);
72
}
73

74
void vp9_init_de_quantizer(VP9D_COMP *pbi) {
John Koleszar's avatar
John Koleszar committed
75 76
  int i;
  int Q;
77
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
78 79

  for (Q = 0; Q < QINDEX_RANGE; Q++) {
80 81 82
    pc->Y1dequant[Q][0] = (short)vp9_dc_quant(Q, pc->y1dc_delta_q);
    pc->Y2dequant[Q][0] = (short)vp9_dc2quant(Q, pc->y2dc_delta_q);
    pc->UVdequant[Q][0] = (short)vp9_dc_uv_quant(Q, pc->uvdc_delta_q);
John Koleszar's avatar
John Koleszar committed
83 84 85

    /* all the ac values =; */
    for (i = 1; i < 16; i++) {
86
      int rc = vp9_default_zig_zag1d[i];
John Koleszar's avatar
John Koleszar committed
87

88 89 90
      pc->Y1dequant[Q][rc] = (short)vp9_ac_yquant(Q);
      pc->Y2dequant[Q][rc] = (short)vp9_ac2quant(Q, pc->y2ac_delta_q);
      pc->UVdequant[Q][rc] = (short)vp9_ac_uv_quant(Q, pc->uvac_delta_q);
John Koleszar's avatar
John Koleszar committed
91
    }
John Koleszar's avatar
John Koleszar committed
92
  }
John Koleszar's avatar
John Koleszar committed
93 94
}

95
static void mb_init_dequantizer(VP9D_COMP *pbi, MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
96 97
  int i;
  int QIndex;
98
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
99 100 101
  int segment_id = xd->mode_info_context->mbmi.segment_id;

  // Set the Q baseline allowing for any segment level adjustment
102
  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_ALT_Q)) {
John Koleszar's avatar
John Koleszar committed
103 104
    /* Abs Value */
    if (xd->mb_segment_abs_delta == SEGMENT_ABSDATA)
105
      QIndex = vp9_get_segdata(xd, segment_id, SEG_LVL_ALT_Q);
John Koleszar's avatar
John Koleszar committed
106 107 108 109

    /* Delta Value */
    else {
      QIndex = pc->base_qindex +
110
               vp9_get_segdata(xd, segment_id, SEG_LVL_ALT_Q);
John Koleszar's avatar
John Koleszar committed
111
      QIndex = (QIndex >= 0) ? ((QIndex <= MAXQ) ? QIndex : MAXQ) : 0;    /* Clamp to valid range */
John Koleszar's avatar
John Koleszar committed
112
    }
John Koleszar's avatar
John Koleszar committed
113 114
  } else
    QIndex = pc->base_qindex;
Deb Mukherjee's avatar
Deb Mukherjee committed
115
  xd->q_index = QIndex;
John Koleszar's avatar
John Koleszar committed
116

John Koleszar's avatar
John Koleszar committed
117 118 119 120
  /* Set up the block level dequant pointers */
  for (i = 0; i < 16; i++) {
    xd->block[i].dequant = pc->Y1dequant[QIndex];
  }
John Koleszar's avatar
John Koleszar committed
121

Hui Su's avatar
Hui Su committed
122
#if CONFIG_LOSSLESS
John Koleszar's avatar
John Koleszar committed
123
  if (!QIndex) {
124 125 126 127
    pbi->mb.inv_xform4x4_1_x8     = vp9_short_inv_walsh4x4_1_x8;
    pbi->mb.inv_xform4x4_x8       = vp9_short_inv_walsh4x4_x8;
    pbi->mb.inv_walsh4x4_1        = vp9_short_inv_walsh4x4_1_lossless;
    pbi->mb.inv_walsh4x4_lossless = vp9_short_inv_walsh4x4_lossless;
128 129 130 131 132
    pbi->idct_add            = vp9_dequant_idct_add_lossless_c;
    pbi->dc_idct_add         = vp9_dequant_dc_idct_add_lossless_c;
    pbi->dc_idct_add_y_block = vp9_dequant_dc_idct_add_y_block_lossless_c;
    pbi->idct_add_y_block    = vp9_dequant_idct_add_y_block_lossless_c;
    pbi->idct_add_uv_block   = vp9_dequant_idct_add_uv_block_lossless_c;
John Koleszar's avatar
John Koleszar committed
133
  } else {
134 135 136 137
    pbi->mb.inv_xform4x4_1_x8     = vp9_short_idct4x4llm_1;
    pbi->mb.inv_xform4x4_x8       = vp9_short_idct4x4llm;
    pbi->mb.inv_walsh4x4_1        = vp9_short_inv_walsh4x4_1;
    pbi->mb.inv_walsh4x4_lossless = vp9_short_inv_walsh4x4;
138 139 140 141 142
    pbi->idct_add            = vp9_dequant_idct_add;
    pbi->dc_idct_add         = vp9_dequant_dc_idct_add;
    pbi->dc_idct_add_y_block = vp9_dequant_dc_idct_add_y_block;
    pbi->idct_add_y_block    = vp9_dequant_idct_add_y_block;
    pbi->idct_add_uv_block   = vp9_dequant_idct_add_uv_block;
John Koleszar's avatar
John Koleszar committed
143
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
144
#else
145 146 147 148
  pbi->mb.inv_xform4x4_1_x8     = vp9_short_idct4x4llm_1;
  pbi->mb.inv_xform4x4_x8       = vp9_short_idct4x4llm;
  pbi->mb.inv_walsh4x4_1        = vp9_short_inv_walsh4x4_1;
  pbi->mb.inv_walsh4x4_lossless = vp9_short_inv_walsh4x4;
149 150 151 152 153
  pbi->idct_add            = vp9_dequant_idct_add;
  pbi->dc_idct_add         = vp9_dequant_dc_idct_add;
  pbi->dc_idct_add_y_block = vp9_dequant_dc_idct_add_y_block;
  pbi->idct_add_y_block    = vp9_dequant_idct_add_y_block;
  pbi->idct_add_uv_block   = vp9_dequant_idct_add_uv_block;
Hui Su's avatar
Hui Su committed
154 155
#endif

John Koleszar's avatar
John Koleszar committed
156 157 158
  for (i = 16; i < 24; i++) {
    xd->block[i].dequant = pc->UVdequant[QIndex];
  }
John Koleszar's avatar
John Koleszar committed
159

John Koleszar's avatar
John Koleszar committed
160
  xd->block[24].dequant = pc->Y2dequant[QIndex];
John Koleszar's avatar
John Koleszar committed
161 162 163 164 165 166 167 168 169

}

#if CONFIG_RUNTIME_CPU_DETECT
#define RTCD_VTABLE(x) (&(pbi)->common.rtcd.x)
#else
#define RTCD_VTABLE(x) NULL
#endif

170 171 172
/* skip_recon_mb() is Modified: Instead of writing the result to predictor buffer and then copying it
 *  to dst buffer, we can write the result directly to dst buffer. This eliminates unnecessary copy.
 */
173
static void skip_recon_mb(VP9D_COMP *pbi, MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
174
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
175 176
#if CONFIG_SUPERBLOCKS
    if (xd->mode_info_context->mbmi.encoded_as_sb) {
177 178
      vp9_build_intra_predictors_sbuv_s(xd);
      vp9_build_intra_predictors_sby_s(xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
179 180
    } else {
#endif
181 182
    vp9_build_intra_predictors_mbuv_s(xd);
    vp9_build_intra_predictors_mby_s(xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
183 184 185
#if CONFIG_SUPERBLOCKS
    }
#endif
John Koleszar's avatar
John Koleszar committed
186
  } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
187 188
#if CONFIG_SUPERBLOCKS
    if (xd->mode_info_context->mbmi.encoded_as_sb) {
189 190 191 192 193 194
      vp9_build_inter32x32_predictors_sb(xd,
                                         xd->dst.y_buffer,
                                         xd->dst.u_buffer,
                                         xd->dst.v_buffer,
                                         xd->dst.y_stride,
                                         xd->dst.uv_stride);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
195 196
    } else {
#endif
197 198 199 200 201 202 203 204 205 206 207 208 209 210
    vp9_build_1st_inter16x16_predictors_mb(xd,
                                           xd->dst.y_buffer,
                                           xd->dst.u_buffer,
                                           xd->dst.v_buffer,
                                           xd->dst.y_stride,
                                           xd->dst.uv_stride);

    if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
      vp9_build_2nd_inter16x16_predictors_mb(xd,
                                             xd->dst.y_buffer,
                                             xd->dst.u_buffer,
                                             xd->dst.v_buffer,
                                             xd->dst.y_stride,
                                             xd->dst.uv_stride);
211
    }
212 213 214 215 216 217 218 219 220 221
#if CONFIG_COMP_INTERINTRA_PRED
    else if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
      vp9_build_interintra_16x16_predictors_mb(xd,
                                               xd->dst.y_buffer,
                                               xd->dst.u_buffer,
                                               xd->dst.v_buffer,
                                               xd->dst.y_stride,
                                               xd->dst.uv_stride);
    }
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
222 223 224
#if CONFIG_SUPERBLOCKS
    }
#endif
John Koleszar's avatar
John Koleszar committed
225
  }
John Koleszar's avatar
John Koleszar committed
226 227
}

228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
#if CONFIG_SUPERBLOCKS
static void decode_superblock(VP9D_COMP *pbi, MACROBLOCKD *xd,
                              int mb_row, unsigned int mb_col,
                              BOOL_DECODER* const bc) {
  int i, n, eobtotal;
  TX_SIZE tx_size = xd->mode_info_context->mbmi.txfm_size;
  VP9_COMMON *const pc = &pbi->common;
  MODE_INFO *orig_mi = xd->mode_info_context;

  assert(xd->mode_info_context->mbmi.encoded_as_sb);

  // re-initialize macroblock dequantizer before detokenization
  if (xd->segmentation_enabled)
    mb_init_dequantizer(pbi, xd);

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

  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
    vp9_reset_mb_tokens_context(xd);
    if (mb_col < pc->mb_cols - 1)
      xd->above_context++;
    if (mb_row < pc->mb_rows - 1)
      xd->left_context++;
    vp9_reset_mb_tokens_context(xd);
    if (mb_col < pc->mb_cols - 1)
      xd->above_context--;
    if (mb_row < pc->mb_rows - 1)
      xd->left_context--;

    /* Special case:  Force the loopfilter to skip when eobtotal and
     * mb_skip_coeff are zero.
     */
    skip_recon_mb(pbi, xd);
    return;
  }

  /* do prediction */
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
    vp9_build_intra_predictors_sby_s(xd);
    vp9_build_intra_predictors_sbuv_s(xd);
  } else {
    vp9_build_inter32x32_predictors_sb(xd, xd->dst.y_buffer,
                                       xd->dst.u_buffer, xd->dst.v_buffer,
                                       xd->dst.y_stride, xd->dst.uv_stride);
  }

  /* dequantization and idct */
  for (n = 0; n < 4; n++) {
    BLOCKD *b = &xd->block[24];
    int x_idx = n & 1, y_idx = n >> 1;

    if (mb_col + x_idx >= pc->mb_cols || mb_row + y_idx >= pc->mb_rows)
      continue;

    xd->above_context = pc->above_context + mb_col + x_idx;
    xd->left_context = pc->left_context + y_idx;
    xd->mode_info_context = orig_mi + x_idx + y_idx * pc->mode_info_stride;
    for (i = 0; i < 25; i++) {
      xd->block[i].eob = 0;
      xd->eobs[i] = 0;
    }

291
    eobtotal = vp9_decode_mb_tokens(pbi, xd, bc);
292 293 294 295 296 297 298 299 300
    if (eobtotal == 0) {  // skip loopfilter
      xd->mode_info_context->mbmi.mb_skip_coeff = 1;
      continue;
    }

    if (tx_size == TX_16X16) {
      vp9_dequant_idct_add_16x16(xd->qcoeff, xd->block[0].dequant,
          xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
          xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
301
          xd->dst.y_stride, xd->dst.y_stride, xd->eobs[0]);
302 303 304 305 306 307 308
      vp9_dequant_idct_add_uv_block_8x8_inplace_c(xd->qcoeff + 16 * 16,
          xd->block[16].dequant,
          xd->dst.u_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
          xd->dst.v_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
          xd->dst.uv_stride, xd->eobs + 16, xd);
    } else if (tx_size == TX_8X8) {
      vp9_dequantize_b_2x2(b);
309
      vp9_short_ihaar2x2(&b->dqcoeff[0], b->diff, 8);
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
      ((int *)b->qcoeff)[0] = 0;  // 2nd order block are set to 0 after idct
      ((int *)b->qcoeff)[1] = 0;
      ((int *)b->qcoeff)[2] = 0;
      ((int *)b->qcoeff)[3] = 0;
      ((int *)b->qcoeff)[4] = 0;
      ((int *)b->qcoeff)[5] = 0;
      ((int *)b->qcoeff)[6] = 0;
      ((int *)b->qcoeff)[7] = 0;
      vp9_dequant_dc_idct_add_y_block_8x8_inplace_c(xd->qcoeff,
          xd->block[0].dequant,
          xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
          xd->dst.y_stride, xd->eobs, xd->block[24].diff, xd);
      vp9_dequant_idct_add_uv_block_8x8_inplace_c(xd->qcoeff + 16 * 16,
          xd->block[16].dequant,
          xd->dst.u_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
          xd->dst.v_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
          xd->dst.uv_stride, xd->eobs + 16, xd);
    } else {
      vp9_dequantize_b(b);
      if (xd->eobs[24] > 1) {
330
        vp9_short_inv_walsh4x4(&b->dqcoeff[0], b->diff);
331 332 333 334 335 336 337 338 339
        ((int *)b->qcoeff)[0] = 0;
        ((int *)b->qcoeff)[1] = 0;
        ((int *)b->qcoeff)[2] = 0;
        ((int *)b->qcoeff)[3] = 0;
        ((int *)b->qcoeff)[4] = 0;
        ((int *)b->qcoeff)[5] = 0;
        ((int *)b->qcoeff)[6] = 0;
        ((int *)b->qcoeff)[7] = 0;
      } else {
340
        xd->inv_walsh4x4_1(&b->dqcoeff[0], b->diff);
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
        ((int *)b->qcoeff)[0] = 0;
      }

      vp9_dequant_dc_idct_add_y_block_4x4_inplace_c(xd->qcoeff,
          xd->block[0].dequant,
          xd->dst.y_buffer + y_idx * 16 * xd->dst.y_stride + x_idx * 16,
          xd->dst.y_stride, xd->eobs, xd->block[24].diff, xd);
      vp9_dequant_idct_add_uv_block_4x4_inplace_c(xd->qcoeff + 16 * 16,
          xd->block[16].dequant,
          xd->dst.u_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
          xd->dst.v_buffer + y_idx * 8 * xd->dst.uv_stride + x_idx * 8,
          xd->dst.uv_stride, xd->eobs + 16, xd);
    }
  }

  xd->above_context = pc->above_context + mb_col;
  xd->left_context = pc->left_context;
  xd->mode_info_context = orig_mi;
}
#endif

362
static void decode_macroblock(VP9D_COMP *pbi, MACROBLOCKD *xd,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
363
                              int mb_row, unsigned int mb_col,
John Koleszar's avatar
John Koleszar committed
364
                              BOOL_DECODER* const bc) {
John Koleszar's avatar
John Koleszar committed
365 366 367
  int eobtotal = 0;
  MB_PREDICTION_MODE mode;
  int i;
Deb Mukherjee's avatar
Deb Mukherjee committed
368 369
  int tx_size;
  TX_TYPE tx_type;
370

371
#if CONFIG_SUPERBLOCKS
372
  assert(!xd->mode_info_context->mbmi.encoded_as_sb);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
373
#endif
John Koleszar's avatar
John Koleszar committed
374

Jingning Han's avatar
Jingning Han committed
375 376 377 378
  // re-initialize macroblock dequantizer before detokenization
  if (xd->segmentation_enabled)
    mb_init_dequantizer(pbi, xd);

Deb Mukherjee's avatar
Deb Mukherjee committed
379
  tx_size = xd->mode_info_context->mbmi.txfm_size;
Deb Mukherjee's avatar
Deb Mukherjee committed
380 381
  mode = xd->mode_info_context->mbmi.mode;

John Koleszar's avatar
John Koleszar committed
382
  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
383
    vp9_reset_mb_tokens_context(xd);
384
  } else if (!bool_error(bc)) {
John Koleszar's avatar
John Koleszar committed
385 386 387
    for (i = 0; i < 25; i++) {
      xd->block[i].eob = 0;
      xd->eobs[i] = 0;
388
    }
389 390
    if (mode != B_PRED) {
      eobtotal = vp9_decode_mb_tokens(pbi, xd, bc);
Deb Mukherjee's avatar
Deb Mukherjee committed
391
    }
John Koleszar's avatar
John Koleszar committed
392
  }
393

Deb Mukherjee's avatar
Deb Mukherjee committed
394
  //mode = xd->mode_info_context->mbmi.mode;
395
  if (pbi->common.frame_type != KEY_FRAME)
396
    vp9_setup_interp_filters(xd, xd->mode_info_context->mbmi.interp_filter,
397
                             &pbi->common);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
398

John Koleszar's avatar
John Koleszar committed
399 400
  if (eobtotal == 0 && mode != B_PRED && mode != SPLITMV
      && mode != I8X8_PRED
401
      && !bool_error(bc)) {
John Koleszar's avatar
John Koleszar committed
402 403 404 405
    /* Special case:  Force the loopfilter to skip when eobtotal and
     * mb_skip_coeff are zero.
     * */
    xd->mode_info_context->mbmi.mb_skip_coeff = 1;
406 407
    skip_recon_mb(pbi, xd);
    return;
John Koleszar's avatar
John Koleszar committed
408
  }
Yaowu Xu's avatar
Yaowu Xu committed
409

Jingning Han's avatar
Jingning Han committed
410 411 412
  // moved to be performed before detokenization
//  if (xd->segmentation_enabled)
//    mb_init_dequantizer(pbi, xd);
413

John Koleszar's avatar
John Koleszar committed
414 415 416
  /* do prediction */
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
    if (mode != I8X8_PRED) {
417
      vp9_build_intra_predictors_mbuv(xd);
John Koleszar's avatar
John Koleszar committed
418
      if (mode != B_PRED) {
419
        vp9_build_intra_predictors_mby(xd);
John Koleszar's avatar
John Koleszar committed
420
      }
John Koleszar's avatar
John Koleszar committed
421
    }
John Koleszar's avatar
John Koleszar committed
422
  } else {
423
    vp9_build_inter_predictors_mb(xd);
John Koleszar's avatar
John Koleszar committed
424 425 426 427 428
  }

  /* dequantization and idct */
  if (mode == I8X8_PRED) {
    for (i = 0; i < 4; i++) {
429
      int ib = vp9_i8x8_block[i];
John Koleszar's avatar
John Koleszar committed
430 431 432 433 434
      const int iblock[4] = {0, 1, 4, 5};
      int j;
      int i8x8mode;
      BLOCKD *b;

435 436 437 438 439 440 441 442
      int idx = (ib & 0x02) ? (ib + 2) : ib;

      short *q  = xd->block[idx].qcoeff;
      short *dq = xd->block[0].dequant;
      unsigned char *pre = xd->block[ib].predictor;
      unsigned char *dst = *(xd->block[ib].base_dst) + xd->block[ib].dst;
      int stride = xd->dst.y_stride;

John Koleszar's avatar
John Koleszar committed
443 444
      b = &xd->block[ib];
      i8x8mode = b->bmi.as_mode.first;
445
      vp9_intra8x8_predict(b, i8x8mode, b->predictor);
John Koleszar's avatar
John Koleszar committed
446

447
      if (xd->mode_info_context->mbmi.txfm_size == TX_8X8) {
Deb Mukherjee's avatar
Deb Mukherjee committed
448 449
        tx_type = get_tx_type(xd, &xd->block[idx]);
        if (tx_type != DCT_DCT) {
450
          vp9_ht_dequant_idct_add_8x8_c(tx_type,
Deb Mukherjee's avatar
Deb Mukherjee committed
451 452
                                        q, dq, pre, dst, 16, stride);
        } else {
Yunqing Wang's avatar
Yunqing Wang committed
453 454
          vp9_dequant_idct_add_8x8_c(q, dq, pre, dst, 16, stride, 0,
                                     xd->eobs[idx]);
Deb Mukherjee's avatar
Deb Mukherjee committed
455 456
        }
        q += 64;
457 458 459
      } else {
        for (j = 0; j < 4; j++) {
          b = &xd->block[ib + iblock[j]];
460
          vp9_dequant_idct_add(b->qcoeff, b->dequant, b->predictor,
461 462 463
                                 *(b->base_dst) + b->dst, 16, b->dst_stride);
        }
      }
John Koleszar's avatar
John Koleszar committed
464
      b = &xd->block[16 + i];
465
      vp9_intra_uv4x4_predict(b, i8x8mode, b->predictor);
Scott LaVarnway's avatar
Scott LaVarnway committed
466 467
      pbi->idct_add(b->qcoeff, b->dequant, b->predictor,
                    *(b->base_dst) + b->dst, 8, b->dst_stride);
John Koleszar's avatar
John Koleszar committed
468
      b = &xd->block[20 + i];
469
      vp9_intra_uv4x4_predict(b, i8x8mode, b->predictor);
Scott LaVarnway's avatar
Scott LaVarnway committed
470 471
      pbi->idct_add(b->qcoeff, b->dequant, b->predictor,
                    *(b->base_dst) + b->dst, 8, b->dst_stride);
Yaowu Xu's avatar
Yaowu Xu committed
472
    }
John Koleszar's avatar
John Koleszar committed
473 474
  } else if (mode == B_PRED) {
    for (i = 0; i < 16; i++) {
475 476 477 478
      int b_mode;
#if CONFIG_COMP_INTRA_PRED
      int b_mode2;
#endif
John Koleszar's avatar
John Koleszar committed
479
      BLOCKD *b = &xd->block[i];
480 481 482 483 484
      b_mode = xd->mode_info_context->bmi[i].as_mode.first;
#if CONFIG_NEWBINTRAMODES
      xd->mode_info_context->bmi[i].as_mode.context = b->bmi.as_mode.context =
          vp9_find_bpred_context(b);
#endif
485 486
      if (!xd->mode_info_context->mbmi.mb_skip_coeff)
        eobtotal += vp9_decode_coefs_4x4(pbi, xd, bc, PLANE_TYPE_Y_WITH_DC, i);
487
#if CONFIG_COMP_INTRA_PRED
488
      b_mode2 = xd->mode_info_context->bmi[i].as_mode.second;
489

John Koleszar's avatar
John Koleszar committed
490
      if (b_mode2 == (B_PREDICTION_MODE)(B_DC_PRED - 1)) {
491
#endif
492
        vp9_intra4x4_predict(b, b_mode, b->predictor);
493
#if CONFIG_COMP_INTRA_PRED
John Koleszar's avatar
John Koleszar committed
494
      } else {
495
        vp9_comp_intra4x4_predict(b, b_mode, b_mode2, b->predictor);
John Koleszar's avatar
John Koleszar committed
496
      }
497
#endif
John Koleszar's avatar
John Koleszar committed
498

Deb Mukherjee's avatar
Deb Mukherjee committed
499 500
      tx_type = get_tx_type(xd, b);
      if (tx_type != DCT_DCT) {
501
        vp9_ht_dequant_idct_add_c(tx_type, b->qcoeff,
Deb Mukherjee's avatar
Deb Mukherjee committed
502 503 504
                                  b->dequant, b->predictor,
                                  *(b->base_dst) + b->dst, 16, b->dst_stride);
      } else {
505
        vp9_dequant_idct_add(b->qcoeff, b->dequant, b->predictor,
Jingning Han's avatar
Jingning Han committed
506
                               *(b->base_dst) + b->dst, 16, b->dst_stride);
Deb Mukherjee's avatar
Deb Mukherjee committed
507
      }
John Koleszar's avatar
John Koleszar committed
508
    }
509 510
    if (!xd->mode_info_context->mbmi.mb_skip_coeff)
      vp9_decode_mb_tokens_4x4_uv(pbi, xd, bc);
John Koleszar's avatar
John Koleszar committed
511
  } else if (mode == SPLITMV) {
512
    if (tx_size == TX_8X8) {
513
      vp9_dequant_idct_add_y_block_8x8(xd->qcoeff, xd->block[0].dequant,
514 515 516
                                         xd->predictor, xd->dst.y_buffer,
                                         xd->dst.y_stride, xd->eobs, xd);
    } else {
Scott LaVarnway's avatar
Scott LaVarnway committed
517
      pbi->idct_add_y_block(xd->qcoeff, xd->block[0].dequant,
518 519
                            xd->predictor, xd->dst.y_buffer,
                            xd->dst.y_stride, xd->eobs);
520
    }
John Koleszar's avatar
John Koleszar committed
521 522
  } else {
    BLOCKD *b = &xd->block[24];
Daniel Kang's avatar
Daniel Kang committed
523

Deb Mukherjee's avatar
Deb Mukherjee committed
524 525 526 527
    if (tx_size == TX_16X16) {
      BLOCKD *bd = &xd->block[0];
      tx_type = get_tx_type(xd, bd);
      if (tx_type != DCT_DCT) {
528
        vp9_ht_dequant_idct_add_16x16_c(tx_type, xd->qcoeff,
529 530 531
                                        xd->block[0].dequant, xd->predictor,
                                        xd->dst.y_buffer, 16, xd->dst.y_stride);
      } else {
532
        vp9_dequant_idct_add_16x16(xd->qcoeff, xd->block[0].dequant,
533 534
                                   xd->predictor, xd->dst.y_buffer,
                                   16, xd->dst.y_stride, xd->eobs[0]);
535
      }
Deb Mukherjee's avatar
Deb Mukherjee committed
536
    } else if (tx_size == TX_8X8) {
537
      vp9_dequantize_b_2x2(b);
538
      vp9_short_ihaar2x2(&b->dqcoeff[0], b->diff, 8);
539
      ((int *)b->qcoeff)[0] = 0;  // 2nd order block are set to 0 after idct
John Koleszar's avatar
John Koleszar committed
540 541 542 543 544 545 546
      ((int *)b->qcoeff)[1] = 0;
      ((int *)b->qcoeff)[2] = 0;
      ((int *)b->qcoeff)[3] = 0;
      ((int *)b->qcoeff)[4] = 0;
      ((int *)b->qcoeff)[5] = 0;
      ((int *)b->qcoeff)[6] = 0;
      ((int *)b->qcoeff)[7] = 0;
547
      vp9_dequant_dc_idct_add_y_block_8x8(xd->qcoeff,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
548 549
          xd->block[0].dequant, xd->predictor, xd->dst.y_buffer,
          xd->dst.y_stride, xd->eobs, xd->block[24].diff, xd);
John Koleszar's avatar
John Koleszar committed
550
    } else {
551
      vp9_dequantize_b(b);
John Koleszar's avatar
John Koleszar committed
552
      if (xd->eobs[24] > 1) {
553
        vp9_short_inv_walsh4x4(&b->dqcoeff[0], b->diff);
John Koleszar's avatar
John Koleszar committed
554 555 556 557 558 559 560 561 562
        ((int *)b->qcoeff)[0] = 0;
        ((int *)b->qcoeff)[1] = 0;
        ((int *)b->qcoeff)[2] = 0;
        ((int *)b->qcoeff)[3] = 0;
        ((int *)b->qcoeff)[4] = 0;
        ((int *)b->qcoeff)[5] = 0;
        ((int *)b->qcoeff)[6] = 0;
        ((int *)b->qcoeff)[7] = 0;
      } else {
563
        xd->inv_walsh4x4_1(&b->dqcoeff[0], b->diff);
John Koleszar's avatar
John Koleszar committed
564 565 566
        ((int *)b->qcoeff)[0] = 0;
      }

Scott LaVarnway's avatar
Scott LaVarnway committed
567 568 569
      pbi->dc_idct_add_y_block(xd->qcoeff, xd->block[0].dequant, xd->predictor,
                               xd->dst.y_buffer, xd->dst.y_stride, xd->eobs,
                               xd->block[24].diff);
570
    }
John Koleszar's avatar
John Koleszar committed
571 572
  }

573 574 575 576 577 578 579 580 581
  if ((tx_size == TX_8X8 &&
       xd->mode_info_context->mbmi.mode != I8X8_PRED &&
       xd->mode_info_context->mbmi.mode != SPLITMV)
      || tx_size == TX_16X16
     )
    vp9_dequant_idct_add_uv_block_8x8
        (xd->qcoeff + 16 * 16, xd->block[16].dequant,
         xd->predictor + 16 * 16, xd->dst.u_buffer, xd->dst.v_buffer,
         xd->dst.uv_stride, xd->eobs + 16, xd);
582
  else if (xd->mode_info_context->mbmi.mode != I8X8_PRED)
583 584 585
    pbi->idct_add_uv_block(xd->qcoeff + 16 * 16, xd->block[16].dequant,
         xd->predictor + 16 * 16, xd->dst.u_buffer, xd->dst.v_buffer,
         xd->dst.uv_stride, xd->eobs + 16);
Yaowu Xu's avatar
Yaowu Xu committed
586
}
John Koleszar's avatar
John Koleszar committed
587

588

589
static int get_delta_q(vp9_reader *bc, int prev, int *q_update) {
John Koleszar's avatar
John Koleszar committed
590
  int ret_val = 0;
John Koleszar's avatar
John Koleszar committed
591

592 593
  if (vp9_read_bit(bc)) {
    ret_val = vp9_read_literal(bc, 4);
John Koleszar's avatar
John Koleszar committed
594

595
    if (vp9_read_bit(bc))
John Koleszar's avatar
John Koleszar committed
596 597
      ret_val = -ret_val;
  }
John Koleszar's avatar
John Koleszar committed
598

John Koleszar's avatar
John Koleszar committed
599 600 601
  /* Trigger a quantizer update if the delta-q value has changed */
  if (ret_val != prev)
    *q_update = 1;
John Koleszar's avatar
John Koleszar committed
602

John Koleszar's avatar
John Koleszar committed
603
  return ret_val;
John Koleszar's avatar
John Koleszar committed
604 605 606 607 608 609 610
}

#ifdef PACKET_TESTING
#include <stdio.h>
FILE *vpxlog = 0;
#endif

Adrian Grange's avatar
Adrian Grange committed
611
/* Decode a row of Superblocks (2x2 region of MBs) */
612
static void
613
decode_sb_row(VP9D_COMP *pbi, VP9_COMMON *pc, int mbrow, MACROBLOCKD *xd,
John Koleszar's avatar
John Koleszar committed
614
              BOOL_DECODER* const bc) {
John Koleszar's avatar
John Koleszar committed
615 616 617 618 619 620 621 622 623 624 625 626 627
  int i;
  int sb_col;
  int mb_row, mb_col;
  int recon_yoffset, recon_uvoffset;
  int ref_fb_idx = pc->lst_fb_idx;
  int dst_fb_idx = pc->new_fb_idx;
  int recon_y_stride = pc->yv12_fb[ref_fb_idx].y_stride;
  int recon_uv_stride = pc->yv12_fb[ref_fb_idx].uv_stride;
  int row_delta[4] = { 0, +1,  0, -1};
  int col_delta[4] = { +1, -1, +1, +1};
  int sb_cols = (pc->mb_cols + 1) >> 1;

  // For a SB there are 2 left contexts, each pertaining to a MB row within
Ronald S. Bultje's avatar
Ronald S. Bultje committed
628
  vpx_memset(pc->left_context, 0, sizeof(pc->left_context));
John Koleszar's avatar
John Koleszar committed
629 630 631 632 633

  mb_row = mbrow;
  mb_col = 0;

  for (sb_col = 0; sb_col < sb_cols; sb_col++) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
634 635 636
    MODE_INFO *mi = xd->mode_info_context;

#if CONFIG_SUPERBLOCKS
637
    mi->mbmi.encoded_as_sb = vp9_read(bc, pc->sb_coded);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
638 639
#endif

John Koleszar's avatar
John Koleszar committed
640 641 642 643 644 645 646
    // Process the 4 MBs within the SB in the order:
    // top-left, top-right, bottom-left, bottom-right
    for (i = 0; i < 4; i++) {
      int dy = row_delta[i];
      int dx = col_delta[i];
      int offset_extended = dy * xd->mode_info_stride + dx;

647 648
      xd->mb_index = i;

Ronald S. Bultje's avatar
Ronald S. Bultje committed
649
      mi = xd->mode_info_context;
John Koleszar's avatar
John Koleszar committed
650 651 652 653 654
      if ((mb_row >= pc->mb_rows) || (mb_col >= pc->mb_cols)) {
        // MB lies outside frame, skip on to next
        mb_row += dy;
        mb_col += dx;
        xd->mode_info_context += offset_extended;
655
        xd->prev_mode_info_context += offset_extended;
John Koleszar's avatar
John Koleszar committed
656 657
        continue;
      }
658 659 660 661
#if CONFIG_SUPERBLOCKS
      if (i)
        mi->mbmi.encoded_as_sb = 0;
#endif
Yaowu Xu's avatar
Yaowu Xu committed
662

John Koleszar's avatar
John Koleszar committed
663 664
      // Set above context pointer
      xd->above_context = pc->above_context + mb_col;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
665
      xd->left_context = pc->left_context + (i >> 1);
John Koleszar's avatar
John Koleszar committed
666 667 668 669 670 671 672

      /* 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
       */
      xd->mb_to_top_edge = -((mb_row * 16)) << 3;
      xd->mb_to_left_edge = -((mb_col * 16) << 3);
673 674 675 676 677 678 679 680 681 682 683
#if CONFIG_SUPERBLOCKS
      if (mi->mbmi.encoded_as_sb) {
        xd->mb_to_bottom_edge = ((pc->mb_rows - 2 - mb_row) * 16) << 3;
        xd->mb_to_right_edge = ((pc->mb_cols - 2 - mb_col) * 16) << 3;
      } else {
#endif
        xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
        xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;
#if CONFIG_SUPERBLOCKS
      }
#endif
John Koleszar's avatar
John Koleszar committed
684 685 686 687 688 689 690 691 692 693 694 695

      xd->up_available = (mb_row != 0);
      xd->left_available = (mb_col != 0);


      recon_yoffset = (mb_row * recon_y_stride * 16) + (mb_col * 16);
      recon_uvoffset = (mb_row * recon_uv_stride * 8) + (mb_col * 8);

      xd->dst.y_buffer = pc->yv12_fb[dst_fb_idx].y_buffer + recon_yoffset;
      xd->dst.u_buffer = pc->yv12_fb[dst_fb_idx].u_buffer + recon_uvoffset;
      xd->dst.v_buffer = pc->yv12_fb[dst_fb_idx].v_buffer + recon_uvoffset;

696
      vp9_decode_mb_mode_mv(pbi, xd, mb_row, mb_col, bc);
697 698 699

      update_blockd_bmi(xd);

John Koleszar's avatar
John Koleszar committed
700 701 702 703 704 705 706 707 708 709 710 711
      /* Select the appropriate reference frame for this MB */
      if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
        ref_fb_idx = pc->lst_fb_idx;
      else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
        ref_fb_idx = pc->gld_fb_idx;
      else
        ref_fb_idx = pc->alt_fb_idx;

      xd->pre.y_buffer = pc->yv12_fb[ref_fb_idx].y_buffer + recon_yoffset;
      xd->pre.u_buffer = pc->yv12_fb[ref_fb_idx].u_buffer + recon_uvoffset;
      xd->pre.v_buffer = pc->yv12_fb[ref_fb_idx].v_buffer + recon_uvoffset;

712
      if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
John Koleszar's avatar
John Koleszar committed
713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
        int second_ref_fb_idx;

        /* Select the appropriate reference frame for this MB */
        if (xd->mode_info_context->mbmi.second_ref_frame == LAST_FRAME)
          second_ref_fb_idx = pc->lst_fb_idx;
        else if (xd->mode_info_context->mbmi.second_ref_frame ==
                 GOLDEN_FRAME)
          second_ref_fb_idx = pc->gld_fb_idx;
        else
          second_ref_fb_idx = pc->alt_fb_idx;

        xd->second_pre.y_buffer =
          pc->yv12_fb[second_ref_fb_idx].y_buffer + recon_yoffset;
        xd->second_pre.u_buffer =
          pc->yv12_fb[second_ref_fb_idx].u_buffer + recon_uvoffset;
        xd->second_pre.v_buffer =
          pc->yv12_fb[second_ref_fb_idx].v_buffer + recon_uvoffset;
      }

      if (xd->mode_info_context->mbmi.ref_frame != INTRA_FRAME) {
        /* propagate errors from reference frames */
        xd->corrupted |= pc->yv12_fb[ref_fb_idx].corrupted;
      }

Ronald S. Bultje's avatar
Ronald S. Bultje committed
737 738
#if CONFIG_SUPERBLOCKS
      if (xd->mode_info_context->mbmi.encoded_as_sb) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
739 740 741 742 743 744 745
        if (mb_col < pc->mb_cols - 1)
          mi[1] = mi[0];
        if (mb_row < pc->mb_rows - 1) {
          mi[pc->mode_info_stride] = mi[0];
          if (mb_col < pc->mb_cols - 1)
            mi[pc->mode_info_stride + 1] = mi[0];
        }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
746
      }
747 748 749 750 751 752 753 754
      if (xd->mode_info_context->mbmi.encoded_as_sb) {
        decode_superblock(pbi, xd, mb_row, mb_col, bc);
      } else {
#endif
        vp9_intra_prediction_down_copy(xd);
        decode_macroblock(pbi, xd, mb_row, mb_col, bc);
#if CONFIG_SUPERBLOCKS
      }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
755
#endif
John Koleszar's avatar
John Koleszar committed
756 757

      /* check if the boolean decoder has suffered an error */
758
      xd->corrupted |= bool_error(bc);
John Koleszar's avatar
John Koleszar committed
759

Ronald S. Bultje's avatar
Ronald S. Bultje committed
760 761 762 763 764 765 766 767 768
#if CONFIG_SUPERBLOCKS
      if (mi->mbmi.encoded_as_sb) {
        assert(!i);
        mb_col += 2;
        xd->mode_info_context += 2;
        xd->prev_mode_info_context += 2;
        break;
      }
#endif
John Koleszar's avatar
John Koleszar committed
769 770 771

      // skip to next MB
      xd->mode_info_context += offset_extended;
772
      xd->prev_mode_info_context += offset_extended;
John Koleszar's avatar
John Koleszar committed
773 774
      mb_row += dy;
      mb_col += dx;
John Koleszar's avatar
John Koleszar committed
775
    }
John Koleszar's avatar
John Koleszar committed
776
  }
John Koleszar's avatar
John Koleszar committed
777

John Koleszar's avatar
John Koleszar committed
778 779
  /* skip prediction column */
  xd->mode_info_context += 1 - (pc->mb_cols & 0x1) + xd->mode_info_stride;
780
  xd->prev_mode_info_context += 1 - (pc->mb_cols & 0x1) + xd->mode_info_stride;
John Koleszar's avatar
John Koleszar committed
781 782
}

John Koleszar's avatar
John Koleszar committed
783 784 785 786
static unsigned int read_partition_size(const unsigned char *cx_size) {
  const unsigned int size =
    cx_size[0] + (cx_size[1] << 8) + (cx_size[2] << 16);
  return size;
John Koleszar's avatar
John Koleszar committed
787 788
}

789 790
static int read_is_valid(const unsigned char *start,
                         size_t               len,
John Koleszar's avatar
John Koleszar committed
791 792
                         const unsigned char *end) {
  return (start + len > start && start + len <= end);
793 794 795
}


796
static void setup_token_decoder(VP9D_COMP *pbi,
John Koleszar's avatar
John Koleszar committed
797 798
                                const unsigned char *cx_data,
                                BOOL_DECODER* const bool_decoder) {
799
  VP9_COMMON          *pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
  const unsigned char *user_data_end = pbi->Source + pbi->source_sz;
  const unsigned char *partition;

  ptrdiff_t            partition_size;
  ptrdiff_t            bytes_left;

  // Set up pointers to token partition
  partition = cx_data;
  bytes_left = user_data_end - partition;
  partition_size = bytes_left;

  /* 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.
   */
  if (!read_is_valid(partition, partition_size, user_data_end)) {
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet or corrupt partition "
                       "%d length", 1);
  }

821 822
  if (vp9_start_decode(bool_decoder,
                       partition, (unsigned int)partition_size))
John Koleszar's avatar
John Koleszar committed
823 824
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
825 826
}

827 828
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
829
  MACROBLOCKD *const xd  = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
830

John Koleszar's avatar
John Koleszar committed
831 832
  if (pc->frame_type == KEY_FRAME) {
    /* Various keyframe initializations */
833
    vp9_init_mv_probs(pc);
John Koleszar's avatar
John Koleszar committed
834

835 836
    vp9_init_mbmode_probs(pc);
    vp9_default_bmode_probs(pc->fc.bmode_prob);
John Koleszar's avatar
John Koleszar committed
837

838 839
    vp9_default_coef_probs(pc);
    vp9_kf_default_bmode_probs(pc->kf_bmode_prob);
John Koleszar's avatar
John Koleszar committed
840

John Koleszar's avatar
John Koleszar committed
841 842
    // Reset the segment feature data to the default stats:
    // Features disabled, 0, with delta coding (Default state).
843
    vp9_clearall_segfeatures(xd);
Paul Wilkins's avatar
Paul Wilkins committed
844

John Koleszar's avatar
John Koleszar committed
845
    xd->mb_segment_abs_delta = SEGMENT_DELTADATA;
John Koleszar's avatar
John Koleszar committed
846

John Koleszar's avatar
John Koleszar committed
847 848 849
    /* reset the mode ref deltasa for loop filter */
    vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
    vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));
John Koleszar's avatar
John Koleszar committed
850

John Koleszar's avatar
John Koleszar committed
851 852 853 854 855
    /* All buffers are implicitly updated on key frames. */
    pc->refresh_golden_frame = 1;
    pc->refresh_alt_ref_frame = 1;
    pc->copy_buffer_to_gf = 0;
    pc->copy_buffer_to_arf = 0;
John Koleszar's avatar
John Koleszar committed
856

John Koleszar's avatar
John Koleszar committed
857 858 859 860 861
    /* Note that Golden and Altref modes cannot be used on a key frame so
     * ref_frame_sign_bias[] is undefined and meaningless
     */
    pc->ref_frame_sign_bias[GOLDEN_FRAME] = 0;
    pc->ref_frame_sign_bias[ALTREF_FRAME] = 0;
862

863
    vp9_init_mode_contexts(&pbi->common);
John Koleszar's avatar
John Koleszar committed
864 865
    vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc));
    vpx_memcpy(&pc->lfc_a, &pc->fc, sizeof(pc->fc));
Yaowu Xu's avatar
Yaowu Xu committed
866

867
    vpx_memcpy(pbi->common.fc.vp9_mode_contexts,
John Koleszar's avatar
John Koleszar committed
868 869
               pbi->common.fc.mode_context,
               sizeof(pbi->common.fc.mode_context));
870 871 872 873 874
    vpx_memset(pc->prev_mip, 0,
               (pc->mb_cols + 1) * (pc->mb_rows + 1)* sizeof(MODE_INFO));
    vpx_memset(pc->mip, 0,
               (pc->mb_cols + 1) * (pc->mb_rows + 1)* sizeof(MODE_INFO));

875 876
    vp9_update_mode_info_border(pc, pc->mip);
    vp9_update_mode_info_in_image(pc, pc->mi);
877

John Koleszar's avatar
John Koleszar committed
878
  } else {
879

John Koleszar's avatar
John Koleszar committed
880 881 882 883 884
    if (!pc->use_bilinear_mc_filter)
      pc->mcomp_filter_type = EIGHTTAP;
    else
      pc->mcomp_filter_type = BILINEAR;

885
    /* To enable choice of different interpolation filters */
886
    vp9_setup_interp_filters(xd, pc->mcomp_filter_type, pc);
John Koleszar's avatar
John Koleszar committed
887
  }
John Koleszar's avatar
John Koleszar committed
888

John Koleszar's avatar
John Koleszar committed
889
  xd->mode_info_context = pc->mi;
890
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
891 892 893 894
  xd->frame_type = pc->frame_type;
  xd->mode_info_context->mbmi.mode = DC_PRED;
  xd->mode_info_stride = pc->mode_info_stride;
  xd->corrupted = 0; /* init without corruption */
895

John Koleszar's avatar
John Koleszar committed
896 897 898
  xd->fullpixel_mask = 0xffffffff;
  if (pc->full_pixel)
    xd->fullpixel_mask = 0xfffffff8;
899

John Koleszar's avatar
John Koleszar committed
900 901
}

902
#if 0
903
static void read_coef_probs2(VP9D_COMP *pbi) {
904
  const vp9_prob grpupd = 192;
John Koleszar's avatar
John Koleszar committed
905
  int i, j, k, l;
906
  vp9_reader *const bc = &pbi->bc;
907
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
908
  for (l = 0; l < ENTROPY_NODES; l++) {