1 /* 2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * 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. 9 */ 10 11 12 #include "vpx_config.h" 13 #include "vp8_rtcd.h" 14 #include "./vpx_scale_rtcd.h" 15 #include "onyxd_int.h" 16 #include "vp8/common/header.h" 17 #include "vp8/common/reconintra4x4.h" 18 #include "vp8/common/reconinter.h" 19 #include "detokenize.h" 20 #include "vp8/common/invtrans.h" 21 #include "vp8/common/alloccommon.h" 22 #include "vp8/common/entropymode.h" 23 #include "vp8/common/quant_common.h" 24 #include "vpx_scale/vpx_scale.h" 25 #include "vp8/common/setupintrarecon.h" 26 27 #include "decodemv.h" 28 #include "vp8/common/extend.h" 29 #if CONFIG_ERROR_CONCEALMENT 30 #include "error_concealment.h" 31 #endif 32 #include "vpx_mem/vpx_mem.h" 33 #include "vp8/common/threading.h" 34 #include "decoderthreading.h" 35 #include "dboolhuff.h" 36 37 #include <assert.h> 38 #include <stdio.h> 39 40 void vp8cx_init_de_quantizer(VP8D_COMP *pbi) 41 { 42 int Q; 43 VP8_COMMON *const pc = & pbi->common; 44 45 for (Q = 0; Q < QINDEX_RANGE; Q++) 46 { 47 pc->Y1dequant[Q][0] = (short)vp8_dc_quant(Q, pc->y1dc_delta_q); 48 pc->Y2dequant[Q][0] = (short)vp8_dc2quant(Q, pc->y2dc_delta_q); 49 pc->UVdequant[Q][0] = (short)vp8_dc_uv_quant(Q, pc->uvdc_delta_q); 50 51 pc->Y1dequant[Q][1] = (short)vp8_ac_yquant(Q); 52 pc->Y2dequant[Q][1] = (short)vp8_ac2quant(Q, pc->y2ac_delta_q); 53 pc->UVdequant[Q][1] = (short)vp8_ac_uv_quant(Q, pc->uvac_delta_q); 54 } 55 } 56 57 void vp8_mb_init_dequantizer(VP8D_COMP *pbi, MACROBLOCKD *xd) 58 { 59 int i; 60 int QIndex; 61 MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi; 62 VP8_COMMON *const pc = & pbi->common; 63 64 /* Decide whether to use the default or alternate baseline Q value. */ 65 if (xd->segmentation_enabled) 66 { 67 /* Abs Value */ 68 if (xd->mb_segement_abs_delta == SEGMENT_ABSDATA) 69 QIndex = xd->segment_feature_data[MB_LVL_ALT_Q][mbmi->segment_id]; 70 71 /* Delta Value */ 72 else 73 { 74 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 */ 76 } 77 } 78 else 79 QIndex = pc->base_qindex; 80 81 /* Set up the macroblock dequant constants */ 82 xd->dequant_y1_dc[0] = 1; 83 xd->dequant_y1[0] = pc->Y1dequant[QIndex][0]; 84 xd->dequant_y2[0] = pc->Y2dequant[QIndex][0]; 85 xd->dequant_uv[0] = pc->UVdequant[QIndex][0]; 86 87 for (i = 1; i < 16; i++) 88 { 89 xd->dequant_y1_dc[i] = 90 xd->dequant_y1[i] = pc->Y1dequant[QIndex][1]; 91 xd->dequant_y2[i] = pc->Y2dequant[QIndex][1]; 92 xd->dequant_uv[i] = pc->UVdequant[QIndex][1]; 93 } 94 } 95 96 static void decode_macroblock(VP8D_COMP *pbi, MACROBLOCKD *xd, 97 unsigned int mb_idx) 98 { 99 MB_PREDICTION_MODE mode; 100 int i; 101 #if CONFIG_ERROR_CONCEALMENT 102 int corruption_detected = 0; 103 #endif 104 105 if (xd->mode_info_context->mbmi.mb_skip_coeff) 106 { 107 vp8_reset_mb_tokens_context(xd); 108 } 109 else if (!vp8dx_bool_error(xd->current_bc)) 110 { 111 int eobtotal; 112 eobtotal = vp8_decode_mb_tokens(pbi, xd); 113 114 /* Special case: Force the loopfilter to skip when eobtotal is zero */ 115 xd->mode_info_context->mbmi.mb_skip_coeff = (eobtotal==0); 116 } 117 118 mode = xd->mode_info_context->mbmi.mode; 119 120 if (xd->segmentation_enabled) 121 vp8_mb_init_dequantizer(pbi, xd); 122 123 124 #if CONFIG_ERROR_CONCEALMENT 125 126 if(pbi->ec_active) 127 { 128 int throw_residual; 129 /* When we have independent partitions we can apply residual even 130 * though other partitions within the frame are corrupt. 131 */ 132 throw_residual = (!pbi->independent_partitions && 133 pbi->frame_corrupt_residual); 134 throw_residual = (throw_residual || vp8dx_bool_error(xd->current_bc)); 135 136 if ((mb_idx >= pbi->mvs_corrupt_from_mb || throw_residual)) 137 { 138 /* MB with corrupt residuals or corrupt mode/motion vectors. 139 * Better to use the predictor as reconstruction. 140 */ 141 pbi->frame_corrupt_residual = 1; 142 vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff)); 143 vp8_conceal_corrupt_mb(xd); 144 145 146 corruption_detected = 1; 147 148 /* force idct to be skipped for B_PRED and use the 149 * prediction only for reconstruction 150 * */ 151 vpx_memset(xd->eobs, 0, 25); 152 } 153 } 154 #endif 155 156 /* do prediction */ 157 if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) 158 { 159 vp8_build_intra_predictors_mbuv_s(xd, 160 xd->recon_above[1], 161 xd->recon_above[2], 162 xd->recon_left[1], 163 xd->recon_left[2], 164 xd->recon_left_stride[1], 165 xd->dst.u_buffer, xd->dst.v_buffer, 166 xd->dst.uv_stride); 167 168 if (mode != B_PRED) 169 { 170 vp8_build_intra_predictors_mby_s(xd, 171 xd->recon_above[0], 172 xd->recon_left[0], 173 xd->recon_left_stride[0], 174 xd->dst.y_buffer, 175 xd->dst.y_stride); 176 } 177 else 178 { 179 short *DQC = xd->dequant_y1; 180 int dst_stride = xd->dst.y_stride; 181 182 /* clear out residual eob info */ 183 if(xd->mode_info_context->mbmi.mb_skip_coeff) 184 vpx_memset(xd->eobs, 0, 25); 185 186 intra_prediction_down_copy(xd, xd->recon_above[0] + 16); 187 188 for (i = 0; i < 16; i++) 189 { 190 BLOCKD *b = &xd->block[i]; 191 unsigned char *dst = xd->dst.y_buffer + b->offset; 192 B_PREDICTION_MODE b_mode = 193 xd->mode_info_context->bmi[i].as_mode; 194 unsigned char *Above = dst - dst_stride; 195 unsigned char *yleft = dst - 1; 196 int left_stride = dst_stride; 197 unsigned char top_left = Above[-1]; 198 199 vp8_intra4x4_predict(Above, yleft, left_stride, b_mode, 200 dst, dst_stride, top_left); 201 202 if (xd->eobs[i]) 203 { 204 if (xd->eobs[i] > 1) 205 { 206 vp8_dequant_idct_add(b->qcoeff, DQC, dst, dst_stride); 207 } 208 else 209 { 210 vp8_dc_only_idct_add 211 (b->qcoeff[0] * DQC[0], 212 dst, dst_stride, 213 dst, dst_stride); 214 vpx_memset(b->qcoeff, 0, 2 * sizeof(b->qcoeff[0])); 215 } 216 } 217 } 218 } 219 } 220 else 221 { 222 vp8_build_inter_predictors_mb(xd); 223 } 224 225 226 #if CONFIG_ERROR_CONCEALMENT 227 if (corruption_detected) 228 { 229 return; 230 } 231 #endif 232 233 if(!xd->mode_info_context->mbmi.mb_skip_coeff) 234 { 235 /* dequantization and idct */ 236 if (mode != B_PRED) 237 { 238 short *DQC = xd->dequant_y1; 239 240 if (mode != SPLITMV) 241 { 242 BLOCKD *b = &xd->block[24]; 243 244 /* do 2nd order transform on the dc block */ 245 if (xd->eobs[24] > 1) 246 { 247 vp8_dequantize_b(b, xd->dequant_y2); 248 249 vp8_short_inv_walsh4x4(&b->dqcoeff[0], 250 xd->qcoeff); 251 vpx_memset(b->qcoeff, 0, 16 * sizeof(b->qcoeff[0])); 252 } 253 else 254 { 255 b->dqcoeff[0] = b->qcoeff[0] * xd->dequant_y2[0]; 256 vp8_short_inv_walsh4x4_1(&b->dqcoeff[0], 257 xd->qcoeff); 258 vpx_memset(b->qcoeff, 0, 2 * sizeof(b->qcoeff[0])); 259 } 260 261 /* override the dc dequant constant in order to preserve the 262 * dc components 263 */ 264 DQC = xd->dequant_y1_dc; 265 } 266 267 vp8_dequant_idct_add_y_block 268 (xd->qcoeff, DQC, 269 xd->dst.y_buffer, 270 xd->dst.y_stride, xd->eobs); 271 } 272 273 vp8_dequant_idct_add_uv_block 274 (xd->qcoeff+16*16, xd->dequant_uv, 275 xd->dst.u_buffer, xd->dst.v_buffer, 276 xd->dst.uv_stride, xd->eobs+16); 277 } 278 } 279 280 static int get_delta_q(vp8_reader *bc, int prev, int *q_update) 281 { 282 int ret_val = 0; 283 284 if (vp8_read_bit(bc)) 285 { 286 ret_val = vp8_read_literal(bc, 4); 287 288 if (vp8_read_bit(bc)) 289 ret_val = -ret_val; 290 } 291 292 /* Trigger a quantizer update if the delta-q value has changed */ 293 if (ret_val != prev) 294 *q_update = 1; 295 296 return ret_val; 297 } 298 299 #ifdef PACKET_TESTING 300 #include <stdio.h> 301 FILE *vpxlog = 0; 302 #endif 303 304 static void yv12_extend_frame_top_c(YV12_BUFFER_CONFIG *ybf) 305 { 306 int i; 307 unsigned char *src_ptr1; 308 unsigned char *dest_ptr1; 309 310 unsigned int Border; 311 int plane_stride; 312 313 /***********/ 314 /* Y Plane */ 315 /***********/ 316 Border = ybf->border; 317 plane_stride = ybf->y_stride; 318 src_ptr1 = ybf->y_buffer - Border; 319 dest_ptr1 = src_ptr1 - (Border * plane_stride); 320 321 for (i = 0; i < (int)Border; i++) 322 { 323 vpx_memcpy(dest_ptr1, src_ptr1, plane_stride); 324 dest_ptr1 += plane_stride; 325 } 326 327 328 /***********/ 329 /* U Plane */ 330 /***********/ 331 plane_stride = ybf->uv_stride; 332 Border /= 2; 333 src_ptr1 = ybf->u_buffer - Border; 334 dest_ptr1 = src_ptr1 - (Border * plane_stride); 335 336 for (i = 0; i < (int)(Border); i++) 337 { 338 vpx_memcpy(dest_ptr1, src_ptr1, plane_stride); 339 dest_ptr1 += plane_stride; 340 } 341 342 /***********/ 343 /* V Plane */ 344 /***********/ 345 346 src_ptr1 = ybf->v_buffer - Border; 347 dest_ptr1 = src_ptr1 - (Border * plane_stride); 348 349 for (i = 0; i < (int)(Border); i++) 350 { 351 vpx_memcpy(dest_ptr1, src_ptr1, plane_stride); 352 dest_ptr1 += plane_stride; 353 } 354 } 355 356 static void yv12_extend_frame_bottom_c(YV12_BUFFER_CONFIG *ybf) 357 { 358 int i; 359 unsigned char *src_ptr1, *src_ptr2; 360 unsigned char *dest_ptr2; 361 362 unsigned int Border; 363 int plane_stride; 364 int plane_height; 365 366 /***********/ 367 /* Y Plane */ 368 /***********/ 369 Border = ybf->border; 370 plane_stride = ybf->y_stride; 371 plane_height = ybf->y_height; 372 373 src_ptr1 = ybf->y_buffer - Border; 374 src_ptr2 = src_ptr1 + (plane_height * plane_stride) - plane_stride; 375 dest_ptr2 = src_ptr2 + plane_stride; 376 377 for (i = 0; i < (int)Border; i++) 378 { 379 vpx_memcpy(dest_ptr2, src_ptr2, plane_stride); 380 dest_ptr2 += plane_stride; 381 } 382 383 384 /***********/ 385 /* U Plane */ 386 /***********/ 387 plane_stride = ybf->uv_stride; 388 plane_height = ybf->uv_height; 389 Border /= 2; 390 391 src_ptr1 = ybf->u_buffer - Border; 392 src_ptr2 = src_ptr1 + (plane_height * plane_stride) - plane_stride; 393 dest_ptr2 = src_ptr2 + plane_stride; 394 395 for (i = 0; i < (int)(Border); i++) 396 { 397 vpx_memcpy(dest_ptr2, src_ptr2, plane_stride); 398 dest_ptr2 += plane_stride; 399 } 400 401 /***********/ 402 /* V Plane */ 403 /***********/ 404 405 src_ptr1 = ybf->v_buffer - Border; 406 src_ptr2 = src_ptr1 + (plane_height * plane_stride) - plane_stride; 407 dest_ptr2 = src_ptr2 + plane_stride; 408 409 for (i = 0; i < (int)(Border); i++) 410 { 411 vpx_memcpy(dest_ptr2, src_ptr2, plane_stride); 412 dest_ptr2 += plane_stride; 413 } 414 } 415 416 static void yv12_extend_frame_left_right_c(YV12_BUFFER_CONFIG *ybf, 417 unsigned char *y_src, 418 unsigned char *u_src, 419 unsigned char *v_src) 420 { 421 int i; 422 unsigned char *src_ptr1, *src_ptr2; 423 unsigned char *dest_ptr1, *dest_ptr2; 424 425 unsigned int Border; 426 int plane_stride; 427 int plane_height; 428 int plane_width; 429 430 /***********/ 431 /* Y Plane */ 432 /***********/ 433 Border = ybf->border; 434 plane_stride = ybf->y_stride; 435 plane_height = 16; 436 plane_width = ybf->y_width; 437 438 /* copy the left and right most columns out */ 439 src_ptr1 = y_src; 440 src_ptr2 = src_ptr1 + plane_width - 1; 441 dest_ptr1 = src_ptr1 - Border; 442 dest_ptr2 = src_ptr2 + 1; 443 444 for (i = 0; i < plane_height; i++) 445 { 446 vpx_memset(dest_ptr1, src_ptr1[0], Border); 447 vpx_memset(dest_ptr2, src_ptr2[0], Border); 448 src_ptr1 += plane_stride; 449 src_ptr2 += plane_stride; 450 dest_ptr1 += plane_stride; 451 dest_ptr2 += plane_stride; 452 } 453 454 /***********/ 455 /* U Plane */ 456 /***********/ 457 plane_stride = ybf->uv_stride; 458 plane_height = 8; 459 plane_width = ybf->uv_width; 460 Border /= 2; 461 462 /* copy the left and right most columns out */ 463 src_ptr1 = u_src; 464 src_ptr2 = src_ptr1 + plane_width - 1; 465 dest_ptr1 = src_ptr1 - Border; 466 dest_ptr2 = src_ptr2 + 1; 467 468 for (i = 0; i < plane_height; i++) 469 { 470 vpx_memset(dest_ptr1, src_ptr1[0], Border); 471 vpx_memset(dest_ptr2, src_ptr2[0], Border); 472 src_ptr1 += plane_stride; 473 src_ptr2 += plane_stride; 474 dest_ptr1 += plane_stride; 475 dest_ptr2 += plane_stride; 476 } 477 478 /***********/ 479 /* V Plane */ 480 /***********/ 481 482 /* copy the left and right most columns out */ 483 src_ptr1 = v_src; 484 src_ptr2 = src_ptr1 + plane_width - 1; 485 dest_ptr1 = src_ptr1 - Border; 486 dest_ptr2 = src_ptr2 + 1; 487 488 for (i = 0; i < plane_height; i++) 489 { 490 vpx_memset(dest_ptr1, src_ptr1[0], Border); 491 vpx_memset(dest_ptr2, src_ptr2[0], Border); 492 src_ptr1 += plane_stride; 493 src_ptr2 += plane_stride; 494 dest_ptr1 += plane_stride; 495 dest_ptr2 += plane_stride; 496 } 497 } 498 499 static void decode_mb_rows(VP8D_COMP *pbi) 500 { 501 VP8_COMMON *const pc = & pbi->common; 502 MACROBLOCKD *const xd = & pbi->mb; 503 504 MODE_INFO *lf_mic = xd->mode_info_context; 505 506 int ibc = 0; 507 int num_part = 1 << pc->multi_token_partition; 508 509 int recon_yoffset, recon_uvoffset; 510 int mb_row, mb_col; 511 int mb_idx = 0; 512 513 YV12_BUFFER_CONFIG *yv12_fb_new = pbi->dec_fb_ref[INTRA_FRAME]; 514 515 int recon_y_stride = yv12_fb_new->y_stride; 516 int recon_uv_stride = yv12_fb_new->uv_stride; 517 518 unsigned char *ref_buffer[MAX_REF_FRAMES][3]; 519 unsigned char *dst_buffer[3]; 520 unsigned char *lf_dst[3]; 521 unsigned char *eb_dst[3]; 522 int i; 523 int ref_fb_corrupted[MAX_REF_FRAMES]; 524 525 ref_fb_corrupted[INTRA_FRAME] = 0; 526 527 for(i = 1; i < MAX_REF_FRAMES; i++) 528 { 529 YV12_BUFFER_CONFIG *this_fb = pbi->dec_fb_ref[i]; 530 531 ref_buffer[i][0] = this_fb->y_buffer; 532 ref_buffer[i][1] = this_fb->u_buffer; 533 ref_buffer[i][2] = this_fb->v_buffer; 534 535 ref_fb_corrupted[i] = this_fb->corrupted; 536 } 537 538 /* Set up the buffer pointers */ 539 eb_dst[0] = lf_dst[0] = dst_buffer[0] = yv12_fb_new->y_buffer; 540 eb_dst[1] = lf_dst[1] = dst_buffer[1] = yv12_fb_new->u_buffer; 541 eb_dst[2] = lf_dst[2] = dst_buffer[2] = yv12_fb_new->v_buffer; 542 543 xd->up_available = 0; 544 545 /* Initialize the loop filter for this frame. */ 546 if(pc->filter_level) 547 vp8_loop_filter_frame_init(pc, xd, pc->filter_level); 548 549 vp8_setup_intra_recon_top_line(yv12_fb_new); 550 551 /* Decode the individual macro block */ 552 for (mb_row = 0; mb_row < pc->mb_rows; mb_row++) 553 { 554 if (num_part > 1) 555 { 556 xd->current_bc = & pbi->mbc[ibc]; 557 ibc++; 558 559 if (ibc == num_part) 560 ibc = 0; 561 } 562 563 recon_yoffset = mb_row * recon_y_stride * 16; 564 recon_uvoffset = mb_row * recon_uv_stride * 8; 565 566 /* reset contexts */ 567 xd->above_context = pc->above_context; 568 vpx_memset(xd->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES)); 569 570 xd->left_available = 0; 571 572 xd->mb_to_top_edge = -((mb_row * 16) << 3); 573 xd->mb_to_bottom_edge = ((pc->mb_rows - 1 - mb_row) * 16) << 3; 574 575 xd->recon_above[0] = dst_buffer[0] + recon_yoffset; 576 xd->recon_above[1] = dst_buffer[1] + recon_uvoffset; 577 xd->recon_above[2] = dst_buffer[2] + recon_uvoffset; 578 579 xd->recon_left[0] = xd->recon_above[0] - 1; 580 xd->recon_left[1] = xd->recon_above[1] - 1; 581 xd->recon_left[2] = xd->recon_above[2] - 1; 582 583 xd->recon_above[0] -= xd->dst.y_stride; 584 xd->recon_above[1] -= xd->dst.uv_stride; 585 xd->recon_above[2] -= xd->dst.uv_stride; 586 587 /* TODO: move to outside row loop */ 588 xd->recon_left_stride[0] = xd->dst.y_stride; 589 xd->recon_left_stride[1] = xd->dst.uv_stride; 590 591 setup_intra_recon_left(xd->recon_left[0], xd->recon_left[1], 592 xd->recon_left[2], xd->dst.y_stride, 593 xd->dst.uv_stride); 594 595 for (mb_col = 0; mb_col < pc->mb_cols; mb_col++) 596 { 597 /* Distance of Mb to the various image edges. 598 * These are specified to 8th pel as they are always compared to values 599 * that are in 1/8th pel units 600 */ 601 xd->mb_to_left_edge = -((mb_col * 16) << 3); 602 xd->mb_to_right_edge = ((pc->mb_cols - 1 - mb_col) * 16) << 3; 603 604 #if CONFIG_ERROR_CONCEALMENT 605 { 606 int corrupt_residual = (!pbi->independent_partitions && 607 pbi->frame_corrupt_residual) || 608 vp8dx_bool_error(xd->current_bc); 609 if (pbi->ec_active && 610 xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME && 611 corrupt_residual) 612 { 613 /* We have an intra block with corrupt coefficients, better to 614 * conceal with an inter block. Interpolate MVs from neighboring 615 * MBs. 616 * 617 * Note that for the first mb with corrupt residual in a frame, 618 * we might not discover that before decoding the residual. That 619 * happens after this check, and therefore no inter concealment 620 * will be done. 621 */ 622 vp8_interpolate_motion(xd, 623 mb_row, mb_col, 624 pc->mb_rows, pc->mb_cols, 625 pc->mode_info_stride); 626 } 627 } 628 #endif 629 630 xd->dst.y_buffer = dst_buffer[0] + recon_yoffset; 631 xd->dst.u_buffer = dst_buffer[1] + recon_uvoffset; 632 xd->dst.v_buffer = dst_buffer[2] + recon_uvoffset; 633 634 xd->pre.y_buffer = ref_buffer[xd->mode_info_context->mbmi.ref_frame][0] + recon_yoffset; 635 xd->pre.u_buffer = ref_buffer[xd->mode_info_context->mbmi.ref_frame][1] + recon_uvoffset; 636 xd->pre.v_buffer = ref_buffer[xd->mode_info_context->mbmi.ref_frame][2] + recon_uvoffset; 637 638 /* propagate errors from reference frames */ 639 xd->corrupted |= ref_fb_corrupted[xd->mode_info_context->mbmi.ref_frame]; 640 641 decode_macroblock(pbi, xd, mb_idx); 642 643 mb_idx++; 644 xd->left_available = 1; 645 646 /* check if the boolean decoder has suffered an error */ 647 xd->corrupted |= vp8dx_bool_error(xd->current_bc); 648 649 xd->recon_above[0] += 16; 650 xd->recon_above[1] += 8; 651 xd->recon_above[2] += 8; 652 xd->recon_left[0] += 16; 653 xd->recon_left[1] += 8; 654 xd->recon_left[2] += 8; 655 656 recon_yoffset += 16; 657 recon_uvoffset += 8; 658 659 ++xd->mode_info_context; /* next mb */ 660 661 xd->above_context++; 662 } 663 664 /* adjust to the next row of mbs */ 665 vp8_extend_mb_row(yv12_fb_new, xd->dst.y_buffer + 16, 666 xd->dst.u_buffer + 8, xd->dst.v_buffer + 8); 667 668 ++xd->mode_info_context; /* skip prediction column */ 669 xd->up_available = 1; 670 671 if(pc->filter_level) 672 { 673 if(mb_row > 0) 674 { 675 if (pc->filter_type == NORMAL_LOOPFILTER) 676 vp8_loop_filter_row_normal(pc, lf_mic, mb_row-1, 677 recon_y_stride, recon_uv_stride, 678 lf_dst[0], lf_dst[1], lf_dst[2]); 679 else 680 vp8_loop_filter_row_simple(pc, lf_mic, mb_row-1, 681 recon_y_stride, recon_uv_stride, 682 lf_dst[0], lf_dst[1], lf_dst[2]); 683 684 if(mb_row > 1) 685 { 686 yv12_extend_frame_left_right_c(yv12_fb_new, 687 eb_dst[0], 688 eb_dst[1], 689 eb_dst[2]); 690 691 eb_dst[0] += recon_y_stride * 16; 692 eb_dst[1] += recon_uv_stride * 8; 693 eb_dst[2] += recon_uv_stride * 8; 694 695 if(mb_row == 2) 696 yv12_extend_frame_top_c(yv12_fb_new); 697 698 } 699 700 lf_dst[0] += recon_y_stride * 16; 701 lf_dst[1] += recon_uv_stride * 8; 702 lf_dst[2] += recon_uv_stride * 8; 703 lf_mic += pc->mb_cols; 704 lf_mic++; /* Skip border mb */ 705 } 706 } 707 else 708 { 709 if(mb_row > 0) 710 { 711 /**/ 712 yv12_extend_frame_left_right_c(yv12_fb_new, 713 eb_dst[0], 714 eb_dst[1], 715 eb_dst[2]); 716 717 eb_dst[0] += recon_y_stride * 16; 718 eb_dst[1] += recon_uv_stride * 8; 719 eb_dst[2] += recon_uv_stride * 8; 720 721 if(mb_row == 1) 722 yv12_extend_frame_top_c(yv12_fb_new); 723 } 724 } 725 } 726 727 if(pc->filter_level) 728 { 729 if (pc->filter_type == NORMAL_LOOPFILTER) 730 vp8_loop_filter_row_normal(pc, lf_mic, mb_row-1, recon_y_stride, 731 recon_uv_stride, lf_dst[0], lf_dst[1], 732 lf_dst[2]); 733 else 734 vp8_loop_filter_row_simple(pc, lf_mic, mb_row-1, recon_y_stride, 735 recon_uv_stride, lf_dst[0], lf_dst[1], 736 lf_dst[2]); 737 738 yv12_extend_frame_left_right_c(yv12_fb_new, 739 eb_dst[0], 740 eb_dst[1], 741 eb_dst[2]); 742 eb_dst[0] += recon_y_stride * 16; 743 eb_dst[1] += recon_uv_stride * 8; 744 eb_dst[2] += recon_uv_stride * 8; 745 } 746 yv12_extend_frame_left_right_c(yv12_fb_new, 747 eb_dst[0], 748 eb_dst[1], 749 eb_dst[2]); 750 751 yv12_extend_frame_bottom_c(yv12_fb_new); 752 753 } 754 755 static unsigned int read_partition_size(VP8D_COMP *pbi, 756 const unsigned char *cx_size) 757 { 758 unsigned char temp[3]; 759 if (pbi->decrypt_cb) 760 { 761 pbi->decrypt_cb(pbi->decrypt_state, cx_size, temp, 3); 762 cx_size = temp; 763 } 764 return cx_size[0] + (cx_size[1] << 8) + (cx_size[2] << 16); 765 } 766 767 static int read_is_valid(const unsigned char *start, 768 size_t len, 769 const unsigned char *end) 770 { 771 return (start + len > start && start + len <= end); 772 } 773 774 static unsigned int read_available_partition_size( 775 VP8D_COMP *pbi, 776 const unsigned char *token_part_sizes, 777 const unsigned char *fragment_start, 778 const unsigned char *first_fragment_end, 779 const unsigned char *fragment_end, 780 int i, 781 int num_part) 782 { 783 VP8_COMMON* pc = &pbi->common; 784 const unsigned char *partition_size_ptr = token_part_sizes + i * 3; 785 unsigned int partition_size = 0; 786 ptrdiff_t bytes_left = fragment_end - fragment_start; 787 /* Calculate the length of this partition. The last partition 788 * size is implicit. If the partition size can't be read, then 789 * either use the remaining data in the buffer (for EC mode) 790 * or throw an error. 791 */ 792 if (i < num_part - 1) 793 { 794 if (read_is_valid(partition_size_ptr, 3, first_fragment_end)) 795 partition_size = read_partition_size(pbi, partition_size_ptr); 796 else if (pbi->ec_active) 797 partition_size = (unsigned int)bytes_left; 798 else 799 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, 800 "Truncated partition size data"); 801 } 802 else 803 partition_size = (unsigned int)bytes_left; 804 805 /* Validate the calculated partition length. If the buffer 806 * described by the partition can't be fully read, then restrict 807 * it to the portion that can be (for EC mode) or throw an error. 808 */ 809 if (!read_is_valid(fragment_start, partition_size, fragment_end)) 810 { 811 if (pbi->ec_active) 812 partition_size = (unsigned int)bytes_left; 813 else 814 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, 815 "Truncated packet or corrupt partition " 816 "%d length", i + 1); 817 } 818 return partition_size; 819 } 820 821 822 static void setup_token_decoder(VP8D_COMP *pbi, 823 const unsigned char* token_part_sizes) 824 { 825 vp8_reader *bool_decoder = &pbi->mbc[0]; 826 unsigned int partition_idx; 827 unsigned int fragment_idx; 828 unsigned int num_token_partitions; 829 const unsigned char *first_fragment_end = pbi->fragments.ptrs[0] + 830 pbi->fragments.sizes[0]; 831 832 TOKEN_PARTITION multi_token_partition = 833 (TOKEN_PARTITION)vp8_read_literal(&pbi->mbc[8], 2); 834 if (!vp8dx_bool_error(&pbi->mbc[8])) 835 pbi->common.multi_token_partition = multi_token_partition; 836 num_token_partitions = 1 << pbi->common.multi_token_partition; 837 838 /* Check for partitions within the fragments and unpack the fragments 839 * so that each fragment pointer points to its corresponding partition. */ 840 for (fragment_idx = 0; fragment_idx < pbi->fragments.count; ++fragment_idx) 841 { 842 unsigned int fragment_size = pbi->fragments.sizes[fragment_idx]; 843 const unsigned char *fragment_end = pbi->fragments.ptrs[fragment_idx] + 844 fragment_size; 845 /* Special case for handling the first partition since we have already 846 * read its size. */ 847 if (fragment_idx == 0) 848 { 849 /* Size of first partition + token partition sizes element */ 850 ptrdiff_t ext_first_part_size = token_part_sizes - 851 pbi->fragments.ptrs[0] + 3 * (num_token_partitions - 1); 852 fragment_size -= (unsigned int)ext_first_part_size; 853 if (fragment_size > 0) 854 { 855 pbi->fragments.sizes[0] = (unsigned int)ext_first_part_size; 856 /* The fragment contains an additional partition. Move to 857 * next. */ 858 fragment_idx++; 859 pbi->fragments.ptrs[fragment_idx] = pbi->fragments.ptrs[0] + 860 pbi->fragments.sizes[0]; 861 } 862 } 863 /* Split the chunk into partitions read from the bitstream */ 864 while (fragment_size > 0) 865 { 866 ptrdiff_t partition_size = read_available_partition_size( 867 pbi, 868 token_part_sizes, 869 pbi->fragments.ptrs[fragment_idx], 870 first_fragment_end, 871 fragment_end, 872 fragment_idx - 1, 873 num_token_partitions); 874 pbi->fragments.sizes[fragment_idx] = (unsigned int)partition_size; 875 fragment_size -= (unsigned int)partition_size; 876 assert(fragment_idx <= num_token_partitions); 877 if (fragment_size > 0) 878 { 879 /* The fragment contains an additional partition. 880 * Move to next. */ 881 fragment_idx++; 882 pbi->fragments.ptrs[fragment_idx] = 883 pbi->fragments.ptrs[fragment_idx - 1] + partition_size; 884 } 885 } 886 } 887 888 pbi->fragments.count = num_token_partitions + 1; 889 890 for (partition_idx = 1; partition_idx < pbi->fragments.count; ++partition_idx) 891 { 892 if (vp8dx_start_decode(bool_decoder, 893 pbi->fragments.ptrs[partition_idx], 894 pbi->fragments.sizes[partition_idx], 895 pbi->decrypt_cb, pbi->decrypt_state)) 896 vpx_internal_error(&pbi->common.error, VPX_CODEC_MEM_ERROR, 897 "Failed to allocate bool decoder %d", 898 partition_idx); 899 900 bool_decoder++; 901 } 902 903 #if CONFIG_MULTITHREAD 904 /* Clamp number of decoder threads */ 905 if (pbi->decoding_thread_count > num_token_partitions - 1) 906 pbi->decoding_thread_count = num_token_partitions - 1; 907 #endif 908 } 909 910 911 static void init_frame(VP8D_COMP *pbi) 912 { 913 VP8_COMMON *const pc = & pbi->common; 914 MACROBLOCKD *const xd = & pbi->mb; 915 916 if (pc->frame_type == KEY_FRAME) 917 { 918 /* Various keyframe initializations */ 919 vpx_memcpy(pc->fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context)); 920 921 vp8_init_mbmode_probs(pc); 922 923 vp8_default_coef_probs(pc); 924 925 /* reset the segment feature data to 0 with delta coding (Default state). */ 926 vpx_memset(xd->segment_feature_data, 0, sizeof(xd->segment_feature_data)); 927 xd->mb_segement_abs_delta = SEGMENT_DELTADATA; 928 929 /* reset the mode ref deltasa for loop filter */ 930 vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas)); 931 vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas)); 932 933 /* All buffers are implicitly updated on key frames. */ 934 pc->refresh_golden_frame = 1; 935 pc->refresh_alt_ref_frame = 1; 936 pc->copy_buffer_to_gf = 0; 937 pc->copy_buffer_to_arf = 0; 938 939 /* Note that Golden and Altref modes cannot be used on a key frame so 940 * ref_frame_sign_bias[] is undefined and meaningless 941 */ 942 pc->ref_frame_sign_bias[GOLDEN_FRAME] = 0; 943 pc->ref_frame_sign_bias[ALTREF_FRAME] = 0; 944 } 945 else 946 { 947 /* To enable choice of different interploation filters */ 948 if (!pc->use_bilinear_mc_filter) 949 { 950 xd->subpixel_predict = vp8_sixtap_predict4x4; 951 xd->subpixel_predict8x4 = vp8_sixtap_predict8x4; 952 xd->subpixel_predict8x8 = vp8_sixtap_predict8x8; 953 xd->subpixel_predict16x16 = vp8_sixtap_predict16x16; 954 } 955 else 956 { 957 xd->subpixel_predict = vp8_bilinear_predict4x4; 958 xd->subpixel_predict8x4 = vp8_bilinear_predict8x4; 959 xd->subpixel_predict8x8 = vp8_bilinear_predict8x8; 960 xd->subpixel_predict16x16 = vp8_bilinear_predict16x16; 961 } 962 963 if (pbi->decoded_key_frame && pbi->ec_enabled && !pbi->ec_active) 964 pbi->ec_active = 1; 965 } 966 967 xd->left_context = &pc->left_context; 968 xd->mode_info_context = pc->mi; 969 xd->frame_type = pc->frame_type; 970 xd->mode_info_context->mbmi.mode = DC_PRED; 971 xd->mode_info_stride = pc->mode_info_stride; 972 xd->corrupted = 0; /* init without corruption */ 973 974 xd->fullpixel_mask = 0xffffffff; 975 if(pc->full_pixel) 976 xd->fullpixel_mask = 0xfffffff8; 977 978 } 979 980 int vp8_decode_frame(VP8D_COMP *pbi) 981 { 982 vp8_reader *const bc = &pbi->mbc[8]; 983 VP8_COMMON *const pc = &pbi->common; 984 MACROBLOCKD *const xd = &pbi->mb; 985 const unsigned char *data = pbi->fragments.ptrs[0]; 986 const unsigned char *data_end = data + pbi->fragments.sizes[0]; 987 ptrdiff_t first_partition_length_in_bytes; 988 989 int i, j, k, l; 990 const int *const mb_feature_data_bits = vp8_mb_feature_data_bits; 991 int corrupt_tokens = 0; 992 int prev_independent_partitions = pbi->independent_partitions; 993 994 YV12_BUFFER_CONFIG *yv12_fb_new = pbi->dec_fb_ref[INTRA_FRAME]; 995 996 /* start with no corruption of current frame */ 997 xd->corrupted = 0; 998 yv12_fb_new->corrupted = 0; 999 1000 if (data_end - data < 3) 1001 { 1002 if (!pbi->ec_active) 1003 { 1004 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, 1005 "Truncated packet"); 1006 } 1007 1008 /* Declare the missing frame as an inter frame since it will 1009 be handled as an inter frame when we have estimated its 1010 motion vectors. */ 1011 pc->frame_type = INTER_FRAME; 1012 pc->version = 0; 1013 pc->show_frame = 1; 1014 first_partition_length_in_bytes = 0; 1015 } 1016 else 1017 { 1018 unsigned char clear_buffer[10]; 1019 const unsigned char *clear = data; 1020 if (pbi->decrypt_cb) 1021 { 1022 int n = (int)(data_end - data); 1023 if (n > 10) n = 10; 1024 pbi->decrypt_cb(pbi->decrypt_state, data, clear_buffer, n); 1025 clear = clear_buffer; 1026 } 1027 1028 pc->frame_type = (FRAME_TYPE)(clear[0] & 1); 1029 pc->version = (clear[0] >> 1) & 7; 1030 pc->show_frame = (clear[0] >> 4) & 1; 1031 first_partition_length_in_bytes = 1032 (clear[0] | (clear[1] << 8) | (clear[2] << 16)) >> 5; 1033 1034 if (!pbi->ec_active && 1035 (data + first_partition_length_in_bytes > data_end 1036 || data + first_partition_length_in_bytes < data)) 1037 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, 1038 "Truncated packet or corrupt partition 0 length"); 1039 1040 data += 3; 1041 clear += 3; 1042 1043 vp8_setup_version(pc); 1044 1045 1046 if (pc->frame_type == KEY_FRAME) 1047 { 1048 /* vet via sync code */ 1049 /* When error concealment is enabled we should only check the sync 1050 * code if we have enough bits available 1051 */ 1052 if (!pbi->ec_active || data + 3 < data_end) 1053 { 1054 if (clear[0] != 0x9d || clear[1] != 0x01 || clear[2] != 0x2a) 1055 vpx_internal_error(&pc->error, VPX_CODEC_UNSUP_BITSTREAM, 1056 "Invalid frame sync code"); 1057 } 1058 1059 /* If error concealment is enabled we should only parse the new size 1060 * if we have enough data. Otherwise we will end up with the wrong 1061 * size. 1062 */ 1063 if (!pbi->ec_active || data + 6 < data_end) 1064 { 1065 pc->Width = (clear[3] | (clear[4] << 8)) & 0x3fff; 1066 pc->horiz_scale = clear[4] >> 6; 1067 pc->Height = (clear[5] | (clear[6] << 8)) & 0x3fff; 1068 pc->vert_scale = clear[6] >> 6; 1069 } 1070 data += 7; 1071 clear += 7; 1072 } 1073 else 1074 { 1075 vpx_memcpy(&xd->pre, yv12_fb_new, sizeof(YV12_BUFFER_CONFIG)); 1076 vpx_memcpy(&xd->dst, yv12_fb_new, sizeof(YV12_BUFFER_CONFIG)); 1077 } 1078 } 1079 if ((!pbi->decoded_key_frame && pc->frame_type != KEY_FRAME)) 1080 { 1081 return -1; 1082 } 1083 1084 init_frame(pbi); 1085 1086 if (vp8dx_start_decode(bc, data, (unsigned int)(data_end - data), 1087 pbi->decrypt_cb, pbi->decrypt_state)) 1088 vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR, 1089 "Failed to allocate bool decoder 0"); 1090 if (pc->frame_type == KEY_FRAME) { 1091 (void)vp8_read_bit(bc); // colorspace 1092 pc->clamp_type = (CLAMP_TYPE)vp8_read_bit(bc); 1093 } 1094 1095 /* Is segmentation enabled */ 1096 xd->segmentation_enabled = (unsigned char)vp8_read_bit(bc); 1097 1098 if (xd->segmentation_enabled) 1099 { 1100 /* Signal whether or not the segmentation map is being explicitly updated this frame. */ 1101 xd->update_mb_segmentation_map = (unsigned char)vp8_read_bit(bc); 1102 xd->update_mb_segmentation_data = (unsigned char)vp8_read_bit(bc); 1103 1104 if (xd->update_mb_segmentation_data) 1105 { 1106 xd->mb_segement_abs_delta = (unsigned char)vp8_read_bit(bc); 1107 1108 vpx_memset(xd->segment_feature_data, 0, sizeof(xd->segment_feature_data)); 1109 1110 /* For each segmentation feature (Quant and loop filter level) */ 1111 for (i = 0; i < MB_LVL_MAX; i++) 1112 { 1113 for (j = 0; j < MAX_MB_SEGMENTS; j++) 1114 { 1115 /* Frame level data */ 1116 if (vp8_read_bit(bc)) 1117 { 1118 xd->segment_feature_data[i][j] = (signed char)vp8_read_literal(bc, mb_feature_data_bits[i]); 1119 1120 if (vp8_read_bit(bc)) 1121 xd->segment_feature_data[i][j] = -xd->segment_feature_data[i][j]; 1122 } 1123 else 1124 xd->segment_feature_data[i][j] = 0; 1125 } 1126 } 1127 } 1128 1129 if (xd->update_mb_segmentation_map) 1130 { 1131 /* Which macro block level features are enabled */ 1132 vpx_memset(xd->mb_segment_tree_probs, 255, sizeof(xd->mb_segment_tree_probs)); 1133 1134 /* Read the probs used to decode the segment id for each macro block. */ 1135 for (i = 0; i < MB_FEATURE_TREE_PROBS; i++) 1136 { 1137 /* If not explicitly set value is defaulted to 255 by memset above */ 1138 if (vp8_read_bit(bc)) 1139 xd->mb_segment_tree_probs[i] = (vp8_prob)vp8_read_literal(bc, 8); 1140 } 1141 } 1142 } 1143 else 1144 { 1145 /* No segmentation updates on this frame */ 1146 xd->update_mb_segmentation_map = 0; 1147 xd->update_mb_segmentation_data = 0; 1148 } 1149 1150 /* Read the loop filter level and type */ 1151 pc->filter_type = (LOOPFILTERTYPE) vp8_read_bit(bc); 1152 pc->filter_level = vp8_read_literal(bc, 6); 1153 pc->sharpness_level = vp8_read_literal(bc, 3); 1154 1155 /* Read in loop filter deltas applied at the MB level based on mode or ref frame. */ 1156 xd->mode_ref_lf_delta_update = 0; 1157 xd->mode_ref_lf_delta_enabled = (unsigned char)vp8_read_bit(bc); 1158 1159 if (xd->mode_ref_lf_delta_enabled) 1160 { 1161 /* Do the deltas need to be updated */ 1162 xd->mode_ref_lf_delta_update = (unsigned char)vp8_read_bit(bc); 1163 1164 if (xd->mode_ref_lf_delta_update) 1165 { 1166 /* Send update */ 1167 for (i = 0; i < MAX_REF_LF_DELTAS; i++) 1168 { 1169 if (vp8_read_bit(bc)) 1170 { 1171 /*sign = vp8_read_bit( bc );*/ 1172 xd->ref_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6); 1173 1174 if (vp8_read_bit(bc)) /* Apply sign */ 1175 xd->ref_lf_deltas[i] = xd->ref_lf_deltas[i] * -1; 1176 } 1177 } 1178 1179 /* Send update */ 1180 for (i = 0; i < MAX_MODE_LF_DELTAS; i++) 1181 { 1182 if (vp8_read_bit(bc)) 1183 { 1184 /*sign = vp8_read_bit( bc );*/ 1185 xd->mode_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6); 1186 1187 if (vp8_read_bit(bc)) /* Apply sign */ 1188 xd->mode_lf_deltas[i] = xd->mode_lf_deltas[i] * -1; 1189 } 1190 } 1191 } 1192 } 1193 1194 setup_token_decoder(pbi, data + first_partition_length_in_bytes); 1195 1196 xd->current_bc = &pbi->mbc[0]; 1197 1198 /* Read the default quantizers. */ 1199 { 1200 int Q, q_update; 1201 1202 Q = vp8_read_literal(bc, 7); /* AC 1st order Q = default */ 1203 pc->base_qindex = Q; 1204 q_update = 0; 1205 pc->y1dc_delta_q = get_delta_q(bc, pc->y1dc_delta_q, &q_update); 1206 pc->y2dc_delta_q = get_delta_q(bc, pc->y2dc_delta_q, &q_update); 1207 pc->y2ac_delta_q = get_delta_q(bc, pc->y2ac_delta_q, &q_update); 1208 pc->uvdc_delta_q = get_delta_q(bc, pc->uvdc_delta_q, &q_update); 1209 pc->uvac_delta_q = get_delta_q(bc, pc->uvac_delta_q, &q_update); 1210 1211 if (q_update) 1212 vp8cx_init_de_quantizer(pbi); 1213 1214 /* MB level dequantizer setup */ 1215 vp8_mb_init_dequantizer(pbi, &pbi->mb); 1216 } 1217 1218 /* Determine if the golden frame or ARF buffer should be updated and how. 1219 * For all non key frames the GF and ARF refresh flags and sign bias 1220 * flags must be set explicitly. 1221 */ 1222 if (pc->frame_type != KEY_FRAME) 1223 { 1224 /* Should the GF or ARF be updated from the current frame */ 1225 pc->refresh_golden_frame = vp8_read_bit(bc); 1226 #if CONFIG_ERROR_CONCEALMENT 1227 /* Assume we shouldn't refresh golden if the bit is missing */ 1228 xd->corrupted |= vp8dx_bool_error(bc); 1229 if (pbi->ec_active && xd->corrupted) 1230 pc->refresh_golden_frame = 0; 1231 #endif 1232 1233 pc->refresh_alt_ref_frame = vp8_read_bit(bc); 1234 #if CONFIG_ERROR_CONCEALMENT 1235 /* Assume we shouldn't refresh altref if the bit is missing */ 1236 xd->corrupted |= vp8dx_bool_error(bc); 1237 if (pbi->ec_active && xd->corrupted) 1238 pc->refresh_alt_ref_frame = 0; 1239 #endif 1240 1241 /* Buffer to buffer copy flags. */ 1242 pc->copy_buffer_to_gf = 0; 1243 1244 if (!pc->refresh_golden_frame) 1245 pc->copy_buffer_to_gf = vp8_read_literal(bc, 2); 1246 1247 #if CONFIG_ERROR_CONCEALMENT 1248 /* Assume we shouldn't copy to the golden if the bit is missing */ 1249 xd->corrupted |= vp8dx_bool_error(bc); 1250 if (pbi->ec_active && xd->corrupted) 1251 pc->copy_buffer_to_gf = 0; 1252 #endif 1253 1254 pc->copy_buffer_to_arf = 0; 1255 1256 if (!pc->refresh_alt_ref_frame) 1257 pc->copy_buffer_to_arf = vp8_read_literal(bc, 2); 1258 1259 #if CONFIG_ERROR_CONCEALMENT 1260 /* Assume we shouldn't copy to the alt-ref if the bit is missing */ 1261 xd->corrupted |= vp8dx_bool_error(bc); 1262 if (pbi->ec_active && xd->corrupted) 1263 pc->copy_buffer_to_arf = 0; 1264 #endif 1265 1266 1267 pc->ref_frame_sign_bias[GOLDEN_FRAME] = vp8_read_bit(bc); 1268 pc->ref_frame_sign_bias[ALTREF_FRAME] = vp8_read_bit(bc); 1269 } 1270 1271 pc->refresh_entropy_probs = vp8_read_bit(bc); 1272 #if CONFIG_ERROR_CONCEALMENT 1273 /* Assume we shouldn't refresh the probabilities if the bit is 1274 * missing */ 1275 xd->corrupted |= vp8dx_bool_error(bc); 1276 if (pbi->ec_active && xd->corrupted) 1277 pc->refresh_entropy_probs = 0; 1278 #endif 1279 if (pc->refresh_entropy_probs == 0) 1280 { 1281 vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc)); 1282 } 1283 1284 pc->refresh_last_frame = pc->frame_type == KEY_FRAME || vp8_read_bit(bc); 1285 1286 #if CONFIG_ERROR_CONCEALMENT 1287 /* Assume we should refresh the last frame if the bit is missing */ 1288 xd->corrupted |= vp8dx_bool_error(bc); 1289 if (pbi->ec_active && xd->corrupted) 1290 pc->refresh_last_frame = 1; 1291 #endif 1292 1293 if (0) 1294 { 1295 FILE *z = fopen("decodestats.stt", "a"); 1296 fprintf(z, "%6d F:%d,G:%d,A:%d,L:%d,Q:%d\n", 1297 pc->current_video_frame, 1298 pc->frame_type, 1299 pc->refresh_golden_frame, 1300 pc->refresh_alt_ref_frame, 1301 pc->refresh_last_frame, 1302 pc->base_qindex); 1303 fclose(z); 1304 } 1305 1306 { 1307 pbi->independent_partitions = 1; 1308 1309 /* read coef probability tree */ 1310 for (i = 0; i < BLOCK_TYPES; i++) 1311 for (j = 0; j < COEF_BANDS; j++) 1312 for (k = 0; k < PREV_COEF_CONTEXTS; k++) 1313 for (l = 0; l < ENTROPY_NODES; l++) 1314 { 1315 1316 vp8_prob *const p = pc->fc.coef_probs [i][j][k] + l; 1317 1318 if (vp8_read(bc, vp8_coef_update_probs [i][j][k][l])) 1319 { 1320 *p = (vp8_prob)vp8_read_literal(bc, 8); 1321 1322 } 1323 if (k > 0 && *p != pc->fc.coef_probs[i][j][k-1][l]) 1324 pbi->independent_partitions = 0; 1325 1326 } 1327 } 1328 1329 /* clear out the coeff buffer */ 1330 vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff)); 1331 1332 vp8_decode_mode_mvs(pbi); 1333 1334 #if CONFIG_ERROR_CONCEALMENT 1335 if (pbi->ec_active && 1336 pbi->mvs_corrupt_from_mb < (unsigned int)pc->mb_cols * pc->mb_rows) 1337 { 1338 /* Motion vectors are missing in this frame. We will try to estimate 1339 * them and then continue decoding the frame as usual */ 1340 vp8_estimate_missing_mvs(pbi); 1341 } 1342 #endif 1343 1344 vpx_memset(pc->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * pc->mb_cols); 1345 pbi->frame_corrupt_residual = 0; 1346 1347 #if CONFIG_MULTITHREAD 1348 if (pbi->b_multithreaded_rd && pc->multi_token_partition != ONE_PARTITION) 1349 { 1350 unsigned int thread; 1351 vp8mt_decode_mb_rows(pbi, xd); 1352 vp8_yv12_extend_frame_borders(yv12_fb_new); 1353 for (thread = 0; thread < pbi->decoding_thread_count; ++thread) 1354 corrupt_tokens |= pbi->mb_row_di[thread].mbd.corrupted; 1355 } 1356 else 1357 #endif 1358 { 1359 decode_mb_rows(pbi); 1360 corrupt_tokens |= xd->corrupted; 1361 } 1362 1363 /* Collect information about decoder corruption. */ 1364 /* 1. Check first boolean decoder for errors. */ 1365 yv12_fb_new->corrupted = vp8dx_bool_error(bc); 1366 /* 2. Check the macroblock information */ 1367 yv12_fb_new->corrupted |= corrupt_tokens; 1368 1369 if (!pbi->decoded_key_frame) 1370 { 1371 if (pc->frame_type == KEY_FRAME && 1372 !yv12_fb_new->corrupted) 1373 pbi->decoded_key_frame = 1; 1374 else 1375 vpx_internal_error(&pbi->common.error, VPX_CODEC_CORRUPT_FRAME, 1376 "A stream must start with a complete key frame"); 1377 } 1378 1379 /* vpx_log("Decoder: Frame Decoded, Size Roughly:%d bytes \n",bc->pos+pbi->bc2.pos); */ 1380 1381 if (pc->refresh_entropy_probs == 0) 1382 { 1383 vpx_memcpy(&pc->fc, &pc->lfc, sizeof(pc->fc)); 1384 pbi->independent_partitions = prev_independent_partitions; 1385 } 1386 1387 #ifdef PACKET_TESTING 1388 { 1389 FILE *f = fopen("decompressor.VP8", "ab"); 1390 unsigned int size = pbi->bc2.pos + pbi->bc.pos + 8; 1391 fwrite((void *) &size, 4, 1, f); 1392 fwrite((void *) pbi->Source, size, 1, f); 1393 fclose(f); 1394 } 1395 #endif 1396 1397 return 0; 1398 } 1399
