decodframe.c 30.3 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"
John Koleszar's avatar
John Koleszar committed
30
#include "vpx_mem/vpx_mem.h"
John Koleszar's avatar
John Koleszar committed
31
#include "vp8/common/idct.h"
John Koleszar's avatar
John Koleszar committed
32
#include "dequantize.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
47
#include "decoderthreading.h"
#include "dboolhuff.h"

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

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

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

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

57
58
59
            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
60
61
62
63
        }
    }
}

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

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

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

88
    /* Set up the block level dequant pointers */
John Koleszar's avatar
John Koleszar committed
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
    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

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

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

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

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

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

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

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

}

179
static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd)
John Koleszar's avatar
John Koleszar committed
180
{
181
    int eobtotal = 0;
182
    int i, do_clamp = xd->mode_info_context->mbmi.need_to_clamp_mvs;
183

184
    if (xd->mode_info_context->mbmi.mb_skip_coeff)
185
186
187
188
189
190
191
192
193
194
195
196
197
198
    {
        vp8_reset_mb_tokens_context(xd);
    }
    else
    {
        eobtotal = vp8_decode_mb_tokens(pbi, xd);
    }

    /* Perform temporary clamping of the MV to be used for prediction */
    if (do_clamp)
    {
        clamp_mvs(xd);
    }

199
200
201
    eobtotal |= (xd->mode_info_context->mbmi.mode == B_PRED ||
                  xd->mode_info_context->mbmi.mode == SPLITMV);
    if (!eobtotal)
202
    {
Scott LaVarnway's avatar
Scott LaVarnway committed
203
204
205
206
207
        /* Special case:  Force the loopfilter to skip when eobtotal and
         * mb_skip_coeff are zero.
         * */
        xd->mode_info_context->mbmi.mb_skip_coeff = 1;

208
209
210
211
212
213
214
        skip_recon_mb(pbi, xd);
        return;
    }

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

215
    /* do prediction */
216
    if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME)
John Koleszar's avatar
John Koleszar committed
217
    {
218
        RECON_INVOKE(&pbi->common.rtcd.recon, build_intra_predictors_mbuv)(xd);
John Koleszar's avatar
John Koleszar committed
219

220
        if (xd->mode_info_context->mbmi.mode != B_PRED)
John Koleszar's avatar
John Koleszar committed
221
        {
222
223
            RECON_INVOKE(&pbi->common.rtcd.recon,
                         build_intra_predictors_mby)(xd);
224
225
        } else {
            vp8_intra_prediction_down_copy(xd);
226
227
228



John Koleszar's avatar
John Koleszar committed
229
230
231
232
233
234
235
        }
    }
    else
    {
        vp8_build_inter_predictors_mb(xd);
    }

236
    /* dequantization and idct */
237
    if (xd->mode_info_context->mbmi.mode != B_PRED && xd->mode_info_context->mbmi.mode != SPLITMV)
John Koleszar's avatar
John Koleszar committed
238
    {
239
        BLOCKD *b = &xd->block[24];
240

John Koleszar's avatar
John Koleszar committed
241
242
        DEQUANT_INVOKE(&pbi->dequant, block)(b);

243
        /* do 2nd order transform on the dc block */
Fritz Koenig's avatar
Fritz Koenig committed
244
        if (xd->eobs[24] > 1)
John Koleszar's avatar
John Koleszar committed
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
        {
            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;
        }

Fritz Koenig's avatar
Fritz Koenig committed
262
        DEQUANT_INVOKE (&pbi->dequant, dc_idct_add_y_block)
263
                        (xd->qcoeff, xd->block[0].dequant,
Fritz Koenig's avatar
Fritz Koenig committed
264
265
                         xd->predictor, xd->dst.y_buffer,
                         xd->dst.y_stride, xd->eobs, xd->block[24].diff);
266
    }
267
    else if (xd->mode_info_context->mbmi.mode == B_PRED)
268
269
    {
        for (i = 0; i < 16; i++)
John Koleszar's avatar
John Koleszar committed
270
        {
271
272

            BLOCKD *b = &xd->block[i];
273
274
            RECON_INVOKE(RTCD_VTABLE(recon), intra4x4_predict)
                         (b, b->bmi.mode, b->predictor);
John Koleszar's avatar
John Koleszar committed
275

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

John Koleszar's avatar
John Koleszar committed
291
292
293
    }
    else
    {
Fritz Koenig's avatar
Fritz Koenig committed
294
        DEQUANT_INVOKE (&pbi->dequant, idct_add_y_block)
295
                        (xd->qcoeff, xd->block[0].dequant,
Fritz Koenig's avatar
Fritz Koenig committed
296
297
                         xd->predictor, xd->dst.y_buffer,
                         xd->dst.y_stride, xd->eobs);
John Koleszar's avatar
John Koleszar committed
298
299
    }

Fritz Koenig's avatar
Fritz Koenig committed
300
    DEQUANT_INVOKE (&pbi->dequant, idct_add_uv_block)
301
                    (xd->qcoeff+16*16, xd->block[16].dequant,
Fritz Koenig's avatar
Fritz Koenig committed
302
303
                     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
304
305
}

306

John Koleszar's avatar
John Koleszar committed
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
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



333
334
static void
decode_mb_row(VP8D_COMP *pbi, VP8_COMMON *pc, int mb_row, MACROBLOCKD *xd)
John Koleszar's avatar
John Koleszar committed
335
336
337
338
339
{

    int i;
    int recon_yoffset, recon_uvoffset;
    int mb_col;
340
341
342
343
    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
344

345
    vpx_memset(&pc->left_context, 0, sizeof(pc->left_context));
John Koleszar's avatar
John Koleszar committed
346
347
    recon_yoffset = mb_row * recon_y_stride * 16;
    recon_uvoffset = mb_row * recon_uv_stride * 8;
348
    /* reset above block coeffs */
John Koleszar's avatar
John Koleszar committed
349

350
    xd->above_context = pc->above_context;
John Koleszar's avatar
John Koleszar committed
351
352
353
354
355
356
357
358
    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++)
    {

359
        if (xd->mode_info_context->mbmi.mode == SPLITMV || xd->mode_info_context->mbmi.mode == B_PRED)
John Koleszar's avatar
John Koleszar committed
360
361
362
363
364
365
366
367
        {
            for (i = 0; i < 16; i++)
            {
                BLOCKD *d = &xd->block[i];
                vpx_memcpy(&d->bmi, &xd->mode_info_context->bmi[i], sizeof(B_MODE_INFO));
            }
        }

368
369
370
        /* 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
         */
John Koleszar's avatar
John Koleszar committed
371
372
373
        xd->mb_to_left_edge = -((mb_col * 16) << 3);
        xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3;

374
375
376
        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
377
378
379

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

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

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

John Koleszar's avatar
John Koleszar committed
398
399
400
        vp8_build_uvmvs(xd, pc->full_pixel);

        /*
401
        if(pc->current_video_frame==0 &&mb_col==1 && mb_row==0)
John Koleszar's avatar
John Koleszar committed
402
403
404
405
        pbi->debugoutput =1;
        else
        pbi->debugoutput =0;
        */
406
        decode_macroblock(pbi, xd);
John Koleszar's avatar
John Koleszar committed
407

408
409
        /* check if the boolean decoder has suffered an error */
        xd->corrupted |= vp8dx_bool_error(xd->current_bc);
John Koleszar's avatar
John Koleszar committed
410
411
412
413
414
415

        recon_yoffset += 16;
        recon_uvoffset += 8;

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

416
        xd->above_context++;
John Koleszar's avatar
John Koleszar committed
417
418
419

    }

420
    /* adjust to the next row of mbs */
John Koleszar's avatar
John Koleszar committed
421
    vp8_extend_mb_row(
422
        &pc->yv12_fb[dst_fb_idx],
John Koleszar's avatar
John Koleszar committed
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
        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;
}


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 */
    pc->multi_token_partition = (TOKEN_PARTITION)vp8_read_literal(&pbi->bc, 2);
    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;
466
        ptrdiff_t            partition_size;
John Koleszar's avatar
John Koleszar committed
467
468
469
470
471
472
473
474
475
476
477
478
479

        /* Calculate the length of this partition. The last partition
         * size is implicit.
         */
        if (i < num_part - 1)
        {
            partition_size = read_partition_size(partition_size_ptr);
        }
        else
        {
            partition_size = user_data_end - partition;
        }

480
481
        if (partition + partition_size > user_data_end
            || partition + partition_size < partition)
John Koleszar's avatar
John Koleszar committed
482
483
484
485
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated packet or corrupt partition "
                               "%d length", i + 1);

Johann's avatar
Johann committed
486
        if (vp8dx_start_decode(bool_decoder, partition, partition_size))
John Koleszar's avatar
John Koleszar committed
487
488
489
490
491
492
493
494
            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++;
    }

495
#if CONFIG_MULTITHREAD
John Koleszar's avatar
John Koleszar committed
496
497
498
    /* Clamp number of decoder threads */
    if (pbi->decoding_thread_count > num_part - 1)
        pbi->decoding_thread_count = num_part - 1;
499
#endif
John Koleszar's avatar
John Koleszar committed
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
}


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

    if (pc->multi_token_partition != ONE_PARTITION)
        vpx_free(pbi->mbc);
}

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

    if (pc->frame_type == KEY_FRAME)
    {
518
        /* Various keyframe initializations */
John Koleszar's avatar
John Koleszar committed
519
520
521
522
523
524
525
        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);

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

530
        /* reset the mode ref deltasa for loop filter */
John Koleszar's avatar
John Koleszar committed
531
532
533
        vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
        vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));

534
        /* All buffers are implicitly updated on key frames. */
John Koleszar's avatar
John Koleszar committed
535
536
537
538
539
        pc->refresh_golden_frame = 1;
        pc->refresh_alt_ref_frame = 1;
        pc->copy_buffer_to_gf = 0;
        pc->copy_buffer_to_arf = 0;

540
541
542
        /* 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
543
544
545
546
547
548
549
550
551
552
        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;

553
        /* To enable choice of different interploation filters */
John Koleszar's avatar
John Koleszar committed
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
        if (pc->mcomp_filter_type == SIXTAP)
        {
            xd->subpixel_predict      = SUBPIX_INVOKE(RTCD_VTABLE(subpix), sixtap4x4);
            xd->subpixel_predict8x4   = SUBPIX_INVOKE(RTCD_VTABLE(subpix), sixtap8x4);
            xd->subpixel_predict8x8   = SUBPIX_INVOKE(RTCD_VTABLE(subpix), sixtap8x8);
            xd->subpixel_predict16x16 = SUBPIX_INVOKE(RTCD_VTABLE(subpix), sixtap16x16);
        }
        else
        {
            xd->subpixel_predict      = SUBPIX_INVOKE(RTCD_VTABLE(subpix), bilinear4x4);
            xd->subpixel_predict8x4   = SUBPIX_INVOKE(RTCD_VTABLE(subpix), bilinear8x4);
            xd->subpixel_predict8x8   = SUBPIX_INVOKE(RTCD_VTABLE(subpix), bilinear8x8);
            xd->subpixel_predict16x16 = SUBPIX_INVOKE(RTCD_VTABLE(subpix), bilinear16x16);
        }
    }

570
    xd->left_context = &pc->left_context;
John Koleszar's avatar
John Koleszar committed
571
572
    xd->mode_info_context = pc->mi;
    xd->frame_type = pc->frame_type;
573
    xd->mode_info_context->mbmi.mode = DC_PRED;
John Koleszar's avatar
John Koleszar committed
574
    xd->mode_info_stride = pc->mode_info_stride;
575
    xd->corrupted = 0; /* init without corruption */
John Koleszar's avatar
John Koleszar committed
576
577
578
579
580
581
582
583
584
}

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;
    const unsigned char *const data_end = data + pbi->source_sz;
585
    ptrdiff_t first_partition_length_in_bytes;
John Koleszar's avatar
John Koleszar committed
586
587
588
589
590

    int mb_row;
    int i, j, k, l;
    const int *const mb_feature_data_bits = vp8_mb_feature_data_bits;

591
592
593
594
    /* start with no corruption of current frame */
    xd->corrupted = 0;
    pc->yv12_fb[pc->new_fb_idx].corrupted = 0;

595
596
597
    if (data_end - data < 3)
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Truncated packet");
John Koleszar's avatar
John Koleszar committed
598
599
600
601
602
603
604
    pc->frame_type = (FRAME_TYPE)(data[0] & 1);
    pc->version = (data[0] >> 1) & 7;
    pc->show_frame = (data[0] >> 4) & 1;
    first_partition_length_in_bytes =
        (data[0] | (data[1] << 8) | (data[2] << 16)) >> 5;
    data += 3;

605
606
    if (data + first_partition_length_in_bytes > data_end
        || data + first_partition_length_in_bytes < data)
John Koleszar's avatar
John Koleszar committed
607
608
609
610
611
612
613
614
615
        vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                           "Truncated packet or corrupt partition 0 length");
    vp8_setup_version(pc);

    if (pc->frame_type == KEY_FRAME)
    {
        const int Width = pc->Width;
        const int Height = pc->Height;

616
        /* vet via sync code */
John Koleszar's avatar
John Koleszar committed
617
618
619
620
621
622
623
624
625
626
627
628
        if (data[0] != 0x9d || data[1] != 0x01 || data[2] != 0x2a)
            vpx_internal_error(&pc->error, VPX_CODEC_UNSUP_BITSTREAM,
                               "Invalid frame sync code");

        pc->Width = (data[3] | (data[4] << 8)) & 0x3fff;
        pc->horiz_scale = data[4] >> 6;
        pc->Height = (data[5] | (data[6] << 8)) & 0x3fff;
        pc->vert_scale = data[6] >> 6;
        data += 7;

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

John Koleszar's avatar
John Koleszar committed
631
632
633
634
635
636
637
638
639
640
641
642
643
644
            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");
            }

645
            if (vp8_alloc_frame_buffers(pc, pc->Width, pc->Height))
John Koleszar's avatar
John Koleszar committed
646
647
                vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                                   "Failed to allocate frame buffers");
648
649
650
651
652

#if CONFIG_MULTITHREAD
            if (pbi->b_multithreaded_rd)
                vp8mt_alloc_temp_buffers(pbi, pc->Width, prev_mb_rows);
#endif
John Koleszar's avatar
John Koleszar committed
653
654
655
656
657
658
659
660
661
662
        }
    }

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

    init_frame(pbi);

Johann's avatar
Johann committed
663
    if (vp8dx_start_decode(bc, data, data_end - data))
John Koleszar's avatar
John Koleszar committed
664
665
666
667
668
669
670
        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);
    }

671
    /* Is segmentation enabled */
John Koleszar's avatar
John Koleszar committed
672
673
674
675
    xd->segmentation_enabled = (unsigned char)vp8_read_bit(bc);

    if (xd->segmentation_enabled)
    {
676
        /* Signal whether or not the segmentation map is being explicitly updated this frame. */
John Koleszar's avatar
John Koleszar committed
677
678
679
680
681
682
683
684
685
        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));

686
            /* For each segmentation feature (Quant and loop filter level) */
John Koleszar's avatar
John Koleszar committed
687
688
689
690
            for (i = 0; i < MB_LVL_MAX; i++)
            {
                for (j = 0; j < MAX_MB_SEGMENTS; j++)
                {
691
                    /* Frame level data */
John Koleszar's avatar
John Koleszar committed
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
                    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)
        {
707
            /* Which macro block level features are enabled */
John Koleszar's avatar
John Koleszar committed
708
709
            vpx_memset(xd->mb_segment_tree_probs, 255, sizeof(xd->mb_segment_tree_probs));

710
            /* Read the probs used to decode the segment id for each macro block. */
John Koleszar's avatar
John Koleszar committed
711
712
            for (i = 0; i < MB_FEATURE_TREE_PROBS; i++)
            {
713
                /* If not explicitly set value is defaulted to 255 by memset above */
John Koleszar's avatar
John Koleszar committed
714
715
716
717
718
719
                if (vp8_read_bit(bc))
                    xd->mb_segment_tree_probs[i] = (vp8_prob)vp8_read_literal(bc, 8);
            }
        }
    }

720
    /* Read the loop filter level and type */
John Koleszar's avatar
John Koleszar committed
721
722
723
724
    pc->filter_type = (LOOPFILTERTYPE) vp8_read_bit(bc);
    pc->filter_level = vp8_read_literal(bc, 6);
    pc->sharpness_level = vp8_read_literal(bc, 3);

725
    /* Read in loop filter deltas applied at the MB level based on mode or ref frame. */
John Koleszar's avatar
John Koleszar committed
726
727
728
729
730
    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)
    {
731
        /* Do the deltas need to be updated */
John Koleszar's avatar
John Koleszar committed
732
733
734
735
        xd->mode_ref_lf_delta_update = (unsigned char)vp8_read_bit(bc);

        if (xd->mode_ref_lf_delta_update)
        {
736
            /* Send update */
John Koleszar's avatar
John Koleszar committed
737
738
739
740
            for (i = 0; i < MAX_REF_LF_DELTAS; i++)
            {
                if (vp8_read_bit(bc))
                {
741
                    /*sign = vp8_read_bit( bc );*/
John Koleszar's avatar
John Koleszar committed
742
743
                    xd->ref_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);

744
                    if (vp8_read_bit(bc))        /* Apply sign */
John Koleszar's avatar
John Koleszar committed
745
746
747
748
                        xd->ref_lf_deltas[i] = xd->ref_lf_deltas[i] * -1;
                }
            }

749
            /* Send update */
John Koleszar's avatar
John Koleszar committed
750
751
752
753
            for (i = 0; i < MAX_MODE_LF_DELTAS; i++)
            {
                if (vp8_read_bit(bc))
                {
754
                    /*sign = vp8_read_bit( bc );*/
John Koleszar's avatar
John Koleszar committed
755
756
                    xd->mode_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6);

757
                    if (vp8_read_bit(bc))        /* Apply sign */
John Koleszar's avatar
John Koleszar committed
758
759
760
761
762
763
764
765
766
                        xd->mode_lf_deltas[i] = xd->mode_lf_deltas[i] * -1;
                }
            }
        }
    }

    setup_token_decoder(pbi, data + first_partition_length_in_bytes);
    xd->current_bc = &pbi->bc2;

767
    /* Read the default quantizers. */
John Koleszar's avatar
John Koleszar committed
768
769
770
    {
        int Q, q_update;

771
        Q = vp8_read_literal(bc, 7);  /* AC 1st order Q = default */
John Koleszar's avatar
John Koleszar committed
772
773
774
775
776
777
778
779
780
781
782
        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);

783
        /* MB level dequantizer setup */
John Koleszar's avatar
John Koleszar committed
784
785
786
        mb_init_dequantizer(pbi, &pbi->mb);
    }

787
788
789
790
    /* 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
791
792
    if (pc->frame_type != KEY_FRAME)
    {
793
        /* Should the GF or ARF be updated from the current frame */
John Koleszar's avatar
John Koleszar committed
794
795
796
        pc->refresh_golden_frame = vp8_read_bit(bc);
        pc->refresh_alt_ref_frame = vp8_read_bit(bc);

797
        /* Buffer to buffer copy flags. */
John Koleszar's avatar
John Koleszar committed
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
        pc->copy_buffer_to_gf = 0;

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

        pc->copy_buffer_to_arf = 0;

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

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

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

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

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


    {
835
        /* read coef probability tree */
John Koleszar's avatar
John Koleszar committed
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852

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

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

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

                        }
                    }
    }

853
854
    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
855

856
    /* set up frame new frame for intra coded blocks */
857
#if CONFIG_MULTITHREAD
858
    if (!(pbi->b_multithreaded_rd) || pc->multi_token_partition == ONE_PARTITION || !(pc->filter_level))
859
#endif
860
        vp8_setup_intra_recon(&pc->yv12_fb[pc->new_fb_idx]);
John Koleszar's avatar
John Koleszar committed
861
862
863
864
865

    vp8_setup_block_dptrs(xd);

    vp8_build_block_doffsets(xd);

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

869
    /* Read the mb_no_coeff_skip flag */
John Koleszar's avatar
John Koleszar committed
870
871
    pc->mb_no_coeff_skip = (int)vp8_read_bit(bc);

Scott LaVarnway's avatar
Scott LaVarnway committed
872
873

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

875
    vpx_memset(pc->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * pc->mb_cols);
John Koleszar's avatar
John Koleszar committed
876
877
878

    vpx_memcpy(&xd->block[0].bmi, &xd->mode_info_context->bmi[0], sizeof(B_MODE_INFO));

879
#if CONFIG_MULTITHREAD
880
    if (pbi->b_multithreaded_rd && pc->multi_token_partition != ONE_PARTITION)
John Koleszar's avatar
John Koleszar committed
881
    {
882
883
884
        vp8mt_decode_mb_rows(pbi, xd);
        if(pbi->common.filter_level)
        {
885
            /*vp8_mt_loop_filter_frame(pbi);*/ /*cm, &pbi->mb, cm->filter_level);*/
886
887
888
889
890

            pc->last_frame_type = pc->frame_type;
            pc->last_filter_type = pc->filter_type;
            pc->last_sharpness_level = pc->sharpness_level;
        }
891
        vp8_yv12_extend_frame_borders_ptr(&pc->yv12_fb[pc->new_fb_idx]);    /*cm->frame_to_show);*/
John Koleszar's avatar
John Koleszar committed
892
893
    }
    else
894
#endif
John Koleszar's avatar
John Koleszar committed
895
896
    {
        int ibc = 0;
897
        int num_part = 1 << pc->multi_token_partition;
John Koleszar's avatar
John Koleszar committed
898

899
        /* Decode the individual macro block */
John Koleszar's avatar
John Koleszar committed
900
901
902
903
904
905
906
907
908
909
910
911
        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;
            }

912
            decode_mb_row(pbi, pc, mb_row, xd);
John Koleszar's avatar
John Koleszar committed
913
914
915
916
917
918
        }
    }


    stop_token_decoder(pbi);

919
920
921
922
923
924
925
926
    /* Collect information about decoder corruption. */
    /* 1. Check first boolean decoder for errors. */
    pc->yv12_fb[pc->new_fb_idx].corrupted =
        vp8dx_bool_error(bc);
    /* 2. Check the macroblock information */
    pc->yv12_fb[pc->new_fb_idx].corrupted |=
        xd->corrupted;

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

929
    /* If this was a kf or Gf note the Q used */
930
931
932
    if ((pc->frame_type == KEY_FRAME) ||
         pc->refresh_golden_frame || pc->refresh_alt_ref_frame)
    {
John Koleszar's avatar
John Koleszar committed
933
        pc->last_kf_gf_q = pc->base_qindex;
934
    }
John Koleszar's avatar
John Koleszar committed
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952

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

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