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/common.h" 18#include "vp8/common/entropymode.h" 19#include "pickinter.h" 20#include "vp8/common/findnearmv.h" 21#include "encodemb.h" 22#include "vp8/common/reconinter.h" 23#include "vp8/common/reconintra4x4.h" 24#include "vp8/common/variance.h" 25#include "mcomp.h" 26#include "rdopt.h" 27#include "vpx_mem/vpx_mem.h" 28#if CONFIG_TEMPORAL_DENOISING 29#include "denoising.h" 30#endif 31 32extern int VP8_UVSSE(MACROBLOCK *x); 33 34#ifdef SPEEDSTATS 35extern unsigned int cnt_pm; 36#endif 37 38extern const int vp8_ref_frame_order[MAX_MODES]; 39extern const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES]; 40 41extern int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4]); 42 43int 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 64int 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 94unsigned 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 120static 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 131static 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 180static 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 244static 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 392static 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 408static 409void 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 460static 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 484static 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 int denoise_aggressive = 0; 491 /* Exit early and don't compute the distortion if this macroblock 492 * is marked inactive. */ 493 if (cpi->active_map_enabled && x->active_ptr[0] == 0) 494 { 495 *sse = 0; 496 *distortion2 = 0; 497 x->skip = 1; 498 return INT_MAX; 499 } 500 501 if((this_mode != NEWMV) || 502 !(cpi->sf.half_pixel_search) || cpi->common.full_pixel==1) 503 *distortion2 = vp8_get_inter_mbpred_error(x, 504 &cpi->fn_ptr[BLOCK_16X16], 505 sse, mv); 506 507 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, *distortion2); 508 509#if CONFIG_TEMPORAL_DENOISING 510 if (cpi->oxcf.noise_sensitivity > 0) { 511 denoise_aggressive = 512 (cpi->denoiser.denoiser_mode == kDenoiserOnYUVAggressive) ? 1 : 0; 513 } 514#endif 515 516 // Adjust rd for ZEROMV and LAST, if LAST is the closest reference frame. 517 if (this_mode == ZEROMV && 518 x->e_mbd.mode_info_context->mbmi.ref_frame == LAST_FRAME && 519 (denoise_aggressive || cpi->closest_reference_frame == LAST_FRAME)) 520 { 521 this_rd = ((int64_t)this_rd) * rd_adj / 100; 522 } 523 524 check_for_encode_breakout(*sse, x); 525 return this_rd; 526} 527 528static void calculate_zeromv_rd_adjustment(VP8_COMP *cpi, MACROBLOCK *x, 529 int *rd_adjustment) 530{ 531 MODE_INFO *mic = x->e_mbd.mode_info_context; 532 int_mv mv_l, mv_a, mv_al; 533 int local_motion_check = 0; 534 535 if (cpi->lf_zeromv_pct > 40) 536 { 537 /* left mb */ 538 mic -= 1; 539 mv_l = mic->mbmi.mv; 540 541 if (mic->mbmi.ref_frame != INTRA_FRAME) 542 if( abs(mv_l.as_mv.row) < 8 && abs(mv_l.as_mv.col) < 8) 543 local_motion_check++; 544 545 /* above-left mb */ 546 mic -= x->e_mbd.mode_info_stride; 547 mv_al = mic->mbmi.mv; 548 549 if (mic->mbmi.ref_frame != INTRA_FRAME) 550 if( abs(mv_al.as_mv.row) < 8 && abs(mv_al.as_mv.col) < 8) 551 local_motion_check++; 552 553 /* above mb */ 554 mic += 1; 555 mv_a = mic->mbmi.mv; 556 557 if (mic->mbmi.ref_frame != INTRA_FRAME) 558 if( abs(mv_a.as_mv.row) < 8 && abs(mv_a.as_mv.col) < 8) 559 local_motion_check++; 560 561 if (((!x->e_mbd.mb_to_top_edge || !x->e_mbd.mb_to_left_edge) 562 && local_motion_check >0) || local_motion_check >2 ) 563 *rd_adjustment = 80; 564 else if (local_motion_check > 0) 565 *rd_adjustment = 90; 566 } 567} 568 569void vp8_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, 570 int recon_uvoffset, int *returnrate, 571 int *returndistortion, int *returnintra, int mb_row, 572 int mb_col) 573{ 574 BLOCK *b = &x->block[0]; 575 BLOCKD *d = &x->e_mbd.block[0]; 576 MACROBLOCKD *xd = &x->e_mbd; 577 MB_MODE_INFO best_mbmode; 578 579 int_mv best_ref_mv_sb[2]; 580 int_mv mode_mv_sb[2][MB_MODE_COUNT]; 581 int_mv best_ref_mv; 582 int_mv *mode_mv; 583 MB_PREDICTION_MODE this_mode; 584 int num00; 585 int mdcounts[4]; 586 int best_rd = INT_MAX; 587 int rd_adjustment = 100; 588 int best_intra_rd = INT_MAX; 589 int mode_index; 590 int rate; 591 int rate2; 592 int distortion2; 593 int bestsme = INT_MAX; 594 int best_mode_index = 0; 595 unsigned int sse = UINT_MAX, best_rd_sse = UINT_MAX; 596#if CONFIG_TEMPORAL_DENOISING 597 unsigned int zero_mv_sse = UINT_MAX, best_sse = UINT_MAX; 598#endif 599 600 int sf_improved_mv_pred = cpi->sf.improved_mv_pred; 601 int_mv mvp; 602 603 int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 604 int saddone=0; 605 /* search range got from mv_pred(). It uses step_param levels. (0-7) */ 606 int sr=0; 607 608 unsigned char *plane[4][3]; 609 int ref_frame_map[4]; 610 int sign_bias = 0; 611 612#if CONFIG_MULTI_RES_ENCODING 613 int dissim = INT_MAX; 614 int parent_ref_frame = 0; 615 int parent_ref_valid = cpi->oxcf.mr_encoder_id && cpi->mr_low_res_mv_avail; 616 int_mv parent_ref_mv; 617 MB_PREDICTION_MODE parent_mode = 0; 618 619 if (parent_ref_valid) 620 { 621 int parent_ref_flag; 622 623 get_lower_res_motion_info(cpi, xd, &dissim, &parent_ref_frame, 624 &parent_mode, &parent_ref_mv, mb_row, mb_col); 625 626 /* TODO(jkoleszar): The references available (ref_frame_flags) to the 627 * lower res encoder should match those available to this encoder, but 628 * there seems to be a situation where this mismatch can happen in the 629 * case of frame dropping and temporal layers. For example, 630 * GOLD being disallowed in ref_frame_flags, but being returned as 631 * parent_ref_frame. 632 * 633 * In this event, take the conservative approach of disabling the 634 * lower res info for this MB. 635 */ 636 parent_ref_flag = 0; 637 if (parent_ref_frame == LAST_FRAME) 638 parent_ref_flag = (cpi->ref_frame_flags & VP8_LAST_FRAME); 639 else if (parent_ref_frame == GOLDEN_FRAME) 640 parent_ref_flag = (cpi->ref_frame_flags & VP8_GOLD_FRAME); 641 else if (parent_ref_frame == ALTREF_FRAME) 642 parent_ref_flag = (cpi->ref_frame_flags & VP8_ALTR_FRAME); 643 644 //assert(!parent_ref_frame || parent_ref_flag); 645 if (parent_ref_frame && !parent_ref_flag) 646 parent_ref_valid = 0; 647 } 648#endif 649 650 mode_mv = mode_mv_sb[sign_bias]; 651 best_ref_mv.as_int = 0; 652 vpx_memset(mode_mv_sb, 0, sizeof(mode_mv_sb)); 653 vpx_memset(&best_mbmode, 0, sizeof(best_mbmode)); 654 655 /* Setup search priorities */ 656#if CONFIG_MULTI_RES_ENCODING 657 if (parent_ref_valid && parent_ref_frame && dissim < 8) 658 { 659 ref_frame_map[0] = -1; 660 ref_frame_map[1] = parent_ref_frame; 661 ref_frame_map[2] = -1; 662 ref_frame_map[3] = -1; 663 } else 664#endif 665 get_reference_search_order(cpi, ref_frame_map); 666 667 /* Check to see if there is at least 1 valid reference frame that we need 668 * to calculate near_mvs. 669 */ 670 if (ref_frame_map[1] > 0) 671 { 672 sign_bias = vp8_find_near_mvs_bias(&x->e_mbd, 673 x->e_mbd.mode_info_context, 674 mode_mv_sb, 675 best_ref_mv_sb, 676 mdcounts, 677 ref_frame_map[1], 678 cpi->common.ref_frame_sign_bias); 679 680 mode_mv = mode_mv_sb[sign_bias]; 681 best_ref_mv.as_int = best_ref_mv_sb[sign_bias].as_int; 682 } 683 684 get_predictor_pointers(cpi, plane, recon_yoffset, recon_uvoffset); 685 686 /* Count of the number of MBs tested so far this frame */ 687 x->mbs_tested_so_far++; 688 689 *returnintra = INT_MAX; 690 x->skip = 0; 691 692 x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME; 693 694 /* If the frame has big static background and current MB is in low 695 * motion area, its mode decision is biased to ZEROMV mode. 696 */ 697 calculate_zeromv_rd_adjustment(cpi, x, &rd_adjustment); 698 699#if CONFIG_TEMPORAL_DENOISING 700 if (cpi->oxcf.noise_sensitivity) { 701 rd_adjustment = (int)(rd_adjustment * 702 cpi->denoiser.denoise_pars.pickmode_mv_bias / 100); 703 } 704#endif 705 706 /* if we encode a new mv this is important 707 * find the best new motion vector 708 */ 709 for (mode_index = 0; mode_index < MAX_MODES; mode_index++) 710 { 711 int frame_cost; 712 int this_rd = INT_MAX; 713 int this_ref_frame = ref_frame_map[vp8_ref_frame_order[mode_index]]; 714 715 if (best_rd <= x->rd_threshes[mode_index]) 716 continue; 717 718 if (this_ref_frame < 0) 719 continue; 720 721 x->e_mbd.mode_info_context->mbmi.ref_frame = this_ref_frame; 722 723 /* everything but intra */ 724 if (x->e_mbd.mode_info_context->mbmi.ref_frame) 725 { 726 x->e_mbd.pre.y_buffer = plane[this_ref_frame][0]; 727 x->e_mbd.pre.u_buffer = plane[this_ref_frame][1]; 728 x->e_mbd.pre.v_buffer = plane[this_ref_frame][2]; 729 730 if (sign_bias != cpi->common.ref_frame_sign_bias[this_ref_frame]) 731 { 732 sign_bias = cpi->common.ref_frame_sign_bias[this_ref_frame]; 733 mode_mv = mode_mv_sb[sign_bias]; 734 best_ref_mv.as_int = best_ref_mv_sb[sign_bias].as_int; 735 } 736 737#if CONFIG_MULTI_RES_ENCODING 738 if (parent_ref_valid) 739 { 740 if (vp8_mode_order[mode_index] == NEARESTMV && 741 mode_mv[NEARESTMV].as_int ==0) 742 continue; 743 if (vp8_mode_order[mode_index] == NEARMV && 744 mode_mv[NEARMV].as_int ==0) 745 continue; 746 747 if (vp8_mode_order[mode_index] == NEWMV && parent_mode == ZEROMV 748 && best_ref_mv.as_int==0) 749 continue; 750 else if(vp8_mode_order[mode_index] == NEWMV && dissim==0 751 && best_ref_mv.as_int==parent_ref_mv.as_int) 752 continue; 753 } 754#endif 755 } 756 757 /* Check to see if the testing frequency for this mode is at its max 758 * If so then prevent it from being tested and increase the threshold 759 * for its testing */ 760 if (x->mode_test_hit_counts[mode_index] && 761 (cpi->mode_check_freq[mode_index] > 1)) 762 { 763 if (x->mbs_tested_so_far <= (cpi->mode_check_freq[mode_index] * 764 x->mode_test_hit_counts[mode_index])) 765 { 766 /* Increase the threshold for coding this mode to make it less 767 * likely to be chosen */ 768 x->rd_thresh_mult[mode_index] += 4; 769 770 if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT) 771 x->rd_thresh_mult[mode_index] = MAX_THRESHMULT; 772 773 x->rd_threshes[mode_index] = 774 (cpi->rd_baseline_thresh[mode_index] >> 7) * 775 x->rd_thresh_mult[mode_index]; 776 continue; 777 } 778 } 779 780 /* We have now reached the point where we are going to test the current 781 * mode so increment the counter for the number of times it has been 782 * tested */ 783 x->mode_test_hit_counts[mode_index] ++; 784 785 rate2 = 0; 786 distortion2 = 0; 787 788 this_mode = vp8_mode_order[mode_index]; 789 790 x->e_mbd.mode_info_context->mbmi.mode = this_mode; 791 x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED; 792 793 /* Work out the cost assosciated with selecting the reference frame */ 794 frame_cost = 795 x->ref_frame_cost[x->e_mbd.mode_info_context->mbmi.ref_frame]; 796 rate2 += frame_cost; 797 798 /* Only consider ZEROMV/ALTREF_FRAME for alt ref frame, 799 * unless ARNR filtering is enabled in which case we want 800 * an unfiltered alternative */ 801 if (cpi->is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0)) 802 { 803 if (this_mode != ZEROMV || 804 x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME) 805 continue; 806 } 807 808 switch (this_mode) 809 { 810 case B_PRED: 811 /* Pass best so far to pick_intra4x4mby_modes to use as breakout */ 812 distortion2 = best_rd_sse; 813 pick_intra4x4mby_modes(x, &rate, &distortion2); 814 815 if (distortion2 == INT_MAX) 816 { 817 this_rd = INT_MAX; 818 } 819 else 820 { 821 rate2 += rate; 822 distortion2 = vp8_variance16x16( 823 *(b->base_src), b->src_stride, 824 x->e_mbd.predictor, 16, &sse); 825 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2); 826 827 if (this_rd < best_intra_rd) 828 { 829 best_intra_rd = this_rd; 830 *returnintra = distortion2; 831 } 832 } 833 834 break; 835 836 case SPLITMV: 837 838 /* Split MV modes currently not supported when RD is not enabled. */ 839 break; 840 841 case DC_PRED: 842 case V_PRED: 843 case H_PRED: 844 case TM_PRED: 845 vp8_build_intra_predictors_mby_s(xd, 846 xd->dst.y_buffer - xd->dst.y_stride, 847 xd->dst.y_buffer - 1, 848 xd->dst.y_stride, 849 xd->predictor, 850 16); 851 distortion2 = vp8_variance16x16 852 (*(b->base_src), b->src_stride, 853 x->e_mbd.predictor, 16, &sse); 854 rate2 += x->mbmode_cost[x->e_mbd.frame_type][x->e_mbd.mode_info_context->mbmi.mode]; 855 this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2); 856 857 if (this_rd < best_intra_rd) 858 { 859 best_intra_rd = this_rd; 860 *returnintra = distortion2; 861 } 862 break; 863 864 case NEWMV: 865 { 866 int thissme; 867 int step_param; 868 int further_steps; 869 int n = 0; 870 int sadpb = x->sadperbit16; 871 int_mv mvp_full; 872 873 int col_min = ((best_ref_mv.as_mv.col+7)>>3) - MAX_FULL_PEL_VAL; 874 int row_min = ((best_ref_mv.as_mv.row+7)>>3) - MAX_FULL_PEL_VAL; 875 int col_max = (best_ref_mv.as_mv.col>>3) 876 + MAX_FULL_PEL_VAL; 877 int row_max = (best_ref_mv.as_mv.row>>3) 878 + MAX_FULL_PEL_VAL; 879 880 int tmp_col_min = x->mv_col_min; 881 int tmp_col_max = x->mv_col_max; 882 int tmp_row_min = x->mv_row_min; 883 int tmp_row_max = x->mv_row_max; 884 885 int speed_adjust = (cpi->Speed > 5) ? ((cpi->Speed >= 8)? 3 : 2) : 1; 886 887 /* Further step/diamond searches as necessary */ 888 step_param = cpi->sf.first_step + speed_adjust; 889 890#if CONFIG_MULTI_RES_ENCODING 891 /* If lower-res drops this frame, then higher-res encoder does 892 motion search without any previous knowledge. Also, since 893 last frame motion info is not stored, then we can not 894 use improved_mv_pred. */ 895 if (cpi->oxcf.mr_encoder_id && !parent_ref_valid) 896 sf_improved_mv_pred = 0; 897 898 if (parent_ref_valid && parent_ref_frame) 899 { 900 /* Use parent MV as predictor. Adjust search range 901 * accordingly. 902 */ 903 mvp.as_int = parent_ref_mv.as_int; 904 mvp_full.as_mv.col = parent_ref_mv.as_mv.col>>3; 905 mvp_full.as_mv.row = parent_ref_mv.as_mv.row>>3; 906 907 if(dissim <=32) step_param += 3; 908 else if(dissim <=128) step_param += 2; 909 else step_param += 1; 910 }else 911#endif 912 { 913 if(sf_improved_mv_pred) 914 { 915 if(!saddone) 916 { 917 vp8_cal_sad(cpi,xd,x, recon_yoffset ,&near_sadidx[0] ); 918 saddone = 1; 919 } 920 921 vp8_mv_pred(cpi, &x->e_mbd, x->e_mbd.mode_info_context, 922 &mvp,x->e_mbd.mode_info_context->mbmi.ref_frame, 923 cpi->common.ref_frame_sign_bias, &sr, 924 &near_sadidx[0]); 925 926 sr += speed_adjust; 927 /* adjust search range according to sr from mv prediction */ 928 if(sr > step_param) 929 step_param = sr; 930 931 mvp_full.as_mv.col = mvp.as_mv.col>>3; 932 mvp_full.as_mv.row = mvp.as_mv.row>>3; 933 }else 934 { 935 mvp.as_int = best_ref_mv.as_int; 936 mvp_full.as_mv.col = best_ref_mv.as_mv.col>>3; 937 mvp_full.as_mv.row = best_ref_mv.as_mv.row>>3; 938 } 939 } 940 941#if CONFIG_MULTI_RES_ENCODING 942 if (parent_ref_valid && parent_ref_frame && dissim <= 2 && 943 MAX(abs(best_ref_mv.as_mv.row - parent_ref_mv.as_mv.row), 944 abs(best_ref_mv.as_mv.col - parent_ref_mv.as_mv.col)) <= 4) 945 { 946 d->bmi.mv.as_int = mvp_full.as_int; 947 mode_mv[NEWMV].as_int = mvp_full.as_int; 948 949 cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv, &best_ref_mv, 950 x->errorperbit, 951 &cpi->fn_ptr[BLOCK_16X16], 952 cpi->mb.mvcost, 953 &distortion2,&sse); 954 }else 955#endif 956 { 957 /* Get intersection of UMV window and valid MV window to 958 * reduce # of checks in diamond search. */ 959 if (x->mv_col_min < col_min ) 960 x->mv_col_min = col_min; 961 if (x->mv_col_max > col_max ) 962 x->mv_col_max = col_max; 963 if (x->mv_row_min < row_min ) 964 x->mv_row_min = row_min; 965 if (x->mv_row_max > row_max ) 966 x->mv_row_max = row_max; 967 968 further_steps = (cpi->Speed >= 8)? 969 0: (cpi->sf.max_step_search_steps - 1 - step_param); 970 971 if (cpi->sf.search_method == HEX) 972 { 973#if CONFIG_MULTI_RES_ENCODING 974 /* TODO: In higher-res pick_inter_mode, step_param is used to 975 * modify hex search range. Here, set step_param to 0 not to 976 * change the behavior in lowest-resolution encoder. 977 * Will improve it later. 978 */ 979 /* Set step_param to 0 to ensure large-range motion search 980 when encoder drops this frame at lower-resolution. 981 */ 982 if (!parent_ref_valid) 983 step_param = 0; 984#endif 985 bestsme = vp8_hex_search(x, b, d, &mvp_full, &d->bmi.mv, 986 step_param, sadpb, 987 &cpi->fn_ptr[BLOCK_16X16], 988 x->mvsadcost, x->mvcost, &best_ref_mv); 989 mode_mv[NEWMV].as_int = d->bmi.mv.as_int; 990 } 991 else 992 { 993 bestsme = cpi->diamond_search_sad(x, b, d, &mvp_full, 994 &d->bmi.mv, step_param, sadpb, &num00, 995 &cpi->fn_ptr[BLOCK_16X16], 996 x->mvcost, &best_ref_mv); 997 mode_mv[NEWMV].as_int = d->bmi.mv.as_int; 998 999 /* Further step/diamond searches as necessary */ 1000 n = num00; 1001 num00 = 0; 1002 1003 while (n < further_steps) 1004 { 1005 n++; 1006 1007 if (num00) 1008 num00--; 1009 else 1010 { 1011 thissme = 1012 cpi->diamond_search_sad(x, b, d, &mvp_full, 1013 &d->bmi.mv, 1014 step_param + n, 1015 sadpb, &num00, 1016 &cpi->fn_ptr[BLOCK_16X16], 1017 x->mvcost, &best_ref_mv); 1018 if (thissme < bestsme) 1019 { 1020 bestsme = thissme; 1021 mode_mv[NEWMV].as_int = d->bmi.mv.as_int; 1022 } 1023 else 1024 { 1025 d->bmi.mv.as_int = mode_mv[NEWMV].as_int; 1026 } 1027 } 1028 } 1029 } 1030 1031 x->mv_col_min = tmp_col_min; 1032 x->mv_col_max = tmp_col_max; 1033 x->mv_row_min = tmp_row_min; 1034 x->mv_row_max = tmp_row_max; 1035 1036 if (bestsme < INT_MAX) 1037 cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv, 1038 &best_ref_mv, x->errorperbit, 1039 &cpi->fn_ptr[BLOCK_16X16], 1040 cpi->mb.mvcost, 1041 &distortion2,&sse); 1042 } 1043 1044 mode_mv[NEWMV].as_int = d->bmi.mv.as_int; 1045 1046 /* mv cost; */ 1047 rate2 += vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv, 1048 cpi->mb.mvcost, 128); 1049 } 1050 1051 case NEARESTMV: 1052 case NEARMV: 1053 1054 if (mode_mv[this_mode].as_int == 0) 1055 continue; 1056 1057 case ZEROMV: 1058 1059 /* Trap vectors that reach beyond the UMV borders 1060 * Note that ALL New MV, Nearest MV Near MV and Zero MV code drops 1061 * through to this point because of the lack of break statements 1062 * in the previous two cases. 1063 */ 1064 if (((mode_mv[this_mode].as_mv.row >> 3) < x->mv_row_min) || 1065 ((mode_mv[this_mode].as_mv.row >> 3) > x->mv_row_max) || 1066 ((mode_mv[this_mode].as_mv.col >> 3) < x->mv_col_min) || 1067 ((mode_mv[this_mode].as_mv.col >> 3) > x->mv_col_max)) 1068 continue; 1069 1070 rate2 += vp8_cost_mv_ref(this_mode, mdcounts); 1071 x->e_mbd.mode_info_context->mbmi.mv.as_int = 1072 mode_mv[this_mode].as_int; 1073 this_rd = evaluate_inter_mode(&sse, rate2, &distortion2, cpi, x, 1074 rd_adjustment); 1075 1076 break; 1077 default: 1078 break; 1079 } 1080 1081#if CONFIG_TEMPORAL_DENOISING 1082 if (cpi->oxcf.noise_sensitivity) 1083 { 1084 1085 /* Store for later use by denoiser. */ 1086 if (this_mode == ZEROMV && sse < zero_mv_sse ) 1087 { 1088 zero_mv_sse = sse; 1089 x->best_zeromv_reference_frame = 1090 x->e_mbd.mode_info_context->mbmi.ref_frame; 1091 } 1092 1093 /* Store the best NEWMV in x for later use in the denoiser. */ 1094 if (x->e_mbd.mode_info_context->mbmi.mode == NEWMV && 1095 sse < best_sse) 1096 { 1097 best_sse = sse; 1098 x->best_sse_inter_mode = NEWMV; 1099 x->best_sse_mv = x->e_mbd.mode_info_context->mbmi.mv; 1100 x->need_to_clamp_best_mvs = 1101 x->e_mbd.mode_info_context->mbmi.need_to_clamp_mvs; 1102 x->best_reference_frame = 1103 x->e_mbd.mode_info_context->mbmi.ref_frame; 1104 } 1105 } 1106#endif 1107 1108 if (this_rd < best_rd || x->skip) 1109 { 1110 /* Note index of best mode */ 1111 best_mode_index = mode_index; 1112 1113 *returnrate = rate2; 1114 *returndistortion = distortion2; 1115 best_rd_sse = sse; 1116 best_rd = this_rd; 1117 vpx_memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi, 1118 sizeof(MB_MODE_INFO)); 1119 1120 /* Testing this mode gave rise to an improvement in best error 1121 * score. Lower threshold a bit for next time 1122 */ 1123 x->rd_thresh_mult[mode_index] = 1124 (x->rd_thresh_mult[mode_index] >= (MIN_THRESHMULT + 2)) ? 1125 x->rd_thresh_mult[mode_index] - 2 : MIN_THRESHMULT; 1126 x->rd_threshes[mode_index] = 1127 (cpi->rd_baseline_thresh[mode_index] >> 7) * 1128 x->rd_thresh_mult[mode_index]; 1129 } 1130 1131 /* If the mode did not help improve the best error case then raise the 1132 * threshold for testing that mode next time around. 1133 */ 1134 else 1135 { 1136 x->rd_thresh_mult[mode_index] += 4; 1137 1138 if (x->rd_thresh_mult[mode_index] > MAX_THRESHMULT) 1139 x->rd_thresh_mult[mode_index] = MAX_THRESHMULT; 1140 1141 x->rd_threshes[mode_index] = 1142 (cpi->rd_baseline_thresh[mode_index] >> 7) * 1143 x->rd_thresh_mult[mode_index]; 1144 } 1145 1146 if (x->skip) 1147 break; 1148 } 1149 1150 /* Reduce the activation RD thresholds for the best choice mode */ 1151 if ((cpi->rd_baseline_thresh[best_mode_index] > 0) && (cpi->rd_baseline_thresh[best_mode_index] < (INT_MAX >> 2))) 1152 { 1153 int best_adjustment = (x->rd_thresh_mult[best_mode_index] >> 3); 1154 1155 x->rd_thresh_mult[best_mode_index] = 1156 (x->rd_thresh_mult[best_mode_index] 1157 >= (MIN_THRESHMULT + best_adjustment)) ? 1158 x->rd_thresh_mult[best_mode_index] - best_adjustment : 1159 MIN_THRESHMULT; 1160 x->rd_threshes[best_mode_index] = 1161 (cpi->rd_baseline_thresh[best_mode_index] >> 7) * 1162 x->rd_thresh_mult[best_mode_index]; 1163 } 1164 1165 1166 { 1167 int this_rdbin = (*returndistortion >> 7); 1168 1169 if (this_rdbin >= 1024) 1170 { 1171 this_rdbin = 1023; 1172 } 1173 1174 x->error_bins[this_rdbin] ++; 1175 } 1176 1177#if CONFIG_TEMPORAL_DENOISING 1178 if (cpi->oxcf.noise_sensitivity) 1179 { 1180 int block_index = mb_row * cpi->common.mb_cols + mb_col; 1181 if (x->best_sse_inter_mode == DC_PRED) 1182 { 1183 /* No best MV found. */ 1184 x->best_sse_inter_mode = best_mbmode.mode; 1185 x->best_sse_mv = best_mbmode.mv; 1186 x->need_to_clamp_best_mvs = best_mbmode.need_to_clamp_mvs; 1187 x->best_reference_frame = best_mbmode.ref_frame; 1188 best_sse = best_rd_sse; 1189 } 1190 x->increase_denoising = 0; 1191 vp8_denoiser_denoise_mb(&cpi->denoiser, x, best_sse, zero_mv_sse, 1192 recon_yoffset, recon_uvoffset, 1193 &cpi->common.lf_info, mb_row, mb_col, 1194 block_index); 1195 1196 /* Reevaluate ZEROMV after denoising. */ 1197 if (best_mbmode.ref_frame == INTRA_FRAME && 1198 x->best_zeromv_reference_frame != INTRA_FRAME) 1199 { 1200 int this_rd = 0; 1201 int this_ref_frame = x->best_zeromv_reference_frame; 1202 rate2 = x->ref_frame_cost[this_ref_frame] + 1203 vp8_cost_mv_ref(ZEROMV, mdcounts); 1204 distortion2 = 0; 1205 1206 /* set up the proper prediction buffers for the frame */ 1207 x->e_mbd.mode_info_context->mbmi.ref_frame = this_ref_frame; 1208 x->e_mbd.pre.y_buffer = plane[this_ref_frame][0]; 1209 x->e_mbd.pre.u_buffer = plane[this_ref_frame][1]; 1210 x->e_mbd.pre.v_buffer = plane[this_ref_frame][2]; 1211 1212 x->e_mbd.mode_info_context->mbmi.mode = ZEROMV; 1213 x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED; 1214 x->e_mbd.mode_info_context->mbmi.mv.as_int = 0; 1215 this_rd = evaluate_inter_mode(&sse, rate2, &distortion2, cpi, x, 1216 rd_adjustment); 1217 1218 if (this_rd < best_rd) 1219 { 1220 vpx_memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi, 1221 sizeof(MB_MODE_INFO)); 1222 } 1223 } 1224 1225 } 1226#endif 1227 1228 if (cpi->is_src_frame_alt_ref && 1229 (best_mbmode.mode != ZEROMV || best_mbmode.ref_frame != ALTREF_FRAME)) 1230 { 1231 x->e_mbd.mode_info_context->mbmi.mode = ZEROMV; 1232 x->e_mbd.mode_info_context->mbmi.ref_frame = ALTREF_FRAME; 1233 x->e_mbd.mode_info_context->mbmi.mv.as_int = 0; 1234 x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED; 1235 x->e_mbd.mode_info_context->mbmi.mb_skip_coeff = 1236 (cpi->common.mb_no_coeff_skip); 1237 x->e_mbd.mode_info_context->mbmi.partitioning = 0; 1238 1239 return; 1240 } 1241 1242 /* set to the best mb mode, this copy can be skip if x->skip since it 1243 * already has the right content */ 1244 if (!x->skip) 1245 vpx_memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mbmode, 1246 sizeof(MB_MODE_INFO)); 1247 1248 if (best_mbmode.mode <= B_PRED) 1249 { 1250 /* set mode_info_context->mbmi.uv_mode */ 1251 pick_intra_mbuv_mode(x); 1252 } 1253 1254 if (sign_bias 1255 != cpi->common.ref_frame_sign_bias[xd->mode_info_context->mbmi.ref_frame]) 1256 best_ref_mv.as_int = best_ref_mv_sb[!sign_bias].as_int; 1257 1258 update_mvcount(x, &best_ref_mv); 1259} 1260 1261 1262void vp8_pick_intra_mode(MACROBLOCK *x, int *rate_) 1263{ 1264 int error4x4, error16x16 = INT_MAX; 1265 int rate, best_rate = 0, distortion, best_sse; 1266 MB_PREDICTION_MODE mode, best_mode = DC_PRED; 1267 int this_rd; 1268 unsigned int sse; 1269 BLOCK *b = &x->block[0]; 1270 MACROBLOCKD *xd = &x->e_mbd; 1271 1272 xd->mode_info_context->mbmi.ref_frame = INTRA_FRAME; 1273 1274 pick_intra_mbuv_mode(x); 1275 1276 for (mode = DC_PRED; mode <= TM_PRED; mode ++) 1277 { 1278 xd->mode_info_context->mbmi.mode = mode; 1279 vp8_build_intra_predictors_mby_s(xd, 1280 xd->dst.y_buffer - xd->dst.y_stride, 1281 xd->dst.y_buffer - 1, 1282 xd->dst.y_stride, 1283 xd->predictor, 1284 16); 1285 distortion = vp8_variance16x16 1286 (*(b->base_src), b->src_stride, xd->predictor, 16, &sse); 1287 rate = x->mbmode_cost[xd->frame_type][mode]; 1288 this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion); 1289 1290 if (error16x16 > this_rd) 1291 { 1292 error16x16 = this_rd; 1293 best_mode = mode; 1294 best_sse = sse; 1295 best_rate = rate; 1296 } 1297 } 1298 xd->mode_info_context->mbmi.mode = best_mode; 1299 1300 error4x4 = pick_intra4x4mby_modes(x, &rate, 1301 &best_sse); 1302 if (error4x4 < error16x16) 1303 { 1304 xd->mode_info_context->mbmi.mode = B_PRED; 1305 best_rate = rate; 1306 } 1307 1308 *rate_ = best_rate; 1309} 1310