decodframe.c 46.6 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"
Yaowu Xu's avatar
Yaowu Xu committed
30
#include "vp8/common/modecont.h"
31
32
33
#if CONFIG_ERROR_CONCEALMENT
#include "error_concealment.h"
#endif
John Koleszar's avatar
John Koleszar committed
34
#include "vpx_mem/vpx_mem.h"
John Koleszar's avatar
John Koleszar committed
35
#include "vp8/common/idct.h"
John Koleszar's avatar
John Koleszar committed
36
#include "dequantize.h"
John Koleszar's avatar
John Koleszar committed
37
#include "vp8/common/threading.h"
John Koleszar's avatar
John Koleszar committed
38
39
40
#include "decoderthreading.h"
#include "dboolhuff.h"

41
//#if CONFIG_SEGFEATURES
42
43
#include "vp8/common/seg_common.h"

John Koleszar's avatar
John Koleszar committed
44
45
46
#include <assert.h>
#include <stdio.h>

47

48
49
50
51
#ifdef DEC_DEBUG
int dec_debug = 0;
#endif

John Koleszar's avatar
John Koleszar committed
52
53
54
55
56
57
58
59
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++)
    {
60
61
62
        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
63

64
        /* all the ac values = ; */
John Koleszar's avatar
John Koleszar committed
65
66
67
68
        for (i = 1; i < 16; i++)
        {
            int rc = vp8_default_zig_zag1d[i];

69
70
71
            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
72
73
74
75
        }
    }
}

76
void mb_init_dequantizer(VP8D_COMP *pbi, MACROBLOCKD *xd)
John Koleszar's avatar
John Koleszar committed
77
78
79
80
{
    int i;
    int QIndex;
    VP8_COMMON *const pc = & pbi->common;
Paul Wilkins's avatar
Paul Wilkins committed
81
    int segment_id = xd->mode_info_context->mbmi.segment_id;
John Koleszar's avatar
John Koleszar committed
82

Paul Wilkins's avatar
Paul Wilkins committed
83
    // Set the Q baseline allowing for any segment level adjustment
84
//#if CONFIG_SEGFEATURES
85
    if ( segfeature_active( xd, segment_id, SEG_LVL_ALT_Q ) )
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 = get_segdata( xd, 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
                     get_segdata( xd, 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
#if CONFIG_DUALPRED
        if (xd->mode_info_context->mbmi.second_ref_frame)
        {
            vp8_build_2nd_inter16x16_predictors_mb(xd, xd->dst.y_buffer,
                                                   xd->dst.u_buffer, xd->dst.v_buffer,
                                                   xd->dst.y_stride, xd->dst.uv_stride);
        }
#endif /* CONFIG_DUALPRED */
147
    }
148
149
150
151
152
153
154
155
156
157
#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
158

John Koleszar's avatar
John Koleszar committed
159
160
}

Yaowu Xu's avatar
Yaowu Xu committed
161
extern const int vp8_i8x8_block[4];
162
163
static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
                              unsigned int mb_idx)
John Koleszar's avatar
John Koleszar committed
164
{
165
    int eobtotal = 0;
166
    int throw_residual = 0;
Gaute Strokkenes's avatar
Gaute Strokkenes committed
167
168
    MB_PREDICTION_MODE mode;
    int i;
169

Paul Wilkins's avatar
Paul Wilkins committed
170
#if CONFIG_T8X8
171
172
173
    int tx_type = get_seg_tx_type( xd,
                                  xd->mode_info_context->mbmi.segment_id);
    xd->mode_info_context->mbmi.txfm_size = tx_type;
Paul Wilkins's avatar
Paul Wilkins committed
174
175
#endif

176
    if (xd->mode_info_context->mbmi.mb_skip_coeff)
177
178
179
    {
        vp8_reset_mb_tokens_context(xd);
    }
180
    else if (!vp8dx_bool_error(xd->current_bc))
181
    {
182
183
184
185
186
187
188

#if CONFIG_T8X8
        for(i = 0; i < 25; i++)
        {
            xd->block[i].eob = 0;
            xd->eobs[i] = 0;
        }
Paul Wilkins's avatar
Paul Wilkins committed
189
190
        if ( tx_type == TX_8X8 )
        {
191
            eobtotal = vp8_decode_mb_tokens_8x8(pbi, xd);
Paul Wilkins's avatar
Paul Wilkins committed
192
        }
193
194
195
196
197
198
199
200
201
202
203
204
205
        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
206
207
    }

Gaute Strokkenes's avatar
Gaute Strokkenes committed
208
209
    mode = xd->mode_info_context->mbmi.mode;

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

220
221
222
        skip_recon_mb(pbi, xd);
        return;
    }
Yaowu Xu's avatar
Yaowu Xu committed
223

224
225
226
227
228
229
230
231
232
233
234
235
236
#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



237
238
239
    if (xd->segmentation_enabled)
        mb_init_dequantizer(pbi, xd);

240
    /* do prediction */
241
    if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
John Koleszar's avatar
John Koleszar committed
242
    {
Yaowu Xu's avatar
Yaowu Xu committed
243
244
        if(mode != I8X8_PRED)
        {
Yaowu Xu's avatar
Yaowu Xu committed
245
246
247
248
249
250
251
252
            RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_mbuv)(xd);
            if (mode != B_PRED)
            {
                RECON_INVOKE(&pbi->common.rtcd.recon,
                    build_intra_predictors_mby)(xd);
            } else {
                vp8_intra_prediction_down_copy(xd);
            }
Yaowu Xu's avatar
Yaowu Xu committed
253
        }
John Koleszar's avatar
John Koleszar committed
254
255
256
257
258
    }
    else
    {
        vp8_build_inter_predictors_mb(xd);
    }
259
260
261
262
263
264
265
    /* 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));

266
#if CONFIG_ERROR_CONCEALMENT
267
268
    if (pbi->ec_active &&
        (mb_idx >= pbi->mvs_corrupt_from_mb || throw_residual))
269
270
    {
        /* MB with corrupt residuals or corrupt mode/motion vectors.
Yaowu Xu's avatar
Yaowu Xu committed
271
272
         * Better to use the predictor as reconstruction.
         */
273
        pbi->frame_corrupt_residual = 1;
274
        vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff));
275
276
277
278
279
        vp8_conceal_corrupt_mb(xd);
        return;
    }
#endif

280
    /* dequantization and idct */
Yaowu Xu's avatar
Yaowu Xu committed
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
    if (mode == I8X8_PRED)
    {
        for (i = 0; i < 4; i++)
        {
            int ib = vp8_i8x8_block[i];
            const int iblock[4]={0,1,4,5};
            int j;
            int i8x8mode;
            BLOCKD *b;

            b = &xd->block[ib];
            i8x8mode= b->bmi.as_mode;
            RECON_INVOKE(RTCD_VTABLE(recon), intra8x8_predict)
                          (b, i8x8mode, b->predictor);

            for(j = 0; j < 4; j++)
            {
                b = &xd->block[ib+iblock[j]];
                if (xd->eobs[ib+iblock[j]] > 1)
                {
                    DEQUANT_INVOKE(&pbi->dequant, idct_add)
                        (b->qcoeff, b->dequant,  b->predictor,
                        *(b->base_dst) + b->dst, 16, b->dst_stride);
                }
                else
                {
                    IDCT_INVOKE(RTCD_VTABLE(idct), idct1_scalar_add)
                        (b->qcoeff[0] * b->dequant[0], b->predictor,
                        *(b->base_dst) + b->dst, 16, b->dst_stride);
                    ((int *)b->qcoeff)[0] = 0;
                }
            }

            b = &xd->block[16+i];
            RECON_INVOKE(RTCD_VTABLE(recon), intra_uv4x4_predict)
                          (b, i8x8mode, b->predictor);
            DEQUANT_INVOKE(&pbi->dequant, idct_add)
                (b->qcoeff, b->dequant,  b->predictor,
                *(b->base_dst) + b->dst, 8, b->dst_stride);
            b = &xd->block[20+i];
            RECON_INVOKE(RTCD_VTABLE(recon), intra_uv4x4_predict)
                          (b, i8x8mode, b->predictor);
            DEQUANT_INVOKE(&pbi->dequant, idct_add)
                (b->qcoeff, b->dequant,  b->predictor,
                *(b->base_dst) + b->dst, 8, b->dst_stride);
        }
    }
Yaowu Xu's avatar
Yaowu Xu committed
328
    else if (mode == B_PRED)
John Koleszar's avatar
John Koleszar committed
329
    {
330
        for (i = 0; i < 16; i++)
John Koleszar's avatar
John Koleszar committed
331
        {
332
            BLOCKD *b = &xd->block[i];
333
334
            int b_mode = xd->mode_info_context->bmi[i].as_mode;

335
            RECON_INVOKE(RTCD_VTABLE(recon), intra4x4_predict)
336
                          (b, b_mode, b->predictor);
John Koleszar's avatar
John Koleszar committed
337

Fritz Koenig's avatar
Fritz Koenig committed
338
            if (xd->eobs[i] > 1)
John Koleszar's avatar
John Koleszar committed
339
            {
Fritz Koenig's avatar
Fritz Koenig committed
340
                DEQUANT_INVOKE(&pbi->dequant, idct_add)
341
                    (b->qcoeff, b->dequant,  b->predictor,
Fritz Koenig's avatar
Fritz Koenig committed
342
                    *(b->base_dst) + b->dst, 16, b->dst_stride);
John Koleszar's avatar
John Koleszar committed
343
344
345
            }
            else
            {
Fritz Koenig's avatar
Fritz Koenig committed
346
                IDCT_INVOKE(RTCD_VTABLE(idct), idct1_scalar_add)
347
                    (b->qcoeff[0] * b->dequant[0], b->predictor,
Fritz Koenig's avatar
Fritz Koenig committed
348
                    *(b->base_dst) + b->dst, 16, b->dst_stride);
John Koleszar's avatar
John Koleszar committed
349
350
351
352
                ((int *)b->qcoeff)[0] = 0;
            }
        }
    }
Gaute Strokkenes's avatar
Gaute Strokkenes committed
353
    else if (mode == SPLITMV)
John Koleszar's avatar
John Koleszar committed
354
    {
355
356
357
358
        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
359
    }
Gaute Strokkenes's avatar
Gaute Strokkenes committed
360
361
362
363
    else
    {
        BLOCKD *b = &xd->block[24];

364
#if CONFIG_T8X8
Paul Wilkins's avatar
Paul Wilkins committed
365
        if( tx_type == TX_8X8 )
Gaute Strokkenes's avatar
Gaute Strokkenes committed
366
        {
Yaowu Xu's avatar
Yaowu Xu committed
367
            DEQUANT_INVOKE(&pbi->dequant, block_2x2)(b);
368
369
370
371
372
373
374
375
376
377
378
379
380
#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
381
382
383
384
385
386
387
            ((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;
388
389
390
391
392
            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
393
        }
394

Gaute Strokkenes's avatar
Gaute Strokkenes committed
395
        else
396
#endif
Yaowu Xu's avatar
Yaowu Xu committed
397
        {
398
            DEQUANT_INVOKE(&pbi->dequant, block)(b);
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
            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);
Yaowu Xu's avatar
Yaowu Xu committed
421
        }
422
423
    }
#if CONFIG_T8X8
Paul Wilkins's avatar
Paul Wilkins committed
424
    if( tx_type == TX_8X8 )
425
426
427
428
429
430
431
432
433
    {
        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
Yaowu Xu's avatar
Yaowu Xu committed
434
    if(xd->mode_info_context->mbmi.mode!=I8X8_PRED)
Yaowu Xu's avatar
Yaowu Xu committed
435
436
437
438
        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
439

Yaowu Xu's avatar
Yaowu Xu committed
440
}
John Koleszar's avatar
John Koleszar committed
441

442

John Koleszar's avatar
John Koleszar committed
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
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



469
470
static void
decode_mb_row(VP8D_COMP *pbi, VP8_COMMON *pc, int mb_row, MACROBLOCKD *xd)
John Koleszar's avatar
John Koleszar committed
471
472
473
{
    int recon_yoffset, recon_uvoffset;
    int mb_col;
474
475
476
477
    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
478

479
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
John Koleszar's avatar
John Koleszar committed
480
481
    recon_yoffset = mb_row * recon_y_stride * 16;
    recon_uvoffset = mb_row * recon_uv_stride * 8;
482
    /* reset above block coeffs */
John Koleszar's avatar
John Koleszar committed
483

484
    xd->above_context = pc->above_context;
John Koleszar's avatar
John Koleszar committed
485
486
487
488
489
490
491
    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++)
    {
492
493
494
495
496
497
498
499
500
        /* 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
        {
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
            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);
            }
522
523
        }
#endif
John Koleszar's avatar
John Koleszar committed
524

Yaowu Xu's avatar
Yaowu Xu committed
525
        update_blockd_bmi(xd);
Yaowu Xu's avatar
Yaowu Xu committed
526

527
528
529
        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
530
531
532

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

533
        /* Select the appropriate reference frame for this MB */
534
        if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
535
            ref_fb_idx = pc->lst_fb_idx;
536
        else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
537
            ref_fb_idx = pc->gld_fb_idx;
John Koleszar's avatar
John Koleszar committed
538
        else
539
540
541
542
543
            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
544

545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
#if CONFIG_DUALPRED
        if (xd->mode_info_context->mbmi.second_ref_frame)
        {
            int second_ref_fb_idx;

            /* Select the appropriate reference frame for this MB */
            if (xd->mode_info_context->mbmi.second_ref_frame == LAST_FRAME)
                second_ref_fb_idx = pc->lst_fb_idx;
            else if (xd->mode_info_context->mbmi.second_ref_frame == GOLDEN_FRAME)
                second_ref_fb_idx = pc->gld_fb_idx;
            else
                second_ref_fb_idx = pc->alt_fb_idx;

            xd->second_pre.y_buffer = pc->yv12_fb[second_ref_fb_idx].y_buffer + recon_yoffset;
            xd->second_pre.u_buffer = pc->yv12_fb[second_ref_fb_idx].u_buffer + recon_uvoffset;
            xd->second_pre.v_buffer = pc->yv12_fb[second_ref_fb_idx].v_buffer + recon_uvoffset;
        }
#endif /* CONFIG_DUALPRED */

564
565
566
567
568
569
        if (xd->mode_info_context->mbmi.ref_frame != INTRA_FRAME)
        {
            /* propagate errors from reference frames */
            xd->corrupted |= pc->yv12_fb[ref_fb_idx].corrupted;
        }

570
#ifdef DEC_DEBUG
571
        dec_debug = (pc->current_video_frame==1 && mb_row==4 && mb_col==0);
572
#endif
573
        decode_macroblock(pbi, xd, mb_row * pc->mb_cols  + mb_col);
John Koleszar's avatar
John Koleszar committed
574

575
576
        /* check if the boolean decoder has suffered an error */
        xd->corrupted |= vp8dx_bool_error(xd->current_bc);
John Koleszar's avatar
John Koleszar committed
577
578
579
580
581
        recon_yoffset += 16;
        recon_uvoffset += 8;

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

582
        xd->above_context++;
John Koleszar's avatar
John Koleszar committed
583
584
585

    }

586
    /* adjust to the next row of mbs */
John Koleszar's avatar
John Koleszar committed
587
    vp8_extend_mb_row(
588
        &pc->yv12_fb[dst_fb_idx],
John Koleszar's avatar
John Koleszar committed
589
590
591
592
593
594
595
596
597
598
599
600
601
602
        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;
}

603
604
605
606
static void setup_token_decoder_partition_input(VP8D_COMP *pbi)
{
    vp8_reader *bool_decoder = &pbi->bc2;
    int part_idx = 1;
607
    int num_token_partitions;
608
609
610

    TOKEN_PARTITION multi_token_partition =
            (TOKEN_PARTITION)vp8_read_literal(&pbi->bc, 2);
611
612
613
614
615
616
    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");
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
    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
644

645
646
647
648
649
650
651
652
653

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
654
655
656
657
658
659
660
661
662
663
664
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 */
665
666
667
668
    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. */
669
    if (!pbi->ec_active || !vp8dx_bool_error(&pbi->bc))
670
671
        pc->multi_token_partition = multi_token_partition;

John Koleszar's avatar
John Koleszar committed
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
    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;
688
689
690
        ptrdiff_t            partition_size, bytes_left;

        bytes_left = user_data_end - partition;
John Koleszar's avatar
John Koleszar committed
691
692

        /* Calculate the length of this partition. The last partition
693
694
695
         * 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
696
697
698
         */
        if (i < num_part - 1)
        {
699
700
            if (read_is_valid(partition_size_ptr, 3, user_data_end))
                partition_size = read_partition_size(partition_size_ptr);
701
            else if (pbi->ec_active)
702
703
704
705
                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
706
707
        }
        else
708
709
710
711
712
713
714
            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
715
        {
716
            if (pbi->ec_active)
717
718
719
720
721
                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
722
723
        }

Johann's avatar
Johann committed
724
        if (vp8dx_start_decode(bool_decoder, partition, partition_size))
John Koleszar's avatar
John Koleszar committed
725
726
727
728
729
730
731
732
            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++;
    }

733
#if CONFIG_MULTITHREAD
John Koleszar's avatar
John Koleszar committed
734
735
736
    /* Clamp number of decoder threads */
    if (pbi->decoding_thread_count > num_part - 1)
        pbi->decoding_thread_count = num_part - 1;
737
#endif
John Koleszar's avatar
John Koleszar committed
738
739
740
741
742
743
744
745
}


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
746
    {
John Koleszar's avatar
John Koleszar committed
747
        vpx_free(pbi->mbc);
James Zern's avatar
James Zern committed
748
749
        pbi->mbc = NULL;
    }
John Koleszar's avatar
John Koleszar committed
750
751
752
753
754
755
756
757
758
}

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

    if (pc->frame_type == KEY_FRAME)
    {
759
        /* Various keyframe initializations */
John Koleszar's avatar
John Koleszar committed
760
761
762
763
764
765
766
        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
767
768
        // Reset the segment feature data to the default stats:
        // Features disabled, 0, with delta coding (Default state).
769
//#if CONFIG_SEGFEATURES
Paul Wilkins's avatar
Paul Wilkins committed
770
        clearall_segfeatures( xd );
Paul Wilkins's avatar
Paul Wilkins committed
771

John Koleszar's avatar
John Koleszar committed
772
773
        xd->mb_segement_abs_delta = SEGMENT_DELTADATA;

774
        /* reset the mode ref deltasa for loop filter */
John Koleszar's avatar
John Koleszar committed
775
776
777
        vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
        vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));

778
        /* All buffers are implicitly updated on key frames. */
John Koleszar's avatar
John Koleszar committed
779
780
781
782
783
        pc->refresh_golden_frame = 1;
        pc->refresh_alt_ref_frame = 1;
        pc->copy_buffer_to_gf = 0;
        pc->copy_buffer_to_arf = 0;

784
785
786
        /* 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
787
788
        pc->ref_frame_sign_bias[GOLDEN_FRAME] = 0;
        pc->ref_frame_sign_bias[ALTREF_FRAME] = 0;
789
790
791

        vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc));
        vpx_memcpy(&pc->lfc_a, &pc->fc, sizeof(pc->fc));
Yaowu Xu's avatar
Yaowu Xu committed
792

Yaowu Xu's avatar
Yaowu Xu committed
793
#if CONFIG_NEWNEAR
794
795
796
797
798
799
800
801
802
803
        vp8_init_mode_contexts(&pbi->common);
        vpx_memcpy( pbi->common.vp8_mode_contexts,
                    pbi->common.mode_context,
                    sizeof(pbi->common.mode_context));

#else
        vpx_memcpy( pbi->common.vp8_mode_contexts,
                    default_vp8_mode_contexts,
                    sizeof(default_vp8_mode_contexts));
#endif /* CONFIG_NEWNEAR */
John Koleszar's avatar
John Koleszar committed
804
805
806
    }
    else
    {
807

John Koleszar's avatar
John Koleszar committed
808
809
810
811
812
        if (!pc->use_bilinear_mc_filter)
            pc->mcomp_filter_type = SIXTAP;
        else
            pc->mcomp_filter_type = BILINEAR;

813
        /* To enable choice of different interploation filters */
John Koleszar's avatar
John Koleszar committed
814
815
816
817
818
819
        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);
820
821
822
823
#if CONFIG_DUALPRED
            xd->subpixel_predict_avg8x8 = SUBPIX_INVOKE(RTCD_VTABLE(subpix), sixtap_avg8x8);
            xd->subpixel_predict_avg16x16 = SUBPIX_INVOKE(RTCD_VTABLE(subpix), sixtap_avg16x16);
#endif /* CONFIG_DUALPRED */
John Koleszar's avatar
John Koleszar committed
824
825
826
827
828
829
830
        }
        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);
831
832
833
834
#if CONFIG_DUALPRED
            xd->subpixel_predict_avg8x8 = SUBPIX_INVOKE(RTCD_VTABLE(subpix), bilinear_avg8x8);
            xd->subpixel_predict_avg16x16 = SUBPIX_INVOKE(RTCD_VTABLE(subpix), bilinear_avg16x16);
#endif /* CONFIG_DUALPRED */
John Koleszar's avatar
John Koleszar committed
835
        }
836
837
838

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

841
    xd->left_context = &pc->left_context;
John Koleszar's avatar
John Koleszar committed
842
843
    xd->mode_info_context = pc->mi;
    xd->frame_type = pc->frame_type;
844
    xd->mode_info_context->mbmi.mode = DC_PRED;
John Koleszar's avatar
John Koleszar committed
845
    xd->mode_info_stride = pc->mode_info_stride;
846
    xd->corrupted = 0; /* init without corruption */
847
848
849
850
851

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

John Koleszar's avatar
John Koleszar committed
852
853
854
855
856
857
858
859
}

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

John Koleszar's avatar
John Koleszar committed
863
864
    int mb_row;
    int i, j, k, l;
865
866
    int corrupt_tokens = 0;
    int prev_independent_partitions = pbi->independent_partitions;
John Koleszar's avatar
John Koleszar committed
867

868
869
870
871
872
873
    if (pbi->input_partition)
    {
        data = pbi->partitions[0];
        data_end =  data + pbi->partition_sizes[0];
    }

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

878
    if (data_end - data < 3)
John Koleszar's avatar
John Koleszar committed
879
    {
880
        if (pbi->ec_active)
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
        {
            /* 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
903

904
        if (!pbi->ec_active && (data + first_partition_length_in_bytes > data_end
905
906
907
            || data + first_partition_length_in_bytes < data))
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated packet or corrupt partition 0 length");
908
909
910

        data += 3;

911
        vp8_setup_version(pc);
John Koleszar's avatar
John Koleszar committed
912

913
        if (pc->frame_type == KEY_FRAME)
John Koleszar's avatar
John Koleszar committed
914
        {
915
916
917
918
919
920
921
            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
             */
922
            if (!pbi->ec_active || data + 3 < data_end)
John Koleszar's avatar
John Koleszar committed
923
            {
924
925
926
                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
927
928
            }

929
930
931
932
            /* 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.
             */
933
            if (!pbi->ec_active || data + 6 < data_end)
John Koleszar's avatar
John Koleszar committed
934
            {
935
936
937
938
                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
939
            }
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
            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
959

960
961
962
963
964
965
966
967
968
969
970
971
972
973
                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
974
975

#if CONFIG_MULTITHREAD
976
977
                if (pbi->b_multithreaded_rd)
                    vp8mt_alloc_temp_buffers(pbi, pc->Width, prev_mb_rows);
978
#endif
979
            }
John Koleszar's avatar
John Koleszar committed
980
981
982
        }
    }

983
984
    if ((!pbi->decoded_key_frame && pc->frame_type != KEY_FRAME) ||
        pc->Width == 0 || pc->Height == 0)
John Koleszar's avatar
John Koleszar committed
985
986
987
988
989
990
    {
        return -1;
    }

    init_frame(pbi);

Johann's avatar
Johann committed
991
    if (vp8dx_start_decode(bc, data, data_end - data))
John Koleszar's avatar
John Koleszar committed
992
993
994
995
996
997
998
        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);
    }

999
    /* Is segmentation enabled */
John Koleszar's avatar
John Koleszar committed
1000
1001
1002
    xd->segmentation_enabled = (unsigned char)vp8_read_bit(bc);
    if (xd->segmentation_enabled)
    {
Paul Wilkins's avatar
Paul Wilkins committed
1003
1004
        // Read whether or not the segmentation map is being explicitly
        // updated this frame.
John Koleszar's avatar
John Koleszar committed
1005
        xd->update_mb_segmentation_map = (unsigned char)vp8_read_bit(bc);
Paul Wilkins's avatar
Paul Wilkins committed
1006
1007
1008

        // If so what method will be used.
        if ( xd->update_mb_segmentation_map )
1009
            pc->temporal_update = (unsigned char)vp8_read_bit(bc);
Paul Wilkins's avatar
Paul Wilkins committed
1010
1011

        // Is the segment data being updated
John Koleszar's avatar
John Koleszar committed
1012
1013
1014
1015
        xd->update_mb_segmentation_data = (unsigned char)vp8_read_bit(bc);

        if (xd->update_mb_segmentation_data)
        {
1016
1017
            int data;

John Koleszar's avatar
John Koleszar committed
1018
1019
            xd->mb_segement_abs_delta = (unsigned char)vp8_read_bit(bc);

1020
//#if CONFIG_SEGFEATURES
Paul Wilkins's avatar
Paul Wilkins committed
1021
            clearall_segfeatures( xd );
Paul Wilkins's avatar
Paul Wilkins committed
1022

1023
            // For each segmentation...
1024
            for (i = 0; i < MAX_MB_SEGMENTS; i++)
1025
1026
            {
                // For each of the segments features...
1027
                for (j = 0; j < SEG_LVL_MAX; j++)
John Koleszar's avatar
John Koleszar committed
1028
                {
Paul Wilkins's avatar
Paul Wilkins committed
1029
                    // Is the feature enabled
John Koleszar's avatar
John Koleszar committed
1030
1031
                    if (vp8_read_bit(bc))
                    {
1032
//#if CONFIG_SEGFEATURES
Paul Wilkins's avatar
Paul Wilkins committed
1033
                        // Update the feature data and mask
1034
                        enable_segfeature(xd, i, j);
John Koleszar's avatar
John Koleszar committed
1035

1036
1037
1038
1039
                        data = (signed char)vp8_read_literal(
                                            bc, seg_feature_data_bits(j));

//#if CONFIG_SEGFEATURES
Paul Wilkins's avatar
Paul Wilkins committed
1040
                        // Is the segment data signed..
1041
                        if ( is_segfeature_signed(j) )
Paul Wilkins's avatar
Paul Wilkins committed
1042
1043
                        {
                            if (vp8_read_bit(bc))
1044
                                data = - data;
Paul Wilkins's avatar
Paul Wilkins committed
1045
                        }
John Koleszar's avatar
John Koleszar committed
1046
1047
                    }
                    else
1048
1049
1050
                        data = 0;

                    set_segdata(xd, i, j, data);
John Koleszar's avatar
John Koleszar committed
1051
1052
1053
1054
1055
1056
                }
            }
        }

        if (xd->update_mb_segmentation_map)
        {
1057
            // Which macro block level features are enabled
1058
1059
            vpx_memset(xd->mb_segment_tree_probs, 255,
                       sizeof(xd->mb_segment_tree_probs));
1060
1061
            vpx_memset(pc->segment_pred_probs, 255,
                       sizeof(pc->segment_pred_probs));
1062
1063
1064

            // Read the probs used to decode the segment id for each macro
            // block.
John Koleszar's avatar
John Koleszar committed
1065
1066
            for (i = 0; i < MB_FEATURE_TREE_PROBS; i++)
            {
1067
1068
                // If not explicitly set value is defaulted to 255 by
                //memset above
John Koleszar's avatar
John Koleszar committed
1069
                if (vp8_read_bit(bc))
1070
1071
                    xd->mb_segment_tree_probs[i] =
                        (vp8_prob)vp8_read_literal(bc, 8);
John Koleszar's avatar
John Koleszar committed
1072
            }
1073

1074
1075
            // If predictive coding of segment map is enabled read the
            // prediction probabilities.
1076
            if ( pc->temporal_update )
1077
1078
1079
            {
                // Read the prediction probs needed to decode the segment id
                // when predictive coding enabled
1080
                for (i = 0; i < PREDICTION_PROBS; i++)
1081
1082
1083
1084
                {
                    // If not explicitly set value is defaulted to 255 by
                    // memset above
                    if (vp8_read_bit(bc))
1085
                        pc->segment_pred_probs[i] =
1086
1087
1088
                            (vp8_prob)vp8_read_literal(bc, 8);
                }
            }
John Koleszar's avatar
John Koleszar committed
1089
1090
1091
        }
    }

1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
#if CONFIG_COMPRED
    // Read common prediction model status flag probability updates for the
    // reference frame
    if ( pc->frame_type == KEY_FRAME )
    {
        // Set the prediction probabilities to defaults
        pc->ref_pred_probs[0] = 120;
        pc->ref_pred_probs[1] = 80;
        pc->ref_pred_probs[2] = 40;
    }
    else
    {
        for (i = 0; i < PREDICTION_PROBS; i++)
        {
            if ( vp8_read_bit(bc) )
                pc->ref_pred_probs[i] = (vp8_prob)vp8_read_literal(bc, 8);
        }
    }
#endif

1112
    /* Read the loop filter level and type */
John Koleszar's avatar
John Koleszar committed
1113
1114
1115
1116
    pc->filter_type = (LOOPFILTERTYPE) vp8_read_bit(bc);
    pc->filter_level = vp8_read_literal(bc, 6);
    pc->sharpness_level = vp8_read_literal(bc, 3);

1117
    /* Read in loop filter deltas applied at the MB level based on mode or ref frame. */
John Koleszar's avatar
John Koleszar committed
1118
1119
1120
1121
1122
    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)
    {
1123
        /* Do the deltas need to be updated */
John Koleszar's avatar
John Koleszar committed
1124
1125
1126
1127
        xd->mode_ref_lf_delta_update = (unsigned char)vp8_read_bit(bc);

        if (xd->mode_ref_lf_delta_update)
        {
1128
            /* Send update */
John Koleszar's avatar
John Koleszar committed
1129
1130
1131
1132
            for (i = 0; i < MAX_REF_LF_DELTAS; i++)
            {
                if (vp8_read_bit(bc))
                {
1133
                    /*sign = vp8_read_bit( bc );*/
John Koleszar's avatar
John Koleszar committed
1134
1135
                    xd->ref_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);

1136
                    if (vp8_read_bit(bc))        /* Apply sign */
John Koleszar's avatar
John Koleszar committed
1137
1138
1139
1140
                        xd->ref_lf_deltas[i] = xd->ref_lf_deltas[i] * -1;
                }
            }

1141
            /* Send update */
John Koleszar's avatar
John Koleszar committed
1142
1143
1144
1145
            for (i = 0; i < MAX_MODE_LF_DELTAS; i++)
            {
                if (vp8_read_bit(bc))
                {
1146
                    /*sign = vp8_read_bit( bc );*/
John Koleszar's avatar
John Koleszar committed
1147
1148
                    xd->mode_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);

1149
                    if (vp8_read_bit(bc))        /* Apply sign */
John Koleszar's avatar
John Koleszar committed
1150
1151
1152
1153
1154
1155
                        xd->mode_lf_deltas[i] = xd->mode_lf_deltas[i] * -1;
                }
            }
        }
    }

1156
1157
1158
1159
1160
1161
1162
1163
    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
1164
1165
    xd->current_bc = &pbi->bc2;

1166
    /* Read the default quantizers. */
John Koleszar's avatar
John Koleszar committed
1167
1168
1169
    {
        int Q, q_update;

Paul Wilkins's avatar
Paul Wilkins committed
1170
        Q = vp8_read_literal(bc, QINDEX_BITS);  /* AC 1st order Q = default */
John Koleszar's avatar
John Koleszar committed
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
        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);

1182
        /* MB level dequantizer setup */
John Koleszar's avatar
John Koleszar committed
1183
1184
1185
        mb_init_dequantizer(pbi, &pbi->mb);
    }

1186
1187
1188
1189
    /* 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
1190
1191
    if (pc->frame_type != KEY_FRAME)
    {
1192
        /* Should the GF or ARF be updated from the current frame */
John Koleszar's avatar
John Koleszar committed
1193
        pc->refresh_golden_frame = vp8_read_bit(bc);
1194
1195
1196
#if CONFIG_ERROR_CONCEALMENT
        /* Assume we shouldn't refresh golden if the bit is missing */
        xd->corrupted |= vp8dx_bool_error(bc);
1197
        if (pbi->ec_active && xd->corrupted)
1198
1199
1200
            pc->refresh_golden_frame = 0;
#endif

John Koleszar's avatar
John Koleszar committed
1201
        pc->refresh_alt_ref_frame = vp8_read_bit(bc);
1202
1203
1204
#if CONFIG_ERROR_CONCEALMENT
        /* Assume we shouldn't refresh altref if the bit is missing */
        xd->corrupted |= vp8dx_bool_error(bc);
1205
        if (pbi->ec_active && xd->corrupted)
1206
1207
            pc->refresh_alt_ref_frame = 0;
#endif
John Koleszar's avatar
John Koleszar committed
1208

1209
        if(pc->refresh_alt_ref_frame)
1210
        {
1211
            vpx_memcpy(&pc->fc, &pc->lfc_a, sizeof(pc->fc));
1212
1213
1214
1215
1216
1217
#if CONFIG_NEWNEAR
            vpx_memcpy( pc->vp8_mode_contexts,
                        pc->mode_context_a,
                        sizeof(pc->vp8_mode_contexts));
#endif
        }
1218
        else
1219
        {
1220
            vpx_memcpy(&pc->fc, &pc->lfc, sizeof(pc->fc));