decodframe.c 42.5 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
#include "decoderthreading.h"
#include "dboolhuff.h"

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

43
44
45
46
#ifdef DEC_DEBUG
int dec_debug = 0;
#endif

John Koleszar's avatar
John Koleszar committed
47
48
49
50
51
52
53
54
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++)
    {
55
56
57
        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
58

59
        /* all the ac values = ; */
John Koleszar's avatar
John Koleszar committed
60
61
62
63
        for (i = 1; i < 16; i++)
        {
            int rc = vp8_default_zig_zag1d[i];

64
65
66
            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
67
68
69
70
        }
    }
}

71
void mb_init_dequantizer(VP8D_COMP *pbi, MACROBLOCKD *xd)
John Koleszar's avatar
John Koleszar committed
72
73
74
75
{
    int i;
    int QIndex;
    VP8_COMMON *const pc = & pbi->common;
Paul Wilkins's avatar
Paul Wilkins committed
76
    int segment_id = xd->mode_info_context->mbmi.segment_id;
John Koleszar's avatar
John Koleszar committed
77

Paul Wilkins's avatar
Paul Wilkins committed
78
79
80
81
82
83
84
85

    // Set the Q baseline allowing for any segment level adjustment
#if CONFIG_SEGFEATURES
    if ( xd->segmentation_enabled &&
         ( xd->segment_feature_mask[segment_id] & (1 << SEG_LVL_ALT_Q) ) )
#else
    if ( xd->segmentation_enabled )
#endif
John Koleszar's avatar
John Koleszar committed
86
    {
87
        /* Abs Value */
John Koleszar's avatar
John Koleszar committed
88
        if (xd->mb_segement_abs_delta == SEGMENT_ABSDATA)
Paul Wilkins's avatar
Paul Wilkins committed
89
            QIndex = xd->segment_feature_data[segment_id][SEG_LVL_ALT_Q];
John Koleszar's avatar
John Koleszar committed
90

91
        /* Delta Value */
John Koleszar's avatar
John Koleszar committed
92
93
        else
        {
94
            QIndex = pc->base_qindex +
Paul Wilkins's avatar
Paul Wilkins committed
95
                xd->segment_feature_data[segment_id][SEG_LVL_ALT_Q];
96
            QIndex = (QIndex >= 0) ? ((QIndex <= MAXQ) ? QIndex : MAXQ) : 0;    /* Clamp to valid range */
John Koleszar's avatar
John Koleszar committed
97
98
99
100
101
        }
    }
    else
        QIndex = pc->base_qindex;

102
    /* Set up the block level dequant pointers */
John Koleszar's avatar
John Koleszar committed
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
    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

123
124
125
/* 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
126
127
static void skip_recon_mb(VP8D_COMP *pbi, MACROBLOCKD *xd)
{
128
    if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
John Koleszar's avatar
John Koleszar committed
129
    {
130
        RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_mbuv_s)(xd);
131
132
        RECON_INVOKE(&pbi->common.rtcd.recon,
                     build_intra_predictors_mby_s)(xd);
John Koleszar's avatar
John Koleszar committed
133
134
135
    }
    else
    {
136
137
138
        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);
139
140
141
142
143
144
145
146
147
148
#ifdef DEC_DEBUG
        if (dec_debug) {
          int i, j;
          printf("Generating predictors\n");
          for (i=0;i<16;i++) {
            for (j=0;j<16;j++) printf("%3d ", xd->dst.y_buffer[i*xd->dst.y_stride+j]);
            printf("\n");
          }
        }
#endif
John Koleszar's avatar
John Koleszar committed
149
150
151
    }
}

152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
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);
}

174
175
176
/* 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
177
178
179
180
181
    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;
182
}
183

184
void clamp_mvs(MACROBLOCKD *xd)
John Koleszar's avatar
John Koleszar committed
185
{
186
    if (xd->mode_info_context->mbmi.mode == SPLITMV)
187
188
189
190
191
    {
        int i;

        for (i=0; i<16; i++)
            clamp_mv_to_umv_border(&xd->block[i].bmi.mv.as_mv, xd);
192
193
        for (i=16; i<24; i++)
            clamp_uvmv_to_umv_border(&xd->block[i].bmi.mv.as_mv, xd);
194
195
196
    }
    else
    {
197
        clamp_mv_to_umv_border(&xd->mode_info_context->mbmi.mv.as_mv, xd);
198
        clamp_uvmv_to_umv_border(&xd->block[16].bmi.mv.as_mv, xd);
199
200
201
202
    }

}

203
204
static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
                              unsigned int mb_idx)
John Koleszar's avatar
John Koleszar committed
205
{
206
    int eobtotal = 0;
207
    int throw_residual = 0;
Gaute Strokkenes's avatar
Gaute Strokkenes committed
208
209
    MB_PREDICTION_MODE mode;
    int i;
210

211
    if (xd->mode_info_context->mbmi.mb_skip_coeff)
212
213
214
215
216
    {
        vp8_reset_mb_tokens_context(xd);
    }
    else
    {
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238

#if CONFIG_T8X8
        for(i = 0; i < 25; i++)
        {
            xd->block[i].eob = 0;
            xd->eobs[i] = 0;
        }
        if (xd->mode_info_context->mbmi.segment_id >= 2)
            eobtotal = vp8_decode_mb_tokens_8x8(pbi, xd);
        else
#endif
            eobtotal = vp8_decode_mb_tokens(pbi, xd);
#ifdef DEC_DEBUG
        if (dec_debug) {
            printf("\nTokens (%d)\n", eobtotal);
            for (i =0; i<400; i++) {
                printf("%3d ", xd->qcoeff[i]);
                if (i%16 == 15) printf("\n");
            }
            printf("\n");
        }
#endif
239
240
241
    }

    /* Perform temporary clamping of the MV to be used for prediction */
Gaute Strokkenes's avatar
Gaute Strokkenes committed
242
    if (xd->mode_info_context->mbmi.need_to_clamp_mvs)
243
244
245
246
    {
        clamp_mvs(xd);
    }

Gaute Strokkenes's avatar
Gaute Strokkenes committed
247
248
    mode = xd->mode_info_context->mbmi.mode;

249
250
    if (eobtotal == 0 && mode != B_PRED && mode != SPLITMV &&
            !vp8dx_bool_error(xd->current_bc))
251
    {
Scott LaVarnway's avatar
Scott LaVarnway committed
252
        /* Special case:  Force the loopfilter to skip when eobtotal and
Yaowu Xu's avatar
Yaowu Xu committed
253
254
         * mb_skip_coeff are zero.
         * */
Scott LaVarnway's avatar
Scott LaVarnway committed
255
256
        xd->mode_info_context->mbmi.mb_skip_coeff = 1;

257
258
259
        skip_recon_mb(pbi, xd);
        return;
    }
Yaowu Xu's avatar
Yaowu Xu committed
260

261
262
263
    if (xd->segmentation_enabled)
        mb_init_dequantizer(pbi, xd);

264
    /* do prediction */
265
    if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
John Koleszar's avatar
John Koleszar committed
266
    {
267
        RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_mbuv)(xd);
John Koleszar's avatar
John Koleszar committed
268

Gaute Strokkenes's avatar
Gaute Strokkenes committed
269
        if (mode != B_PRED)
John Koleszar's avatar
John Koleszar committed
270
        {
271
            RECON_INVOKE(&pbi->common.rtcd.recon,
Yaowu Xu's avatar
Yaowu Xu committed
272
                         build_intra_predictors_mby)(xd);
273
274
        } else {
            vp8_intra_prediction_down_copy(xd);
John Koleszar's avatar
John Koleszar committed
275
276
277
278
279
280
281
        }
    }
    else
    {
        vp8_build_inter_predictors_mb(xd);
    }

282
283
284
285
286
287
288
    /* 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));

289
#if CONFIG_ERROR_CONCEALMENT
290
291
    if (pbi->ec_active &&
        (mb_idx >= pbi->mvs_corrupt_from_mb || throw_residual))
292
293
    {
        /* MB with corrupt residuals or corrupt mode/motion vectors.
Yaowu Xu's avatar
Yaowu Xu committed
294
295
         * Better to use the predictor as reconstruction.
         */
296
        pbi->frame_corrupt_residual = 1;
297
        vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff));
298
299
300
301
302
        vp8_conceal_corrupt_mb(xd);
        return;
    }
#endif

303
    /* dequantization and idct */
Gaute Strokkenes's avatar
Gaute Strokkenes committed
304
    if (mode == B_PRED)
John Koleszar's avatar
John Koleszar committed
305
    {
306
        for (i = 0; i < 16; i++)
John Koleszar's avatar
John Koleszar committed
307
        {
308
            BLOCKD *b = &xd->block[i];
309
310
            int b_mode = xd->mode_info_context->bmi[i].as_mode;

311
            RECON_INVOKE(RTCD_VTABLE(recon), intra4x4_predict)
312
                          (b, b_mode, b->predictor);
John Koleszar's avatar
John Koleszar committed
313

Fritz Koenig's avatar
Fritz Koenig committed
314
            if (xd->eobs[i] > 1)
John Koleszar's avatar
John Koleszar committed
315
            {
Fritz Koenig's avatar
Fritz Koenig committed
316
                DEQUANT_INVOKE(&pbi->dequant, idct_add)
317
                    (b->qcoeff, b->dequant,  b->predictor,
Fritz Koenig's avatar
Fritz Koenig committed
318
                    *(b->base_dst) + b->dst, 16, b->dst_stride);
John Koleszar's avatar
John Koleszar committed
319
320
321
            }
            else
            {
Fritz Koenig's avatar
Fritz Koenig committed
322
                IDCT_INVOKE(RTCD_VTABLE(idct), idct1_scalar_add)
323
                    (b->qcoeff[0] * b->dequant[0], b->predictor,
Fritz Koenig's avatar
Fritz Koenig committed
324
                    *(b->base_dst) + b->dst, 16, b->dst_stride);
John Koleszar's avatar
John Koleszar committed
325
326
327
                ((int *)b->qcoeff)[0] = 0;
            }
        }
Yaowu Xu's avatar
Yaowu Xu committed
328

John Koleszar's avatar
John Koleszar committed
329
    }
Gaute Strokkenes's avatar
Gaute Strokkenes committed
330
    else if (mode == SPLITMV)
John Koleszar's avatar
John Koleszar committed
331
    {
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
#if CONFIG_T8X8
        if(xd->mode_info_context->mbmi.segment_id >= 2)
        {
            DEQUANT_INVOKE (&pbi->dequant, idct_add_y_block_8x8)
                (xd->qcoeff, xd->block[0].dequant,
                xd->predictor, xd->dst.y_buffer,
                xd->dst.y_stride, xd->eobs, xd);
        }
        else
#endif
        {
            DEQUANT_INVOKE (&pbi->dequant, idct_add_y_block)
                (xd->qcoeff, xd->block[0].dequant,
                xd->predictor, xd->dst.y_buffer,
                xd->dst.y_stride, xd->eobs);
        }
John Koleszar's avatar
John Koleszar committed
348
    }
Gaute Strokkenes's avatar
Gaute Strokkenes committed
349
350
351
352
353
354
355
    else
    {
        BLOCKD *b = &xd->block[24];

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

        /* do 2nd order transform on the dc block */
356
357
#if CONFIG_T8X8
        if(xd->mode_info_context->mbmi.segment_id >= 2)
Gaute Strokkenes's avatar
Gaute Strokkenes committed
358
        {
359
360
361
362
363
364
365
366
367
368
369
370
371
372
            DEQUANT_INVOKE(&pbi->dequant, block_8x8)(b);
#ifdef DEC_DEBUG
            if (dec_debug)
            {
                int j;
                printf("DQcoeff Haar\n");
                for (j=0;j<16;j++) {
                    printf("%d ", b->dqcoeff[j]);
                }
                printf("\n");
            }
#endif
            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 inverse transform
Gaute Strokkenes's avatar
Gaute Strokkenes committed
373
374
375
376
377
378
379
            ((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;
380
381
382
383
384
            DEQUANT_INVOKE (&pbi->dequant, dc_idct_add_y_block_8x8)
                (xd->qcoeff, xd->block[0].dequant,
                xd->predictor, xd->dst.y_buffer,
                xd->dst.y_stride, xd->eobs, xd->block[24].diff, xd);

Gaute Strokkenes's avatar
Gaute Strokkenes committed
385
        }
386

Gaute Strokkenes's avatar
Gaute Strokkenes committed
387
        else
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
#endif
            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);
    }
#if CONFIG_T8X8
    if(xd->mode_info_context->mbmi.segment_id >= 2)
    {
        DEQUANT_INVOKE (&pbi->dequant, idct_add_uv_block_8x8)//
            (xd->qcoeff+16*16, xd->block[16].dequant,
            xd->predictor+16*16, xd->dst.u_buffer, xd->dst.v_buffer,
            xd->dst.uv_stride, xd->eobs+16, xd);//

    }
    else
#endif
Gaute Strokkenes's avatar
Gaute Strokkenes committed
423

Yaowu Xu's avatar
Yaowu Xu committed
424
425
426
427
    DEQUANT_INVOKE (&pbi->dequant, idct_add_uv_block)
                    (xd->qcoeff+16*16, xd->block[16].dequant,
                     xd->predictor+16*16, xd->dst.u_buffer, xd->dst.v_buffer,
                     xd->dst.uv_stride, xd->eobs+16);
John Koleszar's avatar
John Koleszar committed
428

Yaowu Xu's avatar
Yaowu Xu committed
429
}
John Koleszar's avatar
John Koleszar committed
430

431

John Koleszar's avatar
John Koleszar committed
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
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



458
459
static void
decode_mb_row(VP8D_COMP *pbi, VP8_COMMON *pc, int mb_row, MACROBLOCKD *xd)
John Koleszar's avatar
John Koleszar committed
460
461
462
{
    int recon_yoffset, recon_uvoffset;
    int mb_col;
463
464
465
466
    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
467

468
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
John Koleszar's avatar
John Koleszar committed
469
470
    recon_yoffset = mb_row * recon_y_stride * 16;
    recon_uvoffset = mb_row * recon_uv_stride * 8;
471
    /* reset above block coeffs */
John Koleszar's avatar
John Koleszar committed
472

473
    xd->above_context = pc->above_context;
John Koleszar's avatar
John Koleszar committed
474
475
476
477
478
479
480
    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++)
    {
481
482
483
484
485
486
487
488
489
        /* 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
        {
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
            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);
            }
511
512
        }
#endif
John Koleszar's avatar
John Koleszar committed
513

514
515
516
        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
517
518
519

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

520
        /* Select the appropriate reference frame for this MB */
521
        if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
522
            ref_fb_idx = pc->lst_fb_idx;
523
        else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
524
            ref_fb_idx = pc->gld_fb_idx;
John Koleszar's avatar
John Koleszar committed
525
        else
526
527
528
529
530
            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
531

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

538
539
540
#ifdef DEC_DEBUG
        dec_debug = (pc->current_video_frame==5 && mb_row==2 && mb_col==3);
#endif
541
        decode_macroblock(pbi, xd, mb_row * pc->mb_cols  + mb_col);
John Koleszar's avatar
John Koleszar committed
542

543
544
        /* check if the boolean decoder has suffered an error */
        xd->corrupted |= vp8dx_bool_error(xd->current_bc);
John Koleszar's avatar
John Koleszar committed
545
546
547
548
549
        recon_yoffset += 16;
        recon_uvoffset += 8;

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

550
        xd->above_context++;
John Koleszar's avatar
John Koleszar committed
551
552
553

    }

554
    /* adjust to the next row of mbs */
John Koleszar's avatar
John Koleszar committed
555
    vp8_extend_mb_row(
556
        &pc->yv12_fb[dst_fb_idx],
John Koleszar's avatar
John Koleszar committed
557
558
559
560
561
562
563
564
565
566
567
568
569
570
        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;
}

571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
static void setup_token_decoder_partition_input(VP8D_COMP *pbi)
{
    vp8_reader *bool_decoder = &pbi->bc2;
    int part_idx = 1;

    TOKEN_PARTITION multi_token_partition =
            (TOKEN_PARTITION)vp8_read_literal(&pbi->bc, 2);
    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
605

606
607
608
609
610
611
612
613
614

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
615
616
617
618
619
620
621
622
623
624
625
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 */
626
627
628
629
    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. */
630
    if (!pbi->ec_active || !vp8dx_bool_error(&pbi->bc))
631
632
        pc->multi_token_partition = multi_token_partition;

John Koleszar's avatar
John Koleszar committed
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
    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;
649
650
651
        ptrdiff_t            partition_size, bytes_left;

        bytes_left = user_data_end - partition;
John Koleszar's avatar
John Koleszar committed
652
653

        /* Calculate the length of this partition. The last partition
654
655
656
         * 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
657
658
659
         */
        if (i < num_part - 1)
        {
660
661
            if (read_is_valid(partition_size_ptr, 3, user_data_end))
                partition_size = read_partition_size(partition_size_ptr);
662
            else if (pbi->ec_active)
663
664
665
666
                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
667
668
        }
        else
669
670
671
672
673
674
675
            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
676
        {
677
            if (pbi->ec_active)
678
679
680
681
682
                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
683
684
        }

Johann's avatar
Johann committed
685
        if (vp8dx_start_decode(bool_decoder, partition, partition_size))
John Koleszar's avatar
John Koleszar committed
686
687
688
689
690
691
692
693
            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++;
    }

694
#if CONFIG_MULTITHREAD
John Koleszar's avatar
John Koleszar committed
695
696
697
    /* Clamp number of decoder threads */
    if (pbi->decoding_thread_count > num_part - 1)
        pbi->decoding_thread_count = num_part - 1;
698
#endif
John Koleszar's avatar
John Koleszar committed
699
700
701
702
703
704
705
706
}


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
707
    {
John Koleszar's avatar
John Koleszar committed
708
        vpx_free(pbi->mbc);
James Zern's avatar
James Zern committed
709
710
        pbi->mbc = NULL;
    }
John Koleszar's avatar
John Koleszar committed
711
712
713
714
715
716
717
718
719
}

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

    if (pc->frame_type == KEY_FRAME)
    {
720
        /* Various keyframe initializations */
John Koleszar's avatar
John Koleszar committed
721
722
723
724
725
726
727
        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);

Paul Wilkins's avatar
Paul Wilkins committed
728
729
730
731
732
733
734
735
736
        // Reset the segment feature data to the default stats:
        // Features disabled, 0, with delta coding (Default state).
#if CONFIG_SEGFEATURES
        vpx_memset(xd->segment_feature_mask, 0,
                   sizeof(xd->segment_feature_mask));
#endif
        vpx_memset(xd->segment_feature_data, 0,
                   sizeof(xd->segment_feature_data));

John Koleszar's avatar
John Koleszar committed
737
738
        xd->mb_segement_abs_delta = SEGMENT_DELTADATA;

739
        /* reset the mode ref deltasa for loop filter */
John Koleszar's avatar
John Koleszar committed
740
741
742
        vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
        vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));

743
        /* All buffers are implicitly updated on key frames. */
John Koleszar's avatar
John Koleszar committed
744
745
746
747
748
        pc->refresh_golden_frame = 1;
        pc->refresh_alt_ref_frame = 1;
        pc->copy_buffer_to_gf = 0;
        pc->copy_buffer_to_arf = 0;

749
750
751
        /* 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
752
753
754
755
756
757
758
759
760
761
        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;

762
        /* To enable choice of different interploation filters */
John Koleszar's avatar
John Koleszar committed
763
764
765
766
767
768
769
770
771
772
773
774
775
776
        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);
        }
777
778
779

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

782
    xd->left_context = &pc->left_context;
John Koleszar's avatar
John Koleszar committed
783
784
    xd->mode_info_context = pc->mi;
    xd->frame_type = pc->frame_type;
785
    xd->mode_info_context->mbmi.mode = DC_PRED;
John Koleszar's avatar
John Koleszar committed
786
    xd->mode_info_stride = pc->mode_info_stride;
787
    xd->corrupted = 0; /* init without corruption */
788
789
790
791
792

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

John Koleszar's avatar
John Koleszar committed
793
794
795
796
797
798
799
800
}

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;
801
    const unsigned char *data_end = data + pbi->source_sz;
802
    ptrdiff_t first_partition_length_in_bytes;
Yaowu Xu's avatar
Yaowu Xu committed
803

John Koleszar's avatar
John Koleszar committed
804
805
806
    int mb_row;
    int i, j, k, l;
    const int *const mb_feature_data_bits = vp8_mb_feature_data_bits;
807
808
    int corrupt_tokens = 0;
    int prev_independent_partitions = pbi->independent_partitions;
John Koleszar's avatar
John Koleszar committed
809

810
811
812
813
814
815
    if (pbi->input_partition)
    {
        data = pbi->partitions[0];
        data_end =  data + pbi->partition_sizes[0];
    }

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

820
    if (data_end - data < 3)
John Koleszar's avatar
John Koleszar committed
821
    {
822
        if (pbi->ec_active)
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
        {
            /* 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;
        data += 3;
John Koleszar's avatar
John Koleszar committed
846

847
        if (!pbi->ec_active && (data + first_partition_length_in_bytes > data_end
848
849
850
851
            || data + first_partition_length_in_bytes < data))
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated packet or corrupt partition 0 length");
        vp8_setup_version(pc);
John Koleszar's avatar
John Koleszar committed
852

853
        if (pc->frame_type == KEY_FRAME)
John Koleszar's avatar
John Koleszar committed
854
        {
855
856
857
858
859
860
861
            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
             */
862
            if (!pbi->ec_active || data + 3 < data_end)
John Koleszar's avatar
John Koleszar committed
863
            {
864
865
866
                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
867
868
            }

869
870
871
872
            /* 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.
             */
873
            if (!pbi->ec_active || data + 6 < data_end)
John Koleszar's avatar
John Koleszar committed
874
            {
875
876
877
878
                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
879
            }
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
            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
899

900
901
902
903
904
905
906
907
908
909
910
911
912
913
                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
914
915

#if CONFIG_MULTITHREAD
916
917
                if (pbi->b_multithreaded_rd)
                    vp8mt_alloc_temp_buffers(pbi, pc->Width, prev_mb_rows);
918
#endif
919
            }
John Koleszar's avatar
John Koleszar committed
920
921
922
923
924
925
926
927
928
929
        }
    }

    if (pc->Width == 0 || pc->Height == 0)
    {
        return -1;
    }

    init_frame(pbi);

Johann's avatar
Johann committed
930
    if (vp8dx_start_decode(bc, data, data_end - data))
John Koleszar's avatar
John Koleszar committed
931
932
933
934
935
936
937
        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);
    }

938
    /* Is segmentation enabled */
John Koleszar's avatar
John Koleszar committed
939
940
941
    xd->segmentation_enabled = (unsigned char)vp8_read_bit(bc);
    if (xd->segmentation_enabled)
    {
942
        /* Signal whether or not the segmentation map is being explicitly updated this frame. */
John Koleszar's avatar
John Koleszar committed
943
944
945
946
947
948
949
        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);

Paul Wilkins's avatar
Paul Wilkins committed
950
951
952
            // Clear down feature data structure
            vpx_memset(xd->segment_feature_data, 0,
                       sizeof(xd->segment_feature_data));
John Koleszar's avatar
John Koleszar committed
953

954
#if CONFIG_SEGFEATURES
Paul Wilkins's avatar
Paul Wilkins committed
955
956
957
958
            // Clear down feature enabled masks
            vpx_memset(xd->segment_feature_mask, 0,
                       sizeof(xd->segment_feature_mask));

959
960
961
962
963
964
965
966
967
            // For each segmentation...
            for (j = 0; j < MAX_MB_SEGMENTS; j++)
            {
                // For each of the segments features...
                for (i = 0; i < SEG_LVL_MAX; i++)
                {

#else
            // For each segmentation feature...
Paul Wilkins's avatar
Paul Wilkins committed
968
            for (i = 0; i < SEG_LVL_MAX; i++)
John Koleszar's avatar
John Koleszar committed
969
            {
970
                // For each segmentation...
John Koleszar's avatar
John Koleszar committed
971
972
                for (j = 0; j < MAX_MB_SEGMENTS; j++)
                {
973
#endif
Paul Wilkins's avatar
Paul Wilkins committed
974
                    // Is the feature enabled
John Koleszar's avatar
John Koleszar committed
975
976
                    if (vp8_read_bit(bc))
                    {
Paul Wilkins's avatar
Paul Wilkins committed
977
978
979
980
981
#if CONFIG_SEGFEATURES
                        // Update the feature data and mask
                        xd->segment_feature_mask[j] |= (1 << i);
#endif

982
                        xd->segment_feature_data[j][i] = (signed char)vp8_read_literal(bc, mb_feature_data_bits[i]);
John Koleszar's avatar
John Koleszar committed
983
984

                        if (vp8_read_bit(bc))
985
                            xd->segment_feature_data[j][i] = -xd->segment_feature_data[j][i];
John Koleszar's avatar
John Koleszar committed
986
987
                    }
                    else
Paul Wilkins's avatar
Paul Wilkins committed
988
                    {
989
                        xd->segment_feature_data[j][i] = 0;
Paul Wilkins's avatar
Paul Wilkins committed
990
                    }
John Koleszar's avatar
John Koleszar committed
991
992
993
994
995
996
                }
            }
        }

        if (xd->update_mb_segmentation_map)
        {
997
            /* Which macro block level features are enabled */
John Koleszar's avatar
John Koleszar committed
998
            vpx_memset(xd->mb_segment_tree_probs, 255, sizeof(xd->mb_segment_tree_probs));
999
#if CONFIG_SEGMENTATION
1000
            /* Read the probs used to decode the segment id for each macro block. */
1001
1002
            for (i = 0; i < MB_FEATURE_TREE_PROBS+3; i++)
#else
John Koleszar's avatar
John Koleszar committed
1003
            for (i = 0; i < MB_FEATURE_TREE_PROBS; i++)
1004
#endif
John Koleszar's avatar
John Koleszar committed
1005
            {
1006
                /* If not explicitly set value is defaulted to 255 by memset above */
John Koleszar's avatar
John Koleszar committed
1007
1008
1009
1010
1011
1012
                if (vp8_read_bit(bc))
                    xd->mb_segment_tree_probs[i] = (vp8_prob)vp8_read_literal(bc, 8);
            }
        }
    }

1013
    /* Read the loop filter level and type */
John Koleszar's avatar
John Koleszar committed
1014
1015
1016
1017
    pc->filter_type = (LOOPFILTERTYPE) vp8_read_bit(bc);
    pc->filter_level = vp8_read_literal(bc, 6);
    pc->sharpness_level = vp8_read_literal(bc, 3);

1018
    /* Read in loop filter deltas applied at the MB level based on mode or ref frame. */
John Koleszar's avatar
John Koleszar committed
1019
1020
1021
1022
1023
    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)
    {
1024
        /* Do the deltas need to be updated */
John Koleszar's avatar
John Koleszar committed
1025
1026
1027
1028
        xd->mode_ref_lf_delta_update = (unsigned char)vp8_read_bit(bc);

        if (xd->mode_ref_lf_delta_update)
        {
1029
            /* Send update */
John Koleszar's avatar
John Koleszar committed
1030
1031
1032
1033
            for (i = 0; i < MAX_REF_LF_DELTAS; i++)
            {
                if (vp8_read_bit(bc))
                {
1034
                    /*sign = vp8_read_bit( bc );*/
John Koleszar's avatar
John Koleszar committed
1035
1036
                    xd->ref_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);

1037
                    if (vp8_read_bit(bc))        /* Apply sign */
John Koleszar's avatar
John Koleszar committed
1038
1039
1040
1041
                        xd->ref_lf_deltas[i] = xd->ref_lf_deltas[i] * -1;
                }
            }

1042
            /* Send update */
John Koleszar's avatar
John Koleszar committed
1043
1044
1045
1046
            for (i = 0; i < MAX_MODE_LF_DELTAS; i++)
            {
                if (vp8_read_bit(bc))
                {
1047
                    /*sign = vp8_read_bit( bc );*/
John Koleszar's avatar
John Koleszar committed
1048
1049
                    xd->mode_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);

1050
                    if (vp8_read_bit(bc))        /* Apply sign */
John Koleszar's avatar
John Koleszar committed
1051
1052
1053
1054
1055
1056
                        xd->mode_lf_deltas[i] = xd->mode_lf_deltas[i] * -1;
                }
            }
        }
    }

1057
1058
1059
1060
1061
1062
1063
1064
    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
1065
1066
    xd->current_bc = &pbi->bc2;

1067
    /* Read the default quantizers. */
John Koleszar's avatar
John Koleszar committed
1068
1069
1070
    {
        int Q, q_update;

1071
        Q = vp8_read_literal(bc, 7);  /* AC 1st order Q = default */
John Koleszar's avatar
John Koleszar committed
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
        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);

1083
        /* MB level dequantizer setup */
John Koleszar's avatar
John Koleszar committed
1084
1085
1086
        mb_init_dequantizer(pbi, &pbi->mb);
    }

1087
1088
1089
1090
    /* 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
1091
1092
    if (pc->frame_type != KEY_FRAME)
    {
1093
        /* Should the GF or ARF be updated from the current frame */
John Koleszar's avatar
John Koleszar committed
1094
        pc->refresh_golden_frame = vp8_read_bit(bc);
1095
1096
1097
#if CONFIG_ERROR_CONCEALMENT
        /* Assume we shouldn't refresh golden if the bit is missing */
        xd->corrupted |= vp8dx_bool_error(bc);
1098
        if (pbi->ec_active && xd->corrupted)
1099
1100
1101
            pc->refresh_golden_frame = 0;
#endif

John Koleszar's avatar
John Koleszar committed
1102
        pc->refresh_alt_ref_frame = vp8_read_bit(bc);
1103
1104
1105
#if CONFIG_ERROR_CONCEALMENT
        /* Assume we shouldn't refresh altref if the bit is missing */
        xd->corrupted |= vp8dx_bool_error(bc);
1106
        if (pbi->ec_active && xd->corrupted)
1107
1108
            pc->refresh_alt_ref_frame = 0;
#endif
John Koleszar's avatar
John Koleszar committed
1109

1110
        /* Buffer to buffer copy flags. */
John Koleszar's avatar
John Koleszar committed
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
        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);

1133
1134
1135
#if CONFIG_ERROR_CONCEALMENT
    /* Assume we should refresh the last frame if the bit is missing */
    xd->corrupted |= vp8dx_bool_error(bc);
1136
    if (pbi->ec_active && xd->corrupted)
1137
1138
1139
        pc->refresh_last_frame = 1;
#endif

John Koleszar's avatar
John Koleszar committed
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
    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);
    }

    {
1154
1155
        pbi->independent_partitions = 1;

1156
        /* read coef probability tree */
John Koleszar's avatar
John Koleszar committed
1157
1158
1159
        for (i = 0; i < BLOCK_TYPES; i++)
            for (j = 0; j < COEF_BANDS; j++)
                for (k = 0; k < PREV_COEF_CONTEXTS; k++)
1160
                    for (l = 0; l < ENTROPY_NODES; l++)
John Koleszar's avatar
John Koleszar committed
1161
1162
1163
1164
1165
1166
1167
1168
1169
                    {

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

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

John Koleszar's avatar
John Koleszar committed
1173
1174
                    }
    }
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
#if CONFIG_T8X8
    {
        // read coef probability tree

        for (i = 0; i < BLOCK_TYPES; i++)
            for (j = 0; j < COEF_BANDS; j++)
                for (k = 0; k < PREV_COEF_CONTEXTS; k++)
                    for (l = 0; l < MAX_ENTROPY_TOKENS - 1; l++)
                    {

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

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

                        }
                    }
    }
#endif
John Koleszar's avatar
John Koleszar committed
1195

1196
1197
    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
1198

1199
1200
#if CONFIG_SEGMENTATION
     // Create the encoder segmentation map and set all entries to 0
1201
1202
     if (!pbi->segmentation_map)
       CHECK_MEM_ERROR(pbi->segmentation_map, vpx_calloc((pc->mb_rows * pc->mb_cols), 1));
1203
1204
#endif

1205
    /* set up frame new frame for intra coded blocks */
1206
#if CONFIG_MULTITHREAD
1207
    if (!(pbi->b_multithreaded_rd) || pc->multi_token_partition == ONE_PARTITION || !(pc->filter_level))
1208
#endif
1209
        vp8_setup_intra_recon(&pc->yv12_fb[pc->new_fb_idx]);
John Koleszar's avatar
John Koleszar committed
1210
1211
1212
1213
1214

    vp8_setup_block_dptrs(xd);

    vp8_build_block_doffsets(xd);

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

1218
    /* Read the mb_no_coeff_skip flag */
John Koleszar's avatar
John Koleszar committed
1219
1220
1221
    pc->mb_no_coeff_skip = (int)vp8_read_bit(bc);


Scott LaVarnway's avatar
Scott LaVarnway committed
1222
    vp8_decode_mode_mvs(pbi);
John Koleszar's avatar
John Koleszar committed
1223

1224
#if CONFIG_ERROR_CONCEALMENT
1225
    if (pbi->ec_active &&
1226
1227
1228
1229
1230
1231
1232
1233
            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

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

1236
#if CONFIG_MULTITHREAD
1237
    if (pbi->b_multithreaded_rd && pc->multi_token_partition != ONE_PARTITION)
John Koleszar's avatar
John Koleszar committed
1238
    {
1239
1240
        int i;
        pbi->frame_corrupt_residual = 0;
1241
        vp8mt_decode_mb_rows(pbi, xd);
1242
        vp8_yv12_extend_frame_borders_ptr(&pc->yv12_fb[pc->new_fb_idx]);    /*cm->frame_to_show);*/
1243
1244
        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
1245
1246
    }
    else
1247
#endif
John Koleszar's avatar
John Koleszar committed
1248
1249
    {
        int ibc = 0;
1250
        int num_part = 1 << pc->multi_token_partition;
1251
        pbi->frame_corrupt_residual = 0;
John Koleszar's avatar
John Koleszar committed
1252

1253
        /* Decode the individual macro block */
John Koleszar's avatar
John Koleszar committed
1254
1255
1256
1257
1258