source/libvpx/vp8/decoder/decodframe.c - Issue 111463005: libvpx: Pull from upstream

Side by Side Diff: source/libvpx/vp8/decoder/decodframe.c

Issue 111463005: libvpx: Pull from upstream (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/deps/third_party/libvpx/

Patch Set: Created 7 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

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

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_id x],

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_id x)

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_con text));

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 update d 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_d ata));

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_l iteral(bc, mb_feature_data_bits[i]);

1119

1120 if (vp8_read_bit(bc))

1121 xd->segment_feature_data[i][j] = -xd->segment_featur e_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_tre e_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 abo ve */

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 f rame. */

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_col s);

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 }

OLD	NEW

« no previous file with comments | « source/libvpx/vp8/decoder/decodeframe.c ('k') | source/libvpx/vp8/encoder/onyx_if.c » ('j') | no next file with comments »