decodframe.c 47 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 "onyxd_int.h"
13 14 15 16
#include "vp9/common/header.h"
#include "vp9/common/reconintra.h"
#include "vp9/common/reconintra4x4.h"
#include "vp9/common/reconinter.h"
17
#include "vp9/decoder/decodframe.h"
John Koleszar's avatar
John Koleszar committed
18
#include "detokenize.h"
19 20 21 22
#include "vp9/common/invtrans.h"
#include "vp9/common/alloccommon.h"
#include "vp9/common/entropymode.h"
#include "vp9/common/quant_common.h"
23
#include "vpx_scale/vpxscale.h"
24
#include "vp9/common/setupintrarecon.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
25

John Koleszar's avatar
John Koleszar committed
26
#include "decodemv.h"
27 28
#include "vp9/common/extend.h"
#include "vp9/common/modecont.h"
John Koleszar's avatar
John Koleszar committed
29
#include "vpx_mem/vpx_mem.h"
30
#include "vp9/common/idct.h"
John Koleszar's avatar
John Koleszar committed
31 32
#include "dboolhuff.h"

33 34
#include "vp9/common/seg_common.h"
#include "vp9/common/entropy.h"
35
#include "vpx_rtcd.h"
36

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

40

41 42
#define COEFCOUNT_TESTING

John Koleszar's avatar
John Koleszar committed
43 44 45 46 47 48 49 50 51 52 53 54
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;
55 56
}

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

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

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

  for (Q = 0; Q < QINDEX_RANGE; Q++) {
81 82 83
    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
84 85 86

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

89 90 91
      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
92
    }
John Koleszar's avatar
John Koleszar committed
93
  }
John Koleszar's avatar
John Koleszar committed
94 95
}

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

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

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

John Koleszar's avatar
John Koleszar committed
118 119 120 121
  /* 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
122

Hui Su's avatar
Hui Su committed
123
#if CONFIG_LOSSLESS
John Koleszar's avatar
John Koleszar committed
124
  if (!QIndex) {
125 126 127 128 129
    pbi->common.rtcd.idct.idct1        = vp9_short_inv_walsh4x4_1_x8_c;
    pbi->common.rtcd.idct.idct16       = vp9_short_inv_walsh4x4_x8_c;
    pbi->common.rtcd.idct.idct1_scalar_add  = vp9_dc_only_inv_walsh_add_c;
    pbi->common.rtcd.idct.iwalsh1      = vp9_short_inv_walsh4x4_1_lossless_c;
    pbi->common.rtcd.idct.iwalsh16     = vp9_short_inv_walsh4x4_lossless_c;
130 131 132 133 134
    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
135
  } else {
136 137 138 139 140
    pbi->common.rtcd.idct.idct1        = vp9_short_idct4x4llm_1_c;
    pbi->common.rtcd.idct.idct16       = vp9_short_idct4x4llm_c;
    pbi->common.rtcd.idct.idct1_scalar_add  = vp9_dc_only_idct_add_c;
    pbi->common.rtcd.idct.iwalsh1      = vp9_short_inv_walsh4x4_1_c;
    pbi->common.rtcd.idct.iwalsh16     = vp9_short_inv_walsh4x4_c;
141 142 143 144 145
    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
146
  }
Scott LaVarnway's avatar
Scott LaVarnway committed
147
#else
148 149 150 151 152
  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
153 154
#endif

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

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

}

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

169 170 171
/* 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.
 */
172
static void skip_recon_mb(VP9D_COMP *pbi, MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
173
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
174 175
#if CONFIG_SUPERBLOCKS
    if (xd->mode_info_context->mbmi.encoded_as_sb) {
176 177
      vp9_build_intra_predictors_sbuv_s(xd);
      vp9_build_intra_predictors_sby_s(xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
178 179
    } else {
#endif
180 181
    vp9_build_intra_predictors_mbuv_s(xd);
    vp9_build_intra_predictors_mby_s(xd);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
182 183 184
#if CONFIG_SUPERBLOCKS
    }
#endif
John Koleszar's avatar
John Koleszar committed
185
  } else {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
186 187
#if CONFIG_SUPERBLOCKS
    if (xd->mode_info_context->mbmi.encoded_as_sb) {
188
      vp9_build_inter32x32_predictors_sb(xd, xd->dst.y_buffer,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
189 190 191 192
                                         xd->dst.u_buffer, xd->dst.v_buffer,
                                         xd->dst.y_stride, xd->dst.uv_stride);
    } else {
#endif
193
    vp9_build_1st_inter16x16_predictors_mb(xd, xd->dst.y_buffer,
194 195
                                           xd->dst.u_buffer, xd->dst.v_buffer,
                                           xd->dst.y_stride, xd->dst.uv_stride);
John Koleszar's avatar
John Koleszar committed
196 197

    if (xd->mode_info_context->mbmi.second_ref_frame) {
198
      vp9_build_2nd_inter16x16_predictors_mb(xd, xd->dst.y_buffer,
John Koleszar's avatar
John Koleszar committed
199 200
                                             xd->dst.u_buffer, xd->dst.v_buffer,
                                             xd->dst.y_stride, xd->dst.uv_stride);
201
    }
Ronald S. Bultje's avatar
Ronald S. Bultje committed
202 203 204
#if CONFIG_SUPERBLOCKS
    }
#endif
John Koleszar's avatar
John Koleszar committed
205
  }
John Koleszar's avatar
John Koleszar committed
206 207
}

208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 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
#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;
    }

    if (tx_size == TX_16X16) {
      eobtotal = vp9_decode_mb_tokens_16x16(pbi, xd, bc);
    } else if (tx_size == TX_8X8) {
      eobtotal = vp9_decode_mb_tokens_8x8(pbi, xd, bc);
    } else {
      eobtotal = vp9_decode_mb_tokens(pbi, xd, bc);
    }
    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,
287
          xd->dst.y_stride, xd->dst.y_stride, xd->eobs[0]);
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
      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);
      IDCT_INVOKE(RTCD_VTABLE(idct), ihaar2)(&b->dqcoeff[0], b->diff, 8);
      ((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) {
        IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh16)(&b->dqcoeff[0], b->diff);
        ((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 {
        IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh1)(&b->dqcoeff[0], b->diff);
        ((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

348
static void decode_macroblock(VP9D_COMP *pbi, MACROBLOCKD *xd,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
349
                              int mb_row, unsigned int mb_col,
John Koleszar's avatar
John Koleszar committed
350
                              BOOL_DECODER* const bc) {
John Koleszar's avatar
John Koleszar committed
351 352 353
  int eobtotal = 0;
  MB_PREDICTION_MODE mode;
  int i;
Deb Mukherjee's avatar
Deb Mukherjee committed
354 355
  int tx_size;
  TX_TYPE tx_type;
356

357
#if CONFIG_SUPERBLOCKS
358
  assert(!xd->mode_info_context->mbmi.encoded_as_sb);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
359
#endif
John Koleszar's avatar
John Koleszar committed
360

Jingning Han's avatar
Jingning Han committed
361 362 363 364
  // re-initialize macroblock dequantizer before detokenization
  if (xd->segmentation_enabled)
    mb_init_dequantizer(pbi, xd);

Deb Mukherjee's avatar
Deb Mukherjee committed
365
  tx_size = xd->mode_info_context->mbmi.txfm_size;
Deb Mukherjee's avatar
Deb Mukherjee committed
366 367
  mode = xd->mode_info_context->mbmi.mode;

John Koleszar's avatar
John Koleszar committed
368
  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
369
    vp9_reset_mb_tokens_context(xd);
370
  } else if (!bool_error(bc)) {
John Koleszar's avatar
John Koleszar committed
371 372 373
    for (i = 0; i < 25; i++) {
      xd->block[i].eob = 0;
      xd->eobs[i] = 0;
374
    }
Deb Mukherjee's avatar
Deb Mukherjee committed
375
    if (tx_size == TX_16X16) {
376
      eobtotal = vp9_decode_mb_tokens_16x16(pbi, xd, bc);
Deb Mukherjee's avatar
Deb Mukherjee committed
377
    } else if (tx_size == TX_8X8) {
378
      eobtotal = vp9_decode_mb_tokens_8x8(pbi, xd, bc);
Deb Mukherjee's avatar
Deb Mukherjee committed
379
    } else {
380
      eobtotal = vp9_decode_mb_tokens(pbi, xd, bc);
Deb Mukherjee's avatar
Deb Mukherjee committed
381
    }
John Koleszar's avatar
John Koleszar committed
382
  }
383

Deb Mukherjee's avatar
Deb Mukherjee committed
384
  //mode = xd->mode_info_context->mbmi.mode;
385
  if (pbi->common.frame_type != KEY_FRAME)
386
    vp9_setup_interp_filters(xd, xd->mode_info_context->mbmi.interp_filter,
387
                             &pbi->common);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
388

John Koleszar's avatar
John Koleszar committed
389 390
  if (eobtotal == 0 && mode != B_PRED && mode != SPLITMV
      && mode != I8X8_PRED
391
      && !bool_error(bc)) {
John Koleszar's avatar
John Koleszar committed
392 393 394 395
    /* Special case:  Force the loopfilter to skip when eobtotal and
     * mb_skip_coeff are zero.
     * */
    xd->mode_info_context->mbmi.mb_skip_coeff = 1;
396 397
    skip_recon_mb(pbi, xd);
    return;
John Koleszar's avatar
John Koleszar committed
398
  }
Yaowu Xu's avatar
Yaowu Xu committed
399

Jingning Han's avatar
Jingning Han committed
400 401 402
  // moved to be performed before detokenization
//  if (xd->segmentation_enabled)
//    mb_init_dequantizer(pbi, xd);
403

John Koleszar's avatar
John Koleszar committed
404 405 406
  /* do prediction */
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
    if (mode != I8X8_PRED) {
407
      vp9_build_intra_predictors_mbuv(xd);
John Koleszar's avatar
John Koleszar committed
408
      if (mode != B_PRED) {
409
        vp9_build_intra_predictors_mby(xd);
John Koleszar's avatar
John Koleszar committed
410
      }
John Koleszar's avatar
John Koleszar committed
411
    }
John Koleszar's avatar
John Koleszar committed
412
  } else {
413
    vp9_build_inter_predictors_mb(xd);
John Koleszar's avatar
John Koleszar committed
414 415 416 417 418
  }

  /* dequantization and idct */
  if (mode == I8X8_PRED) {
    for (i = 0; i < 4; i++) {
419
      int ib = vp9_i8x8_block[i];
John Koleszar's avatar
John Koleszar committed
420 421 422 423 424
      const int iblock[4] = {0, 1, 4, 5};
      int j;
      int i8x8mode;
      BLOCKD *b;

425 426 427 428 429 430 431 432
      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
433 434
      b = &xd->block[ib];
      i8x8mode = b->bmi.as_mode.first;
435
      vp9_intra8x8_predict(b, i8x8mode, b->predictor);
John Koleszar's avatar
John Koleszar committed
436

437
      if (xd->mode_info_context->mbmi.txfm_size == TX_8X8) {
Deb Mukherjee's avatar
Deb Mukherjee committed
438 439
        tx_type = get_tx_type(xd, &xd->block[idx]);
        if (tx_type != DCT_DCT) {
440
          vp9_ht_dequant_idct_add_8x8_c(tx_type,
Deb Mukherjee's avatar
Deb Mukherjee committed
441 442
                                        q, dq, pre, dst, 16, stride);
        } else {
443
          vp9_dequant_idct_add_8x8_c(q, dq, pre, dst, 16, stride);
Deb Mukherjee's avatar
Deb Mukherjee committed
444 445
        }
        q += 64;
446 447 448
      } else {
        for (j = 0; j < 4; j++) {
          b = &xd->block[ib + iblock[j]];
449
          vp9_dequant_idct_add(b->qcoeff, b->dequant, b->predictor,
450 451 452
                                 *(b->base_dst) + b->dst, 16, b->dst_stride);
        }
      }
John Koleszar's avatar
John Koleszar committed
453
      b = &xd->block[16 + i];
454
      vp9_intra_uv4x4_predict(b, i8x8mode, b->predictor);
Scott LaVarnway's avatar
Scott LaVarnway committed
455 456
      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
457
      b = &xd->block[20 + i];
458
      vp9_intra_uv4x4_predict(b, i8x8mode, b->predictor);
Scott LaVarnway's avatar
Scott LaVarnway committed
459 460
      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
461
    }
John Koleszar's avatar
John Koleszar committed
462 463 464 465
  } else if (mode == B_PRED) {
    for (i = 0; i < 16; i++) {
      BLOCKD *b = &xd->block[i];
      int b_mode = xd->mode_info_context->bmi[i].as_mode.first;
466
#if CONFIG_COMP_INTRA_PRED
John Koleszar's avatar
John Koleszar committed
467
      int b_mode2 = xd->mode_info_context->bmi[i].as_mode.second;
468

John Koleszar's avatar
John Koleszar committed
469
      if (b_mode2 == (B_PREDICTION_MODE)(B_DC_PRED - 1)) {
470
#endif
471
        vp9_intra4x4_predict(b, b_mode, b->predictor);
472
#if CONFIG_COMP_INTRA_PRED
John Koleszar's avatar
John Koleszar committed
473
      } else {
474
        vp9_comp_intra4x4_predict(b, b_mode, b_mode2, b->predictor);
John Koleszar's avatar
John Koleszar committed
475
      }
476
#endif
John Koleszar's avatar
John Koleszar committed
477

Deb Mukherjee's avatar
Deb Mukherjee committed
478 479
      tx_type = get_tx_type(xd, b);
      if (tx_type != DCT_DCT) {
480
        vp9_ht_dequant_idct_add_c(tx_type, b->qcoeff,
Deb Mukherjee's avatar
Deb Mukherjee committed
481 482 483
                                  b->dequant, b->predictor,
                                  *(b->base_dst) + b->dst, 16, b->dst_stride);
      } else {
484
        vp9_dequant_idct_add(b->qcoeff, b->dequant, b->predictor,
Jingning Han's avatar
Jingning Han committed
485
                               *(b->base_dst) + b->dst, 16, b->dst_stride);
Deb Mukherjee's avatar
Deb Mukherjee committed
486
      }
John Koleszar's avatar
John Koleszar committed
487
    }
John Koleszar's avatar
John Koleszar committed
488
  } else if (mode == SPLITMV) {
489
    if (tx_size == TX_8X8) {
490
      vp9_dequant_idct_add_y_block_8x8(xd->qcoeff, xd->block[0].dequant,
491 492 493
                                         xd->predictor, xd->dst.y_buffer,
                                         xd->dst.y_stride, xd->eobs, xd);
    } else {
Scott LaVarnway's avatar
Scott LaVarnway committed
494
      pbi->idct_add_y_block(xd->qcoeff, xd->block[0].dequant,
495 496 497
                                       xd->predictor, xd->dst.y_buffer,
                                       xd->dst.y_stride, xd->eobs);
    }
John Koleszar's avatar
John Koleszar committed
498 499
  } else {
    BLOCKD *b = &xd->block[24];
Daniel Kang's avatar
Daniel Kang committed
500

Deb Mukherjee's avatar
Deb Mukherjee committed
501 502 503 504
    if (tx_size == TX_16X16) {
      BLOCKD *bd = &xd->block[0];
      tx_type = get_tx_type(xd, bd);
      if (tx_type != DCT_DCT) {
505
        vp9_ht_dequant_idct_add_16x16_c(tx_type, xd->qcoeff,
506 507 508
                                        xd->block[0].dequant, xd->predictor,
                                        xd->dst.y_buffer, 16, xd->dst.y_stride);
      } else {
509
        vp9_dequant_idct_add_16x16(xd->qcoeff, xd->block[0].dequant,
510
                                     xd->predictor, xd->dst.y_buffer,
Yunqing Wang's avatar
Yunqing Wang committed
511
                                     16, xd->dst.y_stride, xd->eobs[0]);
512
      }
Deb Mukherjee's avatar
Deb Mukherjee committed
513
    } else if (tx_size == TX_8X8) {
514
      vp9_dequantize_b_2x2(b);
John Koleszar's avatar
John Koleszar committed
515
      IDCT_INVOKE(RTCD_VTABLE(idct), ihaar2)(&b->dqcoeff[0], b->diff, 8);
516
      ((int *)b->qcoeff)[0] = 0;  // 2nd order block are set to 0 after idct
John Koleszar's avatar
John Koleszar committed
517 518 519 520 521 522 523
      ((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;
524
        vp9_dequant_dc_idct_add_y_block_8x8(xd->qcoeff,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
525 526
          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
527
    } else {
528
      vp9_dequantize_b(b);
John Koleszar's avatar
John Koleszar committed
529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
      if (xd->eobs[24] > 1) {
        IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh16)(&b->dqcoeff[0], b->diff);
        ((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 {
        IDCT_INVOKE(RTCD_VTABLE(idct), iwalsh1)(&b->dqcoeff[0], b->diff);
        ((int *)b->qcoeff)[0] = 0;
      }

Scott LaVarnway's avatar
Scott LaVarnway committed
544 545 546
      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);
547
    }
John Koleszar's avatar
John Koleszar committed
548 549
  }

550 551 552 553 554 555 556 557 558 559 560 561 562
  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);
  else if (xd->mode_info_context->mbmi.mode != I8X8_PRED)
    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
563
}
John Koleszar's avatar
John Koleszar committed
564

565

566
static int get_delta_q(vp9_reader *bc, int prev, int *q_update) {
John Koleszar's avatar
John Koleszar committed
567
  int ret_val = 0;
John Koleszar's avatar
John Koleszar committed
568

569 570
  if (vp9_read_bit(bc)) {
    ret_val = vp9_read_literal(bc, 4);
John Koleszar's avatar
John Koleszar committed
571

572
    if (vp9_read_bit(bc))
John Koleszar's avatar
John Koleszar committed
573 574
      ret_val = -ret_val;
  }
John Koleszar's avatar
John Koleszar committed
575

John Koleszar's avatar
John Koleszar committed
576 577 578
  /* 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
579

John Koleszar's avatar
John Koleszar committed
580
  return ret_val;
John Koleszar's avatar
John Koleszar committed
581 582 583 584 585 586 587
}

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

Adrian Grange's avatar
Adrian Grange committed
588
/* Decode a row of Superblocks (2x2 region of MBs) */
589
static void
590
decode_sb_row(VP9D_COMP *pbi, VP9_COMMON *pc, int mbrow, MACROBLOCKD *xd,
John Koleszar's avatar
John Koleszar committed
591
              BOOL_DECODER* const bc) {
John Koleszar's avatar
John Koleszar committed
592 593 594 595 596 597 598 599 600 601 602 603 604
  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
605
  vpx_memset(pc->left_context, 0, sizeof(pc->left_context));
John Koleszar's avatar
John Koleszar committed
606 607 608 609 610

  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
611 612 613
    MODE_INFO *mi = xd->mode_info_context;

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

John Koleszar's avatar
John Koleszar committed
617 618 619 620 621 622 623
    // 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;

624 625
      xd->mb_index = i;

Ronald S. Bultje's avatar
Ronald S. Bultje committed
626
      mi = xd->mode_info_context;
John Koleszar's avatar
John Koleszar committed
627 628 629 630 631
      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;
632
        xd->prev_mode_info_context += offset_extended;
John Koleszar's avatar
John Koleszar committed
633 634
        continue;
      }
Yaowu Xu's avatar
Yaowu Xu committed
635

John Koleszar's avatar
John Koleszar committed
636 637
      // Set above context pointer
      xd->above_context = pc->above_context + mb_col;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
638
      xd->left_context = pc->left_context + (i >> 1);
John Koleszar's avatar
John Koleszar committed
639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660

      /* 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_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;

      xd->mb_to_left_edge = -((mb_col * 16) << 3);
      xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;

      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;

Ronald S. Bultje's avatar
Ronald S. Bultje committed
661 662 663 664
#if CONFIG_SUPERBLOCKS
      if (i)
        mi->mbmi.encoded_as_sb = 0;
#endif
665
      vp9_decode_mb_mode_mv(pbi, xd, mb_row, mb_col, bc);
666 667 668

      update_blockd_bmi(xd);

John Koleszar's avatar
John Koleszar committed
669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705
      /* 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;

      if (xd->mode_info_context->mbmi.second_ref_frame) {
        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
706 707
#if CONFIG_SUPERBLOCKS
      if (xd->mode_info_context->mbmi.encoded_as_sb) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
708 709 710 711 712 713 714
        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
715
      }
716 717 718 719 720 721 722 723
      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
724
#endif
John Koleszar's avatar
John Koleszar committed
725 726

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
729 730 731 732 733 734 735 736 737
#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
738 739 740

      // skip to next MB
      xd->mode_info_context += offset_extended;
741
      xd->prev_mode_info_context += offset_extended;
John Koleszar's avatar
John Koleszar committed
742 743
      mb_row += dy;
      mb_col += dx;
John Koleszar's avatar
John Koleszar committed
744
    }
John Koleszar's avatar
John Koleszar committed
745
  }
John Koleszar's avatar
John Koleszar committed
746

John Koleszar's avatar
John Koleszar committed
747 748
  /* skip prediction column */
  xd->mode_info_context += 1 - (pc->mb_cols & 0x1) + xd->mode_info_stride;
749
  xd->prev_mode_info_context += 1 - (pc->mb_cols & 0x1) + xd->mode_info_stride;
John Koleszar's avatar
John Koleszar committed
750 751
}

John Koleszar's avatar
John Koleszar committed
752 753 754 755
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
756 757
}

758 759
static int read_is_valid(const unsigned char *start,
                         size_t               len,
John Koleszar's avatar
John Koleszar committed
760 761
                         const unsigned char *end) {
  return (start + len > start && start + len <= end);
762 763 764
}


765
static void setup_token_decoder(VP9D_COMP *pbi,
John Koleszar's avatar
John Koleszar committed
766 767
                                const unsigned char *cx_data,
                                BOOL_DECODER* const bool_decoder) {
768
  VP9_COMMON          *pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789
  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);
  }

790 791
  if (vp9_start_decode(bool_decoder,
                       partition, (unsigned int)partition_size))
John Koleszar's avatar
John Koleszar committed
792 793
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
794 795
}

796 797
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
798
  MACROBLOCKD *const xd  = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
799

John Koleszar's avatar
John Koleszar committed
800 801
  if (pc->frame_type == KEY_FRAME) {
    /* Various keyframe initializations */
802
    vp9_init_mv_probs(pc);
John Koleszar's avatar
John Koleszar committed
803

804 805
    vp9_init_mbmode_probs(pc);
    vp9_default_bmode_probs(pc->fc.bmode_prob);
John Koleszar's avatar
John Koleszar committed
806

807 808
    vp9_default_coef_probs(pc);
    vp9_kf_default_bmode_probs(pc->kf_bmode_prob);
John Koleszar's avatar
John Koleszar committed
809

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

John Koleszar's avatar
John Koleszar committed
814
    xd->mb_segment_abs_delta = SEGMENT_DELTADATA;
John Koleszar's avatar
John Koleszar committed
815

John Koleszar's avatar
John Koleszar committed
816 817 818
    /* 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
819

John Koleszar's avatar
John Koleszar committed
820 821 822 823 824
    /* 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
825

John Koleszar's avatar
John Koleszar committed
826 827 828 829 830
    /* 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;
831

832
    vp9_init_mode_contexts(&pbi->common);
John Koleszar's avatar
John Koleszar committed
833 834
    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
835

John Koleszar's avatar
John Koleszar committed
836 837 838
    vpx_memcpy(pbi->common.fc.vp8_mode_contexts,
               pbi->common.fc.mode_context,
               sizeof(pbi->common.fc.mode_context));
839 840 841 842 843
    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));

844 845
    vp9_update_mode_info_border(pc, pc->mip);
    vp9_update_mode_info_in_image(pc, pc->mi);
846

John Koleszar's avatar
John Koleszar committed
847
  } else {
848

John Koleszar's avatar
John Koleszar committed
849 850 851 852 853
    if (!pc->use_bilinear_mc_filter)
      pc->mcomp_filter_type = EIGHTTAP;
    else
      pc->mcomp_filter_type = BILINEAR;

854
    /* To enable choice of different interpolation filters */
855
    vp9_setup_interp_filters(xd, pc->mcomp_filter_type, pc);
John Koleszar's avatar
John Koleszar committed
856
  }
John Koleszar's avatar
John Koleszar committed
857

John Koleszar's avatar
John Koleszar committed
858
  xd->mode_info_context = pc->mi;
859
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
860 861 862 863
  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 */
864

John Koleszar's avatar
John Koleszar committed
865 866 867
  xd->fullpixel_mask = 0xffffffff;
  if (pc->full_pixel)
    xd->fullpixel_mask = 0xfffffff8;
868

John Koleszar's avatar
John Koleszar committed
869 870
}

871
#if 0
872
static void read_coef_probs2(VP9D_COMP *pbi) {
873
  const vp9_prob grpupd = 192;
John Koleszar's avatar
John Koleszar committed
874
  int i, j, k, l;
875
  vp9_reader *const bc = &pbi->bc;
876
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
877
  for (l = 0; l < ENTROPY_NODES; l++) {
878
    if (vp9_read(bc, grpupd)) {
John Koleszar's avatar
John Koleszar committed
879 880 881 882 883 884 885
      // printf("Decoding %d\n", l);
      for (i = 0; i < BLOCK_TYPES; i++)
        for (j = !i; j < COEF_BANDS; j++)
          for (k = 0; k < PREV_COEF_CONTEXTS; k++) {
            if (k >= 3 && ((i == 0 && j == 1) ||
                           (i > 0 && j == 0)))
              continue;
886
            {
887 888
              vp9_prob *const p = pc->fc.coef_probs [i][j][k] + l;
              int u = vp9_read(bc, COEF_UPDATE_PROB);
John Koleszar's avatar
John Koleszar committed
889 890 891 892