| OLD | NEW |
|---|
| (Empty) | |
| 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][mb
mi->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 val
ues |
| 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 neighbo
ring |
| 615 * MBs. |
| 616 * |
| 617 * Note that for the first mb with corrupt residual in a fra
me, |
| 618 * we might not discover that before decoding the residual.
That |
| 619 * happens after this check, and therefore no inter concealm
ent |
| 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_fr
ame]; |
| 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 if(mb_row > 1) |
| 684 { |
| 685 yv12_extend_frame_left_right_c(yv12_fb_new, |
| 686 eb_dst[0], |
| 687 eb_dst[1], |
| 688 eb_dst[2]); |
| 689 |
| 690 eb_dst[0] += recon_y_stride * 16; |
| 691 eb_dst[1] += recon_uv_stride * 8; |
| 692 eb_dst[2] += recon_uv_stride * 8; |
| 693 } |
| 694 |
| 695 lf_dst[0] += recon_y_stride * 16; |
| 696 lf_dst[1] += recon_uv_stride * 8; |
| 697 lf_dst[2] += recon_uv_stride * 8; |
| 698 lf_mic += pc->mb_cols; |
| 699 lf_mic++; /* Skip border mb */ |
| 700 } |
| 701 } |
| 702 else |
| 703 { |
| 704 if(mb_row > 0) |
| 705 { |
| 706 /**/ |
| 707 yv12_extend_frame_left_right_c(yv12_fb_new, |
| 708 eb_dst[0], |
| 709 eb_dst[1], |
| 710 eb_dst[2]); |
| 711 eb_dst[0] += recon_y_stride * 16; |
| 712 eb_dst[1] += recon_uv_stride * 8; |
| 713 eb_dst[2] += recon_uv_stride * 8; |
| 714 } |
| 715 } |
| 716 } |
| 717 |
| 718 if(pc->filter_level) |
| 719 { |
| 720 if (pc->filter_type == NORMAL_LOOPFILTER) |
| 721 vp8_loop_filter_row_normal(pc, lf_mic, mb_row-1, recon_y_stride, |
| 722 recon_uv_stride, lf_dst[0], lf_dst[1], |
| 723 lf_dst[2]); |
| 724 else |
| 725 vp8_loop_filter_row_simple(pc, lf_mic, mb_row-1, recon_y_stride, |
| 726 recon_uv_stride, lf_dst[0], lf_dst[1], |
| 727 lf_dst[2]); |
| 728 |
| 729 yv12_extend_frame_left_right_c(yv12_fb_new, |
| 730 eb_dst[0], |
| 731 eb_dst[1], |
| 732 eb_dst[2]); |
| 733 eb_dst[0] += recon_y_stride * 16; |
| 734 eb_dst[1] += recon_uv_stride * 8; |
| 735 eb_dst[2] += recon_uv_stride * 8; |
| 736 } |
| 737 yv12_extend_frame_left_right_c(yv12_fb_new, |
| 738 eb_dst[0], |
| 739 eb_dst[1], |
| 740 eb_dst[2]); |
| 741 yv12_extend_frame_top_c(yv12_fb_new); |
| 742 yv12_extend_frame_bottom_c(yv12_fb_new); |
| 743 |
| 744 } |
| 745 |
| 746 static unsigned int read_partition_size(VP8D_COMP *pbi, |
| 747 const unsigned char *cx_size) |
| 748 { |
| 749 unsigned char temp[3]; |
| 750 if (pbi->decrypt_cb) |
| 751 { |
| 752 pbi->decrypt_cb(pbi->decrypt_state, cx_size, temp, 3); |
| 753 cx_size = temp; |
| 754 } |
| 755 return cx_size[0] + (cx_size[1] << 8) + (cx_size[2] << 16); |
| 756 } |
| 757 |
| 758 static int read_is_valid(const unsigned char *start, |
| 759 size_t len, |
| 760 const unsigned char *end) |
| 761 { |
| 762 return (start + len > start && start + len <= end); |
| 763 } |
| 764 |
| 765 static unsigned int read_available_partition_size( |
| 766 VP8D_COMP *pbi, |
| 767 const unsigned char *token_part_sizes, |
| 768 const unsigned char *fragment_start, |
| 769 const unsigned char *first_fragment_end, |
| 770 const unsigned char *fragment_end, |
| 771 int i, |
| 772 int num_part) |
| 773 { |
| 774 VP8_COMMON* pc = &pbi->common; |
| 775 const unsigned char *partition_size_ptr = token_part_sizes + i * 3; |
| 776 unsigned int partition_size = 0; |
| 777 ptrdiff_t bytes_left = fragment_end - fragment_start; |
| 778 /* Calculate the length of this partition. The last partition |
| 779 * size is implicit. If the partition size can't be read, then |
| 780 * either use the remaining data in the buffer (for EC mode) |
| 781 * or throw an error. |
| 782 */ |
| 783 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 else |
| 790 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, |
| 791 "Truncated partition size data"); |
| 792 } |
| 793 else |
| 794 partition_size = (unsigned int)bytes_left; |
| 795 |
| 796 /* Validate the calculated partition length. If the buffer |
| 797 * described by the partition can't be fully read, then restrict |
| 798 * it to the portion that can be (for EC mode) or throw an error. |
| 799 */ |
| 800 if (!read_is_valid(fragment_start, partition_size, fragment_end)) |
| 801 { |
| 802 if (pbi->ec_active) |
| 803 partition_size = (unsigned int)bytes_left; |
| 804 else |
| 805 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, |
| 806 "Truncated packet or corrupt partition " |
| 807 "%d length", i + 1); |
| 808 } |
| 809 return partition_size; |
| 810 } |
| 811 |
| 812 |
| 813 static void setup_token_decoder(VP8D_COMP *pbi, |
| 814 const unsigned char* token_part_sizes) |
| 815 { |
| 816 vp8_reader *bool_decoder = &pbi->mbc[0]; |
| 817 unsigned int partition_idx; |
| 818 unsigned int fragment_idx; |
| 819 unsigned int num_token_partitions; |
| 820 const unsigned char *first_fragment_end = pbi->fragments.ptrs[0] + |
| 821 pbi->fragments.sizes[0]; |
| 822 |
| 823 TOKEN_PARTITION multi_token_partition = |
| 824 (TOKEN_PARTITION)vp8_read_literal(&pbi->mbc[8], 2); |
| 825 if (!vp8dx_bool_error(&pbi->mbc[8])) |
| 826 pbi->common.multi_token_partition = multi_token_partition; |
| 827 num_token_partitions = 1 << pbi->common.multi_token_partition; |
| 828 |
| 829 /* Check for partitions within the fragments and unpack the fragments |
| 830 * so that each fragment pointer points to its corresponding partition. */ |
| 831 for (fragment_idx = 0; fragment_idx < pbi->fragments.count; ++fragment_idx) |
| 832 { |
| 833 unsigned int fragment_size = pbi->fragments.sizes[fragment_idx]; |
| 834 const unsigned char *fragment_end = pbi->fragments.ptrs[fragment_idx] + |
| 835 fragment_size; |
| 836 /* Special case for handling the first partition since we have already |
| 837 * read its size. */ |
| 838 if (fragment_idx == 0) |
| 839 { |
| 840 /* Size of first partition + token partition sizes element */ |
| 841 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 if (fragment_size > 0) |
| 845 { |
| 846 pbi->fragments.sizes[0] = (unsigned int)ext_first_part_size; |
| 847 /* The fragment contains an additional partition. Move to |
| 848 * next. */ |
| 849 fragment_idx++; |
| 850 pbi->fragments.ptrs[fragment_idx] = pbi->fragments.ptrs[0] + |
| 851 pbi->fragments.sizes[0]; |
| 852 } |
| 853 } |
| 854 /* Split the chunk into partitions read from the bitstream */ |
| 855 while (fragment_size > 0) |
| 856 { |
| 857 ptrdiff_t partition_size = read_available_partition_size( |
| 858 pbi, |
| 859 token_part_sizes, |
| 860 pbi->fragments.ptrs[fragment_id
x], |
| 861 first_fragment_end, |
| 862 fragment_end, |
| 863 fragment_idx - 1, |
| 864 num_token_partitions); |
| 865 pbi->fragments.sizes[fragment_idx] = (unsigned int)partition_size; |
| 866 fragment_size -= (unsigned int)partition_size; |
| 867 assert(fragment_idx <= num_token_partitions); |
| 868 if (fragment_size > 0) |
| 869 { |
| 870 /* The fragment contains an additional partition. |
| 871 * Move to next. */ |
| 872 fragment_idx++; |
| 873 pbi->fragments.ptrs[fragment_idx] = |
| 874 pbi->fragments.ptrs[fragment_idx - 1] + partition_size; |
| 875 } |
| 876 } |
| 877 } |
| 878 |
| 879 pbi->fragments.count = num_token_partitions + 1; |
| 880 |
| 881 for (partition_idx = 1; partition_idx < pbi->fragments.count; ++partition_id
x) |
| 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 vpx_internal_error(&pbi->common.error, VPX_CODEC_MEM_ERROR, |
| 888 "Failed to allocate bool decoder %d", |
| 889 partition_idx); |
| 890 |
| 891 bool_decoder++; |
| 892 } |
| 893 |
| 894 #if CONFIG_MULTITHREAD |
| 895 /* Clamp number of decoder threads */ |
| 896 if (pbi->decoding_thread_count > num_token_partitions - 1) |
| 897 pbi->decoding_thread_count = num_token_partitions - 1; |
| 898 #endif |
| 899 } |
| 900 |
| 901 |
| 902 static void init_frame(VP8D_COMP *pbi) |
| 903 { |
| 904 VP8_COMMON *const pc = & pbi->common; |
| 905 MACROBLOCKD *const xd = & pbi->mb; |
| 906 |
| 907 if (pc->frame_type == KEY_FRAME) |
| 908 { |
| 909 /* Various keyframe initializations */ |
| 910 vpx_memcpy(pc->fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_con
text)); |
| 911 |
| 912 vp8_init_mbmode_probs(pc); |
| 913 |
| 914 vp8_default_coef_probs(pc); |
| 915 |
| 916 /* reset the segment feature data to 0 with delta coding (Default state)
. */ |
| 917 vpx_memset(xd->segment_feature_data, 0, sizeof(xd->segment_feature_data)
); |
| 918 xd->mb_segement_abs_delta = SEGMENT_DELTADATA; |
| 919 |
| 920 /* reset the mode ref deltasa for loop filter */ |
| 921 vpx_memset(xd->ref_lf_deltas, 0, sizeof(xd->ref_lf_deltas)); |
| 922 vpx_memset(xd->mode_lf_deltas, 0, sizeof(xd->mode_lf_deltas)); |
| 923 |
| 924 /* All buffers are implicitly updated on key frames. */ |
| 925 pc->refresh_golden_frame = 1; |
| 926 pc->refresh_alt_ref_frame = 1; |
| 927 pc->copy_buffer_to_gf = 0; |
| 928 pc->copy_buffer_to_arf = 0; |
| 929 |
| 930 /* Note that Golden and Altref modes cannot be used on a key frame so |
| 931 * ref_frame_sign_bias[] is undefined and meaningless |
| 932 */ |
| 933 pc->ref_frame_sign_bias[GOLDEN_FRAME] = 0; |
| 934 pc->ref_frame_sign_bias[ALTREF_FRAME] = 0; |
| 935 } |
| 936 else |
| 937 { |
| 938 /* To enable choice of different interploation filters */ |
| 939 if (!pc->use_bilinear_mc_filter) |
| 940 { |
| 941 xd->subpixel_predict = vp8_sixtap_predict4x4; |
| 942 xd->subpixel_predict8x4 = vp8_sixtap_predict8x4; |
| 943 xd->subpixel_predict8x8 = vp8_sixtap_predict8x8; |
| 944 xd->subpixel_predict16x16 = vp8_sixtap_predict16x16; |
| 945 } |
| 946 else |
| 947 { |
| 948 xd->subpixel_predict = vp8_bilinear_predict4x4; |
| 949 xd->subpixel_predict8x4 = vp8_bilinear_predict8x4; |
| 950 xd->subpixel_predict8x8 = vp8_bilinear_predict8x8; |
| 951 xd->subpixel_predict16x16 = vp8_bilinear_predict16x16; |
| 952 } |
| 953 |
| 954 if (pbi->decoded_key_frame && pbi->ec_enabled && !pbi->ec_active) |
| 955 pbi->ec_active = 1; |
| 956 } |
| 957 |
| 958 xd->left_context = &pc->left_context; |
| 959 xd->mode_info_context = pc->mi; |
| 960 xd->frame_type = pc->frame_type; |
| 961 xd->mode_info_context->mbmi.mode = DC_PRED; |
| 962 xd->mode_info_stride = pc->mode_info_stride; |
| 963 xd->corrupted = 0; /* init without corruption */ |
| 964 |
| 965 xd->fullpixel_mask = 0xffffffff; |
| 966 if(pc->full_pixel) |
| 967 xd->fullpixel_mask = 0xfffffff8; |
| 968 |
| 969 } |
| 970 |
| 971 int vp8_decode_frame(VP8D_COMP *pbi) |
| 972 { |
| 973 vp8_reader *const bc = &pbi->mbc[8]; |
| 974 VP8_COMMON *const pc = &pbi->common; |
| 975 MACROBLOCKD *const xd = &pbi->mb; |
| 976 const unsigned char *data = pbi->fragments.ptrs[0]; |
| 977 const unsigned char *data_end = data + pbi->fragments.sizes[0]; |
| 978 ptrdiff_t first_partition_length_in_bytes; |
| 979 |
| 980 int i, j, k, l; |
| 981 const int *const mb_feature_data_bits = vp8_mb_feature_data_bits; |
| 982 int corrupt_tokens = 0; |
| 983 int prev_independent_partitions = pbi->independent_partitions; |
| 984 |
| 985 YV12_BUFFER_CONFIG *yv12_fb_new = pbi->dec_fb_ref[INTRA_FRAME]; |
| 986 |
| 987 /* start with no corruption of current frame */ |
| 988 xd->corrupted = 0; |
| 989 yv12_fb_new->corrupted = 0; |
| 990 |
| 991 if (data_end - data < 3) |
| 992 { |
| 993 if (!pbi->ec_active) |
| 994 { |
| 995 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, |
| 996 "Truncated packet"); |
| 997 } |
| 998 |
| 999 /* Declare the missing frame as an inter frame since it will |
| 1000 be handled as an inter frame when we have estimated its |
| 1001 motion vectors. */ |
| 1002 pc->frame_type = INTER_FRAME; |
| 1003 pc->version = 0; |
| 1004 pc->show_frame = 1; |
| 1005 first_partition_length_in_bytes = 0; |
| 1006 } |
| 1007 else |
| 1008 { |
| 1009 unsigned char clear_buffer[10]; |
| 1010 const unsigned char *clear = data; |
| 1011 if (pbi->decrypt_cb) |
| 1012 { |
| 1013 int n = (int)(data_end - data); |
| 1014 if (n > 10) n = 10; |
| 1015 pbi->decrypt_cb(pbi->decrypt_state, data, clear_buffer, n); |
| 1016 clear = clear_buffer; |
| 1017 } |
| 1018 |
| 1019 pc->frame_type = (FRAME_TYPE)(clear[0] & 1); |
| 1020 pc->version = (clear[0] >> 1) & 7; |
| 1021 pc->show_frame = (clear[0] >> 4) & 1; |
| 1022 first_partition_length_in_bytes = |
| 1023 (clear[0] | (clear[1] << 8) | (clear[2] << 16)) >> 5; |
| 1024 |
| 1025 if (!pbi->ec_active && |
| 1026 (data + first_partition_length_in_bytes > data_end |
| 1027 || data + first_partition_length_in_bytes < data)) |
| 1028 vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, |
| 1029 "Truncated packet or corrupt partition 0 length")
; |
| 1030 |
| 1031 data += 3; |
| 1032 clear += 3; |
| 1033 |
| 1034 vp8_setup_version(pc); |
| 1035 |
| 1036 |
| 1037 if (pc->frame_type == KEY_FRAME) |
| 1038 { |
| 1039 /* vet via sync code */ |
| 1040 /* When error concealment is enabled we should only check the sync |
| 1041 * code if we have enough bits available |
| 1042 */ |
| 1043 if (!pbi->ec_active || data + 3 < data_end) |
| 1044 { |
| 1045 if (clear[0] != 0x9d || clear[1] != 0x01 || clear[2] != 0x2a) |
| 1046 vpx_internal_error(&pc->error, VPX_CODEC_UNSUP_BITSTREAM, |
| 1047 "Invalid frame sync code"); |
| 1048 } |
| 1049 |
| 1050 /* If error concealment is enabled we should only parse the new size |
| 1051 * if we have enough data. Otherwise we will end up with the wrong |
| 1052 * size. |
| 1053 */ |
| 1054 if (!pbi->ec_active || data + 6 < data_end) |
| 1055 { |
| 1056 pc->Width = (clear[3] | (clear[4] << 8)) & 0x3fff; |
| 1057 pc->horiz_scale = clear[4] >> 6; |
| 1058 pc->Height = (clear[5] | (clear[6] << 8)) & 0x3fff; |
| 1059 pc->vert_scale = clear[6] >> 6; |
| 1060 } |
| 1061 data += 7; |
| 1062 clear += 7; |
| 1063 } |
| 1064 else |
| 1065 { |
| 1066 vpx_memcpy(&xd->pre, yv12_fb_new, sizeof(YV12_BUFFER_CONFIG)); |
| 1067 vpx_memcpy(&xd->dst, yv12_fb_new, sizeof(YV12_BUFFER_CONFIG)); |
| 1068 } |
| 1069 } |
| 1070 if ((!pbi->decoded_key_frame && pc->frame_type != KEY_FRAME)) |
| 1071 { |
| 1072 return -1; |
| 1073 } |
| 1074 |
| 1075 init_frame(pbi); |
| 1076 |
| 1077 if (vp8dx_start_decode(bc, data, (unsigned int)(data_end - data), |
| 1078 pbi->decrypt_cb, pbi->decrypt_state)) |
| 1079 vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR, |
| 1080 "Failed to allocate bool decoder 0"); |
| 1081 if (pc->frame_type == KEY_FRAME) { |
| 1082 (void)vp8_read_bit(bc); // colorspace |
| 1083 pc->clamp_type = (CLAMP_TYPE)vp8_read_bit(bc); |
| 1084 } |
| 1085 |
| 1086 /* Is segmentation enabled */ |
| 1087 xd->segmentation_enabled = (unsigned char)vp8_read_bit(bc); |
| 1088 |
| 1089 if (xd->segmentation_enabled) |
| 1090 { |
| 1091 /* Signal whether or not the segmentation map is being explicitly update
d this frame. */ |
| 1092 xd->update_mb_segmentation_map = (unsigned char)vp8_read_bit(bc); |
| 1093 xd->update_mb_segmentation_data = (unsigned char)vp8_read_bit(bc); |
| 1094 |
| 1095 if (xd->update_mb_segmentation_data) |
| 1096 { |
| 1097 xd->mb_segement_abs_delta = (unsigned char)vp8_read_bit(bc); |
| 1098 |
| 1099 vpx_memset(xd->segment_feature_data, 0, sizeof(xd->segment_feature_d
ata)); |
| 1100 |
| 1101 /* For each segmentation feature (Quant and loop filter level) */ |
| 1102 for (i = 0; i < MB_LVL_MAX; i++) |
| 1103 { |
| 1104 for (j = 0; j < MAX_MB_SEGMENTS; j++) |
| 1105 { |
| 1106 /* Frame level data */ |
| 1107 if (vp8_read_bit(bc)) |
| 1108 { |
| 1109 xd->segment_feature_data[i][j] = (signed char)vp8_read_l
iteral(bc, mb_feature_data_bits[i]); |
| 1110 |
| 1111 if (vp8_read_bit(bc)) |
| 1112 xd->segment_feature_data[i][j] = -xd->segment_featur
e_data[i][j]; |
| 1113 } |
| 1114 else |
| 1115 xd->segment_feature_data[i][j] = 0; |
| 1116 } |
| 1117 } |
| 1118 } |
| 1119 |
| 1120 if (xd->update_mb_segmentation_map) |
| 1121 { |
| 1122 /* Which macro block level features are enabled */ |
| 1123 vpx_memset(xd->mb_segment_tree_probs, 255, sizeof(xd->mb_segment_tre
e_probs)); |
| 1124 |
| 1125 /* Read the probs used to decode the segment id for each macro block
. */ |
| 1126 for (i = 0; i < MB_FEATURE_TREE_PROBS; i++) |
| 1127 { |
| 1128 /* If not explicitly set value is defaulted to 255 by memset abo
ve */ |
| 1129 if (vp8_read_bit(bc)) |
| 1130 xd->mb_segment_tree_probs[i] = (vp8_prob)vp8_read_literal(bc
, 8); |
| 1131 } |
| 1132 } |
| 1133 } |
| 1134 else |
| 1135 { |
| 1136 /* No segmentation updates on this frame */ |
| 1137 xd->update_mb_segmentation_map = 0; |
| 1138 xd->update_mb_segmentation_data = 0; |
| 1139 } |
| 1140 |
| 1141 /* Read the loop filter level and type */ |
| 1142 pc->filter_type = (LOOPFILTERTYPE) vp8_read_bit(bc); |
| 1143 pc->filter_level = vp8_read_literal(bc, 6); |
| 1144 pc->sharpness_level = vp8_read_literal(bc, 3); |
| 1145 |
| 1146 /* Read in loop filter deltas applied at the MB level based on mode or ref f
rame. */ |
| 1147 xd->mode_ref_lf_delta_update = 0; |
| 1148 xd->mode_ref_lf_delta_enabled = (unsigned char)vp8_read_bit(bc); |
| 1149 |
| 1150 if (xd->mode_ref_lf_delta_enabled) |
| 1151 { |
| 1152 /* Do the deltas need to be updated */ |
| 1153 xd->mode_ref_lf_delta_update = (unsigned char)vp8_read_bit(bc); |
| 1154 |
| 1155 if (xd->mode_ref_lf_delta_update) |
| 1156 { |
| 1157 /* Send update */ |
| 1158 for (i = 0; i < MAX_REF_LF_DELTAS; i++) |
| 1159 { |
| 1160 if (vp8_read_bit(bc)) |
| 1161 { |
| 1162 /*sign = vp8_read_bit( bc );*/ |
| 1163 xd->ref_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6); |
| 1164 |
| 1165 if (vp8_read_bit(bc)) /* Apply sign */ |
| 1166 xd->ref_lf_deltas[i] = xd->ref_lf_deltas[i] * -1; |
| 1167 } |
| 1168 } |
| 1169 |
| 1170 /* Send update */ |
| 1171 for (i = 0; i < MAX_MODE_LF_DELTAS; i++) |
| 1172 { |
| 1173 if (vp8_read_bit(bc)) |
| 1174 { |
| 1175 /*sign = vp8_read_bit( bc );*/ |
| 1176 xd->mode_lf_deltas[i] = (signed char)vp8_read_literal(bc, 6)
; |
| 1177 |
| 1178 if (vp8_read_bit(bc)) /* Apply sign */ |
| 1179 xd->mode_lf_deltas[i] = xd->mode_lf_deltas[i] * -1; |
| 1180 } |
| 1181 } |
| 1182 } |
| 1183 } |
| 1184 |
| 1185 setup_token_decoder(pbi, data + first_partition_length_in_bytes); |
| 1186 |
| 1187 xd->current_bc = &pbi->mbc[0]; |
| 1188 |
| 1189 /* Read the default quantizers. */ |
| 1190 { |
| 1191 int Q, q_update; |
| 1192 |
| 1193 Q = vp8_read_literal(bc, 7); /* AC 1st order Q = default */ |
| 1194 pc->base_qindex = Q; |
| 1195 q_update = 0; |
| 1196 pc->y1dc_delta_q = get_delta_q(bc, pc->y1dc_delta_q, &q_update); |
| 1197 pc->y2dc_delta_q = get_delta_q(bc, pc->y2dc_delta_q, &q_update); |
| 1198 pc->y2ac_delta_q = get_delta_q(bc, pc->y2ac_delta_q, &q_update); |
| 1199 pc->uvdc_delta_q = get_delta_q(bc, pc->uvdc_delta_q, &q_update); |
| 1200 pc->uvac_delta_q = get_delta_q(bc, pc->uvac_delta_q, &q_update); |
| 1201 |
| 1202 if (q_update) |
| 1203 vp8cx_init_de_quantizer(pbi); |
| 1204 |
| 1205 /* MB level dequantizer setup */ |
| 1206 vp8_mb_init_dequantizer(pbi, &pbi->mb); |
| 1207 } |
| 1208 |
| 1209 /* Determine if the golden frame or ARF buffer should be updated and how. |
| 1210 * For all non key frames the GF and ARF refresh flags and sign bias |
| 1211 * flags must be set explicitly. |
| 1212 */ |
| 1213 if (pc->frame_type != KEY_FRAME) |
| 1214 { |
| 1215 /* Should the GF or ARF be updated from the current frame */ |
| 1216 pc->refresh_golden_frame = vp8_read_bit(bc); |
| 1217 #if CONFIG_ERROR_CONCEALMENT |
| 1218 /* Assume we shouldn't refresh golden if the bit is missing */ |
| 1219 xd->corrupted |= vp8dx_bool_error(bc); |
| 1220 if (pbi->ec_active && xd->corrupted) |
| 1221 pc->refresh_golden_frame = 0; |
| 1222 #endif |
| 1223 |
| 1224 pc->refresh_alt_ref_frame = vp8_read_bit(bc); |
| 1225 #if CONFIG_ERROR_CONCEALMENT |
| 1226 /* Assume we shouldn't refresh altref if the bit is missing */ |
| 1227 xd->corrupted |= vp8dx_bool_error(bc); |
| 1228 if (pbi->ec_active && xd->corrupted) |
| 1229 pc->refresh_alt_ref_frame = 0; |
| 1230 #endif |
| 1231 |
| 1232 /* Buffer to buffer copy flags. */ |
| 1233 pc->copy_buffer_to_gf = 0; |
| 1234 |
| 1235 if (!pc->refresh_golden_frame) |
| 1236 pc->copy_buffer_to_gf = vp8_read_literal(bc, 2); |
| 1237 |
| 1238 #if CONFIG_ERROR_CONCEALMENT |
| 1239 /* Assume we shouldn't copy to the golden if the bit is missing */ |
| 1240 xd->corrupted |= vp8dx_bool_error(bc); |
| 1241 if (pbi->ec_active && xd->corrupted) |
| 1242 pc->copy_buffer_to_gf = 0; |
| 1243 #endif |
| 1244 |
| 1245 pc->copy_buffer_to_arf = 0; |
| 1246 |
| 1247 if (!pc->refresh_alt_ref_frame) |
| 1248 pc->copy_buffer_to_arf = vp8_read_literal(bc, 2); |
| 1249 |
| 1250 #if CONFIG_ERROR_CONCEALMENT |
| 1251 /* Assume we shouldn't copy to the alt-ref if the bit is missing */ |
| 1252 xd->corrupted |= vp8dx_bool_error(bc); |
| 1253 if (pbi->ec_active && xd->corrupted) |
| 1254 pc->copy_buffer_to_arf = 0; |
| 1255 #endif |
| 1256 |
| 1257 |
| 1258 pc->ref_frame_sign_bias[GOLDEN_FRAME] = vp8_read_bit(bc); |
| 1259 pc->ref_frame_sign_bias[ALTREF_FRAME] = vp8_read_bit(bc); |
| 1260 } |
| 1261 |
| 1262 pc->refresh_entropy_probs = vp8_read_bit(bc); |
| 1263 #if CONFIG_ERROR_CONCEALMENT |
| 1264 /* Assume we shouldn't refresh the probabilities if the bit is |
| 1265 * missing */ |
| 1266 xd->corrupted |= vp8dx_bool_error(bc); |
| 1267 if (pbi->ec_active && xd->corrupted) |
| 1268 pc->refresh_entropy_probs = 0; |
| 1269 #endif |
| 1270 if (pc->refresh_entropy_probs == 0) |
| 1271 { |
| 1272 vpx_memcpy(&pc->lfc, &pc->fc, sizeof(pc->fc)); |
| 1273 } |
| 1274 |
| 1275 pc->refresh_last_frame = pc->frame_type == KEY_FRAME || vp8_read_bit(bc); |
| 1276 |
| 1277 #if CONFIG_ERROR_CONCEALMENT |
| 1278 /* Assume we should refresh the last frame if the bit is missing */ |
| 1279 xd->corrupted |= vp8dx_bool_error(bc); |
| 1280 if (pbi->ec_active && xd->corrupted) |
| 1281 pc->refresh_last_frame = 1; |
| 1282 #endif |
| 1283 |
| 1284 if (0) |
| 1285 { |
| 1286 FILE *z = fopen("decodestats.stt", "a"); |
| 1287 fprintf(z, "%6d F:%d,G:%d,A:%d,L:%d,Q:%d\n", |
| 1288 pc->current_video_frame, |
| 1289 pc->frame_type, |
| 1290 pc->refresh_golden_frame, |
| 1291 pc->refresh_alt_ref_frame, |
| 1292 pc->refresh_last_frame, |
| 1293 pc->base_qindex); |
| 1294 fclose(z); |
| 1295 } |
| 1296 |
| 1297 { |
| 1298 pbi->independent_partitions = 1; |
| 1299 |
| 1300 /* read coef probability tree */ |
| 1301 for (i = 0; i < BLOCK_TYPES; i++) |
| 1302 for (j = 0; j < COEF_BANDS; j++) |
| 1303 for (k = 0; k < PREV_COEF_CONTEXTS; k++) |
| 1304 for (l = 0; l < ENTROPY_NODES; l++) |
| 1305 { |
| 1306 |
| 1307 vp8_prob *const p = pc->fc.coef_probs [i][j][k] + l; |
| 1308 |
| 1309 if (vp8_read(bc, vp8_coef_update_probs [i][j][k][l])) |
| 1310 { |
| 1311 *p = (vp8_prob)vp8_read_literal(bc, 8); |
| 1312 |
| 1313 } |
| 1314 if (k > 0 && *p != pc->fc.coef_probs[i][j][k-1][l]) |
| 1315 pbi->independent_partitions = 0; |
| 1316 |
| 1317 } |
| 1318 } |
| 1319 |
| 1320 /* clear out the coeff buffer */ |
| 1321 vpx_memset(xd->qcoeff, 0, sizeof(xd->qcoeff)); |
| 1322 |
| 1323 vp8_decode_mode_mvs(pbi); |
| 1324 |
| 1325 #if CONFIG_ERROR_CONCEALMENT |
| 1326 if (pbi->ec_active && |
| 1327 pbi->mvs_corrupt_from_mb < (unsigned int)pc->mb_cols * pc->mb_rows) |
| 1328 { |
| 1329 /* Motion vectors are missing in this frame. We will try to estimate |
| 1330 * them and then continue decoding the frame as usual */ |
| 1331 vp8_estimate_missing_mvs(pbi); |
| 1332 } |
| 1333 #endif |
| 1334 |
| 1335 vpx_memset(pc->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) * pc->mb_col
s); |
| 1336 pbi->frame_corrupt_residual = 0; |
| 1337 |
| 1338 #if CONFIG_MULTITHREAD |
| 1339 if (pbi->b_multithreaded_rd && pc->multi_token_partition != ONE_PARTITION) |
| 1340 { |
| 1341 unsigned int thread; |
| 1342 vp8mt_decode_mb_rows(pbi, xd); |
| 1343 vp8_yv12_extend_frame_borders(yv12_fb_new); |
| 1344 for (thread = 0; thread < pbi->decoding_thread_count; ++thread) |
| 1345 corrupt_tokens |= pbi->mb_row_di[thread].mbd.corrupted; |
| 1346 } |
| 1347 else |
| 1348 #endif |
| 1349 { |
| 1350 decode_mb_rows(pbi); |
| 1351 corrupt_tokens |= xd->corrupted; |
| 1352 } |
| 1353 |
| 1354 /* Collect information about decoder corruption. */ |
| 1355 /* 1. Check first boolean decoder for errors. */ |
| 1356 yv12_fb_new->corrupted = vp8dx_bool_error(bc); |
| 1357 /* 2. Check the macroblock information */ |
| 1358 yv12_fb_new->corrupted |= corrupt_tokens; |
| 1359 |
| 1360 if (!pbi->decoded_key_frame) |
| 1361 { |
| 1362 if (pc->frame_type == KEY_FRAME && |
| 1363 !yv12_fb_new->corrupted) |
| 1364 pbi->decoded_key_frame = 1; |
| 1365 else |
| 1366 vpx_internal_error(&pbi->common.error, VPX_CODEC_CORRUPT_FRAME, |
| 1367 "A stream must start with a complete key frame"); |
| 1368 } |
| 1369 |
| 1370 /* vpx_log("Decoder: Frame Decoded, Size Roughly:%d bytes \n",bc->pos+pbi->
bc2.pos); */ |
| 1371 |
| 1372 if (pc->refresh_entropy_probs == 0) |
| 1373 { |
| 1374 vpx_memcpy(&pc->fc, &pc->lfc, sizeof(pc->fc)); |
| 1375 pbi->independent_partitions = prev_independent_partitions; |
| 1376 } |
| 1377 |
| 1378 #ifdef PACKET_TESTING |
| 1379 { |
| 1380 FILE *f = fopen("decompressor.VP8", "ab"); |
| 1381 unsigned int size = pbi->bc2.pos + pbi->bc.pos + 8; |
| 1382 fwrite((void *) &size, 4, 1, f); |
| 1383 fwrite((void *) pbi->Source, size, 1, f); |
| 1384 fclose(f); |
| 1385 } |
| 1386 #endif |
| 1387 |
| 1388 return 0; |
| 1389 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 111463005:
libvpx: Pull from upstream (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/deps/third_party/libvpx/