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


John Koleszar's avatar
John Koleszar committed
12
#include "vpx_config.h"
13 14
#include "vp8_rtcd.h"
#include "./vpx_scale_rtcd.h"
John Koleszar's avatar
John Koleszar committed
15
#include "onyxd_int.h"
John Koleszar's avatar
John Koleszar committed
16 17 18
#include "vp8/common/header.h"
#include "vp8/common/reconintra4x4.h"
#include "vp8/common/reconinter.h"
John Koleszar's avatar
John Koleszar committed
19
#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"
Johann's avatar
Johann committed
24
#include "vpx_scale/vpx_scale.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
    }
}

John Koleszar's avatar
John Koleszar committed
57
void vp8_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
static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd,
                              unsigned int mb_idx)
John Koleszar's avatar
John Koleszar committed
98
{
Gaute Strokkenes's avatar
Gaute Strokkenes committed
99 100
    MB_PREDICTION_MODE mode;
    int i;
Scott LaVarnway's avatar
Scott LaVarnway committed
101
#if CONFIG_ERROR_CONCEALMENT
Scott LaVarnway's avatar
Scott LaVarnway committed
102
    int corruption_detected = 0;
Scott LaVarnway's avatar
Scott LaVarnway committed
103
#endif
104

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

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

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

    if (xd->segmentation_enabled)
John Koleszar's avatar
John Koleszar committed
121
        vp8_mb_init_dequantizer(pbi, xd);
122

123

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

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

Scott LaVarnway's avatar
Scott LaVarnway committed
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
        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);
        }
153
    }
Scott LaVarnway's avatar
Scott LaVarnway committed
154
#endif
155

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

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

Scott LaVarnway's avatar
Scott LaVarnway committed
182 183 184 185
            /* 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
186
            intra_prediction_down_copy(xd, xd->recon_above[0] + 16);
Scott LaVarnway's avatar
Scott LaVarnway committed
187 188 189 190

            for (i = 0; i < 16; i++)
            {
                BLOCKD *b = &xd->block[i];
191
                unsigned char *dst = xd->dst.y_buffer + b->offset;
192 193
                B_PREDICTION_MODE b_mode =
                    xd->mode_info_context->bmi[i].as_mode;
194 195 196 197
                unsigned char *Above = dst - dst_stride;
                unsigned char *yleft = dst - 1;
                int left_stride = dst_stride;
                unsigned char top_left = Above[-1];
Scott LaVarnway's avatar
Scott LaVarnway committed
198

Johann's avatar
Johann committed
199 200
                vp8_intra4x4_predict(Above, yleft, left_stride, b_mode,
                                     dst, dst_stride, top_left);
Scott LaVarnway's avatar
Scott LaVarnway committed
201 202 203 204 205

                if (xd->eobs[i])
                {
                    if (xd->eobs[i] > 1)
                    {
206
                    vp8_dequant_idct_add(b->qcoeff, DQC, dst, dst_stride);
Scott LaVarnway's avatar
Scott LaVarnway committed
207 208 209
                    }
                    else
                    {
210
                        vp8_dc_only_idct_add
211
                            (b->qcoeff[0] * DQC[0],
212 213
                                dst, dst_stride,
                                dst, dst_stride);
Scott LaVarnway's avatar
Scott LaVarnway committed
214 215 216 217
                        ((int *)b->qcoeff)[0] = 0;
                    }
                }
            }
John Koleszar's avatar
John Koleszar committed
218 219 220 221 222 223
        }
    }
    else
    {
        vp8_build_inter_predictors_mb(xd);
    }
Scott LaVarnway's avatar
Scott LaVarnway committed
224

225

226
#if CONFIG_ERROR_CONCEALMENT
Scott LaVarnway's avatar
Scott LaVarnway committed
227
    if (corruption_detected)
228 229 230 231 232
    {
        return;
    }
#endif

Scott LaVarnway's avatar
Scott LaVarnway committed
233
    if(!xd->mode_info_context->mbmi.mb_skip_coeff)
234
    {
Scott LaVarnway's avatar
Scott LaVarnway committed
235 236
        /* dequantization and idct */
        if (mode != B_PRED)
John Koleszar's avatar
John Koleszar committed
237
        {
238
            short *DQC = xd->dequant_y1;
John Koleszar's avatar
John Koleszar committed
239

Scott LaVarnway's avatar
Scott LaVarnway committed
240
            if (mode != SPLITMV)
John Koleszar's avatar
John Koleszar committed
241
            {
Scott LaVarnway's avatar
Scott LaVarnway committed
242 243 244 245
                BLOCKD *b = &xd->block[24];

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

249
                    vp8_short_inv_walsh4x4(&b->dqcoeff[0],
Scott LaVarnway's avatar
Scott LaVarnway committed
250 251 252 253 254 255 256 257 258
                        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;
259 260 261
                }
                else
                {
262
                    b->dqcoeff[0] = b->qcoeff[0] * xd->dequant_y2[0];
263
                    vp8_short_inv_walsh4x4_1(&b->dqcoeff[0],
Scott LaVarnway's avatar
Scott LaVarnway committed
264
                        xd->qcoeff);
265 266
                    ((int *)b->qcoeff)[0] = 0;
                }
267

Scott LaVarnway's avatar
Scott LaVarnway committed
268 269 270
                /* override the dc dequant constant in order to preserve the
                 * dc components
                 */
271
                DQC = xd->dequant_y1_dc;
272 273
            }

John Koleszar's avatar
John Koleszar committed
274
            vp8_dequant_idct_add_y_block
275
                            (xd->qcoeff, DQC,
Scott LaVarnway's avatar
Scott LaVarnway committed
276 277 278
                             xd->dst.y_buffer,
                             xd->dst.y_stride, xd->eobs);
        }
279

John Koleszar's avatar
John Koleszar committed
280
        vp8_dequant_idct_add_uv_block
281
                        (xd->qcoeff+16*16, xd->dequant_uv,
Scott LaVarnway's avatar
Scott LaVarnway committed
282 283
                         xd->dst.u_buffer, xd->dst.v_buffer,
                         xd->dst.uv_stride, xd->eobs+16);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
284
    }
John Koleszar's avatar
John Koleszar committed
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
}

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

311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 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 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
static void yv12_extend_frame_top_c(YV12_BUFFER_CONFIG *ybf)
{
    int i;
    unsigned char *src_ptr1;
    unsigned char *dest_ptr1;

    unsigned int Border;
    int plane_stride;

    /***********/
    /* Y Plane */
    /***********/
    Border = ybf->border;
    plane_stride = ybf->y_stride;
    src_ptr1 = ybf->y_buffer - Border;
    dest_ptr1 = src_ptr1 - (Border * plane_stride);

    for (i = 0; i < (int)Border; i++)
    {
        vpx_memcpy(dest_ptr1, src_ptr1, plane_stride);
        dest_ptr1 += plane_stride;
    }


    /***********/
    /* U Plane */
    /***********/
    plane_stride = ybf->uv_stride;
    Border /= 2;
    src_ptr1 = ybf->u_buffer - Border;
    dest_ptr1 = src_ptr1 - (Border * plane_stride);

    for (i = 0; i < (int)(Border); i++)
    {
        vpx_memcpy(dest_ptr1, src_ptr1, plane_stride);
        dest_ptr1 += plane_stride;
    }

    /***********/
    /* V Plane */
    /***********/

    src_ptr1 = ybf->v_buffer - Border;
    dest_ptr1 = src_ptr1 - (Border * plane_stride);

    for (i = 0; i < (int)(Border); i++)
    {
        vpx_memcpy(dest_ptr1, src_ptr1, plane_stride);
        dest_ptr1 += plane_stride;
    }
}

static void yv12_extend_frame_bottom_c(YV12_BUFFER_CONFIG *ybf)
{
    int i;
    unsigned char *src_ptr1, *src_ptr2;
    unsigned char *dest_ptr2;

    unsigned int Border;
    int plane_stride;
    int plane_height;

    /***********/
    /* Y Plane */
    /***********/
    Border = ybf->border;
    plane_stride = ybf->y_stride;
    plane_height = ybf->y_height;

    src_ptr1 = ybf->y_buffer - Border;
    src_ptr2 = src_ptr1 + (plane_height * plane_stride) - plane_stride;
    dest_ptr2 = src_ptr2 + plane_stride;

    for (i = 0; i < (int)Border; i++)
    {
        vpx_memcpy(dest_ptr2, src_ptr2, plane_stride);
        dest_ptr2 += plane_stride;
    }


    /***********/
    /* U Plane */
    /***********/
    plane_stride = ybf->uv_stride;
    plane_height = ybf->uv_height;
    Border /= 2;

    src_ptr1 = ybf->u_buffer - Border;
    src_ptr2 = src_ptr1 + (plane_height * plane_stride) - plane_stride;
    dest_ptr2 = src_ptr2 + plane_stride;

    for (i = 0; i < (int)(Border); i++)
    {
        vpx_memcpy(dest_ptr2, src_ptr2, plane_stride);
        dest_ptr2 += plane_stride;
    }

    /***********/
    /* V Plane */
    /***********/

    src_ptr1 = ybf->v_buffer - Border;
    src_ptr2 = src_ptr1 + (plane_height * plane_stride) - plane_stride;
    dest_ptr2 = src_ptr2 + plane_stride;

    for (i = 0; i < (int)(Border); i++)
    {
        vpx_memcpy(dest_ptr2, src_ptr2, plane_stride);
        dest_ptr2 += plane_stride;
    }
}

static void yv12_extend_frame_left_right_c(YV12_BUFFER_CONFIG *ybf,
                                           unsigned char *y_src,
                                           unsigned char *u_src,
                                           unsigned char *v_src)
{
    int i;
    unsigned char *src_ptr1, *src_ptr2;
    unsigned char *dest_ptr1, *dest_ptr2;

    unsigned int Border;
    int plane_stride;
    int plane_height;
    int plane_width;

    /***********/
    /* Y Plane */
    /***********/
    Border = ybf->border;
    plane_stride = ybf->y_stride;
    plane_height = 16;
    plane_width = ybf->y_width;

    /* copy the left and right most columns out */
    src_ptr1 = y_src;
    src_ptr2 = src_ptr1 + plane_width - 1;
    dest_ptr1 = src_ptr1 - Border;
    dest_ptr2 = src_ptr2 + 1;

    for (i = 0; i < plane_height; i++)
    {
        vpx_memset(dest_ptr1, src_ptr1[0], Border);
        vpx_memset(dest_ptr2, src_ptr2[0], Border);
        src_ptr1  += plane_stride;
        src_ptr2  += plane_stride;
        dest_ptr1 += plane_stride;
        dest_ptr2 += plane_stride;
    }

    /***********/
    /* U Plane */
    /***********/
    plane_stride = ybf->uv_stride;
    plane_height = 8;
    plane_width = ybf->uv_width;
    Border /= 2;

    /* copy the left and right most columns out */
    src_ptr1 = u_src;
    src_ptr2 = src_ptr1 + plane_width - 1;
    dest_ptr1 = src_ptr1 - Border;
    dest_ptr2 = src_ptr2 + 1;

    for (i = 0; i < plane_height; i++)
    {
        vpx_memset(dest_ptr1, src_ptr1[0], Border);
        vpx_memset(dest_ptr2, src_ptr2[0], Border);
        src_ptr1  += plane_stride;
        src_ptr2  += plane_stride;
        dest_ptr1 += plane_stride;
        dest_ptr2 += plane_stride;
    }

    /***********/
    /* V Plane */
    /***********/

    /* copy the left and right most columns out */
    src_ptr1 = v_src;
    src_ptr2 = src_ptr1 + plane_width - 1;
    dest_ptr1 = src_ptr1 - Border;
    dest_ptr2 = src_ptr2 + 1;

    for (i = 0; i < plane_height; i++)
    {
        vpx_memset(dest_ptr1, src_ptr1[0], Border);
        vpx_memset(dest_ptr2, src_ptr2[0], Border);
        src_ptr1  += plane_stride;
        src_ptr2  += plane_stride;
        dest_ptr1 += plane_stride;
        dest_ptr2 += plane_stride;
    }
}

Scott LaVarnway's avatar
Scott LaVarnway committed
506 507 508 509
static void decode_mb_rows(VP8D_COMP *pbi)
{
    VP8_COMMON *const pc = & pbi->common;
    MACROBLOCKD *const xd  = & pbi->mb;
John Koleszar's avatar
John Koleszar committed
510

Scott LaVarnway's avatar
Scott LaVarnway committed
511 512
    MODE_INFO *lf_mic = xd->mode_info_context;

Scott LaVarnway's avatar
Scott LaVarnway committed
513 514
    int ibc = 0;
    int num_part = 1 << pc->multi_token_partition;
John Koleszar's avatar
John Koleszar committed
515 516

    int recon_yoffset, recon_uvoffset;
Scott LaVarnway's avatar
Scott LaVarnway committed
517 518
    int mb_row, mb_col;
    int mb_idx = 0;
519 520 521 522 523

    YV12_BUFFER_CONFIG *yv12_fb_new = pbi->dec_fb_ref[INTRA_FRAME];

    int recon_y_stride = yv12_fb_new->y_stride;
    int recon_uv_stride = yv12_fb_new->uv_stride;
John Koleszar's avatar
John Koleszar committed
524

Scott LaVarnway's avatar
Scott LaVarnway committed
525 526
    unsigned char *ref_buffer[MAX_REF_FRAMES][3];
    unsigned char *dst_buffer[3];
Scott LaVarnway's avatar
Scott LaVarnway committed
527
    unsigned char *lf_dst[3];
528
    unsigned char *eb_dst[3];
Scott LaVarnway's avatar
Scott LaVarnway committed
529 530
    int i;
    int ref_fb_corrupted[MAX_REF_FRAMES];
John Koleszar's avatar
John Koleszar committed
531

Scott LaVarnway's avatar
Scott LaVarnway committed
532
    ref_fb_corrupted[INTRA_FRAME] = 0;
John Koleszar's avatar
John Koleszar committed
533

Scott LaVarnway's avatar
Scott LaVarnway committed
534
    for(i = 1; i < MAX_REF_FRAMES; i++)
John Koleszar's avatar
John Koleszar committed
535
    {
536
        YV12_BUFFER_CONFIG *this_fb = pbi->dec_fb_ref[i];
537

538 539 540 541 542
        ref_buffer[i][0] = this_fb->y_buffer;
        ref_buffer[i][1] = this_fb->u_buffer;
        ref_buffer[i][2] = this_fb->v_buffer;

        ref_fb_corrupted[i] = this_fb->corrupted;
Scott LaVarnway's avatar
Scott LaVarnway committed
543 544
    }

Scott LaVarnway's avatar
Scott LaVarnway committed
545
    /* Set up the buffer pointers */
546 547 548
    eb_dst[0] = lf_dst[0] = dst_buffer[0] = yv12_fb_new->y_buffer;
    eb_dst[1] = lf_dst[1] = dst_buffer[1] = yv12_fb_new->u_buffer;
    eb_dst[2] = lf_dst[2] = dst_buffer[2] = yv12_fb_new->v_buffer;
Scott LaVarnway's avatar
Scott LaVarnway committed
549 550 551

    xd->up_available = 0;

Scott LaVarnway's avatar
Scott LaVarnway committed
552 553 554 555
    /* Initialize the loop filter for this frame. */
    if(pc->filter_level)
        vp8_loop_filter_frame_init(pc, xd, pc->filter_level);

556
    vp8_setup_intra_recon_top_line(yv12_fb_new);
557

Scott LaVarnway's avatar
Scott LaVarnway committed
558 559 560 561
    /* Decode the individual macro block */
    for (mb_row = 0; mb_row < pc->mb_rows; mb_row++)
    {
        if (num_part > 1)
562
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
563 564 565 566 567
            xd->current_bc = & pbi->mbc[ibc];
            ibc++;

            if (ibc == num_part)
                ibc = 0;
568
        }
John Koleszar's avatar
John Koleszar committed
569

Scott LaVarnway's avatar
Scott LaVarnway committed
570 571
        recon_yoffset = mb_row * recon_y_stride * 16;
        recon_uvoffset = mb_row * recon_uv_stride * 8;
John Koleszar's avatar
John Koleszar committed
572

Scott LaVarnway's avatar
Scott LaVarnway committed
573 574 575
        /* reset contexts */
        xd->above_context = pc->above_context;
        vpx_memset(xd->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
John Koleszar's avatar
John Koleszar committed
576

Scott LaVarnway's avatar
Scott LaVarnway committed
577
        xd->left_available = 0;
578

Scott LaVarnway's avatar
Scott LaVarnway committed
579 580
        xd->mb_to_top_edge = -((mb_row * 16)) << 3;
        xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
John Koleszar's avatar
John Koleszar committed
581

Scott LaVarnway's avatar
Scott LaVarnway committed
582 583 584 585 586 587 588 589 590 591 592 593
        xd->recon_above[0] = dst_buffer[0] + recon_yoffset;
        xd->recon_above[1] = dst_buffer[1] + recon_uvoffset;
        xd->recon_above[2] = dst_buffer[2] + recon_uvoffset;

        xd->recon_left[0] = xd->recon_above[0] - 1;
        xd->recon_left[1] = xd->recon_above[1] - 1;
        xd->recon_left[2] = xd->recon_above[2] - 1;

        xd->recon_above[0] -= xd->dst.y_stride;
        xd->recon_above[1] -= xd->dst.uv_stride;
        xd->recon_above[2] -= xd->dst.uv_stride;

John Koleszar's avatar
John Koleszar committed
594
        /* TODO: move to outside row loop */
Scott LaVarnway's avatar
Scott LaVarnway committed
595 596 597
        xd->recon_left_stride[0] = xd->dst.y_stride;
        xd->recon_left_stride[1] = xd->dst.uv_stride;

598 599 600 601
        setup_intra_recon_left(xd->recon_left[0], xd->recon_left[1],
                               xd->recon_left[2], xd->dst.y_stride,
                               xd->dst.uv_stride);

Scott LaVarnway's avatar
Scott LaVarnway committed
602
        for (mb_col = 0; mb_col < pc->mb_cols; mb_col++)
603
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
            /* 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
            {
                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);
                }
            }
#endif

            xd->dst.y_buffer = dst_buffer[0] + recon_yoffset;
            xd->dst.u_buffer = dst_buffer[1] + recon_uvoffset;
            xd->dst.v_buffer = dst_buffer[2] + recon_uvoffset;

            xd->pre.y_buffer = ref_buffer[xd->mode_info_context->mbmi.ref_frame][0] + recon_yoffset;
            xd->pre.u_buffer = ref_buffer[xd->mode_info_context->mbmi.ref_frame][1] + recon_uvoffset;
            xd->pre.v_buffer = ref_buffer[xd->mode_info_context->mbmi.ref_frame][2] + recon_uvoffset;

645
            /* propagate errors from reference frames */
Scott LaVarnway's avatar
Scott LaVarnway committed
646
            xd->corrupted |= ref_fb_corrupted[xd->mode_info_context->mbmi.ref_frame];
647

Scott LaVarnway's avatar
Scott LaVarnway committed
648
            decode_macroblock(pbi, xd, mb_idx);
John Koleszar's avatar
John Koleszar committed
649

Scott LaVarnway's avatar
Scott LaVarnway committed
650 651
            mb_idx++;
            xd->left_available = 1;
John Koleszar's avatar
John Koleszar committed
652

Scott LaVarnway's avatar
Scott LaVarnway committed
653 654
            /* check if the boolean decoder has suffered an error */
            xd->corrupted |= vp8dx_bool_error(xd->current_bc);
John Koleszar's avatar
John Koleszar committed
655

Scott LaVarnway's avatar
Scott LaVarnway committed
656 657 658 659 660 661 662
            xd->recon_above[0] += 16;
            xd->recon_above[1] += 8;
            xd->recon_above[2] += 8;
            xd->recon_left[0] += 16;
            xd->recon_left[1] += 8;
            xd->recon_left[2] += 8;

Scott LaVarnway's avatar
Scott LaVarnway committed
663 664
            recon_yoffset += 16;
            recon_uvoffset += 8;
John Koleszar's avatar
John Koleszar committed
665

Scott LaVarnway's avatar
Scott LaVarnway committed
666
            ++xd->mode_info_context;  /* next mb */
John Koleszar's avatar
John Koleszar committed
667

Scott LaVarnway's avatar
Scott LaVarnway committed
668 669
            xd->above_context++;
        }
John Koleszar's avatar
John Koleszar committed
670

Scott LaVarnway's avatar
Scott LaVarnway committed
671
        /* adjust to the next row of mbs */
672
        vp8_extend_mb_row(yv12_fb_new, xd->dst.y_buffer + 16,
Scott LaVarnway's avatar
Scott LaVarnway committed
673
                          xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
John Koleszar's avatar
John Koleszar committed
674

Scott LaVarnway's avatar
Scott LaVarnway committed
675 676 677
        ++xd->mode_info_context;      /* skip prediction column */
        xd->up_available = 1;

Scott LaVarnway's avatar
Scott LaVarnway committed
678 679 680 681 682 683 684 685 686 687 688 689
        if(pc->filter_level)
        {
            if(mb_row > 0)
            {
                if (pc->filter_type == NORMAL_LOOPFILTER)
                    vp8_loop_filter_row_normal(pc, lf_mic, mb_row-1,
                                               recon_y_stride, recon_uv_stride,
                                               lf_dst[0], lf_dst[1], lf_dst[2]);
                else
                    vp8_loop_filter_row_simple(pc, lf_mic, mb_row-1,
                                               recon_y_stride, recon_uv_stride,
                                               lf_dst[0], lf_dst[1], lf_dst[2]);
690 691 692

                if(mb_row > 1)
                {
693
                    yv12_extend_frame_left_right_c(yv12_fb_new,
694 695 696 697 698 699 700 701 702
                                                   eb_dst[0],
                                                   eb_dst[1],
                                                   eb_dst[2]);

                    eb_dst[0] += recon_y_stride  * 16;
                    eb_dst[1] += recon_uv_stride *  8;
                    eb_dst[2] += recon_uv_stride *  8;

                    if(mb_row == 2)
703
                        yv12_extend_frame_top_c(yv12_fb_new);
704 705 706

                }

Scott LaVarnway's avatar
Scott LaVarnway committed
707 708 709 710 711 712 713
                lf_dst[0] += recon_y_stride  * 16;
                lf_dst[1] += recon_uv_stride *  8;
                lf_dst[2] += recon_uv_stride *  8;
                lf_mic += pc->mb_cols;
                lf_mic++;         /* Skip border mb */
            }
        }
714 715 716 717 718
        else
        {
            if(mb_row > 0)
            {
                /**/
719
                yv12_extend_frame_left_right_c(yv12_fb_new,
720 721 722 723 724 725 726 727 728
                                               eb_dst[0],
                                               eb_dst[1],
                                               eb_dst[2]);

                eb_dst[0] += recon_y_stride  * 16;
                eb_dst[1] += recon_uv_stride *  8;
                eb_dst[2] += recon_uv_stride *  8;

                if(mb_row == 1)
729
                    yv12_extend_frame_top_c(yv12_fb_new);
730 731
            }
        }
Scott LaVarnway's avatar
Scott LaVarnway committed
732 733 734 735 736 737 738 739 740 741 742 743
    }

    if(pc->filter_level)
    {
        if (pc->filter_type == NORMAL_LOOPFILTER)
            vp8_loop_filter_row_normal(pc, lf_mic, mb_row-1, recon_y_stride,
                                       recon_uv_stride, lf_dst[0], lf_dst[1],
                                       lf_dst[2]);
        else
            vp8_loop_filter_row_simple(pc, lf_mic, mb_row-1, recon_y_stride,
                                       recon_uv_stride, lf_dst[0], lf_dst[1],
                                       lf_dst[2]);
744

745
        yv12_extend_frame_left_right_c(yv12_fb_new,
746 747 748 749 750 751
                                       eb_dst[0],
                                       eb_dst[1],
                                       eb_dst[2]);
        eb_dst[0] += recon_y_stride  * 16;
        eb_dst[1] += recon_uv_stride *  8;
        eb_dst[2] += recon_uv_stride *  8;
Scott LaVarnway's avatar
Scott LaVarnway committed
752
    }
753
    yv12_extend_frame_left_right_c(yv12_fb_new,
754 755 756
                                   eb_dst[0],
                                   eb_dst[1],
                                   eb_dst[2]);
Scott LaVarnway's avatar
Scott LaVarnway committed
757

758 759
    yv12_extend_frame_bottom_c(yv12_fb_new);

Scott LaVarnway's avatar
Scott LaVarnway committed
760
}
John Koleszar's avatar
John Koleszar committed
761 762 763 764 765 766 767 768

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

769 770 771
static int read_is_valid(const unsigned char *start,
                         size_t               len,
                         const unsigned char *end)
772
{
773 774
    return (start + len > start && start + len <= end);
}
775

776 777 778 779 780 781 782 783 784 785 786
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;
Attila Nagy's avatar
Attila Nagy committed
787
    unsigned int partition_size = 0;
788 789 790 791 792 793 794
    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)
795
    {
796 797 798
        if (read_is_valid(partition_size_ptr, 3, first_fragment_end))
            partition_size = read_partition_size(partition_size_ptr);
        else if (pbi->ec_active)
799
            partition_size = (unsigned int)bytes_left;
800 801 802
        else
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated partition size data");
803
    }
804
    else
805
        partition_size = (unsigned int)bytes_left;
806

807 808 809 810 811
    /* 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))
812
    {
813
        if (pbi->ec_active)
814
            partition_size = (unsigned int)bytes_left;
815 816 817 818
        else
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated packet or corrupt partition "
                               "%d length", i + 1);
819
    }
820
    return partition_size;
821 822 823
}


John Koleszar's avatar
John Koleszar committed
824
static void setup_token_decoder(VP8D_COMP *pbi,
825
                                const unsigned char* token_part_sizes)
John Koleszar's avatar
John Koleszar committed
826
{
827
    vp8_reader *bool_decoder = &pbi->mbc[0];
828
    unsigned int partition_idx;
829 830
    unsigned int fragment_idx;
    unsigned int num_token_partitions;
831 832
    const unsigned char *first_fragment_end = pbi->fragments.ptrs[0] +
                                          pbi->fragments.sizes[0];
John Koleszar's avatar
John Koleszar committed
833

834
    TOKEN_PARTITION multi_token_partition =
835 836
            (TOKEN_PARTITION)vp8_read_literal(&pbi->mbc[8], 2);
    if (!vp8dx_bool_error(&pbi->mbc[8]))
837 838
        pbi->common.multi_token_partition = multi_token_partition;
    num_token_partitions = 1 << pbi->common.multi_token_partition;
John Koleszar's avatar
John Koleszar committed
839

840 841
    /* Check for partitions within the fragments and unpack the fragments
     * so that each fragment pointer points to its corresponding partition. */
842
    for (fragment_idx = 0; fragment_idx < pbi->fragments.count; ++fragment_idx)
John Koleszar's avatar
John Koleszar committed
843
    {
844 845
        unsigned int fragment_size = pbi->fragments.sizes[fragment_idx];
        const unsigned char *fragment_end = pbi->fragments.ptrs[fragment_idx] +
846 847 848 849
                                            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
850
        {
851 852
            /* Size of first partition + token partition sizes element */
            ptrdiff_t ext_first_part_size = token_part_sizes -
853
                pbi->fragments.ptrs[0] + 3 * (num_token_partitions - 1);
854
            fragment_size -= (unsigned int)ext_first_part_size;
855 856
            if (fragment_size > 0)
            {
857
                pbi->fragments.sizes[0] = (unsigned int)ext_first_part_size;
858 859 860
                /* The fragment contains an additional partition. Move to
                 * next. */
                fragment_idx++;
861 862
                pbi->fragments.ptrs[fragment_idx] = pbi->fragments.ptrs[0] +
                  pbi->fragments.sizes[0];
863
            }
John Koleszar's avatar
John Koleszar committed
864
        }
865 866
        /* Split the chunk into partitions read from the bitstream */
        while (fragment_size > 0)
John Koleszar's avatar
John Koleszar committed
867
        {
868 869 870
            ptrdiff_t partition_size = read_available_partition_size(
                                                 pbi,
                                                 token_part_sizes,
871
                                                 pbi->fragments.ptrs[fragment_idx],
872 873 874 875
                                                 first_fragment_end,
                                                 fragment_end,
                                                 fragment_idx - 1,
                                                 num_token_partitions);
876
            pbi->fragments.sizes[fragment_idx] = (unsigned int)partition_size;
877
            fragment_size -= (unsigned int)partition_size;
878 879 880 881 882 883
            assert(fragment_idx <= num_token_partitions);
            if (fragment_size > 0)
            {
                /* The fragment contains an additional partition.
                 * Move to next. */
                fragment_idx++;
884 885
                pbi->fragments.ptrs[fragment_idx] =
                    pbi->fragments.ptrs[fragment_idx - 1] + partition_size;
886
            }
John Koleszar's avatar
John Koleszar committed
887
        }
888 889
    }

890
    pbi->fragments.count = num_token_partitions + 1;
John Koleszar's avatar
John Koleszar committed
891

892
    for (partition_idx = 1; partition_idx < pbi->fragments.count; ++partition_idx)
893 894
    {
        if (vp8dx_start_decode(bool_decoder,
895
                               pbi->fragments.ptrs[partition_idx],
896 897 898
                               pbi->fragments.sizes[partition_idx],
                               pbi->fragments.ptrs[0],
                               pbi->decrypt_key))
899 900 901
            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
902 903 904 905

        bool_decoder++;
    }

906
#if CONFIG_MULTITHREAD
John Koleszar's avatar
John Koleszar committed
907
    /* Clamp number of decoder threads */
908 909
    if (pbi->decoding_thread_count > num_token_partitions - 1)
        pbi->decoding_thread_count = num_token_partitions - 1;
910
#endif
John Koleszar's avatar
John Koleszar committed
911 912 913 914 915 916 917 918 919 920
}


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

    if (pc->frame_type == KEY_FRAME)
    {
921
        /* Various keyframe initializations */
John Koleszar's avatar
John Koleszar committed
922 923 924 925 926 927
        vpx_memcpy(pc->fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));

        vp8_init_mbmode_probs(pc);

        vp8_default_coef_probs(pc);

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

932
        /* reset the mode ref deltasa for loop filter */
John Koleszar's avatar
John Koleszar committed
933 934 935
        vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
        vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));

936
        /* All buffers are implicitly updated on key frames. */
John Koleszar's avatar
John Koleszar committed
937 938 939 940 941
        pc->refresh_golden_frame = 1;
        pc->refresh_alt_ref_frame = 1;
        pc->copy_buffer_to_gf = 0;
        pc->copy_buffer_to_arf = 0;

942 943 944
        /* 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
945 946 947 948 949
        pc->ref_frame_sign_bias[GOLDEN_FRAME] = 0;
        pc->ref_frame_sign_bias[ALTREF_FRAME] = 0;
    }
    else
    {
950
        /* To enable choice of different interploation filters */
Scott LaVarnway's avatar
Scott LaVarnway committed
951
        if (!pc->use_bilinear_mc_filter)
John Koleszar's avatar
John Koleszar committed
952
        {
John Koleszar's avatar
John Koleszar committed
953 954 955 956
            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
957 958 959
        }
        else
        {
John Koleszar's avatar
John Koleszar committed
960 961 962 963
            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
964
        }
965 966 967

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

970
    xd->left_context = &pc->left_context;
John Koleszar's avatar
John Koleszar committed
971 972
    xd->mode_info_context = pc->mi;
    xd->frame_type = pc->frame_type;
973
    xd->mode_info_context->mbmi.mode = DC_PRED;
John Koleszar's avatar
John Koleszar committed
974
    xd->mode_info_stride = pc->mode_info_stride;
975
    xd->corrupted = 0; /* init without corruption */
976 977 978 979 980

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

John Koleszar's avatar
John Koleszar committed
981 982 983 984
}

int vp8_decode_frame(VP8D_COMP *pbi)
{
985 986 987
    vp8_reader *const bc = &pbi->mbc[8];
    VP8_COMMON *const pc = &pbi->common;
    MACROBLOCKD *const xd  = &pbi->mb;
988
    const unsigned char *data = pbi->fragments.ptrs[0];
989
    const unsigned char *const origin = data;
990
    const unsigned char *data_end =  data + pbi->fragments.sizes[0];
991
    ptrdiff_t first_partition_length_in_bytes;
John Koleszar's avatar
John Koleszar committed
992 993 994

    int i, j, k, l;
    const int *const mb_feature_data_bits = vp8_mb_feature_data_bits;
995 996
    int corrupt_tokens = 0;
    int prev_independent_partitions = pbi->independent_partitions;
John Koleszar's avatar
John Koleszar committed
997

998 999
    YV12_BUFFER_CONFIG *yv12_fb_new = pbi->dec_fb_ref[INTRA_FRAME];

1000 1001
    /* start with no corruption of current frame */
    xd->corrupted = 0;
1002
    yv12_fb_new->corrupted = 0;
1003

1004
    if (data_end - data < 3)
John Koleszar's avatar
John Koleszar committed
1005
    {
Johann's avatar
Johann committed
1006
        if (!pbi->ec_active)
1007 1008 1009 1010
        {
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated packet");
        }
Johann's avatar
Johann committed
1011 1012 1013 1014 1015 1016 1017 1018

        /* 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;
1019 1020 1021
    }
    else
    {
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
        const unsigned char data0 = decrypt_byte(data + 0, origin,
                                                 pbi->decrypt_key);
        const unsigned char data1 = decrypt_byte(data + 1, origin,
                                                 pbi->decrypt_key);
        const unsigned char data2 = decrypt_byte(data + 2, origin,
                                                 pbi->decrypt_key);

        pc->frame_type = (FRAME_TYPE)(data0 & 1);
        pc->version = (data0 >> 1) & 7;
        pc->show_frame = (data0 >> 4) & 1;
1032
        first_partition_length_in_bytes =