decodframe.c 47.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 "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);
379
    } else if (mode != B_PRED) {
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
408
409
      if (mode != B_PRED) {
        vp9_build_intra_predictors_mbuv(xd);
      }
John Koleszar's avatar
John Koleszar committed
410
      if (mode != B_PRED) {
411
        vp9_build_intra_predictors_mby(xd);
John Koleszar's avatar
John Koleszar committed
412
      }
John Koleszar's avatar
John Koleszar committed
413
    }
John Koleszar's avatar
John Koleszar committed
414
  } else {
415
    vp9_build_inter_predictors_mb(xd);
John Koleszar's avatar
John Koleszar committed
416
417
418
419
420
  }

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

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

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

John Koleszar's avatar
John Koleszar committed
482
      if (b_mode2 == (B_PREDICTION_MODE)(B_DC_PRED - 1)) {
483
#endif
484
        vp9_intra4x4_predict(b, b_mode, b->predictor);
485
#if CONFIG_COMP_INTRA_PRED
John Koleszar's avatar
John Koleszar committed
486
      } else {
487
        vp9_comp_intra4x4_predict(b, b_mode, b_mode2, b->predictor);
John Koleszar's avatar
John Koleszar committed
488
      }
489
#endif
John Koleszar's avatar
John Koleszar committed
490

Deb Mukherjee's avatar
Deb Mukherjee committed
491
492
      tx_type = get_tx_type(xd, b);
      if (tx_type != DCT_DCT) {
493
        vp9_ht_dequant_idct_add_c(tx_type, b->qcoeff,
Deb Mukherjee's avatar
Deb Mukherjee committed
494
495
496
                                  b->dequant, b->predictor,
                                  *(b->base_dst) + b->dst, 16, b->dst_stride);
      } else {
497
        vp9_dequant_idct_add(b->qcoeff, b->dequant, b->predictor,
Jingning Han's avatar
Jingning Han committed
498
                               *(b->base_dst) + b->dst, 16, b->dst_stride);
Deb Mukherjee's avatar
Deb Mukherjee committed
499
      }
John Koleszar's avatar
John Koleszar committed
500
    }
501
502
503
504
505
506
507
508
    if (!xd->mode_info_context->mbmi.mb_skip_coeff) {
      for (i = 16; i < 24; ++i)
        eobtotal += vp9_decode_coefs_4x4(pbi, xd, bc, PLANE_TYPE_UV, i);
    }
    vp9_build_intra_predictors_mbuv(xd);
    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);
John Koleszar's avatar
John Koleszar committed
509
  } else if (mode == SPLITMV) {
510
    if (tx_size == TX_8X8) {
511
      vp9_dequant_idct_add_y_block_8x8(xd->qcoeff, xd->block[0].dequant,
512
513
514
                                         xd->predictor, xd->dst.y_buffer,
                                         xd->dst.y_stride, xd->eobs, xd);
    } else {
Scott LaVarnway's avatar
Scott LaVarnway committed
515
      pbi->idct_add_y_block(xd->qcoeff, xd->block[0].dequant,
516
517
                            xd->predictor, xd->dst.y_buffer,
                            xd->dst.y_stride, xd->eobs);
518
    }
John Koleszar's avatar
John Koleszar committed
519
520
  } else {
    BLOCKD *b = &xd->block[24];
Daniel Kang's avatar
Daniel Kang committed
521

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

571
572
573
574
575
576
577
578
579
  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);
580
581
  else if (xd->mode_info_context->mbmi.mode != I8X8_PRED &&
           xd->mode_info_context->mbmi.mode != B_PRED)
582
583
584
    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
585
}
John Koleszar's avatar
John Koleszar committed
586

587

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

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

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

John Koleszar's avatar
John Koleszar committed
598
599
600
  /* 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
601

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

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

Adrian Grange's avatar
Adrian Grange committed
610
/* Decode a row of Superblocks (2x2 region of MBs) */
611
static void
612
decode_sb_row(VP9D_COMP *pbi, VP9_COMMON *pc, int mbrow, MACROBLOCKD *xd,
John Koleszar's avatar
John Koleszar committed
613
              BOOL_DECODER* const bc) {
John Koleszar's avatar
John Koleszar committed
614
615
616
617
618
619
620
621
622
623
624
625
626
  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
627
  vpx_memset(pc->left_context, 0, sizeof(pc->left_context));
John Koleszar's avatar
John Koleszar committed
628
629
630
631
632

  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
633
634
635
    MODE_INFO *mi = xd->mode_info_context;

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

John Koleszar's avatar
John Koleszar committed
639
640
641
642
643
644
645
    // 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;

646
647
      xd->mb_index = i;

Ronald S. Bultje's avatar
Ronald S. Bultje committed
648
      mi = xd->mode_info_context;
John Koleszar's avatar
John Koleszar committed
649
650
651
652
653
      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;
654
        xd->prev_mode_info_context += offset_extended;
John Koleszar's avatar
John Koleszar committed
655
656
        continue;
      }
Yaowu Xu's avatar
Yaowu Xu committed
657

John Koleszar's avatar
John Koleszar committed
658
659
      // Set above context pointer
      xd->above_context = pc->above_context + mb_col;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
660
      xd->left_context = pc->left_context + (i >> 1);
John Koleszar's avatar
John Koleszar committed
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682

      /* 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
683
684
685
686
#if CONFIG_SUPERBLOCKS
      if (i)
        mi->mbmi.encoded_as_sb = 0;
#endif
687
      vp9_decode_mb_mode_mv(pbi, xd, mb_row, mb_col, bc);
688
689
690

      update_blockd_bmi(xd);

John Koleszar's avatar
John Koleszar committed
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
      /* 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
728
729
#if CONFIG_SUPERBLOCKS
      if (xd->mode_info_context->mbmi.encoded_as_sb) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
730
731
732
733
734
735
736
        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
737
      }
738
739
740
741
742
743
744
745
      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
746
#endif
John Koleszar's avatar
John Koleszar committed
747
748

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
751
752
753
754
755
756
757
758
759
#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
760
761
762

      // skip to next MB
      xd->mode_info_context += offset_extended;
763
      xd->prev_mode_info_context += offset_extended;
John Koleszar's avatar
John Koleszar committed
764
765
      mb_row += dy;
      mb_col += dx;
John Koleszar's avatar
John Koleszar committed
766
    }
John Koleszar's avatar
John Koleszar committed
767
  }
John Koleszar's avatar
John Koleszar committed
768

John Koleszar's avatar
John Koleszar committed
769
770
  /* skip prediction column */
  xd->mode_info_context += 1 - (pc->mb_cols & 0x1) + xd->mode_info_stride;
771
  xd->prev_mode_info_context += 1 - (pc->mb_cols & 0x1) + xd->mode_info_stride;
John Koleszar's avatar
John Koleszar committed
772
773
}

John Koleszar's avatar
John Koleszar committed
774
775
776
777
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
778
779
}

780
781
static int read_is_valid(const unsigned char *start,
                         size_t               len,
John Koleszar's avatar
John Koleszar committed
782
783
                         const unsigned char *end) {
  return (start + len > start && start + len <= end);
784
785
786
}


787
static void setup_token_decoder(VP9D_COMP *pbi,
John Koleszar's avatar
John Koleszar committed
788
789
                                const unsigned char *cx_data,
                                BOOL_DECODER* const bool_decoder) {
790
  VP9_COMMON          *pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
  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);
  }

812
813
  if (vp9_start_decode(bool_decoder,
                       partition, (unsigned int)partition_size))
John Koleszar's avatar
John Koleszar committed
814
815
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
816
817
}

818
819
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
820
  MACROBLOCKD *const xd  = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
821

John Koleszar's avatar
John Koleszar committed
822
823
  if (pc->frame_type == KEY_FRAME) {
    /* Various keyframe initializations */
824
    vp9_init_mv_probs(pc);
John Koleszar's avatar
John Koleszar committed
825

826
827
    vp9_init_mbmode_probs(pc);
    vp9_default_bmode_probs(pc->fc.bmode_prob);
John Koleszar's avatar
John Koleszar committed
828

829
830
    vp9_default_coef_probs(pc);
    vp9_kf_default_bmode_probs(pc->kf_bmode_prob);
John Koleszar's avatar
John Koleszar committed
831

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

John Koleszar's avatar
John Koleszar committed
836
    xd->mb_segment_abs_delta = SEGMENT_DELTADATA;
John Koleszar's avatar
John Koleszar committed
837

John Koleszar's avatar
John Koleszar committed
838
839
840
    /* 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
841

John Koleszar's avatar
John Koleszar committed
842
843
844
845
846
    /* 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
847

John Koleszar's avatar
John Koleszar committed
848
849
850
851
852
    /* 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;
853

854
    vp9_init_mode_contexts(&pbi->common);
John Koleszar's avatar
John Koleszar committed
855
856
    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
857

858
    vpx_memcpy(pbi->common.fc.vp9_mode_contexts,
John Koleszar's avatar
John Koleszar committed
859
860
               pbi->common.fc.mode_context,
               sizeof(pbi->common.fc.mode_context));
861
862
863
864
865
    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));

866
867
    vp9_update_mode_info_border(pc, pc->mip);
    vp9_update_mode_info_in_image(pc, pc->mi);
868

John Koleszar's avatar
John Koleszar committed
869
  } else {
870

John Koleszar's avatar
John Koleszar committed
871
872
873
874
875
    if (!pc->use_bilinear_mc_filter)
      pc->mcomp_filter_type = EIGHTTAP;
    else
      pc->mcomp_filter_type = BILINEAR;

876
    /* To enable choice of different interpolation filters */
877
    vp9_setup_interp_filters(xd, pc->mcomp_filter_type, pc);
John Koleszar's avatar
John Koleszar committed
878
  }
John Koleszar's avatar
John Koleszar committed
879

John Koleszar's avatar
John Koleszar committed
880
  xd->mode_info_context = pc->mi;
881
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
882
883
884
885
  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 */
886

John Koleszar's avatar
John Koleszar committed
887
888
889
  xd->fullpixel_mask = 0xffffffff;
  if (pc->full_pixel)
    xd->fullpixel_mask = 0xfffffff8;
890

John Koleszar's avatar
John Koleszar committed
891
892
}

893
#if 0
894
static void read_coef_probs2(VP9D_COMP *pbi) {
895
  const vp9_prob grpupd = 192;
John Koleszar's avatar
John Koleszar committed
896
  int i, j, k, l;
897
  vp9_reader *const bc = &pbi->bc;
898
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
899
  for (l = 0; l < ENTROPY_NODES; l++) {
900
    if (vp9_read(bc, grpupd)) {
John Koleszar's avatar
John Koleszar committed
901
902
903
904
905
906
907
      // 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;
908
            {
909
910
              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
911
912
913
914
915
916
917
              if (u) *p = read_prob_diff_update(bc, *p);
            }
          }
    }
  }
  if (pbi->common.txfm_mode == ALLOW_8X8) {
    for (l = 0; l < ENTROPY_NODES; l++) {
918
      if (vp9_read(bc, grpupd)) {
John Koleszar's avatar
John Koleszar committed
919
920
921
922
923
924
925
        for (i = 0; i < BLOCK_TYPES_8X8; 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;
              {
926
                vp9_prob *const p = pc->fc.coef_probs_8x8 [i][j][k] + l;
927

928
                int u = vp9_read(bc, COEF_UPDATE_PROB_8X8);
John Koleszar's avatar
John Koleszar committed
929
930
                if (u) *p = read_prob_diff_update(bc, *p);
              }
931
            }
John Koleszar's avatar
John Koleszar committed
932
      }
933
    }
John Koleszar's avatar
John Koleszar committed
934
  }
935
}
936
#endif
937

938
939
static void read_coef_probs_common(
    BOOL_DECODER* const bc,
940
    vp9_prob coef_probs[BLOCK_TYPES][COEF_BANDS]
941
                       [PREV_COEF_CONTEXTS][ENTROPY_NODES]) {
John Koleszar's avatar
John Koleszar committed
942
943
  int i, j, k, l;

944
  if (vp9_read_bit(bc)) {
945
946
947
    for (i = 0; i < BLOCK_TYPES; i++) {
      for (j = !i; j < COEF_BANDS; j++) {
        /* NB: This j loop starts from 1 on block type i == 0 */
948
949
950
951
952
        for (k = 0; k < PREV_COEF_CONTEXTS; k++) {
          if (k >= 3 && ((i == 0 && j == 1) ||
                         (i > 0 && j == 0)))
            continue;
          for (l = 0; l < ENTROPY_NODES; l++) {
953
            vp9_prob *const p = coef_probs[i][j][k] + l;
Daniel Kang's avatar
Daniel Kang committed
954

955
            if (vp9_read(bc, COEF_UPDATE_PROB)) {
956
957
958
959
              *p = read_prob_diff_update(bc, *p);
            }
          }
        }
960
961
      }
    }
962
  }
963
}
964

965
966
static void read_coef_probs(VP9D_COMP *pbi, BOOL_DECODER* const bc) {
  VP9_COMMON *const pc = &pbi->common;
Daniel Kang's avatar
Daniel Kang committed
967

968
969
  read_coef_probs_common(bc, pc->fc.coef_probs);
  read_coef_probs_common(bc, pc->fc.hybrid_coef_probs);
970

971
972
973
  if (pbi->common.txfm_mode != ONLY_4X4) {
    read_coef_probs_common(bc, pc->fc.coef_probs_8x8);
    read_coef_probs_common(bc, pc->fc.hybrid_coef_probs_8x8);
Daniel Kang's avatar
Daniel Kang committed
974
  }
975
976
977
  if (pbi->common.txfm_mode > ALLOW_8X8) {
    read_coef_probs_common(bc, pc->fc.coef_probs_16x16);
    read_coef_probs_common(bc, pc->fc.hybrid_coef_probs_16x16);
978
  }
979
980
}

981
int vp9_decode_frame(VP9D_COMP *pbi) {
John Koleszar's avatar
John Koleszar committed
982
  BOOL_DECODER header_bc, residual_bc;
983
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
984
  MACROBLOCKD *const xd  = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
  const unsigned char *data = (const unsigned char *)pbi->Source;
  const unsigned char *data_end = data + pbi->source_sz;
  ptrdiff_t first_partition_length_in_bytes = 0;

  int mb_row;
  int i, j;
  int corrupt_tokens = 0;

  /* start with no corruption of current frame */
  xd->corrupted = 0;
  pc->yv12_fb[pc->new_fb_idx].corrupted = 0;

  if (data_end - data < 3) {
    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                       "Truncated packet");
  } else {
    pc->last_frame_type = pc->frame_type;
    pc->frame_type = (FRAME_TYPE)(data[0] & 1);
    pc->version = (data[0] >> 1) & 7;
    pc->show_frame = (data[0] >> 4) & 1;
    first_partition_length_in_bytes =
      (data[0] | (data[1] << 8) | (data[2] << 16)) >> 5;

    if ((data + first_partition_length_in_bytes > data_end
         || data + first_partition_length_in_bytes < data))
      vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                         "Truncated packet or corrupt partition 0 length");

    data += 3;

1015
    vp9_setup_version(pc);
Yaowu Xu's avatar
Yaowu Xu committed
1016

John Koleszar's avatar
John Koleszar committed
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
    if (pc->frame_type == KEY_FRAME) {
      const int Width = pc->Width;
      const int Height = pc->Height;

      /* vet via sync code */
      /* When error concealment is enabled we should only check the sync
       * code if we have enough bits available
       */
      if (data + 3 < data_end) {
        if (data[0] != 0x9d || data[1] != 0x01 || data[2] != 0x2a)
          vpx_internal_error(&pc->error, VPX_CODEC_UNSUP_BITSTREAM,
                             "Invalid frame sync code");
      }

      /* If error concealment is enabled we should only parse the new size
       * if we have enough data. Otherwise we will end up with the wrong
       * size.
       */
      if (data + 6 < data_end) {
        pc->Width = (data[3] | (data[4] << 8)) & 0x3fff;
        pc->horiz_scale = data[4] >> 6;
        pc->Height = (data[5] | (data[6] << 8)) & 0x3fff;
        pc->vert_scale = data[6] >> 6;
      }
      data += 7;

      if (Width != pc->Width  ||  Height != pc->Height) {
        if (pc->Width <= 0) {
          pc->Width = Width;
          vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                             "Invalid frame width");
        }
John Koleszar's avatar
John Koleszar committed
1049

John Koleszar's avatar
John Koleszar committed
1050
1051
1052
1053
1054
        if (pc->Height <= 0) {
          pc->Height = Height;
          vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                             "Invalid frame height");
        }
1055

1056
        if (vp9_alloc_frame_buffers(pc, pc->Width, pc->Height))
John Koleszar's avatar
John Koleszar committed
1057
1058
1059
          vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                             "Failed to allocate frame buffers");
      }
1060
    }
John Koleszar's avatar
John Koleszar committed
1061
  }
John Koleszar's avatar
John Koleszar committed
1062