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 <limits.h> 13 #include "vpx_config.h" 14 #include "onyx_int.h" 15 #include "modecosts.h" 16 #include "encodeintra.h" 17 #include "vp8/common/entropymode.h" 18 #include "pickinter.h" 19 #include "vp8/common/findnearmv.h" 20 #include "encodemb.h" 21 #include "vp8/common/reconinter.h" 22 #include "vp8/common/reconintra4x4.h" 23 #include "vp8/common/variance.h" 24 #include "mcomp.h" 25 #include "rdopt.h" 26 #include "vpx_mem/vpx_mem.h" 27 #if CONFIG_TEMPORAL_DENOISING 28 #include "denoising.h" 29 #endif 30 31 extern int VP8_UVSSE(MACROBLOCK *x); 32 33 #ifdef SPEEDSTATS 34 extern unsigned int cnt_pm; 35 #endif 36 37 extern const int vp8_ref_frame_order[MAX_MODES]; 38 extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES]; 39 40 extern int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4]); 41 42 43 int vp8_skip_fractional_mv_step(MACROBLOCK *mb, BLOCK *b, BLOCKD *d, 44 int_mv *bestmv, int_mv *ref_mv, 45 int error_per_bit, 46 const vp8_variance_fn_ptr_t *vfp, 47 int *mvcost[2], int *distortion, 48 unsigned int *sse) 49 { 50 (void) b; 51 (void) d; 52 (void) ref_mv; 53 (void) error_per_bit; 54 (void) vfp; 55 (void) mvcost; 56 (void) distortion; 57 (void) sse; 58 bestmv->as_mv.row <<= 3; 59 bestmv->as_mv.col <<= 3; 60 return 0; 61 } 62 63 64 int vp8_get_inter_mbpred_error(MACROBLOCK *mb, 65 const vp8_variance_fn_ptr_t *vfp, 66 unsigned int *sse, 67 int_mv this_mv) 68 { 69 70 BLOCK *b = &mb->block[0]; 71 BLOCKD *d = &mb->e_mbd.block[0]; 72 unsigned char *what = (*(b->base_src) + b->src); 73 int what_stride = b->src_stride; 74 int pre_stride = mb->e_mbd.pre.y_stride; 75 unsigned char *in_what = mb->e_mbd.pre.y_buffer + d->offset ; 76 int in_what_stride = pre_stride; 77 int xoffset = this_mv.as_mv.col & 7; 78 int yoffset = this_mv.as_mv.row & 7; 79 80 in_what += (this_mv.as_mv.row >> 3) * pre_stride + (this_mv.as_mv.col >> 3); 81 82 if (xoffset | yoffset) 83 { 84 return vfp->svf(in_what, in_what_stride, xoffset, yoffset, what, what_stride, sse); 85 } 86 else 87 { 88 return vfp->vf(what, what_stride, in_what, in_what_stride, sse); 89 } 90 91 } 92 93 94 unsigned int vp8_get4x4sse_cs_c 95 ( 96 const unsigned char *src_ptr, 97 int source_stride, 98 const unsigned char *ref_ptr, 99 int recon_stride 100 ) 101 { 102 int distortion = 0; 103 int r, c; 104 105 for (r = 0; r < 4; r++) 106 { 107 for (c = 0; c < 4; c++) 108 { 109 int diff = src_ptr[c] - ref_ptr[c]; 110 distortion += diff * diff; 111 } 112 113 src_ptr += source_stride; 114 ref_ptr += recon_stride; 115 } 116 117 return distortion; 118 } 119 120 static int get_prediction_error(BLOCK *be, BLOCKD *b) 121 { 122 unsigned char *sptr; 123 unsigned char *dptr; 124 sptr = (*(be->base_src) + be->src); 125 dptr = b->predictor; 126 127 return vp8_get4x4sse_cs(sptr, be->src_stride, dptr, 16); 128 129 } 130 131 static int pick_intra4x4block( 132 MACROBLOCK *x, 133 int ib, 134 B_PREDICTION_MODE *best_mode, 135 const int *mode_costs, 136 137 int *bestrate, 138 int *bestdistortion) 139 { 140 141 BLOCKD *b = &x->e_mbd.block[ib]; 142 BLOCK *be = &x->block[ib]; 143 int dst_stride = x->e_mbd.dst.y_stride; 144 unsigned char *dst = x->e_mbd.dst.y_buffer + b->offset; 145 B_PREDICTION_MODE mode; 146 int best_rd = INT_MAX; 147 int rate; 148 int distortion; 149 150 unsigned char *Above = dst - dst_stride; 151 unsigned char *yleft = dst - 1; 152 unsigned char top_left = Above[-1]; 153 154 for (mode = B_DC_PRED; mode <= B_HE_PRED; mode++) 155 { 156 int this_rd; 157 158 rate = mode_costs[mode]; 159 160 vp8_intra4x4_predict(Above, yleft, dst_stride, mode, 161 b->predictor, 16, top_left); 162 distortion = get_prediction_error(be, b); 163 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion); 164 165 if (this_rd < best_rd) 166 { 167 *bestrate = rate; 168 *bestdistortion = distortion; 169 best_rd = this_rd; 170 *best_mode = mode; 171 } 172 } 173 174 b->bmi.as_mode = *best_mode; 175 vp8_encode_intra4x4block(x, ib); 176 return best_rd; 177 } 178 179 180 static int pick_intra4x4mby_modes 181 ( 182 MACROBLOCK *mb, 183 int *Rate, 184 int *best_dist 185 ) 186 { 187 MACROBLOCKD *const xd = &mb->e_mbd; 188 int i; 189 int cost = mb->mbmode_cost [xd->frame_type] [B_PRED]; 190 int error; 191 int distortion = 0; 192 const int *bmode_costs; 193 194 intra_prediction_down_copy(xd, xd->dst.y_buffer - xd->dst.y_stride + 16); 195 196 bmode_costs = mb->inter_bmode_costs; 197 198 for (i = 0; i < 16; i++) 199 { 200 MODE_INFO *const mic = xd->mode_info_context; 201 const int mis = xd->mode_info_stride; 202 203 B_PREDICTION_MODE UNINITIALIZED_IS_SAFE(best_mode); 204 int UNINITIALIZED_IS_SAFE(r), UNINITIALIZED_IS_SAFE(d); 205 206 if (mb->e_mbd.frame_type == KEY_FRAME) 207 { 208 const B_PREDICTION_MODE A = above_block_mode(mic, i, mis); 209 const B_PREDICTION_MODE L = left_block_mode(mic, i); 210 211 bmode_costs = mb->bmode_costs[A][L]; 212 } 213 214 215 pick_intra4x4block(mb, i, &best_mode, bmode_costs, &r, &d); 216 217 cost += r; 218 distortion += d; 219 mic->bmi[i].as_mode = best_mode; 220 221 /* Break out case where we have already exceeded best so far value 222 * that was passed in 223 */ 224 if (distortion > *best_dist) 225 break; 226 } 227 228 *Rate = cost; 229 230 if (i == 16) 231 { 232 *best_dist = distortion; 233 error = RDCOST(mb->rdmult, mb->rddiv, cost, distortion); 234 } 235 else 236 { 237 *best_dist = INT_MAX; 238 error = INT_MAX; 239 } 240 241 return error; 242 } 243 244 static void pick_intra_mbuv_mode(MACROBLOCK *mb) 245 { 246 247 MACROBLOCKD *x = &mb->e_mbd; 248 unsigned char *uabove_row = x->dst.u_buffer - x->dst.uv_stride; 249 unsigned char *vabove_row = x->dst.v_buffer - x->dst.uv_stride; 250 unsigned char *usrc_ptr = (mb->block[16].src + *mb->block[16].base_src); 251 unsigned char *vsrc_ptr = (mb->block[20].src + *mb->block[20].base_src); 252 int uvsrc_stride = mb->block[16].src_stride; 253 unsigned char uleft_col[8]; 254 unsigned char vleft_col[8]; 255 unsigned char utop_left = uabove_row[-1]; 256 unsigned char vtop_left = vabove_row[-1]; 257 int i, j; 258 int expected_udc; 259 int expected_vdc; 260 int shift; 261 int Uaverage = 0; 262 int Vaverage = 0; 263 int diff; 264 int pred_error[4] = {0, 0, 0, 0}, best_error = INT_MAX; 265 MB_PREDICTION_MODE UNINITIALIZED_IS_SAFE(best_mode); 266 267 268 for (i = 0; i < 8; i++) 269 { 270 uleft_col[i] = x->dst.u_buffer [i* x->dst.uv_stride -1]; 271 vleft_col[i] = x->dst.v_buffer [i* x->dst.uv_stride -1]; 272 } 273 274 if (!x->up_available && !x->left_available) 275 { 276 expected_udc = 128; 277 expected_vdc = 128; 278 } 279 else 280 { 281 shift = 2; 282 283 if (x->up_available) 284 { 285 286 for (i = 0; i < 8; i++) 287 { 288 Uaverage += uabove_row[i]; 289 Vaverage += vabove_row[i]; 290 } 291 292 shift ++; 293 294 } 295 296 if (x->left_available) 297 { 298 for (i = 0; i < 8; i++) 299 { 300 Uaverage += uleft_col[i]; 301 Vaverage += vleft_col[i]; 302 } 303 304 shift ++; 305 306 } 307 308 expected_udc = (Uaverage + (1 << (shift - 1))) >> shift; 309 expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift; 310 } 311 312 313 for (i = 0; i < 8; i++) 314 { 315 for (j = 0; j < 8; j++) 316 { 317 318 int predu = uleft_col[i] + uabove_row[j] - utop_left; 319 int predv = vleft_col[i] + vabove_row[j] - vtop_left; 320 int u_p, v_p; 321 322 u_p = usrc_ptr[j]; 323 v_p = vsrc_ptr[j]; 324 325 if (predu < 0) 326 predu = 0; 327 328 if (predu > 255) 329 predu = 255; 330 331 if (predv < 0) 332 predv = 0; 333 334 if (predv > 255) 335 predv = 255; 336 337 338 diff = u_p - expected_udc; 339 pred_error[DC_PRED] += diff * diff; 340 diff = v_p - expected_vdc; 341 pred_error[DC_PRED] += diff * diff; 342 343 344 diff = u_p - uabove_row[j]; 345 pred_error[V_PRED] += diff * diff; 346 diff = v_p - vabove_row[j]; 347 pred_error[V_PRED] += diff * diff; 348 349 350 diff = u_p - uleft_col[i]; 351 pred_error[H_PRED] += diff * diff; 352 diff = v_p - vleft_col[i]; 353 pred_error[H_PRED] += diff * diff; 354 355 356 diff = u_p - predu; 357 pred_error[TM_PRED] += diff * diff; 358 diff = v_p - predv; 359 pred_error[TM_PRED] += diff * diff; 360 361 362 } 363 364 usrc_ptr += uvsrc_stride; 365 vsrc_ptr += uvsrc_stride; 366 367 if (i == 3) 368 { 369 usrc_ptr = (mb->block[18].src + *mb->block[18].base_src); 370 vsrc_ptr = (mb->block[22].src + *mb->block[22].base_src); 371 } 372 373 374 375 } 376 377 378 for (i = DC_PRED; i <= TM_PRED; i++) 379 { 380 if (best_error > pred_error[i]) 381 { 382 best_error = pred_error[i]; 383 best_mode = (MB_PREDICTION_MODE)i; 384 } 385 } 386 387 388 mb->e_mbd.mode_info_context->mbmi.uv_mode = best_mode; 389 390 } 391 392 static void update_mvcount(MACROBLOCK *x, int_mv *best_ref_mv) 393 { 394 MACROBLOCKD *xd = &x->e_mbd; 395 /* Split MV modes currently not supported when RD is nopt enabled, 396 * therefore, only need to modify MVcount in NEWMV mode. */ 397 if (xd->mode_info_context->mbmi.mode == NEWMV) 398 { 399 x->MVcount[0][mv_max+((xd->mode_info_context->mbmi.mv.as_mv.row - 400 best_ref_mv->as_mv.row) >> 1)]++; 401 x->MVcount[1][mv_max+((xd->mode_info_context->mbmi.mv.as_mv.col - 402 best_ref_mv->as_mv.col) >> 1)]++; 403 } 404 } 405 406 407 #if CONFIG_MULTI_RES_ENCODING 408 static 409 void get_lower_res_motion_info(VP8_COMP *cpi, MACROBLOCKD *xd, int *dissim, 410 int *parent_ref_frame, 411 MB_PREDICTION_MODE *parent_mode, 412 int_mv *parent_ref_mv, int mb_row, int mb_col) 413 { 414 LOWER_RES_MB_INFO* store_mode_info 415 = ((LOWER_RES_FRAME_INFO*)cpi->oxcf.mr_low_res_mode_info)->mb_info; 416 unsigned int parent_mb_index; 417 418 /* Consider different down_sampling_factor. */ 419 { 420 /* TODO: Removed the loop that supports special down_sampling_factor 421 * such as 2, 4, 8. Will revisit it if needed. 422 * Should also try using a look-up table to see if it helps 423 * performance. */ 424 int parent_mb_row, parent_mb_col; 425 426 parent_mb_row = mb_row*cpi->oxcf.mr_down_sampling_factor.den 427 /cpi->oxcf.mr_down_sampling_factor.num; 428 parent_mb_col = mb_col*cpi->oxcf.mr_down_sampling_factor.den 429 /cpi->oxcf.mr_down_sampling_factor.num; 430 parent_mb_index = parent_mb_row*cpi->mr_low_res_mb_cols + parent_mb_col; 431 } 432 433 /* Read lower-resolution mode & motion result from memory.*/ 434 *parent_ref_frame = store_mode_info[parent_mb_index].ref_frame; 435 *parent_mode = store_mode_info[parent_mb_index].mode; 436 *dissim = store_mode_info[parent_mb_index].dissim; 437 438 /* For highest-resolution encoder, adjust dissim value. Lower its quality 439 * for good performance. */ 440 if (cpi->oxcf.mr_encoder_id == (cpi->oxcf.mr_total_resolutions - 1)) 441 *dissim>>=1; 442 443 if(*parent_ref_frame != INTRA_FRAME) 444 { 445 /* Consider different down_sampling_factor. 446 * The result can be rounded to be more precise, but it takes more time. 447 */ 448 (*parent_ref_mv).as_mv.row = store_mode_info[parent_mb_index].mv.as_mv.row 449 *cpi->oxcf.mr_down_sampling_factor.num 450 /cpi->oxcf.mr_down_sampling_factor.den; 451 (*parent_ref_mv).as_mv.col = store_mode_info[parent_mb_index].mv.as_mv.col 452 *cpi->oxcf.mr_down_sampling_factor.num 453 /cpi->oxcf.mr_down_sampling_factor.den; 454 455 vp8_clamp_mv2(parent_ref_mv, xd); 456 } 457 } 458 #endif 459 460 static void check_for_encode_breakout(unsigned int sse, MACROBLOCK* x) 461 { 462 MACROBLOCKD *xd = &x->e_mbd; 463 464 unsigned int threshold = (xd->block[0].dequant[1] 465 * xd->block[0].dequant[1] >>4); 466 467 if(threshold < x->encode_breakout) 468 threshold = x->encode_breakout; 469 470 if (sse < threshold ) 471 { 472 /* Check u and v to make sure skip is ok */ 473 unsigned int sse2 = 0; 474 475 sse2 = VP8_UVSSE(x); 476 477 if (sse2 * 2 < x->encode_breakout) 478 x->skip = 1; 479 else 480 x->skip = 0; 481 } 482 } 483 484 static int evaluate_inter_mode(unsigned int* sse, int rate2, int* distortion2, 485 VP8_COMP *cpi, MACROBLOCK *x, int rd_adj) 486 { 487 MB_PREDICTION_MODE this_mode = x->e_mbd.mode_info_context->mbmi.mode; 488 int_mv mv = x->e_mbd.mode_info_context->mbmi.mv; 489 int this_rd; 490 /* Exit early and don't compute the distortion if this macroblock 491 * is marked inactive. */ 492 if (cpi->active_map_enabled && x->active_ptr[0] == 0) 493 { 494 *sse = 0; 495 *distortion2 = 0; 496 x->skip = 1; 497 return INT_MAX; 498 } 499 500 if((this_mode != NEWMV) || 501 !(cpi->sf.half_pixel_search) || cpi->common.full_pixel==1) 502 *distortion2 = vp8_get_inter_mbpred_error(x, 503 &cpi->fn_ptr[BLOCK_16X16], 504 sse, mv); 505 506 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, *distortion2); 507 508 /* Adjust rd to bias to ZEROMV */ 509 if(this_mode == ZEROMV) 510 { 511 /* Bias to ZEROMV on LAST_FRAME reference when it is available. */ 512 if ((cpi->ref_frame_flags & VP8_LAST_FRAME & 513 cpi->common.refresh_last_frame) 514 && x->e_mbd.mode_info_context->mbmi.ref_frame != LAST_FRAME) 515 rd_adj = 100; 516 517 // rd_adj <= 100 518 this_rd = ((int64_t)this_rd) * rd_adj / 100; 519 } 520 521 check_for_encode_breakout(*sse, x); 522 return this_rd; 523 } 524 525 static void calculate_zeromv_rd_adjustment(VP8_COMP *cpi, MACROBLOCK *x, 526 int *rd_adjustment) 527 { 528 MODE_INFO *mic = x->e_mbd.mode_info_context; 529 int_mv mv_l, mv_a, mv_al; 530 int local_motion_check = 0; 531 532 if (cpi->lf_zeromv_pct > 40) 533 { 534 /* left mb */ 535 mic -= 1; 536 mv_l = mic->mbmi.mv; 537 538 if (mic->mbmi.ref_frame != INTRA_FRAME) 539 if( abs(mv_l.as_mv.row) < 8 && abs(mv_l.as_mv.col) < 8) 540 local_motion_check++; 541 542 /* above-left mb */ 543 mic -= x->e_mbd.mode_info_stride; 544 mv_al = mic->mbmi.mv; 545 546 if (mic->mbmi.ref_frame != INTRA_FRAME) 547 if( abs(mv_al.as_mv.row) < 8 && abs(mv_al.as_mv.col) < 8) 548 local_motion_check++; 549 550 /* above mb */ 551 mic += 1; 552 mv_a = mic->mbmi.mv; 553 554 if (mic->mbmi.ref_frame != INTRA_FRAME) 555 if( abs(mv_a.as_mv.row) < 8 && abs(mv_a.as_mv.col) < 8) 556 local_motion_check++; 557 558 if (((!x->e_mbd.mb_to_top_edge || !x->e_mbd.mb_to_left_edge) 559 && local_motion_check >0) || local_motion_check >2 ) 560 *rd_adjustment = 80; 561 else if (local_motion_check > 0) 562 *rd_adjustment = 90; 563 } 564 } 565 566 void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, 567 int recon_uvoffset, int *returnrate, 568 int *returndistortion, int *returnintra, int mb_row, 569 int mb_col) 570 { 571 BLOCK *b = &x->block[0]; 572 BLOCKD *d = &x->e_mbd.block[0]; 573 MACROBLOCKD *xd = &x->e_mbd; 574 MB_MODE_INFO best_mbmode; 575 576 int_mv best_ref_mv_sb[2]; 577 int_mv mode_mv_sb[2][MB_MODE_COUNT]; 578 int_mv best_ref_mv; 579 int_mv *mode_mv; 580 MB_PREDICTION_MODE this_mode; 581 int num00; 582 int mdcounts[4]; 583 int best_rd = INT_MAX; 584 int rd_adjustment = 100; 585 int best_intra_rd = INT_MAX; 586 int mode_index; 587 int rate; 588 int rate2; 589 int distortion2; 590 int bestsme = INT_MAX; 591 int best_mode_index = 0; 592 unsigned int sse = INT_MAX, best_rd_sse = INT_MAX; 593 #if CONFIG_TEMPORAL_DENOISING 594 unsigned int zero_mv_sse = INT_MAX, best_sse = INT_MAX; 595 #endif 596 597 int sf_improved_mv_pred = cpi->sf.improved_mv_pred; 598 int_mv mvp; 599 600 int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 601 int saddone=0; 602 /* search range got from mv_pred(). It uses step_param levels. (0-7) */ 603 int sr=0; 604 605 unsigned char *plane[4][3]; 606 int ref_frame_map[4]; 607 int sign_bias = 0; 608 609 #if CONFIG_MULTI_RES_ENCODING 610 int dissim = INT_MAX; 611 int parent_ref_frame = 0; 612 int parent_ref_valid = cpi->oxcf.mr_encoder_id && cpi->mr_low_res_mv_avail; 613 int_mv parent_ref_mv; 614 MB_PREDICTION_MODE parent_mode = 0; 615 616 if (parent_ref_valid) 617 { 618 int parent_ref_flag; 619 620 get_lower_res_motion_info(cpi, xd, &dissim, &parent_ref_frame, 621 &parent_mode, &parent_ref_mv, mb_row, mb_col); 622 623 /* TODO(jkoleszar): The references available (ref_frame_flags) to the 624 * lower res encoder should match those available to this encoder, but 625 * there seems to be a situation where this mismatch can happen in the 626 * case of frame dropping and temporal layers. For example, 627 * GOLD being disallowed in ref_frame_flags, but being returned as 628 * parent_ref_frame. 629 * 630 * In this event, take the conservative approach of disabling the 631 * lower res info for this MB. 632 */ 633 parent_ref_flag = 0; 634 if (parent_ref_frame == LAST_FRAME) 635 parent_ref_flag = (cpi->ref_frame_flags & VP8_LAST_FRAME); 636 else if (parent_ref_frame == GOLDEN_FRAME) 637 parent_ref_flag = (cpi->ref_frame_flags & VP8_GOLD_FRAME); 638 else if (parent_ref_frame == ALTREF_FRAME) 639 parent_ref_flag = (cpi->ref_frame_flags & VP8_ALTR_FRAME); 640 641 //assert(!parent_ref_frame || parent_ref_flag); 642 if (parent_ref_frame && !parent_ref_flag) 643 parent_ref_valid = 0; 644 } 645 #endif 646 647 mode_mv = mode_mv_sb[sign_bias]; 648 best_ref_mv.as_int = 0; 649 vpx_memset(mode_mv_sb, 0, sizeof(mode_mv_sb)); 650 vpx_memset(&best_mbmode, 0, sizeof(best_mbmode)); 651 652 /* Setup search priorities */ 653 #if CONFIG_MULTI_RES_ENCODING 654 if (parent_ref_valid && parent_ref_frame && dissim < 8) 655 { 656 ref_frame_map[0] = -1; 657 ref_frame_map[1] = parent_ref_frame; 658 ref_frame_map[2] = -1; 659 ref_frame_map[3] = -1; 660 } else 661 #endif 662 get_reference_search_order(cpi, ref_frame_map); 663 664 /* Check to see if there is at least 1 valid reference frame that we need 665 * to calculate near_mvs. 666 */ 667 if (ref_frame_map[1] > 0) 668 { 669 sign_bias = vp8_find_near_mvs_bias(&x->e_mbd, 670 x->e_mbd.mode_info_context, 671 mode_mv_sb, 672 best_ref_mv_sb, 673 mdcounts, 674 ref_frame_map[1], 675 cpi->common.ref_frame_sign_bias); 676 677 mode_mv = mode_mv_sb[sign_bias]; 678 best_ref_mv.as_int = best_ref_mv_sb[sign_bias].as_int; 679 } 680 681 get_predictor_pointers(cpi, plane, recon_yoffset, recon_uvoffset); 682 683 /* Count of the number of MBs tested so far this frame */ 684 x->mbs_tested_so_far++; 685 686 *returnintra = INT_MAX; 687 x->skip = 0; 688 689 x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME; 690 691 /* If the frame has big static background and current MB is in low 692 * motion area, its mode decision is biased to ZEROMV mode. 693 */ 694 calculate_zeromv_rd_adjustment(cpi, x, &rd_adjustment); 695 696 /* if we encode a new mv this is important 697 * find the best new motion vector 698 */ 699 for (mode_index = 0; mode_index < MAX_MODES; mode_index++) 700 { 701 int frame_cost; 702 int this_rd = INT_MAX; 703 int this_ref_frame = ref_frame_map[vp8_ref_frame_order[mode_index]]; 704 705 if (best_rd <= x->rd_threshes[mode_index]) 706 continue; 707 708 if (this_ref_frame < 0) 709 continue; 710 711 x->e_mbd.mode_info_context->mbmi.ref_frame = this_ref_frame; 712 713 /* everything but intra */ 714 if (x->e_mbd.mode_info_context->mbmi.ref_frame) 715 { 716 x->e_mbd.pre.y_buffer = plane[this_ref_frame][0]; 717 x->e_mbd.pre.u_buffer = plane[this_ref_frame][1]; 718 x->e_mbd.pre.v_buffer = plane[this_ref_frame][2]; 719 720 if (sign_bias != cpi->common.ref_frame_sign_bias[this_ref_frame]) 721 { 722 sign_bias = cpi->common.ref_frame_sign_bias[this_ref_frame]; 723 mode_mv = mode_mv_sb[sign_bias]; 724 best_ref_mv.as_int = best_ref_mv_sb[sign_bias].as_int; 725 } 726 727 #if CONFIG_MULTI_RES_ENCODING 728 if (parent_ref_valid) 729 { 730 if (vp8_mode_order[mode_index] == NEARESTMV && 731 mode_mv[NEARESTMV].as_int ==0) 732 continue; 733 if (vp8_mode_order[mode_index] == NEARMV && 734 mode_mv[NEARMV].as_int ==0) 735 continue; 736 737 if (vp8_mode_order[mode_index] == NEWMV && parent_mode == ZEROMV 738 && best_ref_mv.as_int==0) 739 continue; 740 else if(vp8_mode_order[mode_index] == NEWMV && dissim==0 741 && best_ref_mv.as_int==parent_ref_mv.as_int) 742 continue; 743 } 744 #endif 745 } 746 747 /* Check to see if the testing frequency for this mode is at its max 748 * If so then prevent it from being tested and increase the threshold 749 * for its testing */ 750 if (x->mode_test_hit_counts[mode_index] && 751 (cpi->mode_check_freq[mode_index] > 1)) 752 { 753 if (x->mbs_tested_so_far <= (cpi->mode_check_freq[mode_index] * 754 x->mode_test_hit_counts[mode_index])) 755 { 756 /* Increase the threshold for coding this mode to make it less 757 * likely to be chosen */ 758 x->rd_thresh_mult[mode_index] += 4; 759 760 if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT) 761 x->rd_thresh_mult[mode_index] = MAX_THRESHMULT; 762 763 x->rd_threshes[mode_index] = 764 (cpi->rd_baseline_thresh[mode_index] >> 7) * 765 x->rd_thresh_mult[mode_index]; 766 continue; 767 } 768 } 769 770 /* We have now reached the point where we are going to test the current 771 * mode so increment the counter for the number of times it has been 772 * tested */ 773 x->mode_test_hit_counts[mode_index] ++; 774 775 rate2 = 0; 776 distortion2 = 0; 777 778 this_mode = vp8_mode_order[mode_index]; 779 780 x->e_mbd.mode_info_context->mbmi.mode = this_mode; 781 x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED; 782 783 /* Work out the cost assosciated with selecting the reference frame */ 784 frame_cost = 785 x->ref_frame_cost[x->e_mbd.mode_info_context->mbmi.ref_frame]; 786 rate2 += frame_cost; 787 788 /* Only consider ZEROMV/ALTREF_FRAME for alt ref frame, 789 * unless ARNR filtering is enabled in which case we want 790 * an unfiltered alternative */ 791 if (cpi->is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0)) 792 { 793 if (this_mode != ZEROMV || 794 x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME) 795 continue; 796 } 797 798 switch (this_mode) 799 { 800 case B_PRED: 801 /* Pass best so far to pick_intra4x4mby_modes to use as breakout */ 802 distortion2 = best_rd_sse; 803 pick_intra4x4mby_modes(x, &rate, &distortion2); 804 805 if (distortion2 == INT_MAX) 806 { 807 this_rd = INT_MAX; 808 } 809 else 810 { 811 rate2 += rate; 812 distortion2 = vp8_variance16x16( 813 *(b->base_src), b->src_stride, 814 x->e_mbd.predictor, 16, &sse); 815 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2); 816 817 if (this_rd < best_intra_rd) 818 { 819 best_intra_rd = this_rd; 820 *returnintra = distortion2; 821 } 822 } 823 824 break; 825 826 case SPLITMV: 827 828 /* Split MV modes currently not supported when RD is not enabled. */ 829 break; 830 831 case DC_PRED: 832 case V_PRED: 833 case H_PRED: 834 case TM_PRED: 835 vp8_build_intra_predictors_mby_s(xd, 836 xd->dst.y_buffer - xd->dst.y_stride, 837 xd->dst.y_buffer - 1, 838 xd->dst.y_stride, 839 xd->predictor, 840 16); 841 distortion2 = vp8_variance16x16 842 (*(b->base_src), b->src_stride, 843 x->e_mbd.predictor, 16, &sse); 844 rate2 += x->mbmode_cost[x->e_mbd.frame_type][x->e_mbd.mode_info_context->mbmi.mode]; 845 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2); 846 847 if (this_rd < best_intra_rd) 848 { 849 best_intra_rd = this_rd; 850 *returnintra = distortion2; 851 } 852 break; 853 854 case NEWMV: 855 { 856 int thissme; 857 int step_param; 858 int further_steps; 859 int n = 0; 860 int sadpb = x->sadperbit16; 861 int_mv mvp_full; 862 863 int col_min = ((best_ref_mv.as_mv.col+7)>>3) - MAX_FULL_PEL_VAL; 864 int row_min = ((best_ref_mv.as_mv.row+7)>>3) - MAX_FULL_PEL_VAL; 865 int col_max = (best_ref_mv.as_mv.col>>3) 866 + MAX_FULL_PEL_VAL; 867 int row_max = (best_ref_mv.as_mv.row>>3) 868 + MAX_FULL_PEL_VAL; 869 870 int tmp_col_min = x->mv_col_min; 871 int tmp_col_max = x->mv_col_max; 872 int tmp_row_min = x->mv_row_min; 873 int tmp_row_max = x->mv_row_max; 874 875 int speed_adjust = (cpi->Speed > 5) ? ((cpi->Speed >= 8)? 3 : 2) : 1; 876 877 /* Further step/diamond searches as necessary */ 878 step_param = cpi->sf.first_step + speed_adjust; 879 880 #if CONFIG_MULTI_RES_ENCODING 881 /* If lower-res drops this frame, then higher-res encoder does 882 motion search without any previous knowledge. Also, since 883 last frame motion info is not stored, then we can not 884 use improved_mv_pred. */ 885 if (cpi->oxcf.mr_encoder_id && !parent_ref_valid) 886 sf_improved_mv_pred = 0; 887 888 if (parent_ref_valid && parent_ref_frame) 889 { 890 /* Use parent MV as predictor. Adjust search range 891 * accordingly. 892 */ 893 mvp.as_int = parent_ref_mv.as_int; 894 mvp_full.as_mv.col = parent_ref_mv.as_mv.col>>3; 895 mvp_full.as_mv.row = parent_ref_mv.as_mv.row>>3; 896 897 if(dissim <=32) step_param += 3; 898 else if(dissim <=128) step_param += 2; 899 else step_param += 1; 900 }else 901 #endif 902 { 903 if(sf_improved_mv_pred) 904 { 905 if(!saddone) 906 { 907 vp8_cal_sad(cpi,xd,x, recon_yoffset ,&near_sadidx[0] ); 908 saddone = 1; 909 } 910 911 vp8_mv_pred(cpi, &x->e_mbd, x->e_mbd.mode_info_context, 912 &mvp,x->e_mbd.mode_info_context->mbmi.ref_frame, 913 cpi->common.ref_frame_sign_bias, &sr, 914 &near_sadidx[0]); 915 916 sr += speed_adjust; 917 /* adjust search range according to sr from mv prediction */ 918 if(sr > step_param) 919 step_param = sr; 920 921 mvp_full.as_mv.col = mvp.as_mv.col>>3; 922 mvp_full.as_mv.row = mvp.as_mv.row>>3; 923 }else 924 { 925 mvp.as_int = best_ref_mv.as_int; 926 mvp_full.as_mv.col = best_ref_mv.as_mv.col>>3; 927 mvp_full.as_mv.row = best_ref_mv.as_mv.row>>3; 928 } 929 } 930 931 #if CONFIG_MULTI_RES_ENCODING 932 if (parent_ref_valid && parent_ref_frame && dissim <= 2 && 933 MAX(abs(best_ref_mv.as_mv.row - parent_ref_mv.as_mv.row), 934 abs(best_ref_mv.as_mv.col - parent_ref_mv.as_mv.col)) <= 4) 935 { 936 d->bmi.mv.as_int = mvp_full.as_int; 937 mode_mv[NEWMV].as_int = mvp_full.as_int; 938 939 cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv, &best_ref_mv, 940 x->errorperbit, 941 &cpi->fn_ptr[BLOCK_16X16], 942 cpi->mb.mvcost, 943 &distortion2,&sse); 944 }else 945 #endif 946 { 947 /* Get intersection of UMV window and valid MV window to 948 * reduce # of checks in diamond search. */ 949 if (x->mv_col_min < col_min ) 950 x->mv_col_min = col_min; 951 if (x->mv_col_max > col_max ) 952 x->mv_col_max = col_max; 953 if (x->mv_row_min < row_min ) 954 x->mv_row_min = row_min; 955 if (x->mv_row_max > row_max ) 956 x->mv_row_max = row_max; 957 958 further_steps = (cpi->Speed >= 8)? 959 0: (cpi->sf.max_step_search_steps - 1 - step_param); 960 961 if (cpi->sf.search_method == HEX) 962 { 963 #if CONFIG_MULTI_RES_ENCODING 964 /* TODO: In higher-res pick_inter_mode, step_param is used to 965 * modify hex search range. Here, set step_param to 0 not to 966 * change the behavior in lowest-resolution encoder. 967 * Will improve it later. 968 */ 969 /* Set step_param to 0 to ensure large-range motion search 970 when encoder drops this frame at lower-resolution. 971 */ 972 if (!parent_ref_valid) 973 step_param = 0; 974 #endif 975 bestsme = vp8_hex_search(x, b, d, &mvp_full, &d->bmi.mv, 976 step_param, sadpb, 977 &cpi->fn_ptr[BLOCK_16X16], 978 x->mvsadcost, x->mvcost, &best_ref_mv); 979 mode_mv[NEWMV].as_int = d->bmi.mv.as_int; 980 } 981 else 982 { 983 bestsme = cpi->diamond_search_sad(x, b, d, &mvp_full, 984 &d->bmi.mv, step_param, sadpb, &num00, 985 &cpi->fn_ptr[BLOCK_16X16], 986 x->mvcost, &best_ref_mv); 987 mode_mv[NEWMV].as_int = d->bmi.mv.as_int; 988 989 /* Further step/diamond searches as necessary */ 990 n = num00; 991 num00 = 0; 992 993 while (n < further_steps) 994 { 995 n++; 996 997 if (num00) 998 num00--; 999 else 1000 { 1001 thissme = 1002 cpi->diamond_search_sad(x, b, d, &mvp_full, 1003 &d->bmi.mv, 1004 step_param + n, 1005 sadpb, &num00, 1006 &cpi->fn_ptr[BLOCK_16X16], 1007 x->mvcost, &best_ref_mv); 1008 if (thissme < bestsme) 1009 { 1010 bestsme = thissme; 1011 mode_mv[NEWMV].as_int = d->bmi.mv.as_int; 1012 } 1013 else 1014 { 1015 d->bmi.mv.as_int = mode_mv[NEWMV].as_int; 1016 } 1017 } 1018 } 1019 } 1020 1021 x->mv_col_min = tmp_col_min; 1022 x->mv_col_max = tmp_col_max; 1023 x->mv_row_min = tmp_row_min; 1024 x->mv_row_max = tmp_row_max; 1025 1026 if (bestsme < INT_MAX) 1027 cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv, 1028 &best_ref_mv, x->errorperbit, 1029 &cpi->fn_ptr[BLOCK_16X16], 1030 cpi->mb.mvcost, 1031 &distortion2,&sse); 1032 } 1033 1034 mode_mv[NEWMV].as_int = d->bmi.mv.as_int; 1035 1036 /* mv cost; */ 1037 rate2 += vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv, 1038 cpi->mb.mvcost, 128); 1039 } 1040 1041 case NEARESTMV: 1042 case NEARMV: 1043 1044 if (mode_mv[this_mode].as_int == 0) 1045 continue; 1046 1047 case ZEROMV: 1048 1049 /* Trap vectors that reach beyond the UMV borders 1050 * Note that ALL New MV, Nearest MV Near MV and Zero MV code drops 1051 * through to this point because of the lack of break statements 1052 * in the previous two cases. 1053 */ 1054 if (((mode_mv[this_mode].as_mv.row >> 3) < x->mv_row_min) || 1055 ((mode_mv[this_mode].as_mv.row >> 3) > x->mv_row_max) || 1056 ((mode_mv[this_mode].as_mv.col >> 3) < x->mv_col_min) || 1057 ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max)) 1058 continue; 1059 1060 rate2 += vp8_cost_mv_ref(this_mode, mdcounts); 1061 x->e_mbd.mode_info_context->mbmi.mv.as_int = 1062 mode_mv[this_mode].as_int; 1063 this_rd = evaluate_inter_mode(&sse, rate2, &distortion2, cpi, x, 1064 rd_adjustment); 1065 1066 break; 1067 default: 1068 break; 1069 } 1070 1071 #if CONFIG_TEMPORAL_DENOISING 1072 if (cpi->oxcf.noise_sensitivity) 1073 { 1074 1075 /* Store for later use by denoiser. */ 1076 if (this_mode == ZEROMV && sse < zero_mv_sse ) 1077 { 1078 zero_mv_sse = sse; 1079 x->best_zeromv_reference_frame = 1080 x->e_mbd.mode_info_context->mbmi.ref_frame; 1081 } 1082 1083 /* Store the best NEWMV in x for later use in the denoiser. */ 1084 if (x->e_mbd.mode_info_context->mbmi.mode == NEWMV && 1085 sse < best_sse) 1086 { 1087 best_sse = sse; 1088 x->best_sse_inter_mode = NEWMV; 1089 x->best_sse_mv = x->e_mbd.mode_info_context->mbmi.mv; 1090 x->need_to_clamp_best_mvs = 1091 x->e_mbd.mode_info_context->mbmi.need_to_clamp_mvs; 1092 x->best_reference_frame = 1093 x->e_mbd.mode_info_context->mbmi.ref_frame; 1094 } 1095 } 1096 #endif 1097 1098 if (this_rd < best_rd || x->skip) 1099 { 1100 /* Note index of best mode */ 1101 best_mode_index = mode_index; 1102 1103 *returnrate = rate2; 1104 *returndistortion = distortion2; 1105 best_rd_sse = sse; 1106 best_rd = this_rd; 1107 vpx_memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi, 1108 sizeof(MB_MODE_INFO)); 1109 1110 /* Testing this mode gave rise to an improvement in best error 1111 * score. Lower threshold a bit for next time 1112 */ 1113 x->rd_thresh_mult[mode_index] = 1114 (x->rd_thresh_mult[mode_index] >= (MIN_THRESHMULT + 2)) ? 1115 x->rd_thresh_mult[mode_index] - 2 : MIN_THRESHMULT; 1116 x->rd_threshes[mode_index] = 1117 (cpi->rd_baseline_thresh[mode_index] >> 7) * 1118 x->rd_thresh_mult[mode_index]; 1119 } 1120 1121 /* If the mode did not help improve the best error case then raise the 1122 * threshold for testing that mode next time around. 1123 */ 1124 else 1125 { 1126 x->rd_thresh_mult[mode_index] += 4; 1127 1128 if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT) 1129 x->rd_thresh_mult[mode_index] = MAX_THRESHMULT; 1130 1131 x->rd_threshes[mode_index] = 1132 (cpi->rd_baseline_thresh[mode_index] >> 7) * 1133 x->rd_thresh_mult[mode_index]; 1134 } 1135 1136 if (x->skip) 1137 break; 1138 } 1139 1140 /* Reduce the activation RD thresholds for the best choice mode */ 1141 if ((cpi->rd_baseline_thresh[best_mode_index] > 0) && (cpi->rd_baseline_thresh[best_mode_index] < (INT_MAX >> 2))) 1142 { 1143 int best_adjustment = (x->rd_thresh_mult[best_mode_index] >> 3); 1144 1145 x->rd_thresh_mult[best_mode_index] = 1146 (x->rd_thresh_mult[best_mode_index] 1147 >= (MIN_THRESHMULT + best_adjustment)) ? 1148 x->rd_thresh_mult[best_mode_index] - best_adjustment : 1149 MIN_THRESHMULT; 1150 x->rd_threshes[best_mode_index] = 1151 (cpi->rd_baseline_thresh[best_mode_index] >> 7) * 1152 x->rd_thresh_mult[best_mode_index]; 1153 } 1154 1155 1156 { 1157 int this_rdbin = (*returndistortion >> 7); 1158 1159 if (this_rdbin >= 1024) 1160 { 1161 this_rdbin = 1023; 1162 } 1163 1164 x->error_bins[this_rdbin] ++; 1165 } 1166 1167 #if CONFIG_TEMPORAL_DENOISING 1168 if (cpi->oxcf.noise_sensitivity) 1169 { 1170 if (x->best_sse_inter_mode == DC_PRED) 1171 { 1172 /* No best MV found. */ 1173 x->best_sse_inter_mode = best_mbmode.mode; 1174 x->best_sse_mv = best_mbmode.mv; 1175 x->need_to_clamp_best_mvs = best_mbmode.need_to_clamp_mvs; 1176 x->best_reference_frame = best_mbmode.ref_frame; 1177 best_sse = best_rd_sse; 1178 } 1179 vp8_denoiser_denoise_mb(&cpi->denoiser, x, best_sse, zero_mv_sse, 1180 recon_yoffset, recon_uvoffset); 1181 1182 1183 /* Reevaluate ZEROMV after denoising. */ 1184 if (best_mbmode.ref_frame == INTRA_FRAME && 1185 x->best_zeromv_reference_frame != INTRA_FRAME) 1186 { 1187 int this_rd = 0; 1188 int this_ref_frame = x->best_zeromv_reference_frame; 1189 rate2 = x->ref_frame_cost[this_ref_frame] + 1190 vp8_cost_mv_ref(ZEROMV, mdcounts); 1191 distortion2 = 0; 1192 1193 /* set up the proper prediction buffers for the frame */ 1194 x->e_mbd.mode_info_context->mbmi.ref_frame = this_ref_frame; 1195 x->e_mbd.pre.y_buffer = plane[this_ref_frame][0]; 1196 x->e_mbd.pre.u_buffer = plane[this_ref_frame][1]; 1197 x->e_mbd.pre.v_buffer = plane[this_ref_frame][2]; 1198 1199 x->e_mbd.mode_info_context->mbmi.mode = ZEROMV; 1200 x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED; 1201 x->e_mbd.mode_info_context->mbmi.mv.as_int = 0; 1202 this_rd = evaluate_inter_mode(&sse, rate2, &distortion2, cpi, x, 1203 rd_adjustment); 1204 1205 if (this_rd < best_rd) 1206 { 1207 vpx_memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi, 1208 sizeof(MB_MODE_INFO)); 1209 } 1210 } 1211 1212 } 1213 #endif 1214 1215 if (cpi->is_src_frame_alt_ref && 1216 (best_mbmode.mode != ZEROMV || best_mbmode.ref_frame != ALTREF_FRAME)) 1217 { 1218 x->e_mbd.mode_info_context->mbmi.mode = ZEROMV; 1219 x->e_mbd.mode_info_context->mbmi.ref_frame = ALTREF_FRAME; 1220 x->e_mbd.mode_info_context->mbmi.mv.as_int = 0; 1221 x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED; 1222 x->e_mbd.mode_info_context->mbmi.mb_skip_coeff = 1223 (cpi->common.mb_no_coeff_skip); 1224 x->e_mbd.mode_info_context->mbmi.partitioning = 0; 1225 1226 return; 1227 } 1228 1229 /* set to the best mb mode, this copy can be skip if x->skip since it 1230 * already has the right content */ 1231 if (!x->skip) 1232 vpx_memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mbmode, 1233 sizeof(MB_MODE_INFO)); 1234 1235 if (best_mbmode.mode <= B_PRED) 1236 { 1237 /* set mode_info_context->mbmi.uv_mode */ 1238 pick_intra_mbuv_mode(x); 1239 } 1240 1241 if (sign_bias 1242 != cpi->common.ref_frame_sign_bias[xd->mode_info_context->mbmi.ref_frame]) 1243 best_ref_mv.as_int = best_ref_mv_sb[!sign_bias].as_int; 1244 1245 update_mvcount(x, &best_ref_mv); 1246 } 1247 1248 1249 void vp8_pick_intra_mode(MACROBLOCK *x, int *rate_) 1250 { 1251 int error4x4, error16x16 = INT_MAX; 1252 int rate, best_rate = 0, distortion, best_sse; 1253 MB_PREDICTION_MODE mode, best_mode = DC_PRED; 1254 int this_rd; 1255 unsigned int sse; 1256 BLOCK *b = &x->block[0]; 1257 MACROBLOCKD *xd = &x->e_mbd; 1258 1259 xd->mode_info_context->mbmi.ref_frame = INTRA_FRAME; 1260 1261 pick_intra_mbuv_mode(x); 1262 1263 for (mode = DC_PRED; mode <= TM_PRED; mode ++) 1264 { 1265 xd->mode_info_context->mbmi.mode = mode; 1266 vp8_build_intra_predictors_mby_s(xd, 1267 xd->dst.y_buffer - xd->dst.y_stride, 1268 xd->dst.y_buffer - 1, 1269 xd->dst.y_stride, 1270 xd->predictor, 1271 16); 1272 distortion = vp8_variance16x16 1273 (*(b->base_src), b->src_stride, xd->predictor, 16, &sse); 1274 rate = x->mbmode_cost[xd->frame_type][mode]; 1275 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion); 1276 1277 if (error16x16 > this_rd) 1278 { 1279 error16x16 = this_rd; 1280 best_mode = mode; 1281 best_sse = sse; 1282 best_rate = rate; 1283 } 1284 } 1285 xd->mode_info_context->mbmi.mode = best_mode; 1286 1287 error4x4 = pick_intra4x4mby_modes(x, &rate, 1288 &best_sse); 1289 if (error4x4 < error16x16) 1290 { 1291 xd->mode_info_context->mbmi.mode = B_PRED; 1292 best_rate = rate; 1293 } 1294 1295 *rate_ = best_rate; 1296 } 1297
