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

John Koleszar's avatar
John Koleszar committed
28
#include "decodemv.h"
John Koleszar's avatar
John Koleszar committed
29
#include "vp8/common/extend.h"
30
31
32
#if CONFIG_ERROR_CONCEALMENT
#include "error_concealment.h"
#endif
John Koleszar's avatar
John Koleszar committed
33
#include "vpx_mem/vpx_mem.h"
John Koleszar's avatar
John Koleszar committed
34
#include "vp8/common/idct.h"
John Koleszar's avatar
John Koleszar committed
35
#include "dequantize.h"
John Koleszar's avatar
John Koleszar committed
36
#include "vp8/common/threading.h"
John Koleszar's avatar
John Koleszar committed
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include "decoderthreading.h"
#include "dboolhuff.h"

#include <assert.h>
#include <stdio.h>

void vp8cx_init_de_quantizer(VP8D_COMP *pbi)
{
    int i;
    int Q;
    VP8_COMMON *const pc = & pbi->common;

    for (Q = 0; Q < QINDEX_RANGE; Q++)
    {
51
52
53
        pc->Y1dequant[Q][0] = (short)vp8_dc_quant(Q, pc->y1dc_delta_q);
        pc->Y2dequant[Q][0] = (short)vp8_dc2quant(Q, pc->y2dc_delta_q);
        pc->UVdequant[Q][0] = (short)vp8_dc_uv_quant(Q, pc->uvdc_delta_q);
John Koleszar's avatar
John Koleszar committed
54

55
        /* all the ac values = ; */
John Koleszar's avatar
John Koleszar committed
56
57
58
59
        for (i = 1; i < 16; i++)
        {
            int rc = vp8_default_zig_zag1d[i];

60
61
62
            pc->Y1dequant[Q][rc] = (short)vp8_ac_yquant(Q);
            pc->Y2dequant[Q][rc] = (short)vp8_ac2quant(Q, pc->y2ac_delta_q);
            pc->UVdequant[Q][rc] = (short)vp8_ac_uv_quant(Q, pc->uvac_delta_q);
John Koleszar's avatar
John Koleszar committed
63
64
65
66
        }
    }
}

67
void mb_init_dequantizer(VP8D_COMP *pbi, MACROBLOCKD *xd)
John Koleszar's avatar
John Koleszar committed
68
69
70
71
72
73
{
    int i;
    int QIndex;
    MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
    VP8_COMMON *const pc = & pbi->common;

74
    /* Decide whether to use the default or alternate baseline Q value. */
John Koleszar's avatar
John Koleszar committed
75
76
    if (xd->segmentation_enabled)
    {
77
        /* Abs Value */
John Koleszar's avatar
John Koleszar committed
78
79
80
        if (xd->mb_segement_abs_delta == SEGMENT_ABSDATA)
            QIndex = xd->segment_feature_data[MB_LVL_ALT_Q][mbmi->segment_id];

81
        /* Delta Value */
John Koleszar's avatar
John Koleszar committed
82
83
84
        else
        {
            QIndex = pc->base_qindex + xd->segment_feature_data[MB_LVL_ALT_Q][mbmi->segment_id];
85
            QIndex = (QIndex >= 0) ? ((QIndex <= MAXQ) ? QIndex : MAXQ) : 0;    /* Clamp to valid range */
John Koleszar's avatar
John Koleszar committed
86
87
88
89
90
        }
    }
    else
        QIndex = pc->base_qindex;

91
    /* Set up the block level dequant pointers */
John Koleszar's avatar
John Koleszar committed
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
    for (i = 0; i < 16; i++)
    {
        xd->block[i].dequant = pc->Y1dequant[QIndex];
    }

    for (i = 16; i < 24; i++)
    {
        xd->block[i].dequant = pc->UVdequant[QIndex];
    }

    xd->block[24].dequant = pc->Y2dequant[QIndex];

}

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

112
113
114
/* 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.
 */
John Koleszar's avatar
John Koleszar committed
115
116
static void skip_recon_mb(VP8D_COMP *pbi, MACROBLOCKD *xd)
{
117
    if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
John Koleszar's avatar
John Koleszar committed
118
    {
119
        RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_mbuv_s)(xd);
120
121
        RECON_INVOKE(&pbi->common.rtcd.recon,
                     build_intra_predictors_mby_s)(xd);
John Koleszar's avatar
John Koleszar committed
122
123
124
    }
    else
    {
125
126
127
        vp8_build_inter16x16_predictors_mb(xd, xd->dst.y_buffer,
                                           xd->dst.u_buffer, xd->dst.v_buffer,
                                           xd->dst.y_stride, xd->dst.uv_stride);
John Koleszar's avatar
John Koleszar committed
128
129
130
    }
}

131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
static void clamp_mv_to_umv_border(MV *mv, const MACROBLOCKD *xd)
{
    /* If the MV points so far into the UMV border that no visible pixels
     * are used for reconstruction, the subpel part of the MV can be
     * discarded and the MV limited to 16 pixels with equivalent results.
     *
     * This limit kicks in at 19 pixels for the top and left edges, for
     * the 16 pixels plus 3 taps right of the central pixel when subpel
     * filtering. The bottom and right edges use 16 pixels plus 2 pixels
     * left of the central pixel when filtering.
     */
    if (mv->col < (xd->mb_to_left_edge - (19 << 3)))
        mv->col = xd->mb_to_left_edge - (16 << 3);
    else if (mv->col > xd->mb_to_right_edge + (18 << 3))
        mv->col = xd->mb_to_right_edge + (16 << 3);

    if (mv->row < (xd->mb_to_top_edge - (19 << 3)))
        mv->row = xd->mb_to_top_edge - (16 << 3);
    else if (mv->row > xd->mb_to_bottom_edge + (18 << 3))
        mv->row = xd->mb_to_bottom_edge + (16 << 3);
}

153
154
155
/* A version of the above function for chroma block MVs.*/
static void clamp_uvmv_to_umv_border(MV *mv, const MACROBLOCKD *xd)
{
Scott LaVarnway's avatar
Scott LaVarnway committed
156
157
158
159
160
    mv->col = (2*mv->col < (xd->mb_to_left_edge - (19 << 3))) ? (xd->mb_to_left_edge - (16 << 3)) >> 1 : mv->col;
    mv->col = (2*mv->col > xd->mb_to_right_edge + (18 << 3)) ? (xd->mb_to_right_edge + (16 << 3)) >> 1 : mv->col;

    mv->row = (2*mv->row < (xd->mb_to_top_edge - (19 << 3))) ? (xd->mb_to_top_edge - (16 << 3)) >> 1 : mv->row;
    mv->row = (2*mv->row > xd->mb_to_bottom_edge + (18 << 3)) ? (xd->mb_to_bottom_edge + (16 << 3)) >> 1 : mv->row;
161
}
162

163
void clamp_mvs(MACROBLOCKD *xd)
164
{
165
    if (xd->mode_info_context->mbmi.mode == SPLITMV)
166
167
168
169
170
    {
        int i;

        for (i=0; i<16; i++)
            clamp_mv_to_umv_border(&xd->block[i].bmi.mv.as_mv, xd);
171
172
        for (i=16; i<24; i++)
            clamp_uvmv_to_umv_border(&xd->block[i].bmi.mv.as_mv, xd);
173
174
175
    }
    else
    {
176
        clamp_mv_to_umv_border(&xd->mode_info_context->mbmi.mv.as_mv, xd);
177
        clamp_uvmv_to_umv_border(&xd->block[16].bmi.mv.as_mv, xd);
178
179
180
181
    }

}

182
183
static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
                              unsigned int mb_idx)
John Koleszar's avatar
John Koleszar committed
184
{
185
    int eobtotal = 0;
186
    int throw_residual = 0;
Gaute Strokkenes's avatar
Gaute Strokkenes committed
187
188
    MB_PREDICTION_MODE mode;
    int i;
189

190
    if (xd->mode_info_context->mbmi.mb_skip_coeff)
191
192
193
    {
        vp8_reset_mb_tokens_context(xd);
    }
194
    else if (!vp8dx_bool_error(xd->current_bc))
195
196
197
198
199
    {
        eobtotal = vp8_decode_mb_tokens(pbi, xd);
    }

    /* Perform temporary clamping of the MV to be used for prediction */
Gaute Strokkenes's avatar
Gaute Strokkenes committed
200
    if (xd->mode_info_context->mbmi.need_to_clamp_mvs)
201
202
203
204
    {
        clamp_mvs(xd);
    }

Gaute Strokkenes's avatar
Gaute Strokkenes committed
205
206
    mode = xd->mode_info_context->mbmi.mode;

207
208
    if (eobtotal == 0 && mode != B_PRED && mode != SPLITMV &&
            !vp8dx_bool_error(xd->current_bc))
209
    {
Scott LaVarnway's avatar
Scott LaVarnway committed
210
211
212
213
214
        /* Special case:  Force the loopfilter to skip when eobtotal and
         * mb_skip_coeff are zero.
         * */
        xd->mode_info_context->mbmi.mb_skip_coeff = 1;

215
216
217
218
219
220
221
        skip_recon_mb(pbi, xd);
        return;
    }

    if (xd->segmentation_enabled)
        mb_init_dequantizer(pbi, xd);

222
    /* do prediction */
223
    if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
John Koleszar's avatar
John Koleszar committed
224
    {
225
        RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_mbuv)(xd);
John Koleszar's avatar
John Koleszar committed
226

Gaute Strokkenes's avatar
Gaute Strokkenes committed
227
        if (mode != B_PRED)
John Koleszar's avatar
John Koleszar committed
228
        {
229
230
            RECON_INVOKE(&pbi->common.rtcd.recon,
                         build_intra_predictors_mby)(xd);
231
232
        } else {
            vp8_intra_prediction_down_copy(xd);
John Koleszar's avatar
John Koleszar committed
233
234
235
236
237
238
        }
    }
    else
    {
        vp8_build_inter_predictors_mb(xd);
    }
239
240
241
242
243
244
245
    /* When we have independent partitions we can apply residual even
     * though other partitions within the frame are corrupt.
     */
    throw_residual = (!pbi->independent_partitions &&
                      pbi->frame_corrupt_residual);
    throw_residual = (throw_residual || vp8dx_bool_error(xd->current_bc));

246
#if CONFIG_ERROR_CONCEALMENT
247
248
    if (pbi->ec_active &&
        (mb_idx >= pbi->mvs_corrupt_from_mb || throw_residual))
249
250
251
252
    {
        /* MB with corrupt residuals or corrupt mode/motion vectors.
         * Better to use the predictor as reconstruction.
         */
253
        pbi->frame_corrupt_residual = 1;
254
        vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff));
255
256
257
258
259
        vp8_conceal_corrupt_mb(xd);
        return;
    }
#endif

260
    /* dequantization and idct */
Gaute Strokkenes's avatar
Gaute Strokkenes committed
261
    if (mode == B_PRED)
262
263
    {
        for (i = 0; i < 16; i++)
John Koleszar's avatar
John Koleszar committed
264
        {
265
            BLOCKD *b = &xd->block[i];
266
267
            int b_mode = xd->mode_info_context->bmi[i].as_mode;

268
            RECON_INVOKE(RTCD_VTABLE(recon), intra4x4_predict)
269
                          (b, b_mode, b->predictor);
John Koleszar's avatar
John Koleszar committed
270

Fritz Koenig's avatar
Fritz Koenig committed
271
            if (xd->eobs[i] > 1)
John Koleszar's avatar
John Koleszar committed
272
            {
Fritz Koenig's avatar
Fritz Koenig committed
273
                DEQUANT_INVOKE(&pbi->dequant, idct_add)
274
                    (b->qcoeff, b->dequant,  b->predictor,
Fritz Koenig's avatar
Fritz Koenig committed
275
                    *(b->base_dst) + b->dst, 16, b->dst_stride);
John Koleszar's avatar
John Koleszar committed
276
277
278
            }
            else
            {
Fritz Koenig's avatar
Fritz Koenig committed
279
                IDCT_INVOKE(RTCD_VTABLE(idct), idct1_scalar_add)
280
                    (b->qcoeff[0] * b->dequant[0], b->predictor,
Fritz Koenig's avatar
Fritz Koenig committed
281
                    *(b->base_dst) + b->dst, 16, b->dst_stride);
John Koleszar's avatar
John Koleszar committed
282
283
284
                ((int *)b->qcoeff)[0] = 0;
            }
        }
285

John Koleszar's avatar
John Koleszar committed
286
    }
Gaute Strokkenes's avatar
Gaute Strokkenes committed
287
    else if (mode == SPLITMV)
John Koleszar's avatar
John Koleszar committed
288
    {
Fritz Koenig's avatar
Fritz Koenig committed
289
        DEQUANT_INVOKE (&pbi->dequant, idct_add_y_block)
290
                        (xd->qcoeff, xd->block[0].dequant,
Fritz Koenig's avatar
Fritz Koenig committed
291
292
                         xd->predictor, xd->dst.y_buffer,
                         xd->dst.y_stride, xd->eobs);
John Koleszar's avatar
John Koleszar committed
293
    }
Gaute Strokkenes's avatar
Gaute Strokkenes committed
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
    else
    {
        BLOCKD *b = &xd->block[24];

        DEQUANT_INVOKE(&pbi->dequant, block)(b);

        /* do 2nd order transform on the dc block */
        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;
        }

        DEQUANT_INVOKE (&pbi->dequant, 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);
    }
John Koleszar's avatar
John Koleszar committed
324

Fritz Koenig's avatar
Fritz Koenig committed
325
    DEQUANT_INVOKE (&pbi->dequant, idct_add_uv_block)
326
                    (xd->qcoeff+16*16, xd->block[16].dequant,
Fritz Koenig's avatar
Fritz Koenig committed
327
328
                     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
329
330
}

331

John Koleszar's avatar
John Koleszar committed
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
static int get_delta_q(vp8_reader *bc, int prev, int *q_update)
{
    int ret_val = 0;

    if (vp8_read_bit(bc))
    {
        ret_val = vp8_read_literal(bc, 4);

        if (vp8_read_bit(bc))
            ret_val = -ret_val;
    }

    /* Trigger a quantizer update if the delta-q value has changed */
    if (ret_val != prev)
        *q_update = 1;

    return ret_val;
}

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



358
359
static void
decode_mb_row(VP8D_COMP *pbi, VP8_COMMON *pc, int mb_row, MACROBLOCKD *xd)
John Koleszar's avatar
John Koleszar committed
360
361
362
{
    int recon_yoffset, recon_uvoffset;
    int mb_col;
363
364
365
366
    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;
John Koleszar's avatar
John Koleszar committed
367

368
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
John Koleszar's avatar
John Koleszar committed
369
370
    recon_yoffset = mb_row * recon_y_stride * 16;
    recon_uvoffset = mb_row * recon_uv_stride * 8;
371
    /* reset above block coeffs */
John Koleszar's avatar
John Koleszar committed
372

373
    xd->above_context = pc->above_context;
John Koleszar's avatar
John Koleszar committed
374
375
376
377
378
379
380
    xd->up_available = (mb_row != 0);

    xd->mb_to_top_edge = -((mb_row * 16)) << 3;
    xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;

    for (mb_col = 0; mb_col < pc->mb_cols; mb_col++)
    {
381
382
383
384
385
386
387
388
389
        /* 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_left_edge = -((mb_col * 16) << 3);
        xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;

#if CONFIG_ERROR_CONCEALMENT
        {
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
            int corrupt_residual = (!pbi->independent_partitions &&
                                   pbi->frame_corrupt_residual) ||
                                   vp8dx_bool_error(xd->current_bc);
            if (pbi->ec_active &&
                xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME &&
                corrupt_residual)
            {
                /* We have an intra block with corrupt coefficients, better to
                 * conceal with an inter block. Interpolate MVs from neighboring
                 * MBs.
                 *
                 * Note that for the first mb with corrupt residual in a frame,
                 * we might not discover that before decoding the residual. That
                 * happens after this check, and therefore no inter concealment
                 * will be done.
                 */
                vp8_interpolate_motion(xd,
                                       mb_row, mb_col,
                                       pc->mb_rows, pc->mb_cols,
                                       pc->mode_info_stride);
            }
411
412
        }
#endif
John Koleszar's avatar
John Koleszar committed
413

414
415
416
        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;
John Koleszar's avatar
John Koleszar committed
417
418
419

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

420
        /* Select the appropriate reference frame for this MB */
421
        if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
422
            ref_fb_idx = pc->lst_fb_idx;
423
        else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
424
            ref_fb_idx = pc->gld_fb_idx;
John Koleszar's avatar
John Koleszar committed
425
        else
426
427
428
429
430
            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;
John Koleszar's avatar
John Koleszar committed
431

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

438
        decode_macroblock(pbi, xd, mb_row * pc->mb_cols  + mb_col);
John Koleszar's avatar
John Koleszar committed
439

440
441
        /* check if the boolean decoder has suffered an error */
        xd->corrupted |= vp8dx_bool_error(xd->current_bc);
John Koleszar's avatar
John Koleszar committed
442
443
444
445
446
447

        recon_yoffset += 16;
        recon_uvoffset += 8;

        ++xd->mode_info_context;  /* next mb */

448
        xd->above_context++;
John Koleszar's avatar
John Koleszar committed
449
450
451

    }

452
    /* adjust to the next row of mbs */
John Koleszar's avatar
John Koleszar committed
453
    vp8_extend_mb_row(
454
        &pc->yv12_fb[dst_fb_idx],
John Koleszar's avatar
John Koleszar committed
455
456
457
458
459
460
461
462
463
464
465
466
467
468
        xd->dst.y_buffer + 16, xd->dst.u_buffer + 8, xd->dst.v_buffer + 8
    );

    ++xd->mode_info_context;      /* skip prediction column */
}


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;
}

469
470
471
472
static void setup_token_decoder_partition_input(VP8D_COMP *pbi)
{
    vp8_reader *bool_decoder = &pbi->bc2;
    int part_idx = 1;
473
    int num_token_partitions;
474
475
476

    TOKEN_PARTITION multi_token_partition =
            (TOKEN_PARTITION)vp8_read_literal(&pbi->bc, 2);
477
478
479
480
481
482
    if (!vp8dx_bool_error(&pbi->bc))
        pbi->common.multi_token_partition = multi_token_partition;
    num_token_partitions = 1 << pbi->common.multi_token_partition;
    if (num_token_partitions + 1 > pbi->num_partitions)
        vpx_internal_error(&pbi->common.error, VPX_CODEC_CORRUPT_FRAME,
                           "Partitions missing");
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
    assert(vp8dx_bool_error(&pbi->bc) ||
           multi_token_partition == pbi->common.multi_token_partition);
    if (pbi->num_partitions > 2)
    {
        CHECK_MEM_ERROR(pbi->mbc, vpx_malloc((pbi->num_partitions - 1) *
                                             sizeof(vp8_reader)));
        bool_decoder = pbi->mbc;
    }

    for (; part_idx < pbi->num_partitions; ++part_idx)
    {
        if (vp8dx_start_decode(bool_decoder,
                               pbi->partitions[part_idx],
                               pbi->partition_sizes[part_idx]))
            vpx_internal_error(&pbi->common.error, VPX_CODEC_MEM_ERROR,
                               "Failed to allocate bool decoder %d",
                               part_idx);

        bool_decoder++;
    }

#if CONFIG_MULTITHREAD
    /* Clamp number of decoder threads */
    if (pbi->decoding_thread_count > pbi->num_partitions - 1)
        pbi->decoding_thread_count = pbi->num_partitions - 1;
#endif
}
John Koleszar's avatar
John Koleszar committed
510

511
512
513
514
515
516
517
518
519

static int read_is_valid(const unsigned char *start,
                         size_t               len,
                         const unsigned char *end)
{
    return (start + len > start && start + len <= end);
}


John Koleszar's avatar
John Koleszar committed
520
521
522
523
524
525
526
527
528
529
530
static void setup_token_decoder(VP8D_COMP *pbi,
                                const unsigned char *cx_data)
{
    int num_part;
    int i;
    VP8_COMMON          *pc = &pbi->common;
    const unsigned char *user_data_end = pbi->Source + pbi->source_sz;
    vp8_reader          *bool_decoder;
    const unsigned char *partition;

    /* Parse number of token partitions to use */
531
532
533
534
    const TOKEN_PARTITION multi_token_partition =
            (TOKEN_PARTITION)vp8_read_literal(&pbi->bc, 2);
    /* Only update the multi_token_partition field if we are sure the value
     * is correct. */
535
    if (!pbi->ec_active || !vp8dx_bool_error(&pbi->bc))
536
537
        pc->multi_token_partition = multi_token_partition;

John Koleszar's avatar
John Koleszar committed
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
    num_part = 1 << pc->multi_token_partition;

    /* Set up pointers to the first partition */
    partition = cx_data;
    bool_decoder = &pbi->bc2;

    if (num_part > 1)
    {
        CHECK_MEM_ERROR(pbi->mbc, vpx_malloc(num_part * sizeof(vp8_reader)));
        bool_decoder = pbi->mbc;
        partition += 3 * (num_part - 1);
    }

    for (i = 0; i < num_part; i++)
    {
        const unsigned char *partition_size_ptr = cx_data + i * 3;
554
555
556
        ptrdiff_t            partition_size, bytes_left;

        bytes_left = user_data_end - partition;
John Koleszar's avatar
John Koleszar committed
557
558

        /* Calculate the length of this partition. The last partition
559
560
561
         * size is implicit. If the partition size can't be read, then
         * either use the remaining data in the buffer (for EC mode)
         * or throw an error.
John Koleszar's avatar
John Koleszar committed
562
563
564
         */
        if (i < num_part - 1)
        {
565
566
            if (read_is_valid(partition_size_ptr, 3, user_data_end))
                partition_size = read_partition_size(partition_size_ptr);
567
            else if (pbi->ec_active)
568
569
570
571
                partition_size = bytes_left;
            else
                vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                                   "Truncated partition size data");
John Koleszar's avatar
John Koleszar committed
572
573
        }
        else
574
575
576
577
578
579
580
            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))
John Koleszar's avatar
John Koleszar committed
581
        {
582
            if (pbi->ec_active)
583
584
585
586
587
                partition_size = bytes_left;
            else
                vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                                   "Truncated packet or corrupt partition "
                                   "%d length", i + 1);
John Koleszar's avatar
John Koleszar committed
588
589
        }

Johann's avatar
Johann committed
590
        if (vp8dx_start_decode(bool_decoder, partition, partition_size))
John Koleszar's avatar
John Koleszar committed
591
592
593
594
595
596
597
598
            vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                               "Failed to allocate bool decoder %d", i + 1);

        /* Advance to the next partition */
        partition += partition_size;
        bool_decoder++;
    }

599
#if CONFIG_MULTITHREAD
John Koleszar's avatar
John Koleszar committed
600
601
602
    /* Clamp number of decoder threads */
    if (pbi->decoding_thread_count > num_part - 1)
        pbi->decoding_thread_count = num_part - 1;
603
#endif
John Koleszar's avatar
John Koleszar committed
604
605
606
607
608
609
610
611
}


static void stop_token_decoder(VP8D_COMP *pbi)
{
    VP8_COMMON *pc = &pbi->common;

    if (pc->multi_token_partition != ONE_PARTITION)
James Zern's avatar
James Zern committed
612
    {
John Koleszar's avatar
John Koleszar committed
613
        vpx_free(pbi->mbc);
James Zern's avatar
James Zern committed
614
615
        pbi->mbc = NULL;
    }
John Koleszar's avatar
John Koleszar committed
616
617
618
619
620
621
622
623
624
}

static void init_frame(VP8D_COMP *pbi)
{
    VP8_COMMON *const pc = & pbi->common;
    MACROBLOCKD *const xd  = & pbi->mb;

    if (pc->frame_type == KEY_FRAME)
    {
625
        /* Various keyframe initializations */
John Koleszar's avatar
John Koleszar committed
626
627
628
629
630
631
632
        vpx_memcpy(pc->fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));

        vp8_init_mbmode_probs(pc);

        vp8_default_coef_probs(pc);
        vp8_kf_default_bmode_probs(pc->kf_bmode_prob);

633
        /* reset the segment feature data to 0 with delta coding (Default state). */
John Koleszar's avatar
John Koleszar committed
634
635
636
        vpx_memset(xd->segment_feature_data, 0, sizeof(xd->segment_feature_data));
        xd->mb_segement_abs_delta = SEGMENT_DELTADATA;

637
        /* reset the mode ref deltasa for loop filter */
John Koleszar's avatar
John Koleszar committed
638
639
640
        vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
        vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));

641
        /* All buffers are implicitly updated on key frames. */
John Koleszar's avatar
John Koleszar committed
642
643
644
645
646
        pc->refresh_golden_frame = 1;
        pc->refresh_alt_ref_frame = 1;
        pc->copy_buffer_to_gf = 0;
        pc->copy_buffer_to_arf = 0;

647
648
649
        /* Note that Golden and Altref modes cannot be used on a key frame so
         * ref_frame_sign_bias[] is undefined and meaningless
         */
John Koleszar's avatar
John Koleszar committed
650
651
652
653
654
655
656
657
658
659
        pc->ref_frame_sign_bias[GOLDEN_FRAME] = 0;
        pc->ref_frame_sign_bias[ALTREF_FRAME] = 0;
    }
    else
    {
        if (!pc->use_bilinear_mc_filter)
            pc->mcomp_filter_type = SIXTAP;
        else
            pc->mcomp_filter_type = BILINEAR;

660
        /* To enable choice of different interploation filters */
John Koleszar's avatar
John Koleszar committed
661
662
663
664
665
666
667
668
669
670
671
672
673
674
        if (pc->mcomp_filter_type == SIXTAP)
        {
            xd->subpixel_predict      = SUBPIX_INVOKE(RTCD_VTABLE(subpix), sixtap4x4);
            xd->subpixel_predict8x4   = SUBPIX_INVOKE(RTCD_VTABLE(subpix), sixtap8x4);
            xd->subpixel_predict8x8   = SUBPIX_INVOKE(RTCD_VTABLE(subpix), sixtap8x8);
            xd->subpixel_predict16x16 = SUBPIX_INVOKE(RTCD_VTABLE(subpix), sixtap16x16);
        }
        else
        {
            xd->subpixel_predict      = SUBPIX_INVOKE(RTCD_VTABLE(subpix), bilinear4x4);
            xd->subpixel_predict8x4   = SUBPIX_INVOKE(RTCD_VTABLE(subpix), bilinear8x4);
            xd->subpixel_predict8x8   = SUBPIX_INVOKE(RTCD_VTABLE(subpix), bilinear8x8);
            xd->subpixel_predict16x16 = SUBPIX_INVOKE(RTCD_VTABLE(subpix), bilinear16x16);
        }
675
676
677

        if (pbi->decoded_key_frame && pbi->ec_enabled && !pbi->ec_active)
            pbi->ec_active = 1;
John Koleszar's avatar
John Koleszar committed
678
679
    }

680
    xd->left_context = &pc->left_context;
John Koleszar's avatar
John Koleszar committed
681
682
    xd->mode_info_context = pc->mi;
    xd->frame_type = pc->frame_type;
683
    xd->mode_info_context->mbmi.mode = DC_PRED;
John Koleszar's avatar
John Koleszar committed
684
    xd->mode_info_stride = pc->mode_info_stride;
685
    xd->corrupted = 0; /* init without corruption */
686
687
688
689
690

    xd->fullpixel_mask = 0xffffffff;
    if(pc->full_pixel)
        xd->fullpixel_mask = 0xfffffff8;

John Koleszar's avatar
John Koleszar committed
691
692
693
694
695
696
697
698
}

int vp8_decode_frame(VP8D_COMP *pbi)
{
    vp8_reader *const bc = & pbi->bc;
    VP8_COMMON *const pc = & pbi->common;
    MACROBLOCKD *const xd  = & pbi->mb;
    const unsigned char *data = (const unsigned char *)pbi->Source;
699
    const unsigned char *data_end = data + pbi->source_sz;
700
    ptrdiff_t first_partition_length_in_bytes;
John Koleszar's avatar
John Koleszar committed
701
702
703
704

    int mb_row;
    int i, j, k, l;
    const int *const mb_feature_data_bits = vp8_mb_feature_data_bits;
705
706
    int corrupt_tokens = 0;
    int prev_independent_partitions = pbi->independent_partitions;
John Koleszar's avatar
John Koleszar committed
707

708
709
710
711
712
713
    if (pbi->input_partition)
    {
        data = pbi->partitions[0];
        data_end =  data + pbi->partition_sizes[0];
    }

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

718
    if (data_end - data < 3)
John Koleszar's avatar
John Koleszar committed
719
    {
720
        if (pbi->ec_active)
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
        {
            /* Declare the missing frame as an inter frame since it will
               be handled as an inter frame when we have estimated its
               motion vectors. */
            pc->frame_type = INTER_FRAME;
            pc->version = 0;
            pc->show_frame = 1;
            first_partition_length_in_bytes = 0;
        }
        else
        {
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated packet");
        }
    }
    else
    {
        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;
John Koleszar's avatar
John Koleszar committed
743

744
        if (!pbi->ec_active && (data + first_partition_length_in_bytes > data_end
745
746
747
            || data + first_partition_length_in_bytes < data))
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated packet or corrupt partition 0 length");
748
749
750

        data += 3;

751
        vp8_setup_version(pc);
John Koleszar's avatar
John Koleszar committed
752

753
        if (pc->frame_type == KEY_FRAME)
John Koleszar's avatar
John Koleszar committed
754
        {
755
756
757
758
759
760
761
            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
             */
762
            if (!pbi->ec_active || data + 3 < data_end)
John Koleszar's avatar
John Koleszar committed
763
            {
764
765
766
                if (data[0] != 0x9d || data[1] != 0x01 || data[2] != 0x2a)
                    vpx_internal_error(&pc->error, VPX_CODEC_UNSUP_BITSTREAM,
                                   "Invalid frame sync code");
John Koleszar's avatar
John Koleszar committed
767
768
            }

769
770
771
772
            /* 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.
             */
773
            if (!pbi->ec_active || data + 6 < data_end)
John Koleszar's avatar
John Koleszar committed
774
            {
775
776
777
778
                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;
John Koleszar's avatar
John Koleszar committed
779
            }
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
            data += 7;

            if (Width != pc->Width  ||  Height != pc->Height)
            {
                int prev_mb_rows = pc->mb_rows;

                if (pc->Width <= 0)
                {
                    pc->Width = Width;
                    vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                                       "Invalid frame width");
                }

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

800
801
802
803
804
805
806
807
808
809
810
811
812
813
                if (vp8_alloc_frame_buffers(pc, pc->Width, pc->Height))
                    vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                                       "Failed to allocate frame buffers");

#if CONFIG_ERROR_CONCEALMENT
                pbi->overlaps = NULL;
                if (pbi->ec_enabled)
                {
                    if (vp8_alloc_overlap_lists(pbi))
                        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                                           "Failed to allocate overlap lists "
                                           "for error concealment");
                }
#endif
814
815

#if CONFIG_MULTITHREAD
816
817
                if (pbi->b_multithreaded_rd)
                    vp8mt_alloc_temp_buffers(pbi, pc->Width, prev_mb_rows);
818
#endif
819
            }
John Koleszar's avatar
John Koleszar committed
820
821
822
        }
    }

823
824
    if ((!pbi->decoded_key_frame && pc->frame_type != KEY_FRAME) ||
        pc->Width == 0 || pc->Height == 0)
John Koleszar's avatar
John Koleszar committed
825
826
827
828
829
830
    {
        return -1;
    }

    init_frame(pbi);

Johann's avatar
Johann committed
831
    if (vp8dx_start_decode(bc, data, data_end - data))
John Koleszar's avatar
John Koleszar committed
832
833
834
835
836
837
838
        vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                           "Failed to allocate bool decoder 0");
    if (pc->frame_type == KEY_FRAME) {
        pc->clr_type    = (YUV_TYPE)vp8_read_bit(bc);
        pc->clamp_type  = (CLAMP_TYPE)vp8_read_bit(bc);
    }

839
    /* Is segmentation enabled */
John Koleszar's avatar
John Koleszar committed
840
841
842
843
    xd->segmentation_enabled = (unsigned char)vp8_read_bit(bc);

    if (xd->segmentation_enabled)
    {
844
        /* Signal whether or not the segmentation map is being explicitly updated this frame. */
John Koleszar's avatar
John Koleszar committed
845
846
847
848
849
850
851
852
853
        xd->update_mb_segmentation_map = (unsigned char)vp8_read_bit(bc);
        xd->update_mb_segmentation_data = (unsigned char)vp8_read_bit(bc);

        if (xd->update_mb_segmentation_data)
        {
            xd->mb_segement_abs_delta = (unsigned char)vp8_read_bit(bc);

            vpx_memset(xd->segment_feature_data, 0, sizeof(xd->segment_feature_data));

854
            /* For each segmentation feature (Quant and loop filter level) */
John Koleszar's avatar
John Koleszar committed
855
856
857
858
            for (i = 0; i < MB_LVL_MAX; i++)
            {
                for (j = 0; j < MAX_MB_SEGMENTS; j++)
                {
859
                    /* Frame level data */
John Koleszar's avatar
John Koleszar committed
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
                    if (vp8_read_bit(bc))
                    {
                        xd->segment_feature_data[i][j] = (signed char)vp8_read_literal(bc, mb_feature_data_bits[i]);

                        if (vp8_read_bit(bc))
                            xd->segment_feature_data[i][j] = -xd->segment_feature_data[i][j];
                    }
                    else
                        xd->segment_feature_data[i][j] = 0;
                }
            }
        }

        if (xd->update_mb_segmentation_map)
        {
875
            /* Which macro block level features are enabled */
John Koleszar's avatar
John Koleszar committed
876
877
            vpx_memset(xd->mb_segment_tree_probs, 255, sizeof(xd->mb_segment_tree_probs));

878
            /* Read the probs used to decode the segment id for each macro block. */
John Koleszar's avatar
John Koleszar committed
879
880
            for (i = 0; i < MB_FEATURE_TREE_PROBS; i++)
            {
881
                /* If not explicitly set value is defaulted to 255 by memset above */
John Koleszar's avatar
John Koleszar committed
882
883
884
885
886
887
                if (vp8_read_bit(bc))
                    xd->mb_segment_tree_probs[i] = (vp8_prob)vp8_read_literal(bc, 8);
            }
        }
    }

888
    /* Read the loop filter level and type */
John Koleszar's avatar
John Koleszar committed
889
890
891
892
    pc->filter_type = (LOOPFILTERTYPE) vp8_read_bit(bc);
    pc->filter_level = vp8_read_literal(bc, 6);
    pc->sharpness_level = vp8_read_literal(bc, 3);

893
    /* Read in loop filter deltas applied at the MB level based on mode or ref frame. */
John Koleszar's avatar
John Koleszar committed
894
895
896
897
898
    xd->mode_ref_lf_delta_update = 0;
    xd->mode_ref_lf_delta_enabled = (unsigned char)vp8_read_bit(bc);

    if (xd->mode_ref_lf_delta_enabled)
    {
899
        /* Do the deltas need to be updated */
John Koleszar's avatar
John Koleszar committed
900
901
902
903
        xd->mode_ref_lf_delta_update = (unsigned char)vp8_read_bit(bc);

        if (xd->mode_ref_lf_delta_update)
        {
904
            /* Send update */
John Koleszar's avatar
John Koleszar committed
905
906
907
908
            for (i = 0; i < MAX_REF_LF_DELTAS; i++)
            {
                if (vp8_read_bit(bc))
                {
909
                    /*sign = vp8_read_bit( bc );*/
John Koleszar's avatar
John Koleszar committed
910
911
                    xd->ref_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);

912
                    if (vp8_read_bit(bc))        /* Apply sign */
John Koleszar's avatar
John Koleszar committed
913
914
915
916
                        xd->ref_lf_deltas[i] = xd->ref_lf_deltas[i] * -1;
                }
            }

917
            /* Send update */
John Koleszar's avatar
John Koleszar committed
918
919
920
921
            for (i = 0; i < MAX_MODE_LF_DELTAS; i++)
            {
                if (vp8_read_bit(bc))
                {
922
                    /*sign = vp8_read_bit( bc );*/
John Koleszar's avatar
John Koleszar committed
923
924
                    xd->mode_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);

925
                    if (vp8_read_bit(bc))        /* Apply sign */
John Koleszar's avatar
John Koleszar committed
926
927
928
929
930
931
                        xd->mode_lf_deltas[i] = xd->mode_lf_deltas[i] * -1;
                }
            }
        }
    }

932
933
934
935
936
937
938
939
    if (pbi->input_partition)
    {
        setup_token_decoder_partition_input(pbi);
    }
    else
    {
        setup_token_decoder(pbi, data + first_partition_length_in_bytes);
    }
John Koleszar's avatar
John Koleszar committed
940
941
    xd->current_bc = &pbi->bc2;

942
    /* Read the default quantizers. */
John Koleszar's avatar
John Koleszar committed
943
944
945
    {
        int Q, q_update;

946
        Q = vp8_read_literal(bc, 7);  /* AC 1st order Q = default */
John Koleszar's avatar
John Koleszar committed
947
948
949
950
951
952
953
954
955
956
957
        pc->base_qindex = Q;
        q_update = 0;
        pc->y1dc_delta_q = get_delta_q(bc, pc->y1dc_delta_q, &q_update);
        pc->y2dc_delta_q = get_delta_q(bc, pc->y2dc_delta_q, &q_update);
        pc->y2ac_delta_q = get_delta_q(bc, pc->y2ac_delta_q, &q_update);
        pc->uvdc_delta_q = get_delta_q(bc, pc->uvdc_delta_q, &q_update);
        pc->uvac_delta_q = get_delta_q(bc, pc->uvac_delta_q, &q_update);

        if (q_update)
            vp8cx_init_de_quantizer(pbi);

958
        /* MB level dequantizer setup */
John Koleszar's avatar
John Koleszar committed
959
960
961
        mb_init_dequantizer(pbi, &pbi->mb);
    }

962
963
964
965
    /* Determine if the golden frame or ARF buffer should be updated and how.
     * For all non key frames the GF and ARF refresh flags and sign bias
     * flags must be set explicitly.
     */
John Koleszar's avatar
John Koleszar committed
966
967
    if (pc->frame_type != KEY_FRAME)
    {
968
        /* Should the GF or ARF be updated from the current frame */
John Koleszar's avatar
John Koleszar committed
969
        pc->refresh_golden_frame = vp8_read_bit(bc);
970
971
972
#if CONFIG_ERROR_CONCEALMENT
        /* Assume we shouldn't refresh golden if the bit is missing */
        xd->corrupted |= vp8dx_bool_error(bc);
973
        if (pbi->ec_active && xd->corrupted)
974
975
976
            pc->refresh_golden_frame = 0;
#endif

John Koleszar's avatar
John Koleszar committed
977
        pc->refresh_alt_ref_frame = vp8_read_bit(bc);
978
979
980
#if CONFIG_ERROR_CONCEALMENT
        /* Assume we shouldn't refresh altref if the bit is missing */
        xd->corrupted |= vp8dx_bool_error(bc);
981
        if (pbi->ec_active && xd->corrupted)
982
983
            pc->refresh_alt_ref_frame = 0;
#endif
John Koleszar's avatar
John Koleszar committed
984

985
        /* Buffer to buffer copy flags. */
John Koleszar's avatar
John Koleszar committed
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
        pc->copy_buffer_to_gf = 0;

        if (!pc->refresh_golden_frame)
            pc->copy_buffer_to_gf = vp8_read_literal(bc, 2);

        pc->copy_buffer_to_arf = 0;

        if (!pc->refresh_alt_ref_frame)
            pc->copy_buffer_to_arf = vp8_read_literal(bc, 2);

        pc->ref_frame_sign_bias[GOLDEN_FRAME] = vp8_read_bit(bc);
        pc->ref_frame_sign_bias[ALTREF_FRAME] = vp8_read_bit(bc);
    }

    pc->refresh_entropy_probs = vp8_read_bit(bc);
    if (pc->refresh_entropy_probs == 0)
    {
        vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc));
    }

    pc->refresh_last_frame = pc->frame_type == KEY_FRAME  ||  vp8_read_bit(bc);

1008
1009
1010
#if CONFIG_ERROR_CONCEALMENT
    /* Assume we should refresh the last frame if the bit is missing */
    xd->corrupted |= vp8dx_bool_error(bc);
1011
    if (pbi->ec_active && xd->corrupted)
1012
1013
1014
        pc->refresh_last_frame = 1;
#endif

John Koleszar's avatar
John Koleszar committed
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
    if (0)
    {
        FILE *z = fopen("decodestats.stt", "a");
        fprintf(z, "%6d F:%d,G:%d,A:%d,L:%d,Q:%d\n",
                pc->current_video_frame,
                pc->frame_type,
                pc->refresh_golden_frame,
                pc->refresh_alt_ref_frame,
                pc->refresh_last_frame,
                pc->base_qindex);
        fclose(z);
    }

    {
1029
1030
        pbi->independent_partitions = 1;

1031
        /* read coef probability tree */
John Koleszar's avatar
John Koleszar committed
1032
1033
1034
        for (i = 0; i < BLOCK_TYPES; i++)
            for (j = 0; j < COEF_BANDS; j++)
                for (k = 0; k < PREV_COEF_CONTEXTS; k++)
1035
                    for (l = 0; l < ENTROPY_NODES; l++)
John Koleszar's avatar
John Koleszar committed
1036
1037
1038
1039
1040
1041
1042
1043
1044
                    {

                        vp8_prob *const p = pc->fc.coef_probs [i][j][k] + l;

                        if (vp8_read(bc, vp8_coef_update_probs [i][j][k][l]))
                        {
                            *p = (vp8_prob)vp8_read_literal(bc, 8);

                        }
1045
1046
1047
                        if (k > 0 && *p != pc->fc.coef_probs[i][j][k-1][l])
                            pbi->independent_partitions = 0;

John Koleszar's avatar
John Koleszar committed
1048
1049
1050
                    }
    }

1051
1052
    vpx_memcpy(&xd->pre, &pc->yv12_fb[pc->lst_fb_idx], sizeof(YV12_BUFFER_CONFIG));
    vpx_memcpy(&xd->dst, &pc->yv12_fb[pc->new_fb_idx], sizeof(YV12_BUFFER_CONFIG));
John Koleszar's avatar
John Koleszar committed
1053

1054
    /* set up frame new frame for intra coded blocks */
1055
#if CONFIG_MULTITHREAD
1056
    if (!(pbi->b_multithreaded_rd) || pc->multi_token_partition == ONE_PARTITION || !(pc->filter_level))
1057
#endif
1058
        vp8_setup_intra_recon(&pc->yv12_fb[pc->new_fb_idx]);
John Koleszar's avatar
John Koleszar committed
1059
1060
1061
1062
1063

    vp8_setup_block_dptrs(xd);

    vp8_build_block_doffsets(xd);

1064
    /* clear out the coeff buffer */
John Koleszar's avatar
John Koleszar committed
1065
1066
    vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff));

1067
    /* Read the mb_no_coeff_skip flag */
John Koleszar's avatar
John Koleszar committed
1068
1069
    pc->mb_no_coeff_skip = (int)vp8_read_bit(bc);

Scott LaVarnway's avatar
Scott LaVarnway committed
1070
1071

    vp8_decode_mode_mvs(pbi);
John Koleszar's avatar
John Koleszar committed
1072

1073
#if CONFIG_ERROR_CONCEALMENT
1074
    if (pbi->ec_active &&
1075
1076
1077
1078
1079
1080
1081
1082
            pbi->mvs_corrupt_from_mb < (unsigned int)pc->mb_cols * pc->mb_rows)
    {
        /* Motion vectors are missing in this frame. We will try to estimate
         * them and then continue decoding the frame as usual */
        vp8_estimate_missing_mvs(pbi);
    }
#endif

1083
    vpx_memset(pc->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * pc->mb_cols);
John Koleszar's avatar
John Koleszar committed
1084

1085
#if CONFIG_MULTITHREAD
1086
    if (pbi->b_multithreaded_rd && pc->multi_token_partition != ONE_PARTITION)
John Koleszar's avatar
John Koleszar committed
1087
    {
1088
1089
        int i;
        pbi->frame_corrupt_residual = 0;
1090
        vp8mt_decode_mb_rows(pbi, xd);
1091
        vp8_yv12_extend_frame_borders_ptr(&pc->yv12_fb[pc->new_fb_idx]);    /*cm->frame_to_show);*/
1092
1093
        for (i = 0; i < pbi->decoding_thread_count; ++i)
            corrupt_tokens |= pbi->mb_row_di[i].mbd.corrupted;
John Koleszar's avatar
John Koleszar committed
1094
1095
    }
    else
1096
#endif
John Koleszar's avatar
John Koleszar committed
1097
1098
    {
        int ibc = 0;
1099
        int num_part = 1 << pc->multi_token_partition;
1100
        pbi->frame_corrupt_residual = 0;
John Koleszar's avatar
John Koleszar committed
1101

1102
        /* Decode the individual macro block */
John Koleszar's avatar
John Koleszar committed
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
        for (mb_row = 0; mb_row < pc->mb_rows; mb_row++)
        {

            if (num_part > 1)
            {
                xd->current_bc = & pbi->mbc[ibc];
                ibc++;

                if (ibc == num_part)
                    ibc = 0;
            }

1115
            decode_mb_row(pbi, pc, mb_row, xd);
John Koleszar's avatar
John Koleszar committed
1116
        }
1117
        corrupt_tokens |= xd->corrupted;
John Koleszar's avatar
John Koleszar committed
1118
1119
1120
1121
    }

    stop_token_decoder(pbi);

1122
1123
    /* Collect information about decoder corruption. */
    /* 1. Check first boolean decoder for errors. */
1124
    pc->yv12_fb[pc->new_fb_idx].corrupted = vp8dx_bool_error(bc);
1125
    /* 2. Check the macroblock information */
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
    pc->yv12_fb[pc->new_fb_idx].corrupted |= corrupt_tokens;

    if (!pbi->decoded_key_frame)
    {
        if (pc->frame_type == KEY_FRAME &&
            !pc->yv12_fb[pc->new_fb_idx].corrupted)
            pbi->decoded_key_frame = 1;
        else
            vpx_internal_error(&pbi->common.error, VPX_CODEC_CORRUPT_FRAME,
                               "A stream must start with a complete key frame");
    }
1137

1138
    /* vpx_log("Decoder: Frame Decoded, Size Roughly:%d bytes  \n",bc->pos+pbi->bc2.pos); */
John Koleszar's avatar
John Koleszar committed
1139

1140
    /* If this was a kf or Gf note the Q used */
1141
1142
1143
    if ((pc->frame_type == KEY_FRAME) ||
         pc->refresh_golden_frame || pc->refresh_alt_ref_frame)
    {
John Koleszar's avatar
John Koleszar committed
1144
        pc->last_kf_gf_q = pc->base_qindex;
1145
    }
John Koleszar's avatar
John Koleszar committed
1146
1147
1148
1149

    if (pc->refresh_entropy_probs == 0)
    {
        vpx_memcpy(&pc->fc, &pc->lfc, sizeof(pc->fc));
1150
        pbi->independent_partitions = prev_independent_partitions;
John Koleszar's avatar
John Koleszar committed
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
    }

#ifdef PACKET_TESTING
    {
        FILE *f = fopen("decompressor.VP8", "ab");
        unsigned int size = pbi->bc2.pos + pbi->bc.pos + 8;
        fwrite((void *) &size, 4, 1, f);
        fwrite((void *) pbi->Source, size, 1, f);
        fclose(f);
    }
#endif

    return 0;
}