decodframe.c 38.7 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
 */


John Koleszar's avatar
John Koleszar committed
12
13
#include "vpx_config.h"
#include "vpx_rtcd.h"
John Koleszar's avatar
John Koleszar committed
14
#include "onyxd_int.h"
John Koleszar's avatar
John Koleszar committed
15
16
17
#include "vp8/common/header.h"
#include "vp8/common/reconintra4x4.h"
#include "vp8/common/reconinter.h"
John Koleszar's avatar
John Koleszar committed
18
#include "detokenize.h"
John Koleszar's avatar
John Koleszar committed
19
20
21
22
#include "vp8/common/invtrans.h"
#include "vp8/common/alloccommon.h"
#include "vp8/common/entropymode.h"
#include "vp8/common/quant_common.h"
23
24
#include "vpx_scale/vpxscale.h"
#include "vpx_scale/yv12extend.h"
John Koleszar's avatar
John Koleszar committed
25
#include "vp8/common/setupintrarecon.h"
Scott LaVarnway's avatar
Scott LaVarnway committed
26

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

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

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

    for (Q = 0; Q < QINDEX_RANGE; Q++)
    {
47
48
49
        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
50

51
52
53
        pc->Y1dequant[Q][1] = (short)vp8_ac_yquant(Q);
        pc->Y2dequant[Q][1] = (short)vp8_ac2quant(Q, pc->y2ac_delta_q);
        pc->UVdequant[Q][1] = (short)vp8_ac_uv_quant(Q, pc->uvac_delta_q);
John Koleszar's avatar
John Koleszar committed
54
55
56
    }
}

57
void mb_init_dequantizer(VP8D_COMP *pbi, MACROBLOCKD *xd)
John Koleszar's avatar
John Koleszar committed
58
59
60
61
62
63
{
    int i;
    int QIndex;
    MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
    VP8_COMMON *const pc = & pbi->common;

64
    /* Decide whether to use the default or alternate baseline Q value. */
John Koleszar's avatar
John Koleszar committed
65
66
    if (xd->segmentation_enabled)
    {
67
        /* Abs Value */
John Koleszar's avatar
John Koleszar committed
68
69
70
        if (xd->mb_segement_abs_delta == SEGMENT_ABSDATA)
            QIndex = xd->segment_feature_data[MB_LVL_ALT_Q][mbmi->segment_id];

71
        /* Delta Value */
John Koleszar's avatar
John Koleszar committed
72
73
74
        else
        {
            QIndex = pc->base_qindex + xd->segment_feature_data[MB_LVL_ALT_Q][mbmi->segment_id];
75
            QIndex = (QIndex >= 0) ? ((QIndex <= MAXQ) ? QIndex : MAXQ) : 0;    /* Clamp to valid range */
John Koleszar's avatar
John Koleszar committed
76
77
78
79
80
        }
    }
    else
        QIndex = pc->base_qindex;

81
82
83
84
85
    /* Set up the macroblock dequant constants */
    xd->dequant_y1_dc[0] = 1;
    xd->dequant_y1[0] = pc->Y1dequant[QIndex][0];
    xd->dequant_y2[0] = pc->Y2dequant[QIndex][0];
    xd->dequant_uv[0] = pc->UVdequant[QIndex][0];
John Koleszar's avatar
John Koleszar committed
86

87
    for (i = 1; i < 16; i++)
John Koleszar's avatar
John Koleszar committed
88
    {
89
90
91
92
        xd->dequant_y1_dc[i] =
        xd->dequant_y1[i] = pc->Y1dequant[QIndex][1];
        xd->dequant_y2[i] = pc->Y2dequant[QIndex][1];
        xd->dequant_uv[i] = pc->UVdequant[QIndex][1];
John Koleszar's avatar
John Koleszar committed
93
94
95
96
    }
}


97
98
static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
                              unsigned int mb_idx)
John Koleszar's avatar
John Koleszar committed
99
{
Gaute Strokkenes's avatar
Gaute Strokkenes committed
100
101
    MB_PREDICTION_MODE mode;
    int i;
Scott LaVarnway's avatar
Scott LaVarnway committed
102
    int corruption_detected = 0;
103

104
    if (xd->mode_info_context->mbmi.mb_skip_coeff)
105
106
107
    {
        vp8_reset_mb_tokens_context(xd);
    }
108
    else if (!vp8dx_bool_error(xd->current_bc))
109
    {
Scott LaVarnway's avatar
Scott LaVarnway committed
110
        int eobtotal;
111
        eobtotal = vp8_decode_mb_tokens(pbi, xd);
Scott LaVarnway's avatar
Scott LaVarnway committed
112
113
114

        /* Special case:  Force the loopfilter to skip when eobtotal is zero */
        xd->mode_info_context->mbmi.mb_skip_coeff = (eobtotal==0);
115
116
    }

Scott LaVarnway's avatar
Scott LaVarnway committed
117
118
119
120
    mode = xd->mode_info_context->mbmi.mode;

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

122

Scott LaVarnway's avatar
Scott LaVarnway committed
123
#if CONFIG_ERROR_CONCEALMENT
Gaute Strokkenes's avatar
Gaute Strokkenes committed
124

Scott LaVarnway's avatar
Scott LaVarnway committed
125
    if(pbi->ec_active)
126
    {
Scott LaVarnway's avatar
Scott LaVarnway committed
127
128
129
130
131
132
133
        int throw_residual;
        /* 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));
Scott LaVarnway's avatar
Scott LaVarnway committed
134

Scott LaVarnway's avatar
Scott LaVarnway committed
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
        if ((mb_idx >= pbi->mvs_corrupt_from_mb || throw_residual))
        {
            /* MB with corrupt residuals or corrupt mode/motion vectors.
             * Better to use the predictor as reconstruction.
             */
            pbi->frame_corrupt_residual = 1;
            vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff));
            vp8_conceal_corrupt_mb(xd);


            corruption_detected = 1;

            /* force idct to be skipped for B_PRED and use the
             * prediction only for reconstruction
             * */
            vpx_memset(xd->eobs, 0, 25);
        }
152
    }
Scott LaVarnway's avatar
Scott LaVarnway committed
153
#endif
154
155


156
    /* do prediction */
157
    if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
John Koleszar's avatar
John Koleszar committed
158
    {
159
160
161
162
163
164
165
        vp8_build_intra_predictors_mbuv_s(xd,
                                          xd->dst.u_buffer - xd->dst.uv_stride,
                                          xd->dst.v_buffer - xd->dst.uv_stride,
                                          xd->dst.u_buffer - 1,
                                          xd->dst.v_buffer - 1,
                                          xd->dst.uv_stride,
                                          xd->dst.u_buffer, xd->dst.v_buffer);
John Koleszar's avatar
John Koleszar committed
166

Gaute Strokkenes's avatar
Gaute Strokkenes committed
167
        if (mode != B_PRED)
John Koleszar's avatar
John Koleszar committed
168
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
169
170
171
172
173
            vp8_build_intra_predictors_mby_s(xd,
                                                 xd->dst.y_buffer - xd->dst.y_stride,
                                                 xd->dst.y_buffer - 1,
                                                 xd->dst.y_stride,
                                                 xd->dst.y_buffer);
Scott LaVarnway's avatar
Scott LaVarnway committed
174
175
176
        }
        else
        {
177
            short *DQC = xd->dequant_y1;
Scott LaVarnway's avatar
Scott LaVarnway committed
178
179
            int dst_stride = xd->dst.y_stride;
            unsigned char *base_dst = xd->dst.y_buffer;
180

Scott LaVarnway's avatar
Scott LaVarnway committed
181
182
183
184
            /* clear out residual eob info */
            if(xd->mode_info_context->mbmi.mb_skip_coeff)
                vpx_memset(xd->eobs, 0, 25);

Scott LaVarnway's avatar
Scott LaVarnway committed
185
            intra_prediction_down_copy(xd, xd->dst.y_buffer - dst_stride + 16);
Scott LaVarnway's avatar
Scott LaVarnway committed
186
187
188
189
190

            for (i = 0; i < 16; i++)
            {
                BLOCKD *b = &xd->block[i];
                int b_mode = xd->mode_info_context->bmi[i].as_mode;
Scott LaVarnway's avatar
Scott LaVarnway committed
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
                unsigned char *yabove;
                unsigned char *yleft;
                int left_stride;
                unsigned char top_left;

                yabove = base_dst + b->offset - dst_stride;
                yleft = base_dst + b->offset - 1;
                left_stride = dst_stride;
                top_left = yabove[-1];

                //                vp8_intra4x4_predict (base_dst + b->offset, dst_stride, b_mode,
                  //                                    base_dst + b->offset, dst_stride );
                vp8_intra4x4_predict_d_c(yabove, yleft, left_stride,
                                       b_mode,
                                       base_dst + b->offset, dst_stride,
                                       top_left);
Scott LaVarnway's avatar
Scott LaVarnway committed
207
208
209
210
211

                if (xd->eobs[i])
                {
                    if (xd->eobs[i] > 1)
                    {
John Koleszar's avatar
John Koleszar committed
212
                    vp8_dequant_idct_add
213
                            (b->qcoeff, DQC,
Scott LaVarnway's avatar
Scott LaVarnway committed
214
                                base_dst + b->offset, dst_stride);
Scott LaVarnway's avatar
Scott LaVarnway committed
215
216
217
                    }
                    else
                    {
218
                        vp8_dc_only_idct_add
219
                            (b->qcoeff[0] * DQC[0],
Scott LaVarnway's avatar
Scott LaVarnway committed
220
221
                                base_dst + b->offset, dst_stride,
                                base_dst + b->offset, dst_stride);
Scott LaVarnway's avatar
Scott LaVarnway committed
222
223
224
225
                        ((int *)b->qcoeff)[0] = 0;
                    }
                }
            }
John Koleszar's avatar
John Koleszar committed
226
227
228
229
230
231
        }
    }
    else
    {
        vp8_build_inter_predictors_mb(xd);
    }
Scott LaVarnway's avatar
Scott LaVarnway committed
232

233

234
#if CONFIG_ERROR_CONCEALMENT
Scott LaVarnway's avatar
Scott LaVarnway committed
235
    if (corruption_detected)
236
237
238
239
240
    {
        return;
    }
#endif

Scott LaVarnway's avatar
Scott LaVarnway committed
241
    if(!xd->mode_info_context->mbmi.mb_skip_coeff)
242
    {
Scott LaVarnway's avatar
Scott LaVarnway committed
243
244
        /* dequantization and idct */
        if (mode != B_PRED)
John Koleszar's avatar
John Koleszar committed
245
        {
246
            short *DQC = xd->dequant_y1;
John Koleszar's avatar
John Koleszar committed
247

Scott LaVarnway's avatar
Scott LaVarnway committed
248
            if (mode != SPLITMV)
John Koleszar's avatar
John Koleszar committed
249
            {
Scott LaVarnway's avatar
Scott LaVarnway committed
250
251
252
253
                BLOCKD *b = &xd->block[24];

                /* do 2nd order transform on the dc block */
                if (xd->eobs[24] > 1)
254
                {
John Koleszar's avatar
John Koleszar committed
255
                    vp8_dequantize_b(b, xd->dequant_y2);
Scott LaVarnway's avatar
Scott LaVarnway committed
256

257
                    vp8_short_inv_walsh4x4(&b->dqcoeff[0],
Scott LaVarnway's avatar
Scott LaVarnway committed
258
259
260
261
262
263
264
265
266
                        xd->qcoeff);
                    ((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;
267
268
269
                }
                else
                {
270
                    b->dqcoeff[0] = b->qcoeff[0] * xd->dequant_y2[0];
271
                    vp8_short_inv_walsh4x4_1(&b->dqcoeff[0],
Scott LaVarnway's avatar
Scott LaVarnway committed
272
                        xd->qcoeff);
273
274
                    ((int *)b->qcoeff)[0] = 0;
                }
275

Scott LaVarnway's avatar
Scott LaVarnway committed
276
277
278
                /* override the dc dequant constant in order to preserve the
                 * dc components
                 */
279
                DQC = xd->dequant_y1_dc;
280
281
            }

John Koleszar's avatar
John Koleszar committed
282
            vp8_dequant_idct_add_y_block
283
                            (xd->qcoeff, DQC,
Scott LaVarnway's avatar
Scott LaVarnway committed
284
285
286
                             xd->dst.y_buffer,
                             xd->dst.y_stride, xd->eobs);
        }
287

John Koleszar's avatar
John Koleszar committed
288
        vp8_dequant_idct_add_uv_block
289
                        (xd->qcoeff+16*16, xd->dequant_uv,
Scott LaVarnway's avatar
Scott LaVarnway committed
290
291
                         xd->dst.u_buffer, xd->dst.v_buffer,
                         xd->dst.uv_stride, xd->eobs+16);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
292
    }
John Koleszar's avatar
John Koleszar committed
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
}

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



321
322
static void
decode_mb_row(VP8D_COMP *pbi, VP8_COMMON *pc, int mb_row, MACROBLOCKD *xd)
John Koleszar's avatar
John Koleszar committed
323
324
325
{
    int recon_yoffset, recon_uvoffset;
    int mb_col;
326
327
328
329
    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
330

331
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
John Koleszar's avatar
John Koleszar committed
332
333
    recon_yoffset = mb_row * recon_y_stride * 16;
    recon_uvoffset = mb_row * recon_uv_stride * 8;
334
    /* reset above block coeffs */
John Koleszar's avatar
John Koleszar committed
335

336
    xd->above_context = pc->above_context;
John Koleszar's avatar
John Koleszar committed
337
338
339
340
341
342
343
    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++)
    {
344
345
346
347
348
349
350
351
352
        /* 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
        {
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
            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);
            }
374
375
        }
#endif
John Koleszar's avatar
John Koleszar committed
376

377
378
379
        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
380
381
382

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

383
        /* Select the appropriate reference frame for this MB */
384
        if (xd->mode_info_context->mbmi.ref_frame == LAST_FRAME)
385
            ref_fb_idx = pc->lst_fb_idx;
386
        else if (xd->mode_info_context->mbmi.ref_frame == GOLDEN_FRAME)
387
            ref_fb_idx = pc->gld_fb_idx;
John Koleszar's avatar
John Koleszar committed
388
        else
389
390
391
392
393
            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
394

395
396
397
398
399
400
        if (xd->mode_info_context->mbmi.ref_frame != INTRA_FRAME)
        {
            /* propagate errors from reference frames */
            xd->corrupted |= pc->yv12_fb[ref_fb_idx].corrupted;
        }

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

403
404
        /* check if the boolean decoder has suffered an error */
        xd->corrupted |= vp8dx_bool_error(xd->current_bc);
John Koleszar's avatar
John Koleszar committed
405
406
407
408
409
410

        recon_yoffset += 16;
        recon_uvoffset += 8;

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

411
        xd->above_context++;
John Koleszar's avatar
John Koleszar committed
412
413
414

    }

415
    /* adjust to the next row of mbs */
John Koleszar's avatar
John Koleszar committed
416
    vp8_extend_mb_row(
417
        &pc->yv12_fb[dst_fb_idx],
John Koleszar's avatar
John Koleszar committed
418
419
420
421
422
423
424
425
426
427
428
429
430
431
        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;
}

432
433
434
static int read_is_valid(const unsigned char *start,
                         size_t               len,
                         const unsigned char *end)
435
{
436
437
    return (start + len > start && start + len <= end);
}
438

439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
static unsigned int read_available_partition_size(
                                       VP8D_COMP *pbi,
                                       const unsigned char *token_part_sizes,
                                       const unsigned char *fragment_start,
                                       const unsigned char *first_fragment_end,
                                       const unsigned char *fragment_end,
                                       int i,
                                       int num_part)
{
    VP8_COMMON* pc = &pbi->common;
    const unsigned char *partition_size_ptr = token_part_sizes + i * 3;
    unsigned int partition_size;
    ptrdiff_t bytes_left = fragment_end - fragment_start;
    /* Calculate the length of this partition. The last partition
     * 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.
     */
    if (i < num_part - 1)
458
    {
459
460
461
462
463
464
465
        if (read_is_valid(partition_size_ptr, 3, first_fragment_end))
            partition_size = read_partition_size(partition_size_ptr);
        else if (pbi->ec_active)
            partition_size = bytes_left;
        else
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated partition size data");
466
    }
467
468
    else
        partition_size = bytes_left;
469

470
471
472
473
474
    /* 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(fragment_start, partition_size, fragment_end))
475
    {
476
477
478
479
480
481
        if (pbi->ec_active)
            partition_size = bytes_left;
        else
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated packet or corrupt partition "
                               "%d length", i + 1);
482
    }
483
    return partition_size;
484
485
486
}


John Koleszar's avatar
John Koleszar committed
487
static void setup_token_decoder(VP8D_COMP *pbi,
488
                                const unsigned char* token_part_sizes)
John Koleszar's avatar
John Koleszar committed
489
{
490
    vp8_reader *bool_decoder = &pbi->bc2;
491
492
    unsigned int partition_idx;
    int fragment_idx;
493
494
495
    int num_token_partitions;
    const unsigned char *first_fragment_end = pbi->fragments[0] +
                                          pbi->fragment_sizes[0];
John Koleszar's avatar
John Koleszar committed
496

497
    TOKEN_PARTITION multi_token_partition =
498
            (TOKEN_PARTITION)vp8_read_literal(&pbi->bc, 2);
499
500
501
502
    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)
John Koleszar's avatar
John Koleszar committed
503
    {
504
505
        CHECK_MEM_ERROR(pbi->mbc, vpx_malloc(num_token_partitions *
                                             sizeof(vp8_reader)));
John Koleszar's avatar
John Koleszar committed
506
507
508
        bool_decoder = pbi->mbc;
    }

509
510
511
    /* Check for partitions within the fragments and unpack the fragments
     * so that each fragment pointer points to its corresponding partition. */
    for (fragment_idx = 0; fragment_idx < pbi->num_fragments; ++fragment_idx)
John Koleszar's avatar
John Koleszar committed
512
    {
513
514
515
516
517
518
        unsigned int fragment_size = pbi->fragment_sizes[fragment_idx];
        const unsigned char *fragment_end = pbi->fragments[fragment_idx] +
                                            fragment_size;
        /* Special case for handling the first partition since we have already
         * read its size. */
        if (fragment_idx == 0)
John Koleszar's avatar
John Koleszar committed
519
        {
520
521
522
523
524
525
526
527
528
529
530
531
532
            /* Size of first partition + token partition sizes element */
            ptrdiff_t ext_first_part_size = token_part_sizes -
                pbi->fragments[0] + 3 * (num_token_partitions - 1);
            fragment_size -= ext_first_part_size;
            if (fragment_size > 0)
            {
                pbi->fragment_sizes[0] = ext_first_part_size;
                /* The fragment contains an additional partition. Move to
                 * next. */
                fragment_idx++;
                pbi->fragments[fragment_idx] = pbi->fragments[0] +
                  pbi->fragment_sizes[0];
            }
John Koleszar's avatar
John Koleszar committed
533
        }
534
535
        /* Split the chunk into partitions read from the bitstream */
        while (fragment_size > 0)
John Koleszar's avatar
John Koleszar committed
536
        {
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
            ptrdiff_t partition_size = read_available_partition_size(
                                                 pbi,
                                                 token_part_sizes,
                                                 pbi->fragments[fragment_idx],
                                                 first_fragment_end,
                                                 fragment_end,
                                                 fragment_idx - 1,
                                                 num_token_partitions);
            pbi->fragment_sizes[fragment_idx] = partition_size;
            fragment_size -= partition_size;
            assert(fragment_idx <= num_token_partitions);
            if (fragment_size > 0)
            {
                /* The fragment contains an additional partition.
                 * Move to next. */
                fragment_idx++;
                pbi->fragments[fragment_idx] =
                    pbi->fragments[fragment_idx - 1] + partition_size;
            }
John Koleszar's avatar
John Koleszar committed
556
        }
557
558
559
    }

    pbi->num_fragments = num_token_partitions + 1;
John Koleszar's avatar
John Koleszar committed
560

561
562
563
564
565
566
567
568
    for (partition_idx = 1; partition_idx < pbi->num_fragments; ++partition_idx)
    {
        if (vp8dx_start_decode(bool_decoder,
                               pbi->fragments[partition_idx],
                               pbi->fragment_sizes[partition_idx]))
            vpx_internal_error(&pbi->common.error, VPX_CODEC_MEM_ERROR,
                               "Failed to allocate bool decoder %d",
                               partition_idx);
John Koleszar's avatar
John Koleszar committed
569
570
571
572

        bool_decoder++;
    }

573
#if CONFIG_MULTITHREAD
John Koleszar's avatar
John Koleszar committed
574
    /* Clamp number of decoder threads */
575
576
    if (pbi->decoding_thread_count > num_token_partitions - 1)
        pbi->decoding_thread_count = num_token_partitions - 1;
577
#endif
John Koleszar's avatar
John Koleszar committed
578
579
580
581
582
583
584
}

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
585
    {
John Koleszar's avatar
John Koleszar committed
586
        vpx_free(pbi->mbc);
James Zern's avatar
James Zern committed
587
588
        pbi->mbc = NULL;
    }
John Koleszar's avatar
John Koleszar committed
589
590
591
592
593
594
595
596
597
}

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

    if (pc->frame_type == KEY_FRAME)
    {
598
        /* Various keyframe initializations */
John Koleszar's avatar
John Koleszar committed
599
600
601
602
603
604
605
        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);

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

610
        /* reset the mode ref deltasa for loop filter */
John Koleszar's avatar
John Koleszar committed
611
612
613
        vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
        vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));

614
        /* All buffers are implicitly updated on key frames. */
John Koleszar's avatar
John Koleszar committed
615
616
617
618
619
        pc->refresh_golden_frame = 1;
        pc->refresh_alt_ref_frame = 1;
        pc->copy_buffer_to_gf = 0;
        pc->copy_buffer_to_arf = 0;

620
621
622
        /* 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
623
624
625
626
627
628
629
630
631
632
        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;

633
        /* To enable choice of different interploation filters */
John Koleszar's avatar
John Koleszar committed
634
635
        if (pc->mcomp_filter_type == SIXTAP)
        {
John Koleszar's avatar
John Koleszar committed
636
637
638
639
            xd->subpixel_predict        = vp8_sixtap_predict4x4;
            xd->subpixel_predict8x4     = vp8_sixtap_predict8x4;
            xd->subpixel_predict8x8     = vp8_sixtap_predict8x8;
            xd->subpixel_predict16x16   = vp8_sixtap_predict16x16;
John Koleszar's avatar
John Koleszar committed
640
641
642
        }
        else
        {
John Koleszar's avatar
John Koleszar committed
643
644
645
646
            xd->subpixel_predict        = vp8_bilinear_predict4x4;
            xd->subpixel_predict8x4     = vp8_bilinear_predict8x4;
            xd->subpixel_predict8x8     = vp8_bilinear_predict8x8;
            xd->subpixel_predict16x16   = vp8_bilinear_predict16x16;
John Koleszar's avatar
John Koleszar committed
647
        }
648
649
650

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

653
    xd->left_context = &pc->left_context;
John Koleszar's avatar
John Koleszar committed
654
655
    xd->mode_info_context = pc->mi;
    xd->frame_type = pc->frame_type;
656
    xd->mode_info_context->mbmi.mode = DC_PRED;
John Koleszar's avatar
John Koleszar committed
657
    xd->mode_info_stride = pc->mode_info_stride;
658
    xd->corrupted = 0; /* init without corruption */
659
660
661
662
663

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

John Koleszar's avatar
John Koleszar committed
664
665
666
667
668
669
670
}

int vp8_decode_frame(VP8D_COMP *pbi)
{
    vp8_reader *const bc = & pbi->bc;
    VP8_COMMON *const pc = & pbi->common;
    MACROBLOCKD *const xd  = & pbi->mb;
671
672
    const unsigned char *data = pbi->fragments[0];
    const unsigned char *data_end =  data + pbi->fragment_sizes[0];
673
    ptrdiff_t first_partition_length_in_bytes;
John Koleszar's avatar
John Koleszar committed
674
675
676
677

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

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

685
    if (data_end - data < 3)
John Koleszar's avatar
John Koleszar committed
686
    {
Johann's avatar
Johann committed
687
        if (!pbi->ec_active)
688
689
690
691
        {
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated packet");
        }
Johann's avatar
Johann committed
692
693
694
695
696
697
698
699

        /* 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;
700
701
702
703
704
705
706
707
    }
    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
708

709
        if (!pbi->ec_active && (data + first_partition_length_in_bytes > data_end
710
711
712
            || data + first_partition_length_in_bytes < data))
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated packet or corrupt partition 0 length");
713
714
715

        data += 3;

716
        vp8_setup_version(pc);
John Koleszar's avatar
John Koleszar committed
717

718
        if (pc->frame_type == KEY_FRAME)
John Koleszar's avatar
John Koleszar committed
719
        {
720
721
722
723
724
725
726
            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
             */
727
            if (!pbi->ec_active || data + 3 < data_end)
John Koleszar's avatar
John Koleszar committed
728
            {
729
730
731
                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
732
733
            }

734
735
736
737
            /* 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.
             */
738
            if (!pbi->ec_active || data + 6 < data_end)
John Koleszar's avatar
John Koleszar committed
739
            {
740
741
742
743
                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
744
            }
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
            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
764

765
766
767
768
769
770
771
772
773
774
775
776
777
778
                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
779
780

#if CONFIG_MULTITHREAD
781
782
                if (pbi->b_multithreaded_rd)
                    vp8mt_alloc_temp_buffers(pbi, pc->Width, prev_mb_rows);
783
#endif
784
            }
John Koleszar's avatar
John Koleszar committed
785
786
787
        }
    }

788
789
    if ((!pbi->decoded_key_frame && pc->frame_type != KEY_FRAME) ||
        pc->Width == 0 || pc->Height == 0)
John Koleszar's avatar
John Koleszar committed
790
791
792
793
794
795
    {
        return -1;
    }

    init_frame(pbi);

Johann's avatar
Johann committed
796
    if (vp8dx_start_decode(bc, data, data_end - data))
John Koleszar's avatar
John Koleszar committed
797
798
799
800
801
802
803
        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);
    }

804
    /* Is segmentation enabled */
John Koleszar's avatar
John Koleszar committed
805
806
807
808
    xd->segmentation_enabled = (unsigned char)vp8_read_bit(bc);

    if (xd->segmentation_enabled)
    {
809
        /* Signal whether or not the segmentation map is being explicitly updated this frame. */
John Koleszar's avatar
John Koleszar committed
810
811
812
813
814
815
816
817
818
        xd->update_mb_segmentation_map = (unsigned char)vp8_read_bit(bc);
        xd->update_mb_segmentation_data = (unsigned char)vp8_read_bit(bc);

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

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

819
            /* For each segmentation feature (Quant and loop filter level) */
John Koleszar's avatar
John Koleszar committed
820
821
822
823
            for (i = 0; i < MB_LVL_MAX; i++)
            {
                for (j = 0; j < MAX_MB_SEGMENTS; j++)
                {
824
                    /* Frame level data */
John Koleszar's avatar
John Koleszar committed
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
                    if (vp8_read_bit(bc))
                    {
                        xd->segment_feature_data[i][j] = (signed char)vp8_read_literal(bc, mb_feature_data_bits[i]);

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

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

843
            /* Read the probs used to decode the segment id for each macro block. */
John Koleszar's avatar
John Koleszar committed
844
845
            for (i = 0; i < MB_FEATURE_TREE_PROBS; i++)
            {
846
                /* If not explicitly set value is defaulted to 255 by memset above */
John Koleszar's avatar
John Koleszar committed
847
848
849
850
851
852
                if (vp8_read_bit(bc))
                    xd->mb_segment_tree_probs[i] = (vp8_prob)vp8_read_literal(bc, 8);
            }
        }
    }

853
    /* Read the loop filter level and type */
John Koleszar's avatar
John Koleszar committed
854
855
856
857
    pc->filter_type = (LOOPFILTERTYPE) vp8_read_bit(bc);
    pc->filter_level = vp8_read_literal(bc, 6);
    pc->sharpness_level = vp8_read_literal(bc, 3);

858
    /* Read in loop filter deltas applied at the MB level based on mode or ref frame. */
John Koleszar's avatar
John Koleszar committed
859
860
861
862
863
    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)
    {
864
        /* Do the deltas need to be updated */
John Koleszar's avatar
John Koleszar committed
865
866
867
868
        xd->mode_ref_lf_delta_update = (unsigned char)vp8_read_bit(bc);

        if (xd->mode_ref_lf_delta_update)
        {
869
            /* Send update */
John Koleszar's avatar
John Koleszar committed
870
871
872
873
            for (i = 0; i < MAX_REF_LF_DELTAS; i++)
            {
                if (vp8_read_bit(bc))
                {
874
                    /*sign = vp8_read_bit( bc );*/
John Koleszar's avatar
John Koleszar committed
875
876
                    xd->ref_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);

877
                    if (vp8_read_bit(bc))        /* Apply sign */
John Koleszar's avatar
John Koleszar committed
878
879
880
881
                        xd->ref_lf_deltas[i] = xd->ref_lf_deltas[i] * -1;
                }
            }

882
            /* Send update */
John Koleszar's avatar
John Koleszar committed
883
884
885
886
            for (i = 0; i < MAX_MODE_LF_DELTAS; i++)
            {
                if (vp8_read_bit(bc))
                {
887
                    /*sign = vp8_read_bit( bc );*/
John Koleszar's avatar
John Koleszar committed
888
889
                    xd->mode_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);

890
                    if (vp8_read_bit(bc))        /* Apply sign */
John Koleszar's avatar
John Koleszar committed
891
892
893
894
895
896
                        xd->mode_lf_deltas[i] = xd->mode_lf_deltas[i] * -1;
                }
            }
        }
    }

897
898
    setup_token_decoder(pbi, data + first_partition_length_in_bytes);

John Koleszar's avatar
John Koleszar committed
899
900
    xd->current_bc = &pbi->bc2;

901
    /* Read the default quantizers. */
John Koleszar's avatar
John Koleszar committed
902
903
904
    {
        int Q, q_update;

905
        Q = vp8_read_literal(bc, 7);  /* AC 1st order Q = default */
John Koleszar's avatar
John Koleszar committed
906
907
908
909
910
911
912
913
914
915
916
        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);

917
        /* MB level dequantizer setup */
John Koleszar's avatar
John Koleszar committed
918
919
920
        mb_init_dequantizer(pbi, &pbi->mb);
    }

921
922
923
924
    /* 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
925
926
    if (pc->frame_type != KEY_FRAME)
    {
927
        /* Should the GF or ARF be updated from the current frame */
John Koleszar's avatar
John Koleszar committed
928
        pc->refresh_golden_frame = vp8_read_bit(bc);
929
930
931
#if CONFIG_ERROR_CONCEALMENT
        /* Assume we shouldn't refresh golden if the bit is missing */
        xd->corrupted |= vp8dx_bool_error(bc);
932
        if (pbi->ec_active && xd->corrupted)
933
934
935
            pc->refresh_golden_frame = 0;
#endif

John Koleszar's avatar
John Koleszar committed
936
        pc->refresh_alt_ref_frame = vp8_read_bit(bc);
937
938
939
#if CONFIG_ERROR_CONCEALMENT
        /* Assume we shouldn't refresh altref if the bit is missing */
        xd->corrupted |= vp8dx_bool_error(bc);
940
        if (pbi->ec_active && xd->corrupted)
941
942
            pc->refresh_alt_ref_frame = 0;
#endif
John Koleszar's avatar
John Koleszar committed
943

944
        /* Buffer to buffer copy flags. */
John Koleszar's avatar
John Koleszar committed
945
946
947
948
949
        pc->copy_buffer_to_gf = 0;

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

950
951
952
953
954
955
956
#if CONFIG_ERROR_CONCEALMENT
        /* Assume we shouldn't copy to the golden if the bit is missing */
        xd->corrupted |= vp8dx_bool_error(bc);
        if (pbi->ec_active && xd->corrupted)
            pc->copy_buffer_to_gf = 0;
#endif

John Koleszar's avatar
John Koleszar committed
957
958
959
960
961
        pc->copy_buffer_to_arf = 0;

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

962
963
964
965
966
967
968
969
#if CONFIG_ERROR_CONCEALMENT
        /* Assume we shouldn't copy to the alt-ref if the bit is missing */
        xd->corrupted |= vp8dx_bool_error(bc);
        if (pbi->ec_active && xd->corrupted)
            pc->copy_buffer_to_arf = 0;
#endif


John Koleszar's avatar
John Koleszar committed
970
971
972
973
974
        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);
975
976
977
978
979
980
981
#if CONFIG_ERROR_CONCEALMENT
    /* Assume we shouldn't refresh the probabilities if the bit is
     * missing */
    xd->corrupted |= vp8dx_bool_error(bc);
    if (pbi->ec_active && xd->corrupted)
        pc->refresh_entropy_probs = 0;
#endif
John Koleszar's avatar
John Koleszar committed
982
983
984
985
986
987
988
    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);

989
990
991
#if CONFIG_ERROR_CONCEALMENT
    /* Assume we should refresh the last frame if the bit is missing */
    xd->corrupted |= vp8dx_bool_error(bc);
992
    if (pbi->ec_active && xd->corrupted)
993
994
995
        pc->refresh_last_frame = 1;
#endif

John Koleszar's avatar
John Koleszar committed
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
    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);
    }

    {
1010
1011
        pbi->independent_partitions = 1;

1012
        /* read coef probability tree */
John Koleszar's avatar
John Koleszar committed
1013
1014
1015
        for (i = 0; i < BLOCK_TYPES; i++)
            for (j = 0; j < COEF_BANDS; j++)
                for (k = 0; k < PREV_COEF_CONTEXTS; k++)
1016
                    for (l = 0; l < ENTROPY_NODES; l++)
John Koleszar's avatar
John Koleszar committed
1017
1018
1019
1020
1021
1022
1023
1024
1025
                    {

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

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

John Koleszar's avatar
John Koleszar committed
1029
1030
1031
                    }
    }

1032
1033
    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
1034

1035
    /* set up frame new frame for intra coded blocks */
1036
#if CONFIG_MULTITHREAD
1037
    if (!(pbi->b_multithreaded_rd) || pc->multi_token_partition == ONE_PARTITION || !(pc->filter_level))
1038
#endif
1039
        vp8_setup_intra_recon(&pc->yv12_fb[pc->new_fb_idx]);
John Koleszar's avatar
John Koleszar committed
1040
1041
1042
1043
1044

    vp8_setup_block_dptrs(xd);

    vp8_build_block_doffsets(xd);

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

1048
    /* Read the mb_no_coeff_skip flag */
John Koleszar's avatar
John Koleszar committed
1049
1050
    pc->mb_no_coeff_skip = (int)vp8_read_bit(bc);

Scott LaVarnway's avatar
Scott LaVarnway committed
1051
1052

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

1054
#if CONFIG_ERROR_CONCEALMENT
1055
    if (pbi->ec_active &&
1056
1057
1058
1059
1060
1061
1062
1063
            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

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

1066
#if CONFIG_MULTITHREAD
1067
    if (pbi->b_multithreaded_rd && pc->multi_token_partition != ONE_PARTITION)
John Koleszar's avatar
John Koleszar committed
1068
    {
1069
1070
        int i;
        pbi->frame_corrupt_residual = 0;
1071
        vp8mt_decode_mb_rows(pbi, xd);
1072
        vp8_yv12_extend_frame_borders_ptr(&pc->yv12_fb[pc->new_fb_idx]);    /*cm->frame_to_show);*/
1073
1074
        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
1075
1076
    }
    else
1077
#endif
John Koleszar's avatar
John Koleszar committed
1078
1079
    {
        int ibc = 0;
1080
        int num_part = 1 << pc->multi_token_partition;
1081
        pbi->frame_corrupt_residual = 0;
John Koleszar's avatar
John Koleszar committed
1082

1083
        /* Decode the individual macro block */
John Koleszar's avatar
John Koleszar committed
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
        for (mb_row = 0; mb_row < pc->mb_rows; mb_row++)
        {

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

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

1096
            decode_mb_row(pbi, pc, mb_row, xd);
John Koleszar's avatar
John Koleszar committed
1097
        }
1098
        corrupt_tokens |= xd->corrupted;
John Koleszar's avatar
John Koleszar committed
1099
1100
1101
1102
    }

    stop_token_decoder(pbi);

1103
1104
    /* Collect information about decoder corruption. */
    /* 1. Check first boolean decoder for errors. */
1105
    pc->yv12_fb[pc->new_fb_idx].corrupted = vp8dx_bool_error(bc);
1106
    /* 2. Check the macroblock information */
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
    pc->yv12_fb[pc->new_fb_idx].corrupted |= corrupt_tokens;

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

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

1121
    /* If this was a kf or Gf note the Q used */
1122
1123
1124
    if ((pc->frame_type == KEY_FRAME) ||
         pc->refresh_golden_frame || pc->refresh_alt_ref_frame)
    {
John Koleszar's avatar
John Koleszar committed
1125
        pc->last_kf_gf_q = pc->base_qindex;
1126
    }
John Koleszar's avatar
John Koleszar committed
1127
1128
1129
1130

    if (pc->refresh_entropy_probs == 0)
    {
        vpx_memcpy(&pc->fc, &pc->lfc, sizeof(pc->fc));
1131
        pbi->independent_partitions = prev_independent_partitions;
John Koleszar's avatar
John Koleszar committed
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
    }

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

    return 0;
}