decodframe.c 49.2 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5
6
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
7
 *  in the file PATENTS.  All contributing project authors may
8
 *  be found in the AUTHORS file in the root of the source tree.
John Koleszar's avatar
John Koleszar committed
9
10
11
12
 */


#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 "vp9_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
189
190
191
192
193
      vp9_build_inter32x32_predictors_sb(xd,
                                         xd->dst.y_buffer,
                                         xd->dst.u_buffer,
                                         xd->dst.v_buffer,
                                         xd->dst.y_stride,
                                         xd->dst.uv_stride);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
194
195
    } else {
#endif
196
197
198
199
200
201
202
203
204
205
206
207
208
209
    vp9_build_1st_inter16x16_predictors_mb(xd,
                                           xd->dst.y_buffer,
                                           xd->dst.u_buffer,
                                           xd->dst.v_buffer,
                                           xd->dst.y_stride,
                                           xd->dst.uv_stride);

    if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
      vp9_build_2nd_inter16x16_predictors_mb(xd,
                                             xd->dst.y_buffer,
                                             xd->dst.u_buffer,
                                             xd->dst.v_buffer,
                                             xd->dst.y_stride,
                                             xd->dst.uv_stride);
210
    }
211
212
213
214
215
216
217
218
219
220
#if CONFIG_COMP_INTERINTRA_PRED
    else if (xd->mode_info_context->mbmi.second_ref_frame == INTRA_FRAME) {
      vp9_build_interintra_16x16_predictors_mb(xd,
                                               xd->dst.y_buffer,
                                               xd->dst.u_buffer,
                                               xd->dst.v_buffer,
                                               xd->dst.y_stride,
                                               xd->dst.uv_stride);
    }
#endif
Ronald S. Bultje's avatar
Ronald S. Bultje committed
221
222
223
#if CONFIG_SUPERBLOCKS
    }
#endif
John Koleszar's avatar
John Koleszar committed
224
  }
John Koleszar's avatar
John Koleszar committed
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
287
288
289
290
291
292
293
294
#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 {
295
      eobtotal = vp9_decode_mb_tokens_4x4(pbi, xd, bc);
296
297
298
299
300
301
302
303
304
305
    }
    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,
306
          xd->dst.y_stride, xd->dst.y_stride, xd->eobs[0]);
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
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
      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

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

376
#if CONFIG_SUPERBLOCKS
377
  assert(!xd->mode_info_context->mbmi.encoded_as_sb);
Ronald S. Bultje's avatar
Ronald S. Bultje committed
378
#endif
John Koleszar's avatar
John Koleszar committed
379

Jingning Han's avatar
Jingning Han committed
380
381
382
383
  // re-initialize macroblock dequantizer before detokenization
  if (xd->segmentation_enabled)
    mb_init_dequantizer(pbi, xd);

Deb Mukherjee's avatar
Deb Mukherjee committed
384
  tx_size = xd->mode_info_context->mbmi.txfm_size;
Deb Mukherjee's avatar
Deb Mukherjee committed
385
386
  mode = xd->mode_info_context->mbmi.mode;

John Koleszar's avatar
John Koleszar committed
387
  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
388
    vp9_reset_mb_tokens_context(xd);
389
  } else if (!bool_error(bc)) {
John Koleszar's avatar
John Koleszar committed
390
391
392
    for (i = 0; i < 25; i++) {
      xd->block[i].eob = 0;
      xd->eobs[i] = 0;
393
    }
Deb Mukherjee's avatar
Deb Mukherjee committed
394
    if (tx_size == TX_16X16) {
395
      eobtotal = vp9_decode_mb_tokens_16x16(pbi, xd, bc);
Deb Mukherjee's avatar
Deb Mukherjee committed
396
    } else if (tx_size == TX_8X8) {
397
      eobtotal = vp9_decode_mb_tokens_8x8(pbi, xd, bc);
398
399
    } else {
      eobtotal = vp9_decode_mb_tokens_4x4(pbi, xd, bc);
Deb Mukherjee's avatar
Deb Mukherjee committed
400
    }
John Koleszar's avatar
John Koleszar committed
401
  }
402

Deb Mukherjee's avatar
Deb Mukherjee committed
403
  //mode = xd->mode_info_context->mbmi.mode;
404
  if (pbi->common.frame_type != KEY_FRAME)
405
    vp9_setup_interp_filters(xd, xd->mode_info_context->mbmi.interp_filter,
406
                             &pbi->common);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
407

John Koleszar's avatar
John Koleszar committed
408
409
  if (eobtotal == 0 && mode != B_PRED && mode != SPLITMV
      && mode != I8X8_PRED
410
      && !bool_error(bc)) {
John Koleszar's avatar
John Koleszar committed
411
412
413
414
    /* Special case:  Force the loopfilter to skip when eobtotal and
     * mb_skip_coeff are zero.
     * */
    xd->mode_info_context->mbmi.mb_skip_coeff = 1;
415
416
    skip_recon_mb(pbi, xd);
    return;
John Koleszar's avatar
John Koleszar committed
417
  }
Yaowu Xu's avatar
Yaowu Xu committed
418

Jingning Han's avatar
Jingning Han committed
419
420
421
  // moved to be performed before detokenization
//  if (xd->segmentation_enabled)
//    mb_init_dequantizer(pbi, xd);
422

John Koleszar's avatar
John Koleszar committed
423
424
425
  /* do prediction */
  if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
    if (mode != I8X8_PRED) {
426
      vp9_build_intra_predictors_mbuv(xd);
John Koleszar's avatar
John Koleszar committed
427
      if (mode != B_PRED) {
428
        vp9_build_intra_predictors_mby(xd);
John Koleszar's avatar
John Koleszar committed
429
      }
John Koleszar's avatar
John Koleszar committed
430
    }
John Koleszar's avatar
John Koleszar committed
431
  } else {
432
    vp9_build_inter_predictors_mb(xd);
John Koleszar's avatar
John Koleszar committed
433
434
435
436
437
  }

  /* dequantization and idct */
  if (mode == I8X8_PRED) {
    for (i = 0; i < 4; i++) {
438
      int ib = vp9_i8x8_block[i];
John Koleszar's avatar
John Koleszar committed
439
440
441
442
443
      const int iblock[4] = {0, 1, 4, 5};
      int j;
      int i8x8mode;
      BLOCKD *b;

444
445
446
447
448
449
450
451
      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
452
453
      b = &xd->block[ib];
      i8x8mode = b->bmi.as_mode.first;
454
      vp9_intra8x8_predict(b, i8x8mode, b->predictor);
John Koleszar's avatar
John Koleszar committed
455

456
      if (xd->mode_info_context->mbmi.txfm_size == TX_8X8) {
Deb Mukherjee's avatar
Deb Mukherjee committed
457
458
        tx_type = get_tx_type(xd, &xd->block[idx]);
        if (tx_type != DCT_DCT) {
459
          vp9_ht_dequant_idct_add_8x8_c(tx_type,
Deb Mukherjee's avatar
Deb Mukherjee committed
460
461
                                        q, dq, pre, dst, 16, stride);
        } else {
Yunqing Wang's avatar
Yunqing Wang committed
462
463
          vp9_dequant_idct_add_8x8_c(q, dq, pre, dst, 16, stride, 0,
                                     xd->eobs[idx]);
Deb Mukherjee's avatar
Deb Mukherjee committed
464
465
        }
        q += 64;
466
467
468
      } else {
        for (j = 0; j < 4; j++) {
          b = &xd->block[ib + iblock[j]];
469
          vp9_dequant_idct_add(b->qcoeff, b->dequant, b->predictor,
470
471
472
                                 *(b->base_dst) + b->dst, 16, b->dst_stride);
        }
      }
John Koleszar's avatar
John Koleszar committed
473
      b = &xd->block[16 + i];
474
      vp9_intra_uv4x4_predict(b, i8x8mode, b->predictor);
Scott LaVarnway's avatar
Scott LaVarnway committed
475
476
      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
477
      b = &xd->block[20 + i];
478
      vp9_intra_uv4x4_predict(b, i8x8mode, b->predictor);
Scott LaVarnway's avatar
Scott LaVarnway committed
479
480
      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
481
    }
John Koleszar's avatar
John Koleszar committed
482
483
  } else if (mode == B_PRED) {
    for (i = 0; i < 16; i++) {
484
485
486
487
      int b_mode;
#if CONFIG_COMP_INTRA_PRED
      int b_mode2;
#endif
John Koleszar's avatar
John Koleszar committed
488
      BLOCKD *b = &xd->block[i];
489
490
491
492
493
      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
494
#if CONFIG_COMP_INTRA_PRED
495
      b_mode2 = xd->mode_info_context->bmi[i].as_mode.second;
496

John Koleszar's avatar
John Koleszar committed
497
      if (b_mode2 == (B_PREDICTION_MODE)(B_DC_PRED - 1)) {
498
#endif
499
        vp9_intra4x4_predict(b, b_mode, b->predictor);
500
#if CONFIG_COMP_INTRA_PRED
John Koleszar's avatar
John Koleszar committed
501
      } else {
502
        vp9_comp_intra4x4_predict(b, b_mode, b_mode2, b->predictor);
John Koleszar's avatar
John Koleszar committed
503
      }
504
#endif
John Koleszar's avatar
John Koleszar committed
505

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

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

578
579
580
581
582
583
584
585
586
  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);
587
  else if (xd->mode_info_context->mbmi.mode != I8X8_PRED)
588
589
590
    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
591
}
John Koleszar's avatar
John Koleszar committed
592

593

594
static int get_delta_q(vp9_reader *bc, int prev, int *q_update) {
John Koleszar's avatar
John Koleszar committed
595
  int ret_val = 0;
John Koleszar's avatar
John Koleszar committed
596

597
598
  if (vp9_read_bit(bc)) {
    ret_val = vp9_read_literal(bc, 4);
John Koleszar's avatar
John Koleszar committed
599

600
    if (vp9_read_bit(bc))
John Koleszar's avatar
John Koleszar committed
601
602
      ret_val = -ret_val;
  }
John Koleszar's avatar
John Koleszar committed
603

John Koleszar's avatar
John Koleszar committed
604
605
606
  /* 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
607

John Koleszar's avatar
John Koleszar committed
608
  return ret_val;
John Koleszar's avatar
John Koleszar committed
609
610
611
612
613
614
615
}

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

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

  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
639
640
641
    MODE_INFO *mi = xd->mode_info_context;

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

John Koleszar's avatar
John Koleszar committed
645
646
647
648
649
650
651
    // 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;

652
653
      xd->mb_index = i;

Ronald S. Bultje's avatar
Ronald S. Bultje committed
654
      mi = xd->mode_info_context;
John Koleszar's avatar
John Koleszar committed
655
656
657
658
659
      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;
660
        xd->prev_mode_info_context += offset_extended;
John Koleszar's avatar
John Koleszar committed
661
662
        continue;
      }
663
664
665
666
#if CONFIG_SUPERBLOCKS
      if (i)
        mi->mbmi.encoded_as_sb = 0;
#endif
Yaowu Xu's avatar
Yaowu Xu committed
667

John Koleszar's avatar
John Koleszar committed
668
669
      // Set above context pointer
      xd->above_context = pc->above_context + mb_col;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
670
      xd->left_context = pc->left_context + (i >> 1);
John Koleszar's avatar
John Koleszar committed
671
672
673
674
675
676
677

      /* Distance of Mb to the various image edges.
       * These are specified to 8th pel as they are always compared to
       * values that are in 1/8th pel units
       */
      xd->mb_to_top_edge = -((mb_row * 16)) << 3;
      xd->mb_to_left_edge = -((mb_col * 16) << 3);
678
679
680
681
682
683
684
685
686
687
688
#if CONFIG_SUPERBLOCKS
      if (mi->mbmi.encoded_as_sb) {
        xd->mb_to_bottom_edge = ((pc->mb_rows - 2 - mb_row) * 16) << 3;
        xd->mb_to_right_edge = ((pc->mb_cols - 2 - mb_col) * 16) << 3;
      } else {
#endif
        xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
        xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;
#if CONFIG_SUPERBLOCKS
      }
#endif
John Koleszar's avatar
John Koleszar committed
689
690
691
692
693
694
695
696
697
698
699
700

      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;

701
      vp9_decode_mb_mode_mv(pbi, xd, mb_row, mb_col, bc);
702
703
704

      update_blockd_bmi(xd);

John Koleszar's avatar
John Koleszar committed
705
706
707
708
709
710
711
712
713
714
715
716
      /* 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;

717
      if (xd->mode_info_context->mbmi.second_ref_frame > 0) {
John Koleszar's avatar
John Koleszar committed
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
        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
742
743
#if CONFIG_SUPERBLOCKS
      if (xd->mode_info_context->mbmi.encoded_as_sb) {
Ronald S. Bultje's avatar
Ronald S. Bultje committed
744
745
746
747
748
749
750
        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
751
      }
752
753
754
755
756
757
758
759
      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
760
#endif
John Koleszar's avatar
John Koleszar committed
761
762

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

Ronald S. Bultje's avatar
Ronald S. Bultje committed
765
766
767
768
769
770
771
772
773
#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
774
775
776

      // skip to next MB
      xd->mode_info_context += offset_extended;
777
      xd->prev_mode_info_context += offset_extended;
John Koleszar's avatar
John Koleszar committed
778
779
      mb_row += dy;
      mb_col += dx;
John Koleszar's avatar
John Koleszar committed
780
    }
John Koleszar's avatar
John Koleszar committed
781
  }
John Koleszar's avatar
John Koleszar committed
782

John Koleszar's avatar
John Koleszar committed
783
784
  /* skip prediction column */
  xd->mode_info_context += 1 - (pc->mb_cols & 0x1) + xd->mode_info_stride;
785
  xd->prev_mode_info_context += 1 - (pc->mb_cols & 0x1) + xd->mode_info_stride;
John Koleszar's avatar
John Koleszar committed
786
787
}

John Koleszar's avatar
John Koleszar committed
788
789
790
791
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
792
793
}

794
795
static int read_is_valid(const unsigned char *start,
                         size_t               len,
John Koleszar's avatar
John Koleszar committed
796
797
                         const unsigned char *end) {
  return (start + len > start && start + len <= end);
798
799
800
}


801
static void setup_token_decoder(VP9D_COMP *pbi,
John Koleszar's avatar
John Koleszar committed
802
803
                                const unsigned char *cx_data,
                                BOOL_DECODER* const bool_decoder) {
804
  VP9_COMMON          *pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
  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);
  }

826
827
  if (vp9_start_decode(bool_decoder,
                       partition, (unsigned int)partition_size))
John Koleszar's avatar
John Koleszar committed
828
829
    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                       "Failed to allocate bool decoder %d", 1);
John Koleszar's avatar
John Koleszar committed
830
831
}

832
833
static void init_frame(VP9D_COMP *pbi) {
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
834
  MACROBLOCKD *const xd  = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
835

John Koleszar's avatar
John Koleszar committed
836
837
  if (pc->frame_type == KEY_FRAME) {
    /* Various keyframe initializations */
838
    vp9_init_mv_probs(pc);
John Koleszar's avatar
John Koleszar committed
839

840
841
    vp9_init_mbmode_probs(pc);
    vp9_default_bmode_probs(pc->fc.bmode_prob);
John Koleszar's avatar
John Koleszar committed
842

843
844
    vp9_default_coef_probs(pc);
    vp9_kf_default_bmode_probs(pc->kf_bmode_prob);
John Koleszar's avatar
John Koleszar committed
845

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

John Koleszar's avatar
John Koleszar committed
850
    xd->mb_segment_abs_delta = SEGMENT_DELTADATA;
John Koleszar's avatar
John Koleszar committed
851

John Koleszar's avatar
John Koleszar committed
852
853
854
    /* 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
855

John Koleszar's avatar
John Koleszar committed
856
857
858
859
860
    /* 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
861

John Koleszar's avatar
John Koleszar committed
862
863
864
865
866
    /* 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;
867

868
    vp9_init_mode_contexts(&pbi->common);
John Koleszar's avatar
John Koleszar committed
869
870
    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
871

872
    vpx_memcpy(pbi->common.fc.vp9_mode_contexts,
John Koleszar's avatar
John Koleszar committed
873
874
               pbi->common.fc.mode_context,
               sizeof(pbi->common.fc.mode_context));
875
876
877
878
879
    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));

880
881
    vp9_update_mode_info_border(pc, pc->mip);
    vp9_update_mode_info_in_image(pc, pc->mi);
882

John Koleszar's avatar
John Koleszar committed
883
  } else {
884

John Koleszar's avatar
John Koleszar committed
885
886
887
888
889
    if (!pc->use_bilinear_mc_filter)
      pc->mcomp_filter_type = EIGHTTAP;
    else
      pc->mcomp_filter_type = BILINEAR;

890
    /* To enable choice of different interpolation filters */
891
    vp9_setup_interp_filters(xd, pc->mcomp_filter_type, pc);
John Koleszar's avatar
John Koleszar committed
892
  }
John Koleszar's avatar
John Koleszar committed
893

John Koleszar's avatar
John Koleszar committed
894
  xd->mode_info_context = pc->mi;
895
  xd->prev_mode_info_context = pc->prev_mi;
John Koleszar's avatar
John Koleszar committed
896
897
898
899
  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 */
900

John Koleszar's avatar
John Koleszar committed
901
902
903
  xd->fullpixel_mask = 0xffffffff;
  if (pc->full_pixel)
    xd->fullpixel_mask = 0xfffffff8;
904

John Koleszar's avatar
John Koleszar committed
905
906
}

907
#if 0
908
static void read_coef_probs2(VP9D_COMP *pbi) {
909
  const vp9_prob grpupd = 192;
John Koleszar's avatar
John Koleszar committed
910
  int i, j, k, l;
911
  vp9_reader *const bc = &pbi->bc;
912
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
913
  for (l = 0; l < ENTROPY_NODES; l++) {
914
    if (vp9_read(bc, grpupd)) {
John Koleszar's avatar
John Koleszar committed
915
916
917
918
919
920
921
      // 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;
922
            {
923
924
              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
925
926
927
928
929
930
931
              if (u) *p = read_prob_diff_update(bc, *p);
            }
          }
    }
  }
  if (pbi->common.txfm_mode == ALLOW_8X8) {
    for (l = 0; l < ENTROPY_NODES; l++) {
932
      if (vp9_read(bc, grpupd)) {
John Koleszar's avatar
John Koleszar committed
933
934
935
936
937
938
939
        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;
              {
940
                vp9_prob *const p = pc->fc.coef_probs_8x8 [i][j][k] + l;
941

942
                int u = vp9_read(bc, COEF_UPDATE_PROB_8X8);
John Koleszar's avatar
John Koleszar committed
943
944
                if (u) *p = read_prob_diff_update(bc, *p);
              }
945
            }
John Koleszar's avatar
John Koleszar committed
946
      }
947
    }
John Koleszar's avatar
John Koleszar committed
948
  }
949
}
950
#endif
951

952
953
static void read_coef_probs_common(
    BOOL_DECODER* const bc,
954
    vp9_prob coef_probs[BLOCK_TYPES][COEF_BANDS]
955
                       [PREV_COEF_CONTEXTS][ENTROPY_NODES]) {
John Koleszar's avatar
John Koleszar committed
956
957
  int i, j, k, l;

958
  if (vp9_read_bit(bc)) {
959
960
961
    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 */
962
963
964
965
966
        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++) {
967
            vp9_prob *const p = coef_probs[i][j][k] + l;
Daniel Kang's avatar
Daniel Kang committed
968

969
            if (vp9_read(bc, COEF_UPDATE_PROB)) {
970
971
972
973
              *p = read_prob_diff_update(bc, *p);
            }
          }
        }
974
975
      }
    }
976
  }
977
}
978

979
980
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
981

982
983
  read_coef_probs_common(bc, pc->fc.coef_probs);
  read_coef_probs_common(bc, pc->fc.hybrid_coef_probs);
984

985
986
987
  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
988
  }
989
990
991
  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);
992
  }
993
994
}

995
int vp9_decode_frame(VP9D_COMP *pbi) {
John Koleszar's avatar
John Koleszar committed
996
  BOOL_DECODER header_bc, residual_bc;
997
  VP9_COMMON *const pc = &pbi->common;
John Koleszar's avatar
John Koleszar committed
998
  MACROBLOCKD *const xd  = &pbi->mb;
John Koleszar's avatar
John Koleszar committed
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
  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;

1029
    vp9_setup_version(pc);
Yaowu Xu's avatar
Yaowu Xu committed
1030

John Koleszar's avatar
John Koleszar committed
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
    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
1063

John Koleszar's avatar
John Koleszar committed
1064
1065
1066
1067
1068
        if (pc->Height <= 0) {
          pc->Height = Height;
          vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                             "Invalid frame height");
        }
1069

1070
        if (vp9_alloc_frame_buffers(pc, pc->Width, pc->Height))
John Koleszar's avatar
John Koleszar committed
1071
1072
1073
          vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                             "Failed to allocate frame buffers");
      }