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