1 /* 2 * Copyright (c) 2014 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 #include <assert.h> 12 #include <limits.h> 13 #include <math.h> 14 #include <stdio.h> 15 16 #include "./vp9_rtcd.h" 17 18 #include "vpx_mem/vpx_mem.h" 19 20 #include "vp9/common/vp9_common.h" 21 #include "vp9/common/vp9_mvref_common.h" 22 #include "vp9/common/vp9_reconinter.h" 23 #include "vp9/common/vp9_reconintra.h" 24 25 #include "vp9/encoder/vp9_onyx_int.h" 26 #include "vp9/encoder/vp9_ratectrl.h" 27 #include "vp9/encoder/vp9_rdopt.h" 28 29 static void full_pixel_motion_search(VP9_COMP *cpi, MACROBLOCK *x, 30 const TileInfo *const tile, 31 BLOCK_SIZE bsize, int mi_row, int mi_col, 32 int_mv *tmp_mv, int *rate_mv) { 33 MACROBLOCKD *xd = &x->e_mbd; 34 MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; 35 struct buf_2d backup_yv12[MAX_MB_PLANE] = {{0}}; 36 int step_param; 37 int sadpb = x->sadperbit16; 38 MV mvp_full; 39 int ref = mbmi->ref_frame[0]; 40 const MV ref_mv = mbmi->ref_mvs[ref][0].as_mv; 41 int i; 42 43 int tmp_col_min = x->mv_col_min; 44 int tmp_col_max = x->mv_col_max; 45 int tmp_row_min = x->mv_row_min; 46 int tmp_row_max = x->mv_row_max; 47 48 const YV12_BUFFER_CONFIG *scaled_ref_frame = vp9_get_scaled_ref_frame(cpi, 49 ref); 50 if (scaled_ref_frame) { 51 int i; 52 // Swap out the reference frame for a version that's been scaled to 53 // match the resolution of the current frame, allowing the existing 54 // motion search code to be used without additional modifications. 55 for (i = 0; i < MAX_MB_PLANE; i++) 56 backup_yv12[i] = xd->plane[i].pre[0]; 57 58 vp9_setup_pre_planes(xd, 0, scaled_ref_frame, mi_row, mi_col, NULL); 59 } 60 61 vp9_set_mv_search_range(x, &ref_mv); 62 63 // TODO(jingning) exploiting adaptive motion search control in non-RD 64 // mode decision too. 65 step_param = 6; 66 67 for (i = LAST_FRAME; i <= LAST_FRAME && cpi->common.show_frame; ++i) { 68 if ((x->pred_mv_sad[ref] >> 3) > x->pred_mv_sad[i]) { 69 tmp_mv->as_int = INVALID_MV; 70 71 if (scaled_ref_frame) { 72 int i; 73 for (i = 0; i < MAX_MB_PLANE; i++) 74 xd->plane[i].pre[0] = backup_yv12[i]; 75 } 76 return; 77 } 78 } 79 assert(x->mv_best_ref_index[ref] <= 2); 80 if (x->mv_best_ref_index[ref] < 2) 81 mvp_full = mbmi->ref_mvs[ref][x->mv_best_ref_index[ref]].as_mv; 82 else 83 mvp_full = x->pred_mv[ref].as_mv; 84 85 mvp_full.col >>= 3; 86 mvp_full.row >>= 3; 87 88 if (cpi->sf.search_method == FAST_DIAMOND) { 89 // NOTE: this returns SAD 90 vp9_fast_dia_search(x, &mvp_full, step_param, sadpb, 0, 91 &cpi->fn_ptr[bsize], 1, 92 &ref_mv, &tmp_mv->as_mv); 93 } else if (cpi->sf.search_method == FAST_HEX) { 94 // NOTE: this returns SAD 95 vp9_fast_hex_search(x, &mvp_full, step_param, sadpb, 0, 96 &cpi->fn_ptr[bsize], 1, 97 &ref_mv, &tmp_mv->as_mv); 98 } else if (cpi->sf.search_method == HEX) { 99 // NOTE: this returns SAD 100 vp9_hex_search(x, &mvp_full, step_param, sadpb, 1, 101 &cpi->fn_ptr[bsize], 1, 102 &ref_mv, &tmp_mv->as_mv); 103 } else if (cpi->sf.search_method == SQUARE) { 104 // NOTE: this returns SAD 105 vp9_square_search(x, &mvp_full, step_param, sadpb, 1, 106 &cpi->fn_ptr[bsize], 1, 107 &ref_mv, &tmp_mv->as_mv); 108 } else if (cpi->sf.search_method == BIGDIA) { 109 // NOTE: this returns SAD 110 vp9_bigdia_search(x, &mvp_full, step_param, sadpb, 1, 111 &cpi->fn_ptr[bsize], 1, 112 &ref_mv, &tmp_mv->as_mv); 113 } else { 114 int further_steps = (cpi->sf.max_step_search_steps - 1) - step_param; 115 // NOTE: this returns variance 116 vp9_full_pixel_diamond(cpi, x, &mvp_full, step_param, 117 sadpb, further_steps, 1, 118 &cpi->fn_ptr[bsize], 119 &ref_mv, &tmp_mv->as_mv); 120 } 121 x->mv_col_min = tmp_col_min; 122 x->mv_col_max = tmp_col_max; 123 x->mv_row_min = tmp_row_min; 124 x->mv_row_max = tmp_row_max; 125 126 if (scaled_ref_frame) { 127 int i; 128 for (i = 0; i < MAX_MB_PLANE; i++) 129 xd->plane[i].pre[0] = backup_yv12[i]; 130 } 131 132 // calculate the bit cost on motion vector 133 mvp_full.row = tmp_mv->as_mv.row * 8; 134 mvp_full.col = tmp_mv->as_mv.col * 8; 135 *rate_mv = vp9_mv_bit_cost(&mvp_full, &ref_mv, 136 x->nmvjointcost, x->mvcost, MV_COST_WEIGHT); 137 } 138 139 static void sub_pixel_motion_search(VP9_COMP *cpi, MACROBLOCK *x, 140 const TileInfo *const tile, 141 BLOCK_SIZE bsize, int mi_row, int mi_col, 142 MV *tmp_mv) { 143 MACROBLOCKD *xd = &x->e_mbd; 144 MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; 145 struct buf_2d backup_yv12[MAX_MB_PLANE] = {{0}}; 146 int ref = mbmi->ref_frame[0]; 147 MV ref_mv = mbmi->ref_mvs[ref][0].as_mv; 148 int dis; 149 150 const YV12_BUFFER_CONFIG *scaled_ref_frame = vp9_get_scaled_ref_frame(cpi, 151 ref); 152 if (scaled_ref_frame) { 153 int i; 154 // Swap out the reference frame for a version that's been scaled to 155 // match the resolution of the current frame, allowing the existing 156 // motion search code to be used without additional modifications. 157 for (i = 0; i < MAX_MB_PLANE; i++) 158 backup_yv12[i] = xd->plane[i].pre[0]; 159 160 vp9_setup_pre_planes(xd, 0, scaled_ref_frame, mi_row, mi_col, NULL); 161 } 162 163 cpi->find_fractional_mv_step(x, tmp_mv, &ref_mv, 164 cpi->common.allow_high_precision_mv, 165 x->errorperbit, 166 &cpi->fn_ptr[bsize], 167 cpi->sf.subpel_force_stop, 168 cpi->sf.subpel_iters_per_step, 169 x->nmvjointcost, x->mvcost, 170 &dis, &x->pred_sse[ref]); 171 172 if (scaled_ref_frame) { 173 int i; 174 for (i = 0; i < MAX_MB_PLANE; i++) 175 xd->plane[i].pre[0] = backup_yv12[i]; 176 } 177 178 x->pred_mv[ref].as_mv = *tmp_mv; 179 } 180 181 static void model_rd_for_sb_y(VP9_COMP *cpi, BLOCK_SIZE bsize, 182 MACROBLOCK *x, MACROBLOCKD *xd, 183 int *out_rate_sum, int64_t *out_dist_sum) { 184 // Note our transform coeffs are 8 times an orthogonal transform. 185 // Hence quantizer step is also 8 times. To get effective quantizer 186 // we need to divide by 8 before sending to modeling function. 187 unsigned int sse; 188 int rate; 189 int64_t dist; 190 191 struct macroblock_plane *const p = &x->plane[0]; 192 struct macroblockd_plane *const pd = &xd->plane[0]; 193 194 int var = cpi->fn_ptr[bsize].vf(p->src.buf, p->src.stride, 195 pd->dst.buf, pd->dst.stride, &sse); 196 197 vp9_model_rd_from_var_lapndz(sse + var, 1 << num_pels_log2_lookup[bsize], 198 pd->dequant[1] >> 3, &rate, &dist); 199 *out_rate_sum = rate; 200 *out_dist_sum = dist << 3; 201 } 202 203 // TODO(jingning) placeholder for inter-frame non-RD mode decision. 204 // this needs various further optimizations. to be continued.. 205 int64_t vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, 206 const TileInfo *const tile, 207 int mi_row, int mi_col, 208 int *returnrate, 209 int64_t *returndistortion, 210 BLOCK_SIZE bsize) { 211 MACROBLOCKD *xd = &x->e_mbd; 212 MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; 213 struct macroblock_plane *const p = &x->plane[0]; 214 struct macroblockd_plane *const pd = &xd->plane[0]; 215 MB_PREDICTION_MODE this_mode, best_mode = ZEROMV; 216 MV_REFERENCE_FRAME ref_frame, best_ref_frame = LAST_FRAME; 217 INTERP_FILTER best_pred_filter = EIGHTTAP; 218 int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES]; 219 struct buf_2d yv12_mb[4][MAX_MB_PLANE]; 220 static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG, 221 VP9_ALT_FLAG }; 222 int64_t best_rd = INT64_MAX; 223 int64_t this_rd = INT64_MAX; 224 225 int rate = INT_MAX; 226 int64_t dist = INT64_MAX; 227 228 VP9_COMMON *cm = &cpi->common; 229 int intra_cost_penalty = 20 * vp9_dc_quant(cm->base_qindex, cm->y_dc_delta_q); 230 231 const int64_t inter_mode_thresh = RDCOST(x->rdmult, x->rddiv, 232 intra_cost_penalty, 0); 233 const int64_t intra_mode_cost = 50; 234 235 unsigned char segment_id = mbmi->segment_id; 236 const int *const rd_threshes = cpi->rd_threshes[segment_id][bsize]; 237 const int *const rd_thresh_freq_fact = cpi->rd_thresh_freq_fact[bsize]; 238 // Mode index conversion form THR_MODES to MB_PREDICTION_MODE for a ref frame. 239 int mode_idx[MB_MODE_COUNT] = {0}; 240 INTERP_FILTER filter_ref = SWITCHABLE; 241 242 x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH; 243 244 x->skip = 0; 245 if (!x->in_active_map) 246 x->skip = 1; 247 // initialize mode decisions 248 *returnrate = INT_MAX; 249 *returndistortion = INT64_MAX; 250 vpx_memset(mbmi, 0, sizeof(MB_MODE_INFO)); 251 mbmi->sb_type = bsize; 252 mbmi->ref_frame[0] = NONE; 253 mbmi->ref_frame[1] = NONE; 254 mbmi->tx_size = MIN(max_txsize_lookup[bsize], 255 tx_mode_to_biggest_tx_size[cpi->common.tx_mode]); 256 mbmi->interp_filter = cpi->common.interp_filter == SWITCHABLE ? 257 EIGHTTAP : cpi->common.interp_filter; 258 mbmi->skip = 0; 259 mbmi->segment_id = segment_id; 260 261 for (ref_frame = LAST_FRAME; ref_frame <= LAST_FRAME ; ++ref_frame) { 262 x->pred_mv_sad[ref_frame] = INT_MAX; 263 if (cpi->ref_frame_flags & flag_list[ref_frame]) { 264 vp9_setup_buffer_inter(cpi, x, tile, 265 ref_frame, bsize, mi_row, mi_col, 266 frame_mv[NEARESTMV], frame_mv[NEARMV], yv12_mb); 267 } 268 frame_mv[NEWMV][ref_frame].as_int = INVALID_MV; 269 frame_mv[ZEROMV][ref_frame].as_int = 0; 270 } 271 272 if (xd->up_available) 273 filter_ref = xd->mi[-xd->mi_stride]->mbmi.interp_filter; 274 else if (xd->left_available) 275 filter_ref = xd->mi[-1]->mbmi.interp_filter; 276 277 for (ref_frame = LAST_FRAME; ref_frame <= LAST_FRAME ; ++ref_frame) { 278 if (!(cpi->ref_frame_flags & flag_list[ref_frame])) 279 continue; 280 281 // Select prediction reference frames. 282 xd->plane[0].pre[0] = yv12_mb[ref_frame][0]; 283 284 clamp_mv2(&frame_mv[NEARESTMV][ref_frame].as_mv, xd); 285 clamp_mv2(&frame_mv[NEARMV][ref_frame].as_mv, xd); 286 287 mbmi->ref_frame[0] = ref_frame; 288 289 // Set conversion index for LAST_FRAME. 290 if (ref_frame == LAST_FRAME) { 291 mode_idx[NEARESTMV] = THR_NEARESTMV; // LAST_FRAME, NEARESTMV 292 mode_idx[NEARMV] = THR_NEARMV; // LAST_FRAME, NEARMV 293 mode_idx[ZEROMV] = THR_ZEROMV; // LAST_FRAME, ZEROMV 294 mode_idx[NEWMV] = THR_NEWMV; // LAST_FRAME, NEWMV 295 } 296 297 for (this_mode = NEARESTMV; this_mode <= NEWMV; ++this_mode) { 298 int rate_mv = 0; 299 300 if (cpi->sf.disable_inter_mode_mask[bsize] & 301 (1 << INTER_OFFSET(this_mode))) 302 continue; 303 304 if (best_rd < ((int64_t)rd_threshes[mode_idx[this_mode]] * 305 rd_thresh_freq_fact[this_mode] >> 5) || 306 rd_threshes[mode_idx[this_mode]] == INT_MAX) 307 continue; 308 309 if (this_mode == NEWMV) { 310 int rate_mode = 0; 311 if (this_rd < (int64_t)(1 << num_pels_log2_lookup[bsize])) 312 continue; 313 314 full_pixel_motion_search(cpi, x, tile, bsize, mi_row, mi_col, 315 &frame_mv[NEWMV][ref_frame], &rate_mv); 316 317 if (frame_mv[NEWMV][ref_frame].as_int == INVALID_MV) 318 continue; 319 320 rate_mode = x->inter_mode_cost[mbmi->mode_context[ref_frame]] 321 [INTER_OFFSET(this_mode)]; 322 if (RDCOST(x->rdmult, x->rddiv, rate_mv + rate_mode, 0) > best_rd) 323 continue; 324 325 sub_pixel_motion_search(cpi, x, tile, bsize, mi_row, mi_col, 326 &frame_mv[NEWMV][ref_frame].as_mv); 327 } 328 329 if (this_mode != NEARESTMV) 330 if (frame_mv[this_mode][ref_frame].as_int == 331 frame_mv[NEARESTMV][ref_frame].as_int) 332 continue; 333 334 mbmi->mode = this_mode; 335 mbmi->mv[0].as_int = frame_mv[this_mode][ref_frame].as_int; 336 337 // Search for the best prediction filter type, when the resulting 338 // motion vector is at sub-pixel accuracy level for luma component, i.e., 339 // the last three bits are all zeros. 340 if ((this_mode == NEWMV || filter_ref == SWITCHABLE) && 341 ((mbmi->mv[0].as_mv.row & 0x07) != 0 || 342 (mbmi->mv[0].as_mv.col & 0x07) != 0)) { 343 int64_t tmp_rdcost1 = INT64_MAX; 344 int64_t tmp_rdcost2 = INT64_MAX; 345 int64_t tmp_rdcost3 = INT64_MAX; 346 int pf_rate[3]; 347 int64_t pf_dist[3]; 348 349 mbmi->interp_filter = EIGHTTAP; 350 vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); 351 model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rate[EIGHTTAP], 352 &pf_dist[EIGHTTAP]); 353 tmp_rdcost1 = RDCOST(x->rdmult, x->rddiv, 354 vp9_get_switchable_rate(x) + pf_rate[EIGHTTAP], 355 pf_dist[EIGHTTAP]); 356 357 mbmi->interp_filter = EIGHTTAP_SHARP; 358 vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); 359 model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rate[EIGHTTAP_SHARP], 360 &pf_dist[EIGHTTAP_SHARP]); 361 tmp_rdcost2 = RDCOST(x->rdmult, x->rddiv, 362 vp9_get_switchable_rate(x) + pf_rate[EIGHTTAP_SHARP], 363 pf_dist[EIGHTTAP_SHARP]); 364 365 mbmi->interp_filter = EIGHTTAP_SMOOTH; 366 vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); 367 model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rate[EIGHTTAP_SMOOTH], 368 &pf_dist[EIGHTTAP_SMOOTH]); 369 tmp_rdcost3 = RDCOST(x->rdmult, x->rddiv, 370 vp9_get_switchable_rate(x) + pf_rate[EIGHTTAP_SMOOTH], 371 pf_dist[EIGHTTAP_SMOOTH]); 372 373 if (tmp_rdcost2 < tmp_rdcost1) { 374 if (tmp_rdcost2 < tmp_rdcost3) 375 mbmi->interp_filter = EIGHTTAP_SHARP; 376 else 377 mbmi->interp_filter = EIGHTTAP_SMOOTH; 378 } else { 379 if (tmp_rdcost1 < tmp_rdcost3) 380 mbmi->interp_filter = EIGHTTAP; 381 else 382 mbmi->interp_filter = EIGHTTAP_SMOOTH; 383 } 384 385 rate = pf_rate[mbmi->interp_filter]; 386 dist = pf_dist[mbmi->interp_filter]; 387 } else { 388 mbmi->interp_filter = (filter_ref == SWITCHABLE) ? EIGHTTAP: filter_ref; 389 vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); 390 model_rd_for_sb_y(cpi, bsize, x, xd, &rate, &dist); 391 } 392 393 rate += rate_mv; 394 rate += x->inter_mode_cost[mbmi->mode_context[ref_frame]] 395 [INTER_OFFSET(this_mode)]; 396 this_rd = RDCOST(x->rdmult, x->rddiv, rate, dist); 397 398 if (this_rd < best_rd) { 399 best_rd = this_rd; 400 *returnrate = rate; 401 *returndistortion = dist; 402 best_mode = this_mode; 403 best_pred_filter = mbmi->interp_filter; 404 best_ref_frame = ref_frame; 405 } 406 } 407 } 408 409 mbmi->mode = best_mode; 410 mbmi->interp_filter = best_pred_filter; 411 mbmi->ref_frame[0] = best_ref_frame; 412 mbmi->mv[0].as_int = frame_mv[best_mode][best_ref_frame].as_int; 413 xd->mi[0]->bmi[0].as_mv[0].as_int = mbmi->mv[0].as_int; 414 415 // Perform intra prediction search, if the best SAD is above a certain 416 // threshold. 417 if (best_rd > inter_mode_thresh) { 418 for (this_mode = DC_PRED; this_mode <= DC_PRED; ++this_mode) { 419 vp9_predict_intra_block(xd, 0, b_width_log2(bsize), 420 mbmi->tx_size, this_mode, 421 &p->src.buf[0], p->src.stride, 422 &pd->dst.buf[0], pd->dst.stride, 0, 0, 0); 423 424 model_rd_for_sb_y(cpi, bsize, x, xd, &rate, &dist); 425 rate += x->mbmode_cost[this_mode]; 426 rate += intra_cost_penalty; 427 this_rd = RDCOST(x->rdmult, x->rddiv, rate, dist); 428 429 if (this_rd + intra_mode_cost < best_rd) { 430 best_rd = this_rd; 431 *returnrate = rate; 432 *returndistortion = dist; 433 mbmi->mode = this_mode; 434 mbmi->ref_frame[0] = INTRA_FRAME; 435 mbmi->uv_mode = this_mode; 436 mbmi->mv[0].as_int = INVALID_MV; 437 } 438 } 439 } 440 441 return INT64_MAX; 442 } 443
