decodeframe.c 45.8 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);
214
                        vpx_memset(b->qcoeff, 0, 2 * sizeof(b->qcoeff[0]));
Scott LaVarnway's avatar
Scott LaVarnway committed
215 216 217
                    }
                }
            }
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
                        xd->qcoeff);
251
                    vpx_memset(b->qcoeff, 0, 16 * sizeof(b->qcoeff[0]));
252 253 254
                }
                else
                {
255
                    b->dqcoeff[0] = b->qcoeff[0] * xd->dequant_y2[0];
256
                    vp8_short_inv_walsh4x4_1(&b->dqcoeff[0],
Scott LaVarnway's avatar
Scott LaVarnway committed
257
                        xd->qcoeff);
258
                    vpx_memset(b->qcoeff, 0, 2 * sizeof(b->qcoeff[0]));
259
                }
260

Scott LaVarnway's avatar
Scott LaVarnway committed
261 262 263
                /* override the dc dequant constant in order to preserve the
                 * dc components
                 */
264
                DQC = xd->dequant_y1_dc;
265 266
            }

John Koleszar's avatar
John Koleszar committed
267
            vp8_dequant_idct_add_y_block
268
                            (xd->qcoeff, DQC,
Scott LaVarnway's avatar
Scott LaVarnway committed
269 270 271
                             xd->dst.y_buffer,
                             xd->dst.y_stride, xd->eobs);
        }
272

John Koleszar's avatar
John Koleszar committed
273
        vp8_dequant_idct_add_uv_block
274
                        (xd->qcoeff+16*16, xd->dequant_uv,
Scott LaVarnway's avatar
Scott LaVarnway committed
275 276
                         xd->dst.u_buffer, xd->dst.v_buffer,
                         xd->dst.uv_stride, xd->eobs+16);
Gaute Strokkenes's avatar
Gaute Strokkenes committed
277
    }
John Koleszar's avatar
John Koleszar committed
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
}

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

304 305 306 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 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
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
499 500 501 502
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
503

Scott LaVarnway's avatar
Scott LaVarnway committed
504 505
    MODE_INFO *lf_mic = xd->mode_info_context;

Scott LaVarnway's avatar
Scott LaVarnway committed
506 507
    int ibc = 0;
    int num_part = 1 << pc->multi_token_partition;
John Koleszar's avatar
John Koleszar committed
508 509

    int recon_yoffset, recon_uvoffset;
Scott LaVarnway's avatar
Scott LaVarnway committed
510 511
    int mb_row, mb_col;
    int mb_idx = 0;
512 513 514 515 516

    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
517

Scott LaVarnway's avatar
Scott LaVarnway committed
518 519
    unsigned char *ref_buffer[MAX_REF_FRAMES][3];
    unsigned char *dst_buffer[3];
Scott LaVarnway's avatar
Scott LaVarnway committed
520
    unsigned char *lf_dst[3];
521
    unsigned char *eb_dst[3];
Scott LaVarnway's avatar
Scott LaVarnway committed
522 523
    int i;
    int ref_fb_corrupted[MAX_REF_FRAMES];
John Koleszar's avatar
John Koleszar committed
524

Scott LaVarnway's avatar
Scott LaVarnway committed
525
    ref_fb_corrupted[INTRA_FRAME] = 0;
John Koleszar's avatar
John Koleszar committed
526

Scott LaVarnway's avatar
Scott LaVarnway committed
527
    for(i = 1; i < MAX_REF_FRAMES; i++)
John Koleszar's avatar
John Koleszar committed
528
    {
529
        YV12_BUFFER_CONFIG *this_fb = pbi->dec_fb_ref[i];
530

531 532 533 534 535
        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
536 537
    }

Scott LaVarnway's avatar
Scott LaVarnway committed
538
    /* Set up the buffer pointers */
539 540 541
    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
542 543 544

    xd->up_available = 0;

Scott LaVarnway's avatar
Scott LaVarnway committed
545 546 547 548
    /* Initialize the loop filter for this frame. */
    if(pc->filter_level)
        vp8_loop_filter_frame_init(pc, xd, pc->filter_level);

549
    vp8_setup_intra_recon_top_line(yv12_fb_new);
550

Scott LaVarnway's avatar
Scott LaVarnway committed
551 552 553 554
    /* Decode the individual macro block */
    for (mb_row = 0; mb_row < pc->mb_rows; mb_row++)
    {
        if (num_part > 1)
555
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
556 557 558 559 560
            xd->current_bc = & pbi->mbc[ibc];
            ibc++;

            if (ibc == num_part)
                ibc = 0;
561
        }
John Koleszar's avatar
John Koleszar committed
562

Scott LaVarnway's avatar
Scott LaVarnway committed
563 564
        recon_yoffset = mb_row * recon_y_stride * 16;
        recon_uvoffset = mb_row * recon_uv_stride * 8;
John Koleszar's avatar
John Koleszar committed
565

Scott LaVarnway's avatar
Scott LaVarnway committed
566 567 568
        /* 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
569

Scott LaVarnway's avatar
Scott LaVarnway committed
570
        xd->left_available = 0;
571

Yaowu Xu's avatar
Yaowu Xu committed
572
        xd->mb_to_top_edge = -((mb_row * 16) << 3);
Scott LaVarnway's avatar
Scott LaVarnway committed
573
        xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3;
John Koleszar's avatar
John Koleszar committed
574

Scott LaVarnway's avatar
Scott LaVarnway committed
575 576 577 578 579 580 581 582 583 584 585 586
        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
587
        /* TODO: move to outside row loop */
Scott LaVarnway's avatar
Scott LaVarnway committed
588 589 590
        xd->recon_left_stride[0] = xd->dst.y_stride;
        xd->recon_left_stride[1] = xd->dst.uv_stride;

591 592 593 594
        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
595
        for (mb_col = 0; mb_col < pc->mb_cols; mb_col++)
596
        {
Scott LaVarnway's avatar
Scott LaVarnway committed
597 598 599 600 601 602 603 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
            /* 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;

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

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

Scott LaVarnway's avatar
Scott LaVarnway committed
643 644
            mb_idx++;
            xd->left_available = 1;
John Koleszar's avatar
John Koleszar committed
645

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

Scott LaVarnway's avatar
Scott LaVarnway committed
649 650 651 652 653 654 655
            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
656 657
            recon_yoffset += 16;
            recon_uvoffset += 8;
John Koleszar's avatar
John Koleszar committed
658

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

Scott LaVarnway's avatar
Scott LaVarnway committed
661 662
            xd->above_context++;
        }
John Koleszar's avatar
John Koleszar committed
663

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

Scott LaVarnway's avatar
Scott LaVarnway committed
668 669 670
        ++xd->mode_info_context;      /* skip prediction column */
        xd->up_available = 1;

Scott LaVarnway's avatar
Scott LaVarnway committed
671 672 673 674 675 676 677 678 679 680 681 682
        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]);
683 684
                if(mb_row > 1)
                {
685
                    yv12_extend_frame_left_right_c(yv12_fb_new,
686 687 688 689 690 691 692 693 694
                                                   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
695 696 697 698 699 700 701
                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 */
            }
        }
702 703 704 705 706
        else
        {
            if(mb_row > 0)
            {
                /**/
707
                yv12_extend_frame_left_right_c(yv12_fb_new,
708 709 710 711 712 713 714 715
                                               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
716 717 718 719 720 721 722 723 724 725 726 727
    }

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

729
        yv12_extend_frame_left_right_c(yv12_fb_new,
730 731 732 733 734 735
                                       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
736
    }
737
    yv12_extend_frame_left_right_c(yv12_fb_new,
738 739 740
                                   eb_dst[0],
                                   eb_dst[1],
                                   eb_dst[2]);
741
    yv12_extend_frame_top_c(yv12_fb_new);
742 743
    yv12_extend_frame_bottom_c(yv12_fb_new);

Scott LaVarnway's avatar
Scott LaVarnway committed
744
}
John Koleszar's avatar
John Koleszar committed
745

746 747
static unsigned int read_partition_size(VP8D_COMP *pbi,
                                        const unsigned char *cx_size)
John Koleszar's avatar
John Koleszar committed
748
{
749 750 751 752 753 754 755
    unsigned char temp[3];
    if (pbi->decrypt_cb)
    {
        pbi->decrypt_cb(pbi->decrypt_state, cx_size, temp, 3);
        cx_size = temp;
    }
    return cx_size[0] + (cx_size[1] << 8) + (cx_size[2] << 16);
John Koleszar's avatar
John Koleszar committed
756 757
}

758 759 760
static int read_is_valid(const unsigned char *start,
                         size_t               len,
                         const unsigned char *end)
761
{
762 763
    return (start + len > start && start + len <= end);
}
764

765 766 767 768 769 770 771 772 773 774 775
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
776
    unsigned int partition_size = 0;
777 778 779 780 781 782 783
    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)
784
    {
785
        if (read_is_valid(partition_size_ptr, 3, first_fragment_end))
786
            partition_size = read_partition_size(pbi, partition_size_ptr);
787
        else if (pbi->ec_active)
788
            partition_size = (unsigned int)bytes_left;
789 790 791
        else
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated partition size data");
792
    }
793
    else
794
        partition_size = (unsigned int)bytes_left;
795

796 797 798 799 800
    /* 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))
801
    {
802
        if (pbi->ec_active)
803
            partition_size = (unsigned int)bytes_left;
804 805 806 807
        else
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated packet or corrupt partition "
                               "%d length", i + 1);
808
    }
809
    return partition_size;
810 811 812
}


John Koleszar's avatar
John Koleszar committed
813
static void setup_token_decoder(VP8D_COMP *pbi,
814
                                const unsigned char* token_part_sizes)
John Koleszar's avatar
John Koleszar committed
815
{
816
    vp8_reader *bool_decoder = &pbi->mbc[0];
817
    unsigned int partition_idx;
818 819
    unsigned int fragment_idx;
    unsigned int num_token_partitions;
820 821
    const unsigned char *first_fragment_end = pbi->fragments.ptrs[0] +
                                          pbi->fragments.sizes[0];
John Koleszar's avatar
John Koleszar committed
822

823
    TOKEN_PARTITION multi_token_partition =
824 825
            (TOKEN_PARTITION)vp8_read_literal(&pbi->mbc[8], 2);
    if (!vp8dx_bool_error(&pbi->mbc[8]))
826 827
        pbi->common.multi_token_partition = multi_token_partition;
    num_token_partitions = 1 << pbi->common.multi_token_partition;
John Koleszar's avatar
John Koleszar committed
828

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

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

881
    for (partition_idx = 1; partition_idx < pbi->fragments.count; ++partition_idx)
882 883
    {
        if (vp8dx_start_decode(bool_decoder,
884
                               pbi->fragments.ptrs[partition_idx],
885
                               pbi->fragments.sizes[partition_idx],
886
                               pbi->decrypt_cb, pbi->decrypt_state))
887 888 889
            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
890 891 892 893

        bool_decoder++;
    }

894
#if CONFIG_MULTITHREAD
John Koleszar's avatar
John Koleszar committed
895
    /* Clamp number of decoder threads */
896 897
    if (pbi->decoding_thread_count > num_token_partitions - 1)
        pbi->decoding_thread_count = num_token_partitions - 1;
898
#endif
John Koleszar's avatar
John Koleszar committed
899 900 901 902 903 904 905 906 907 908
}


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

    if (pc->frame_type == KEY_FRAME)
    {
909
        /* Various keyframe initializations */
John Koleszar's avatar
John Koleszar committed
910 911 912 913 914 915
        vpx_memcpy(pc->fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));

        vp8_init_mbmode_probs(pc);

        vp8_default_coef_probs(pc);

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

920
        /* reset the mode ref deltasa for loop filter */
John Koleszar's avatar
John Koleszar committed
921 922 923
        vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas));
        vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas));

924
        /* All buffers are implicitly updated on key frames. */
John Koleszar's avatar
John Koleszar committed
925 926 927 928 929
        pc->refresh_golden_frame = 1;
        pc->refresh_alt_ref_frame = 1;
        pc->copy_buffer_to_gf = 0;
        pc->copy_buffer_to_arf = 0;

930 931 932
        /* 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
933 934 935 936 937
        pc->ref_frame_sign_bias[GOLDEN_FRAME] = 0;
        pc->ref_frame_sign_bias[ALTREF_FRAME] = 0;
    }
    else
    {
938
        /* To enable choice of different interploation filters */
Scott LaVarnway's avatar
Scott LaVarnway committed
939
        if (!pc->use_bilinear_mc_filter)
John Koleszar's avatar
John Koleszar committed
940
        {
John Koleszar's avatar
John Koleszar committed
941 942 943 944
            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
945 946 947
        }
        else
        {
John Koleszar's avatar
John Koleszar committed
948 949 950 951
            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
952
        }
953 954 955

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

958
    xd->left_context = &pc->left_context;
John Koleszar's avatar
John Koleszar committed
959 960
    xd->mode_info_context = pc->mi;
    xd->frame_type = pc->frame_type;
961
    xd->mode_info_context->mbmi.mode = DC_PRED;
John Koleszar's avatar
John Koleszar committed
962
    xd->mode_info_stride = pc->mode_info_stride;
963
    xd->corrupted = 0; /* init without corruption */
964 965 966 967 968

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

John Koleszar's avatar
John Koleszar committed
969 970 971 972
}

int vp8_decode_frame(VP8D_COMP *pbi)
{
973 974 975
    vp8_reader *const bc = &pbi->mbc[8];
    VP8_COMMON *const pc = &pbi->common;
    MACROBLOCKD *const xd  = &pbi->mb;
976 977
    const unsigned char *data = pbi->fragments.ptrs[0];
    const unsigned char *data_end =  data + pbi->fragments.sizes[0];
978
    ptrdiff_t first_partition_length_in_bytes;
John Koleszar's avatar
John Koleszar committed
979 980 981

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

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

987 988
    /* start with no corruption of current frame */
    xd->corrupted = 0;
989
    yv12_fb_new->corrupted = 0;
990

991
    if (data_end - data < 3)
John Koleszar's avatar
John Koleszar committed
992
    {
Johann's avatar
Johann committed
993
        if (!pbi->ec_active)
994 995 996 997
        {
            vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                               "Truncated packet");
        }
Johann's avatar
Johann committed
998 999 1000 1001 1002 1003 1004 1005

        /* 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;
1006 1007 1008
    }
    else
    {
</