Refactor codes about motion search
1. Add "best_mv" in MACROBLOCK to store the best motion vector
during motion search, so that we don't need to pass its pointer
to various motion search functions.
2. Declare some functions as static when possible.
3. Fix some indents.
Change-Id: I0778146c0866cbc55e245988c59222577ea8260e
diff --git a/vp10/encoder/block.h b/vp10/encoder/block.h
index 88f1236..4c9f8a5 100644
--- a/vp10/encoder/block.h
+++ b/vp10/encoder/block.h
@@ -165,6 +165,9 @@
// Used to store sub partition's choices.
MV pred_mv[MAX_REF_FRAMES];
+ // Store the best motion vector during motion search
+ int_mv best_mv;
+
// Strong color activity detection. Used in RTC coding mode to enhance
// the visual quality at the boundary of moving color objects.
uint8_t color_sensitivity[2];
diff --git a/vp10/encoder/encoder.h b/vp10/encoder/encoder.h
index 519cd03..608cace 100644
--- a/vp10/encoder/encoder.h
+++ b/vp10/encoder/encoder.h
@@ -447,7 +447,7 @@
ActiveMap active_map;
fractional_mv_step_fp *find_fractional_mv_step;
- vp10_full_search_fn_t full_search_sad;
+ vp10_full_search_fn_t full_search_sad; // It is currently unused.
vp10_diamond_search_fn_t diamond_search_sad;
vp10_variance_fn_ptr_t fn_ptr[BLOCK_SIZES];
uint64_t time_receive_data;
diff --git a/vp10/encoder/mbgraph.c b/vp10/encoder/mbgraph.c
index 5e66ce5..46cff80 100644
--- a/vp10/encoder/mbgraph.c
+++ b/vp10/encoder/mbgraph.c
@@ -25,7 +25,6 @@
static unsigned int do_16x16_motion_iteration(VP10_COMP *cpi,
const MV *ref_mv,
- MV *dst_mv,
int mb_row,
int mb_col) {
MACROBLOCK *const x = &cpi->td.mb;
@@ -51,8 +50,7 @@
/*cpi->sf.search_method == HEX*/
vp10_hex_search(x, &ref_full, step_param, x->errorperbit, 0,
- cond_cost_list(cpi, cost_list),
- &v_fn_ptr, 0, ref_mv, dst_mv);
+ cond_cost_list(cpi, cost_list), &v_fn_ptr, 0, ref_mv);
// Try sub-pixel MC
// if (bestsme > error_thresh && bestsme < INT_MAX)
@@ -60,7 +58,7 @@
int distortion;
unsigned int sse;
cpi->find_fractional_mv_step(
- x, dst_mv, ref_mv, cpi->common.allow_high_precision_mv, x->errorperbit,
+ x, ref_mv, cpi->common.allow_high_precision_mv, x->errorperbit,
&v_fn_ptr, 0, mv_sf->subpel_iters_per_step,
cond_cost_list(cpi, cost_list),
NULL, NULL,
@@ -74,7 +72,7 @@
#endif // CONFIG_EXT_INTER
xd->mi[0]->mbmi.mode = NEWMV;
- xd->mi[0]->mbmi.mv[0].as_mv = *dst_mv;
+ xd->mi[0]->mbmi.mv[0] = x->best_mv;
#if CONFIG_EXT_INTER
xd->mi[0]->mbmi.ref_frame[1] = NONE;
#endif // CONFIG_EXT_INTER
@@ -92,40 +90,40 @@
}
static int do_16x16_motion_search(VP10_COMP *cpi, const MV *ref_mv,
- int_mv *dst_mv, int mb_row, int mb_col) {
+ int mb_row, int mb_col) {
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
unsigned int err, tmp_err;
- MV tmp_mv;
+ MV best_mv;
// Try zero MV first
// FIXME should really use something like near/nearest MV and/or MV prediction
err = vpx_sad16x16(x->plane[0].src.buf, x->plane[0].src.stride,
xd->plane[0].pre[0].buf, xd->plane[0].pre[0].stride);
- dst_mv->as_int = 0;
+ best_mv.col = best_mv.row = 0;
// Test last reference frame using the previous best mv as the
// starting point (best reference) for the search
- tmp_err = do_16x16_motion_iteration(cpi, ref_mv, &tmp_mv, mb_row, mb_col);
+ tmp_err = do_16x16_motion_iteration(cpi, ref_mv, mb_row, mb_col);
if (tmp_err < err) {
err = tmp_err;
- dst_mv->as_mv = tmp_mv;
+ best_mv = x->best_mv.as_mv;
}
// If the current best reference mv is not centered on 0,0 then do a 0,0
// based search as well.
if (ref_mv->row != 0 || ref_mv->col != 0) {
unsigned int tmp_err;
- MV zero_ref_mv = {0, 0}, tmp_mv;
+ MV zero_ref_mv = {0, 0};
- tmp_err = do_16x16_motion_iteration(cpi, &zero_ref_mv, &tmp_mv,
- mb_row, mb_col);
+ tmp_err = do_16x16_motion_iteration(cpi, &zero_ref_mv, mb_row, mb_col);
if (tmp_err < err) {
- dst_mv->as_mv = tmp_mv;
err = tmp_err;
+ best_mv = x->best_mv.as_mv;
}
}
+ x->best_mv.as_mv = best_mv;
return err;
}
@@ -213,8 +211,8 @@
xd->plane[0].pre[0].stride = golden_ref->y_stride;
g_motion_error = do_16x16_motion_search(cpi,
prev_golden_ref_mv,
- &stats->ref[GOLDEN_FRAME].m.mv,
mb_row, mb_col);
+ stats->ref[GOLDEN_FRAME].m.mv = x->best_mv;
stats->ref[GOLDEN_FRAME].err = g_motion_error;
} else {
stats->ref[GOLDEN_FRAME].err = INT_MAX;
diff --git a/vp10/encoder/mcomp.c b/vp10/encoder/mcomp.c
index e7bd700..afbf3e9 100644
--- a/vp10/encoder/mcomp.c
+++ b/vp10/encoder/mcomp.c
@@ -315,6 +315,7 @@
unsigned int sse; \
unsigned int whichdir; \
int thismse; \
+ MV *bestmv = &x->best_mv.as_mv; \
const unsigned int halfiters = iters_per_step; \
const unsigned int quarteriters = iters_per_step; \
const unsigned int eighthiters = iters_per_step; \
@@ -411,8 +412,8 @@
}
int vp10_find_best_sub_pixel_tree_pruned_evenmore(
- const MACROBLOCK *x,
- MV *bestmv, const MV *ref_mv,
+ MACROBLOCK *x,
+ const MV *ref_mv,
int allow_hp,
int error_per_bit,
const vp10_variance_fn_ptr_t *vfp,
@@ -491,20 +492,20 @@
return besterr;
}
-int vp10_find_best_sub_pixel_tree_pruned_more(const MACROBLOCK *x,
- MV *bestmv, const MV *ref_mv,
- int allow_hp,
- int error_per_bit,
- const vp10_variance_fn_ptr_t *vfp,
- int forced_stop,
- int iters_per_step,
- int *cost_list,
- int *mvjcost, int *mvcost[2],
- int *distortion,
- unsigned int *sse1,
- const uint8_t *second_pred,
- int w, int h,
- int use_upsampled_ref) {
+int vp10_find_best_sub_pixel_tree_pruned_more(MACROBLOCK *x,
+ const MV *ref_mv,
+ int allow_hp,
+ int error_per_bit,
+ const vp10_variance_fn_ptr_t *vfp,
+ int forced_stop,
+ int iters_per_step,
+ int *cost_list,
+ int *mvjcost, int *mvcost[2],
+ int *distortion,
+ unsigned int *sse1,
+ const uint8_t *second_pred,
+ int w, int h,
+ int use_upsampled_ref) {
SETUP_SUBPEL_SEARCH;
(void) use_upsampled_ref;
@@ -568,19 +569,19 @@
return besterr;
}
-int vp10_find_best_sub_pixel_tree_pruned(const MACROBLOCK *x,
- MV *bestmv, const MV *ref_mv,
- int allow_hp,
- int error_per_bit,
- const vp10_variance_fn_ptr_t *vfp,
- int forced_stop,
- int iters_per_step,
- int *cost_list,
- int *mvjcost, int *mvcost[2],
- int *distortion,
- unsigned int *sse1,
- const uint8_t *second_pred,
- int w, int h, int use_upsampled_ref) {
+int vp10_find_best_sub_pixel_tree_pruned(MACROBLOCK *x,
+ const MV *ref_mv,
+ int allow_hp,
+ int error_per_bit,
+ const vp10_variance_fn_ptr_t *vfp,
+ int forced_stop,
+ int iters_per_step,
+ int *cost_list,
+ int *mvjcost, int *mvcost[2],
+ int *distortion,
+ unsigned int *sse1,
+ const uint8_t *second_pred,
+ int w, int h, int use_upsampled_ref) {
SETUP_SUBPEL_SEARCH;
(void) use_upsampled_ref;
@@ -724,19 +725,19 @@
return besterr;
}
-int vp10_find_best_sub_pixel_tree(const MACROBLOCK *x,
- MV *bestmv, const MV *ref_mv,
- int allow_hp,
- int error_per_bit,
- const vp10_variance_fn_ptr_t *vfp,
- int forced_stop,
- int iters_per_step,
- int *cost_list,
- int *mvjcost, int *mvcost[2],
- int *distortion,
- unsigned int *sse1,
- const uint8_t *second_pred,
- int w, int h, int use_upsampled_ref) {
+int vp10_find_best_sub_pixel_tree(MACROBLOCK *x,
+ const MV *ref_mv,
+ int allow_hp,
+ int error_per_bit,
+ const vp10_variance_fn_ptr_t *vfp,
+ int forced_stop,
+ int iters_per_step,
+ int *cost_list,
+ int *mvjcost, int *mvcost[2],
+ int *distortion,
+ unsigned int *sse1,
+ const uint8_t *second_pred,
+ int w, int h, int use_upsampled_ref) {
const uint8_t *const src_address = x->plane[0].src.buf;
const int src_stride = x->plane[0].src.stride;
const MACROBLOCKD *xd = &x->e_mbd;
@@ -744,6 +745,7 @@
unsigned int sse;
unsigned int thismse;
const int y_stride = xd->plane[0].pre[0].stride;
+ MV *bestmv = &x->best_mv.as_mv;
const int offset = bestmv->row * y_stride + bestmv->col;
const uint8_t *const y = xd->plane[0].pre[0].buf;
@@ -1037,19 +1039,18 @@
// candidates as indicated in the num_candidates and candidates arrays
// passed into this function
//
-static int vp10_pattern_search(const MACROBLOCK *x,
- MV *start_mv,
- int search_param,
- int sad_per_bit,
- int do_init_search,
- int *cost_list,
- const vp10_variance_fn_ptr_t *vfp,
- int use_mvcost,
- const MV *center_mv,
- MV *best_mv,
- const int num_candidates[MAX_PATTERN_SCALES],
- const MV candidates[MAX_PATTERN_SCALES]
- [MAX_PATTERN_CANDIDATES]) {
+static int pattern_search(MACROBLOCK *x,
+ MV *start_mv,
+ int search_param,
+ int sad_per_bit,
+ int do_init_search,
+ int *cost_list,
+ const vp10_variance_fn_ptr_t *vfp,
+ int use_mvcost,
+ const MV *center_mv,
+ const int num_candidates[MAX_PATTERN_SCALES],
+ const MV candidates[MAX_PATTERN_SCALES]
+ [MAX_PATTERN_CANDIDATES]) {
const MACROBLOCKD *const xd = &x->e_mbd;
static const int search_param_to_steps[MAX_MVSEARCH_STEPS] = {
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
@@ -1294,8 +1295,8 @@
calc_int_cost_list(x, center_mv, sad_per_bit, vfp, &best_mv, cost_list);
}
}
- best_mv->row = br;
- best_mv->col = bc;
+ x->best_mv.as_mv.row = br;
+ x->best_mv.as_mv.col = bc;
return bestsad;
}
@@ -1332,15 +1333,15 @@
x->mvcost, x->errorperbit) : 0);
}
-int vp10_hex_search(const MACROBLOCK *x,
- MV *start_mv,
- int search_param,
- int sad_per_bit,
- int do_init_search,
- int *cost_list,
- const vp10_variance_fn_ptr_t *vfp,
- int use_mvcost,
- const MV *center_mv, MV *best_mv) {
+int vp10_hex_search(MACROBLOCK *x,
+ MV *start_mv,
+ int search_param,
+ int sad_per_bit,
+ int do_init_search,
+ int *cost_list,
+ const vp10_variance_fn_ptr_t *vfp,
+ int use_mvcost,
+ const MV *center_mv) {
// First scale has 8-closest points, the rest have 6 points in hex shape
// at increasing scales
static const int hex_num_candidates[MAX_PATTERN_SCALES] = {
@@ -1361,22 +1362,20 @@
{{-512, -1024}, {512, -1024}, {1024, 0}, {512, 1024}, { -512, 1024},
{ -1024, 0}},
};
- return vp10_pattern_search(x, start_mv, search_param, sad_per_bit,
- do_init_search, cost_list, vfp, use_mvcost,
- center_mv, best_mv, hex_num_candidates,
- hex_candidates);
+ return pattern_search(x, start_mv, search_param, sad_per_bit,
+ do_init_search, cost_list, vfp, use_mvcost,
+ center_mv, hex_num_candidates, hex_candidates);
}
-int vp10_bigdia_search(const MACROBLOCK *x,
- MV *start_mv,
- int search_param,
- int sad_per_bit,
- int do_init_search,
- int *cost_list,
- const vp10_variance_fn_ptr_t *vfp,
- int use_mvcost,
- const MV *center_mv,
- MV *best_mv) {
+static int bigdia_search(MACROBLOCK *x,
+ MV *start_mv,
+ int search_param,
+ int sad_per_bit,
+ int do_init_search,
+ int *cost_list,
+ const vp10_variance_fn_ptr_t *vfp,
+ int use_mvcost,
+ const MV *center_mv) {
// First scale has 4-closest points, the rest have 8 points in diamond
// shape at increasing scales
static const int bigdia_num_candidates[MAX_PATTERN_SCALES] = {
@@ -1403,25 +1402,23 @@
{{-512, -512}, {0, -1024}, {512, -512}, {1024, 0}, {512, 512}, {0, 1024},
{-512, 512}, {-1024, 0}},
};
- return vp10_pattern_search(x, start_mv, search_param, sad_per_bit,
- do_init_search, cost_list, vfp, use_mvcost,
- center_mv, best_mv, bigdia_num_candidates,
- bigdia_candidates);
+ return pattern_search(x, start_mv, search_param, sad_per_bit,
+ do_init_search, cost_list, vfp, use_mvcost,
+ center_mv, bigdia_num_candidates, bigdia_candidates);
}
-int vp10_square_search(const MACROBLOCK *x,
- MV *start_mv,
- int search_param,
- int sad_per_bit,
- int do_init_search,
- int *cost_list,
- const vp10_variance_fn_ptr_t *vfp,
- int use_mvcost,
- const MV *center_mv,
- MV *best_mv) {
+static int square_search(MACROBLOCK *x,
+ MV *start_mv,
+ int search_param,
+ int sad_per_bit,
+ int do_init_search,
+ int *cost_list,
+ const vp10_variance_fn_ptr_t *vfp,
+ int use_mvcost,
+ const MV *center_mv) {
// All scales have 8 closest points in square shape
static const int square_num_candidates[MAX_PATTERN_SCALES] = {
- 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
};
// Note that the largest candidate step at each scale is 2^scale
static const MV square_candidates[MAX_PATTERN_SCALES]
@@ -1445,40 +1442,37 @@
{{-1024, -1024}, {0, -1024}, {1024, -1024}, {1024, 0}, {1024, 1024},
{0, 1024}, {-1024, 1024}, {-1024, 0}},
};
- return vp10_pattern_search(x, start_mv, search_param, sad_per_bit,
- do_init_search, cost_list, vfp, use_mvcost,
- center_mv, best_mv, square_num_candidates,
- square_candidates);
+ return pattern_search(x, start_mv, search_param, sad_per_bit,
+ do_init_search, cost_list, vfp, use_mvcost,
+ center_mv, square_num_candidates, square_candidates);
}
-int vp10_fast_hex_search(const MACROBLOCK *x,
- MV *ref_mv,
- int search_param,
- int sad_per_bit,
- int do_init_search, // must be zero for fast_hex
- int *cost_list,
- const vp10_variance_fn_ptr_t *vfp,
- int use_mvcost,
- const MV *center_mv,
- MV *best_mv) {
+static int fast_hex_search(MACROBLOCK *x,
+ MV *ref_mv,
+ int search_param,
+ int sad_per_bit,
+ int do_init_search, // must be zero for fast_hex
+ int *cost_list,
+ const vp10_variance_fn_ptr_t *vfp,
+ int use_mvcost,
+ const MV *center_mv) {
return vp10_hex_search(
x, ref_mv, VPXMAX(MAX_MVSEARCH_STEPS - 2, search_param), sad_per_bit,
- do_init_search, cost_list, vfp, use_mvcost, center_mv, best_mv);
+ do_init_search, cost_list, vfp, use_mvcost, center_mv);
}
-int vp10_fast_dia_search(const MACROBLOCK *x,
- MV *ref_mv,
- int search_param,
- int sad_per_bit,
- int do_init_search,
- int *cost_list,
- const vp10_variance_fn_ptr_t *vfp,
- int use_mvcost,
- const MV *center_mv,
- MV *best_mv) {
- return vp10_bigdia_search(
+static int fast_dia_search(MACROBLOCK *x,
+ MV *ref_mv,
+ int search_param,
+ int sad_per_bit,
+ int do_init_search,
+ int *cost_list,
+ const vp10_variance_fn_ptr_t *vfp,
+ int use_mvcost,
+ const MV *center_mv) {
+ return bigdia_search(
x, ref_mv, VPXMAX(MAX_MVSEARCH_STEPS - 2, search_param), sad_per_bit,
- do_init_search, cost_list, vfp, use_mvcost, center_mv, best_mv);
+ do_init_search, cost_list, vfp, use_mvcost, center_mv);
}
#undef CHECK_BETTER
@@ -1924,12 +1918,12 @@
/* do_refine: If last step (1-away) of n-step search doesn't pick the center
point as the best match, we will do a final 1-away diamond
refining search */
-int vp10_full_pixel_diamond(const VP10_COMP *cpi, MACROBLOCK *x,
- MV *mvp_full, int step_param,
- int sadpb, int further_steps, int do_refine,
- int *cost_list,
- const vp10_variance_fn_ptr_t *fn_ptr,
- const MV *ref_mv, MV *dst_mv) {
+static int full_pixel_diamond(VP10_COMP *cpi, MACROBLOCK *x,
+ MV *mvp_full, int step_param,
+ int sadpb, int further_steps, int do_refine,
+ int *cost_list,
+ const vp10_variance_fn_ptr_t *fn_ptr,
+ const MV *ref_mv) {
MV temp_mv;
int thissme, n, num00 = 0;
int bestsme = cpi->diamond_search_sad(x, &cpi->ss_cfg, mvp_full, &temp_mv,
@@ -1937,7 +1931,7 @@
fn_ptr, ref_mv);
if (bestsme < INT_MAX)
bestsme = vp10_get_mvpred_var(x, &temp_mv, ref_mv, fn_ptr, 1);
- *dst_mv = temp_mv;
+ x->best_mv.as_mv = temp_mv;
// If there won't be more n-step search, check to see if refining search is
// needed.
@@ -1962,7 +1956,7 @@
if (thissme < bestsme) {
bestsme = thissme;
- *dst_mv = temp_mv;
+ x->best_mv.as_mv = temp_mv;
}
}
}
@@ -1970,20 +1964,20 @@
// final 1-away diamond refining search
if (do_refine) {
const int search_range = 8;
- MV best_mv = *dst_mv;
+ MV best_mv = x->best_mv.as_mv;
thissme = vp10_refining_search_sad(x, &best_mv, sadpb, search_range,
fn_ptr, ref_mv);
if (thissme < INT_MAX)
thissme = vp10_get_mvpred_var(x, &best_mv, ref_mv, fn_ptr, 1);
if (thissme < bestsme) {
bestsme = thissme;
- *dst_mv = best_mv;
+ x->best_mv.as_mv = best_mv;
}
}
// Return cost list.
if (cost_list) {
- calc_int_cost_list(x, ref_mv, sadpb, fn_ptr, dst_mv, cost_list);
+ calc_int_cost_list(x, ref_mv, sadpb, fn_ptr, &x->best_mv.as_mv, cost_list);
}
return bestsme;
}
@@ -1994,7 +1988,8 @@
// Runs an limited range exhaustive mesh search using a pattern set
// according to the encode speed profile.
static int full_pixel_exhaustive(VP10_COMP *cpi, MACROBLOCK *x,
- MV *centre_mv_full, int sadpb, int *cost_list,
+ const MV *centre_mv_full, int sadpb,
+ int *cost_list,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *ref_mv, MV *dst_mv) {
const SPEED_FEATURES *const sf = &cpi->sf;
@@ -2053,9 +2048,9 @@
}
int vp10_full_search_sad_c(const MACROBLOCK *x, const MV *ref_mv,
- int sad_per_bit, int distance,
- const vp10_variance_fn_ptr_t *fn_ptr,
- const MV *center_mv, MV *best_mv) {
+ int sad_per_bit, int distance,
+ const vp10_variance_fn_ptr_t *fn_ptr,
+ const MV *center_mv, MV *best_mv) {
int r, c;
const MACROBLOCKD *const xd = &x->e_mbd;
const struct buf_2d *const what = &x->plane[0].src;
@@ -2086,9 +2081,9 @@
}
int vp10_full_search_sadx3(const MACROBLOCK *x, const MV *ref_mv,
- int sad_per_bit, int distance,
- const vp10_variance_fn_ptr_t *fn_ptr,
- const MV *center_mv, MV *best_mv) {
+ int sad_per_bit, int distance,
+ const vp10_variance_fn_ptr_t *fn_ptr,
+ const MV *center_mv, MV *best_mv) {
int r;
const MACROBLOCKD *const xd = &x->e_mbd;
const struct buf_2d *const what = &x->plane[0].src;
@@ -2151,9 +2146,9 @@
}
int vp10_full_search_sadx8(const MACROBLOCK *x, const MV *ref_mv,
- int sad_per_bit, int distance,
- const vp10_variance_fn_ptr_t *fn_ptr,
- const MV *center_mv, MV *best_mv) {
+ int sad_per_bit, int distance,
+ const vp10_variance_fn_ptr_t *fn_ptr,
+ const MV *center_mv, MV *best_mv) {
int r;
const MACROBLOCKD *const xd = &x->e_mbd;
const struct buf_2d *const what = &x->plane[0].src;
@@ -2318,29 +2313,30 @@
// This function is called when we do joint motion search in comp_inter_inter
// mode.
-int vp10_refining_search_8p_c(const MACROBLOCK *x,
- MV *ref_mv, int error_per_bit,
- int search_range,
- const vp10_variance_fn_ptr_t *fn_ptr,
- const MV *center_mv,
- const uint8_t *second_pred) {
+int vp10_refining_search_8p_c(MACROBLOCK *x,
+ int error_per_bit,
+ int search_range,
+ const vp10_variance_fn_ptr_t *fn_ptr,
+ const MV *center_mv,
+ const uint8_t *second_pred) {
const MV neighbors[8] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0},
{-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
const MACROBLOCKD *const xd = &x->e_mbd;
const struct buf_2d *const what = &x->plane[0].src;
const struct buf_2d *const in_what = &xd->plane[0].pre[0];
const MV fcenter_mv = {center_mv->row >> 3, center_mv->col >> 3};
+ MV *best_mv = &x->best_mv.as_mv;
unsigned int best_sad = fn_ptr->sdaf(what->buf, what->stride,
- get_buf_from_mv(in_what, ref_mv), in_what->stride, second_pred) +
- mvsad_err_cost(x, ref_mv, &fcenter_mv, error_per_bit);
+ get_buf_from_mv(in_what, best_mv), in_what->stride, second_pred) +
+ mvsad_err_cost(x, best_mv, &fcenter_mv, error_per_bit);
int i, j;
for (i = 0; i < search_range; ++i) {
int best_site = -1;
for (j = 0; j < 8; ++j) {
- const MV mv = {ref_mv->row + neighbors[j].row,
- ref_mv->col + neighbors[j].col};
+ const MV mv = {best_mv->row + neighbors[j].row,
+ best_mv->col + neighbors[j].col};
if (is_mv_in(x, &mv)) {
unsigned int sad = fn_ptr->sdaf(what->buf, what->stride,
@@ -2358,8 +2354,8 @@
if (best_site == -1) {
break;
} else {
- ref_mv->row += neighbors[best_site].row;
- ref_mv->col += neighbors[best_site].col;
+ best_mv->row += neighbors[best_site].row;
+ best_mv->col += neighbors[best_site].col;
}
}
return best_sad;
@@ -2378,15 +2374,15 @@
}
int vp10_full_pixel_search(VP10_COMP *cpi, MACROBLOCK *x,
- BLOCK_SIZE bsize, MV *mvp_full,
- int step_param, int error_per_bit,
- int *cost_list,
- const MV *ref_mv, MV *tmp_mv,
- int var_max, int rd) {
+ BLOCK_SIZE bsize, MV *mvp_full,
+ int step_param, int error_per_bit,
+ int *cost_list, const MV *ref_mv,
+ int var_max, int rd) {
const SPEED_FEATURES *const sf = &cpi->sf;
const SEARCH_METHODS method = sf->mv.search_method;
vp10_variance_fn_ptr_t *fn_ptr = &cpi->fn_ptr[bsize];
int var = 0;
+
if (cost_list) {
cost_list[0] = INT_MAX;
cost_list[1] = INT_MAX;
@@ -2400,29 +2396,29 @@
switch (method) {
case FAST_DIAMOND:
- var = vp10_fast_dia_search(x, mvp_full, step_param, error_per_bit, 0,
- cost_list, fn_ptr, 1, ref_mv, tmp_mv);
+ var = fast_dia_search(x, mvp_full, step_param, error_per_bit, 0,
+ cost_list, fn_ptr, 1, ref_mv);
break;
case FAST_HEX:
- var = vp10_fast_hex_search(x, mvp_full, step_param, error_per_bit, 0,
- cost_list, fn_ptr, 1, ref_mv, tmp_mv);
+ var = fast_hex_search(x, mvp_full, step_param, error_per_bit, 0,
+ cost_list, fn_ptr, 1, ref_mv);
break;
case HEX:
var = vp10_hex_search(x, mvp_full, step_param, error_per_bit, 1,
- cost_list, fn_ptr, 1, ref_mv, tmp_mv);
+ cost_list, fn_ptr, 1, ref_mv);
break;
case SQUARE:
- var = vp10_square_search(x, mvp_full, step_param, error_per_bit, 1,
- cost_list, fn_ptr, 1, ref_mv, tmp_mv);
+ var = square_search(x, mvp_full, step_param, error_per_bit, 1,
+ cost_list, fn_ptr, 1, ref_mv);
break;
case BIGDIA:
- var = vp10_bigdia_search(x, mvp_full, step_param, error_per_bit, 1,
- cost_list, fn_ptr, 1, ref_mv, tmp_mv);
+ var = bigdia_search(x, mvp_full, step_param, error_per_bit, 1,
+ cost_list, fn_ptr, 1, ref_mv);
break;
case NSTEP:
- var = vp10_full_pixel_diamond(cpi, x, mvp_full, step_param, error_per_bit,
- MAX_MVSEARCH_STEPS - 1 - step_param,
- 1, cost_list, fn_ptr, ref_mv, tmp_mv);
+ var = full_pixel_diamond(cpi, x, mvp_full, step_param, error_per_bit,
+ MAX_MVSEARCH_STEPS - 1 - step_param,
+ 1, cost_list, fn_ptr, ref_mv);
// Should we allow a follow on exhaustive search?
if (is_exhaustive_allowed(cpi, x)) {
@@ -2434,13 +2430,13 @@
if (var > exhuastive_thr) {
int var_ex;
MV tmp_mv_ex;
- var_ex = full_pixel_exhaustive(cpi, x, tmp_mv,
+ var_ex = full_pixel_exhaustive(cpi, x, &x->best_mv.as_mv,
error_per_bit, cost_list, fn_ptr,
ref_mv, &tmp_mv_ex);
if (var_ex < var) {
var = var_ex;
- *tmp_mv = tmp_mv_ex;
+ x->best_mv.as_mv = tmp_mv_ex;
}
}
}
@@ -2452,7 +2448,7 @@
}
if (method != NSTEP && rd && var < var_max)
- var = vp10_get_mvpred_var(x, tmp_mv, ref_mv, fn_ptr, 1);
+ var = vp10_get_mvpred_var(x, &x->best_mv.as_mv, ref_mv, fn_ptr, 1);
return var;
}
diff --git a/vp10/encoder/mcomp.h b/vp10/encoder/mcomp.h
index 704e26c..f97f6c7 100644
--- a/vp10/encoder/mcomp.h
+++ b/vp10/encoder/mcomp.h
@@ -82,31 +82,24 @@
// Perform integral projection based motion estimation.
unsigned int vp10_int_pro_motion_estimation(const struct VP10_COMP *cpi,
- MACROBLOCK *x,
- BLOCK_SIZE bsize,
- int mi_row, int mi_col);
+ MACROBLOCK *x,
+ BLOCK_SIZE bsize,
+ int mi_row, int mi_col);
-typedef int (integer_mv_pattern_search_fn) (
- const MACROBLOCK *x,
- MV *ref_mv,
- int search_param,
- int error_per_bit,
- int do_init_search,
- int *cost_list,
- const vp10_variance_fn_ptr_t *vf,
- int use_mvcost,
- const MV *center_mv,
- MV *best_mv);
-integer_mv_pattern_search_fn vp10_hex_search;
-integer_mv_pattern_search_fn vp10_bigdia_search;
-integer_mv_pattern_search_fn vp10_square_search;
-integer_mv_pattern_search_fn vp10_fast_hex_search;
-integer_mv_pattern_search_fn vp10_fast_dia_search;
+int vp10_hex_search(MACROBLOCK *x,
+ MV *start_mv,
+ int search_param,
+ int sad_per_bit,
+ int do_init_search,
+ int *cost_list,
+ const vp10_variance_fn_ptr_t *vfp,
+ int use_mvcost,
+ const MV *center_mv);
typedef int (fractional_mv_step_fp) (
- const MACROBLOCK *x,
- MV *bestmv, const MV *ref_mv,
+ MACROBLOCK *x,
+ const MV *ref_mv,
int allow_hp,
int error_per_bit,
const vp10_variance_fn_ptr_t *vfp,
@@ -124,39 +117,32 @@
extern fractional_mv_step_fp vp10_find_best_sub_pixel_tree_pruned_evenmore;
typedef int (*vp10_full_search_fn_t)(const MACROBLOCK *x,
- const MV *ref_mv, int sad_per_bit,
- int distance,
- const vp10_variance_fn_ptr_t *fn_ptr,
- const MV *center_mv, MV *best_mv);
+ const MV *ref_mv, int sad_per_bit,
+ int distance,
+ const vp10_variance_fn_ptr_t *fn_ptr,
+ const MV *center_mv, MV *best_mv);
-typedef int (*vp10_refining_search_fn_t)(const MACROBLOCK *x,
- MV *ref_mv, int sad_per_bit,
- int distance,
+typedef int (*vp10_diamond_search_fn_t)(const MACROBLOCK *x,
+ const search_site_config *cfg,
+ MV *ref_mv, MV *best_mv,
+ int search_param, int sad_per_bit,
+ int *num00,
const vp10_variance_fn_ptr_t *fn_ptr,
const MV *center_mv);
-typedef int (*vp10_diamond_search_fn_t)(const MACROBLOCK *x,
- const search_site_config *cfg,
- MV *ref_mv, MV *best_mv,
- int search_param, int sad_per_bit,
- int *num00,
- const vp10_variance_fn_ptr_t *fn_ptr,
- const MV *center_mv);
-
-int vp10_refining_search_8p_c(const MACROBLOCK *x,
- MV *ref_mv, int error_per_bit,
- int search_range,
- const vp10_variance_fn_ptr_t *fn_ptr,
- const MV *center_mv, const uint8_t *second_pred);
+int vp10_refining_search_8p_c(MACROBLOCK *x,
+ int error_per_bit,
+ int search_range,
+ const vp10_variance_fn_ptr_t *fn_ptr,
+ const MV *center_mv, const uint8_t *second_pred);
struct VP10_COMP;
int vp10_full_pixel_search(struct VP10_COMP *cpi, MACROBLOCK *x,
- BLOCK_SIZE bsize, MV *mvp_full,
- int step_param, int error_per_bit,
- int *cost_list,
- const MV *ref_mv, MV *tmp_mv,
- int var_max, int rd);
+ BLOCK_SIZE bsize, MV *mvp_full,
+ int step_param, int error_per_bit,
+ int *cost_list, const MV *ref_mv,
+ int var_max, int rd);
#if CONFIG_EXT_INTER
int vp10_find_best_masked_sub_pixel_tree(const MACROBLOCK *x,
diff --git a/vp10/encoder/rdopt.c b/vp10/encoder/rdopt.c
index b96e6e4..ace1e22 100644
--- a/vp10/encoder/rdopt.c
+++ b/vp10/encoder/rdopt.c
@@ -4753,7 +4753,7 @@
struct buf_2d ref_yv12[2];
int bestsme = INT_MAX;
int sadpb = x->sadperbit16;
- MV tmp_mv;
+ MV *const best_mv = &x->best_mv.as_mv;
int search_range = 3;
int tmp_col_min = x->mv_col_min;
@@ -4814,23 +4814,22 @@
vp10_set_mv_search_range(x, &ref_mv[id].as_mv);
// Use the mv result from the single mode as mv predictor.
- tmp_mv = frame_mv[refs[id]].as_mv;
+ *best_mv = frame_mv[refs[id]].as_mv;
- tmp_mv.col >>= 3;
- tmp_mv.row >>= 3;
+ best_mv->col >>= 3;
+ best_mv->row >>= 3;
#if CONFIG_REF_MV
vp10_set_mvcost(x, refs[id]);
#endif
// Small-range full-pixel motion search.
- bestsme = vp10_refining_search_8p_c(x, &tmp_mv, sadpb,
- search_range,
- &cpi->fn_ptr[bsize],
- &ref_mv[id].as_mv, second_pred);
+ bestsme = vp10_refining_search_8p_c(x, sadpb, search_range,
+ &cpi->fn_ptr[bsize],
+ &ref_mv[id].as_mv, second_pred);
if (bestsme < INT_MAX)
- bestsme = vp10_get_mvpred_av_var(x, &tmp_mv, &ref_mv[id].as_mv,
- second_pred, &cpi->fn_ptr[bsize], 1);
+ bestsme = vp10_get_mvpred_av_var(x, best_mv, &ref_mv[id].as_mv,
+ second_pred, &cpi->fn_ptr[bsize], 1);
x->mv_col_min = tmp_col_min;
x->mv_col_max = tmp_col_max;
@@ -4859,8 +4858,7 @@
pd->pre[0].stride)) << 3];
bestsme = cpi->find_fractional_mv_step(
- x, &tmp_mv,
- &ref_mv[id].as_mv,
+ x, &ref_mv[id].as_mv,
cpi->common.allow_high_precision_mv,
x->errorperbit,
&cpi->fn_ptr[bsize],
@@ -4875,8 +4873,7 @@
} else {
(void) block;
bestsme = cpi->find_fractional_mv_step(
- x, &tmp_mv,
- &ref_mv[id].as_mv,
+ x, &ref_mv[id].as_mv,
cpi->common.allow_high_precision_mv,
x->errorperbit,
&cpi->fn_ptr[bsize],
@@ -4893,7 +4890,7 @@
xd->plane[0].pre[0] = ref_yv12[0];
if (bestsme < last_besterr[id]) {
- frame_mv[refs[id]].as_mv = tmp_mv;
+ frame_mv[refs[id]].as_mv = *best_mv;
last_besterr[id] = bestsme;
} else {
break;
@@ -5196,11 +5193,6 @@
run_mv_search)
#endif // CONFIG_EXT_INTER
) {
-#if CONFIG_EXT_INTER
- MV *const new_mv = &mode_mv[this_mode][0].as_mv;
-#else
- MV *const new_mv = &mode_mv[NEWMV][0].as_mv;
-#endif // CONFIG_EXT_INTER
int step_param = 0;
int bestsme = INT_MAX;
int sadpb = x->sadperbit4;
@@ -5268,8 +5260,7 @@
bestsme = vp10_full_pixel_search(
cpi, x, bsize, &mvp_full, step_param, sadpb,
cpi->sf.mv.subpel_search_method != SUBPEL_TREE ? cost_list : NULL,
- &bsi->ref_mv[0]->as_mv, new_mv,
- INT_MAX, 1);
+ &bsi->ref_mv[0]->as_mv, INT_MAX, 1);
if (bestsme < INT_MAX) {
int distortion;
@@ -5294,9 +5285,7 @@
pd->pre[0].stride)) << 3];
cpi->find_fractional_mv_step(
- x,
- new_mv,
- &bsi->ref_mv[0]->as_mv,
+ x, &bsi->ref_mv[0]->as_mv,
cm->allow_high_precision_mv,
x->errorperbit, &cpi->fn_ptr[bsize],
cpi->sf.mv.subpel_force_stop,
@@ -5311,9 +5300,7 @@
pd->pre[0] = backup_pred;
} else {
cpi->find_fractional_mv_step(
- x,
- new_mv,
- &bsi->ref_mv[0]->as_mv,
+ x, &bsi->ref_mv[0]->as_mv,
cm->allow_high_precision_mv,
x->errorperbit, &cpi->fn_ptr[bsize],
cpi->sf.mv.subpel_force_stop,
@@ -5327,14 +5314,20 @@
// save motion search result for use in compound prediction
#if CONFIG_EXT_INTER
- seg_mvs[i][mv_idx][mbmi->ref_frame[0]].as_mv = *new_mv;
+ seg_mvs[i][mv_idx][mbmi->ref_frame[0]].as_mv = x->best_mv.as_mv;
#else
- seg_mvs[i][mbmi->ref_frame[0]].as_mv = *new_mv;
+ seg_mvs[i][mbmi->ref_frame[0]].as_mv = x->best_mv.as_mv;
#endif // CONFIG_EXT_INTER
}
if (cpi->sf.adaptive_motion_search)
- x->pred_mv[mbmi->ref_frame[0]] = *new_mv;
+ x->pred_mv[mbmi->ref_frame[0]] = x->best_mv.as_mv;
+
+#if CONFIG_EXT_INTER
+ mode_mv[this_mode][0] = x->best_mv;
+#else
+ mode_mv[NEWMV][0] = x->best_mv;
+#endif // CONFIG_EXT_INTER
// restore src pointers
mi_buf_restore(x, orig_src, orig_pre);
@@ -5903,7 +5896,7 @@
int ref_idx,
int mv_idx,
#endif // CONFIG_EXT_INTER
- int_mv *tmp_mv, int *rate_mv) {
+ int *rate_mv) {
MACROBLOCKD *xd = &x->e_mbd;
const VP10_COMMON *cm = &cpi->common;
MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
@@ -5985,7 +5978,7 @@
if ((x->pred_mv_sad[ref] >> 3) > x->pred_mv_sad[i]) {
x->pred_mv[ref].row = 0;
x->pred_mv[ref].col = 0;
- tmp_mv->as_int = INVALID_MV;
+ x->best_mv.as_int = INVALID_MV;
if (scaled_ref_frame) {
int i;
@@ -6005,7 +5998,7 @@
bestsme = vp10_full_pixel_search(cpi, x, bsize, &mvp_full, step_param, sadpb,
cond_cost_list(cpi, cost_list),
- &ref_mv, &tmp_mv->as_mv, INT_MAX, 1);
+ &ref_mv, INT_MAX, 1);
x->mv_col_min = tmp_col_min;
x->mv_col_max = tmp_col_max;
@@ -6027,7 +6020,7 @@
upsampled_ref->y_stride, (mi_row << 3), (mi_col << 3),
NULL, pd->subsampling_x, pd->subsampling_y);
- bestsme = cpi->find_fractional_mv_step(x, &tmp_mv->as_mv, &ref_mv,
+ bestsme = cpi->find_fractional_mv_step(x, &ref_mv,
cm->allow_high_precision_mv,
x->errorperbit,
&cpi->fn_ptr[bsize],
@@ -6041,7 +6034,7 @@
// Restore the reference frames.
pd->pre[ref_idx] = backup_pred;
} else {
- cpi->find_fractional_mv_step(x, &tmp_mv->as_mv, &ref_mv,
+ cpi->find_fractional_mv_step(x, &ref_mv,
cm->allow_high_precision_mv,
x->errorperbit,
&cpi->fn_ptr[bsize],
@@ -6052,11 +6045,11 @@
&dis, &x->pred_sse[ref], NULL, 0, 0, 0);
}
}
- *rate_mv = vp10_mv_bit_cost(&tmp_mv->as_mv, &ref_mv,
+ *rate_mv = vp10_mv_bit_cost(&x->best_mv.as_mv, &ref_mv,
x->nmvjointcost, x->mvcost, MV_COST_WEIGHT);
if (cpi->sf.adaptive_motion_search)
- x->pred_mv[ref] = tmp_mv->as_mv;
+ x->pred_mv[ref] = x->best_mv.as_mv;
if (scaled_ref_frame) {
int i;
@@ -6990,34 +6983,32 @@
}
#endif // CONFIG_EXT_INTER
} else {
- int_mv tmp_mv;
-
#if CONFIG_EXT_INTER
if (is_comp_interintra_pred) {
- tmp_mv = single_newmvs[mv_idx][refs[0]];
+ x->best_mv = single_newmvs[mv_idx][refs[0]];
rate_mv = single_newmvs_rate[mv_idx][refs[0]];
} else {
single_motion_search(cpi, x, bsize, mi_row, mi_col,
- 0, mv_idx, &tmp_mv, &rate_mv);
- single_newmvs[mv_idx][refs[0]] = tmp_mv;
+ 0, mv_idx, &rate_mv);
+ single_newmvs[mv_idx][refs[0]] = x->best_mv;
single_newmvs_rate[mv_idx][refs[0]] = rate_mv;
}
#else
- single_motion_search(cpi, x, bsize, mi_row, mi_col, &tmp_mv, &rate_mv);
- single_newmv[refs[0]] = tmp_mv;
+ single_motion_search(cpi, x, bsize, mi_row, mi_col, &rate_mv);
+ single_newmv[refs[0]] = x->best_mv;
#endif // CONFIG_EXT_INTER
- if (tmp_mv.as_int == INVALID_MV)
+ if (x->best_mv.as_int == INVALID_MV)
return INT64_MAX;
- frame_mv[refs[0]] = tmp_mv;
- xd->mi[0]->bmi[0].as_mv[0] = tmp_mv;
+ frame_mv[refs[0]] = x->best_mv;
+ xd->mi[0]->bmi[0].as_mv[0] = x->best_mv;
// Estimate the rate implications of a new mv but discount this
// under certain circumstances where we want to help initiate a weak
// motion field, where the distortion gain for a single block may not
// be enough to overcome the cost of a new mv.
- if (discount_newmv_test(cpi, this_mode, tmp_mv, mode_mv, refs[0])) {
+ if (discount_newmv_test(cpi, this_mode, x->best_mv, mode_mv, refs[0])) {
rate_mv = VPXMAX((rate_mv / NEW_MV_DISCOUNT_FACTOR), 1);
}
}
diff --git a/vp10/encoder/temporal_filter.c b/vp10/encoder/temporal_filter.c
index 39be057..d125dae 100644
--- a/vp10/encoder/temporal_filter.c
+++ b/vp10/encoder/temporal_filter.c
@@ -288,7 +288,6 @@
MV best_ref_mv1 = {0, 0};
MV best_ref_mv1_full; /* full-pixel value of best_ref_mv1 */
- MV *ref_mv = &x->e_mbd.mi[0]->bmi[0].as_mv[0].as_mv;
// Save input state
struct buf_2d src = x->plane[0].src;
@@ -315,12 +314,11 @@
// Ignore mv costing by sending NULL pointer instead of cost arrays
vp10_hex_search(x, &best_ref_mv1_full, step_param, sadpb, 1,
- cond_cost_list(cpi, cost_list),
- &cpi->fn_ptr[BLOCK_16X16], 0, &best_ref_mv1, ref_mv);
+ cond_cost_list(cpi, cost_list),
+ &cpi->fn_ptr[BLOCK_16X16], 0, &best_ref_mv1);
// Ignore mv costing by sending NULL pointer instead of cost array
- bestsme = cpi->find_fractional_mv_step(x, ref_mv,
- &best_ref_mv1,
+ bestsme = cpi->find_fractional_mv_step(x, &best_ref_mv1,
cpi->common.allow_high_precision_mv,
x->errorperbit,
&cpi->fn_ptr[BLOCK_16X16],
@@ -329,6 +327,8 @@
NULL, NULL,
&distortion, &sse, NULL, 0, 0, 0);
+ x->e_mbd.mi[0]->bmi[0].as_mv[0] = x->best_mv;
+
// Restore input state
x->plane[0].src = src;
xd->plane[0].pre[0] = pre;
