diff --git a/av1/encoder/firstpass.c b/av1/encoder/firstpass.c
index 31b9283..9183c28 100644
--- a/av1/encoder/firstpass.c
+++ b/av1/encoder/firstpass.c
@@ -229,12 +229,16 @@
   aom_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[bsize];
   const int new_mv_mode_penalty = NEW_MV_MODE_PENALTY;
   const int sr = get_search_range(cpi);
-  int step_param = 3 + sr;
+  const int step_param = 3 + sr;
   int cost_list[5];
 
-  tmp_err = av1_full_pixel_search(cpi, x, bsize, start_mv, step_param, NSTEP, 0,
-                                  x->sadperbit, cond_cost_list(cpi, cost_list),
-                                  ref_mv, 0, &cpi->ss_cfg[SS_CFG_FPF],
+  const search_site_config *first_pass_search_sites = &cpi->ss_cfg[SS_CFG_FPF];
+  FULLPEL_MOTION_SEARCH_PARAMS ms_params;
+  av1_make_default_fullpel_ms_params(&ms_params, cpi, x, bsize, ref_mv,
+                                     first_pass_search_sites);
+  ms_params.search_method = NSTEP;
+
+  tmp_err = av1_full_pixel_search(start_mv, &ms_params, step_param, cost_list,
                                   &x->best_mv.as_fullmv, NULL);
 
   if (tmp_err < INT_MAX) {
diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c
index 35a0463..8600571 100644
--- a/av1/encoder/mcomp.c
+++ b/av1/encoder/mcomp.c
@@ -13,7 +13,6 @@
 #include <math.h>
 #include <stdio.h>
 
-#include "av1/common/filter.h"
 #include "config/aom_config.h"
 #include "config/aom_dsp_rtcd.h"
 
@@ -23,6 +22,7 @@
 
 #include "av1/common/av1_common_int.h"
 #include "av1/common/common.h"
+#include "av1/common/filter.h"
 #include "av1/common/mvref_common.h"
 #include "av1/common/reconinter.h"
 
@@ -47,6 +47,49 @@
 #define SSE_LAMBDA_HDRES 1  // Used by mv_cost_err_fn
 #define SAD_LAMBDA_HDRES 8  // Used by mvsad_err_cost during full pixel search
 
+void av1_make_default_fullpel_ms_params(
+    FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const struct AV1_COMP *cpi,
+    const MACROBLOCK *x, BLOCK_SIZE bsize, const MV *ref_mv,
+    const search_site_config *search_sites) {
+  // High level params
+  ms_params->bsize = bsize;
+  ms_params->vfp = &cpi->fn_ptr[bsize];
+
+  ms_params->src = &x->plane[0].src;
+  ms_params->ref = &x->e_mbd.plane[0].pre[0];
+
+  ms_params->second_pred = NULL;
+  ms_params->mask = NULL;
+  ms_params->mask_stride = 0;
+  ms_params->inv_mask = 0;
+
+  ms_params->search_method = cpi->sf.mv_sf.search_method;
+  ms_params->search_sites = search_sites;
+
+  ms_params->mesh_patterns[0] = cpi->sf.mv_sf.mesh_patterns;
+  ms_params->mesh_patterns[1] = cpi->sf.mv_sf.intrabc_mesh_patterns;
+  ms_params->force_mesh_thresh = cpi->sf.mv_sf.exhaustive_searches_thresh;
+  ms_params->prune_mesh_search = cpi->sf.mv_sf.prune_mesh_search;
+  ms_params->run_mesh_search = 0;
+
+  ms_params->is_intra_mode = 0;
+
+  ms_params->fast_obmc_search = cpi->sf.mv_sf.obmc_full_pixel_search_level;
+
+  ms_params->mv_limits = x->mv_limits;
+  av1_set_mv_search_range(&ms_params->mv_limits, ref_mv);
+
+  // Mvcost params
+  ms_params->mv_cost_params.ref_mv = ref_mv;
+  ms_params->mv_cost_params.full_ref_mv = get_fullmv_from_mv(ref_mv);
+  ms_params->mv_cost_params.error_per_bit = x->errorperbit;
+  ms_params->mv_cost_params.sad_per_bit = x->sadperbit;
+  ms_params->mv_cost_params.mvjcost = x->nmv_vec_cost;
+  ms_params->mv_cost_params.mvcost[0] = x->mv_cost_stack[0];
+  ms_params->mv_cost_params.mvcost[1] = x->mv_cost_stack[1];
+  ms_params->mv_cost_params.mv_cost_type = x->mv_cost_type;
+}
+
 void av1_make_default_subpel_ms_params(
     SUBPEL_MOTION_SEARCH_PARAMS *ms_params, const struct AV1_COMP *cpi,
     const MACROBLOCK *x, BLOCK_SIZE bsize, const MV *ref_mv,
@@ -63,6 +106,7 @@
   // Mvcost params
   ms_params->mv_cost_params.ref_mv = ref_mv;
   ms_params->mv_cost_params.error_per_bit = x->errorperbit;
+  ms_params->mv_cost_params.sad_per_bit = x->sadperbit;
   ms_params->mv_cost_params.mvjcost = x->nmv_vec_cost;
   ms_params->mv_cost_params.mvcost[0] = x->mv_cost_stack[0];
   ms_params->mv_cost_params.mvcost[1] = x->mv_cost_stack[1];
@@ -150,9 +194,9 @@
 // Returns the cost of using the current mv during the motion search. This is
 // used when var is used as the error metric.
 #define PIXEL_TRANSFORM_ERROR_SCALE 4
-static int mv_err_cost(const MV *mv, const MV *ref_mv, const int *mvjcost,
-                       const int *const mvcost[2], int error_per_bit,
-                       MV_COST_TYPE mv_cost_type) {
+static INLINE int mv_err_cost(const MV *mv, const MV *ref_mv,
+                              const int *mvjcost, const int *const mvcost[2],
+                              int error_per_bit, MV_COST_TYPE mv_cost_type) {
   const MV diff = { mv->row - ref_mv->row, mv->col - ref_mv->col };
   const MV abs_diff = { abs(diff.row), abs(diff.col) };
 
@@ -185,18 +229,17 @@
 
 // Returns the cost of using the current mv during the motion search. This is
 // only used during full pixel motion search when sad is used as the error
-// metric.
-static int mvsad_err_cost(const MACROBLOCK *x, const FULLPEL_MV *mv,
-                          const FULLPEL_MV *ref_mv, int sad_per_bit) {
+// metric
+static INLINE int mvsad_err_cost(const FULLPEL_MV *mv, const FULLPEL_MV *ref_mv,
+                                 const int *mvjcost, const int *const mvcost[2],
+                                 int sad_per_bit, MV_COST_TYPE mv_cost_type) {
   const MV diff = { GET_MV_SUBPEL(mv->row - ref_mv->row),
                     GET_MV_SUBPEL(mv->col - ref_mv->col) };
-  const MV_COST_TYPE mv_cost_type = x->mv_cost_type;
 
   switch (mv_cost_type) {
     case MV_COST_ENTROPY:
       return ROUND_POWER_OF_TWO(
-          (unsigned)mv_cost(&diff, x->nmv_vec_cost,
-                            CONVERT_TO_CONST_MVCOST(x->mv_cost_stack)) *
+          (unsigned)mv_cost(&diff, mvjcost, CONVERT_TO_CONST_MVCOST(mvcost)) *
               sad_per_bit,
           AV1_PROB_COST_SHIFT);
     case MV_COST_L1_LOWRES:
@@ -210,6 +253,14 @@
   }
 }
 
+static INLINE int mvsad_err_cost_(const FULLPEL_MV *mv,
+                                  const MV_COST_PARAMS *mv_cost_params) {
+  return mvsad_err_cost(mv, &mv_cost_params->full_ref_mv,
+                        mv_cost_params->mvjcost, mv_cost_params->mvcost,
+                        mv_cost_params->sad_per_bit,
+                        mv_cost_params->mv_cost_type);
+}
+
 // =============================================================================
 //  Fullpixel Motion Search: Translational
 // =============================================================================
@@ -343,6 +394,38 @@
          ((col + range) <= mv_limits->col_max);
 }
 
+static INLINE int get_mvpred_var_cost(
+    const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const FULLPEL_MV *this_mv) {
+  const aom_variance_fn_ptr_t *vfp = ms_params->vfp;
+  const MV sub_this_mv = get_mv_from_fullmv(this_mv);
+  const struct buf_2d *const src = ms_params->src;
+  const struct buf_2d *const ref = ms_params->ref;
+  const uint8_t *src_buf = src->buf;
+  const int src_stride = src->stride;
+  const int ref_stride = ref->stride;
+
+  unsigned unused;
+  int bestsme;
+
+  bestsme = vfp->vf(src_buf, src_stride, get_buf_from_mv(ref, this_mv),
+                    ref_stride, &unused);
+
+  bestsme += mv_err_cost_(&sub_this_mv, &ms_params->mv_cost_params);
+
+  return bestsme;
+}
+
+static INLINE int get_mvpred_sad(const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                                 const struct buf_2d *const src,
+                                 const uint8_t *const ref_address,
+                                 const int ref_stride) {
+  const aom_variance_fn_ptr_t *vfp = ms_params->vfp;
+  const uint8_t *src_buf = src->buf;
+  const int src_stride = src->stride;
+
+  return vfp->sdf(src_buf, src_stride, ref_address, ref_stride);
+}
+
 // Calculates and returns a sad+mvcost list around an integer best pel during
 // fullpixel motion search. The resulting list can be used to speed up subpel
 // motion search later.
@@ -350,128 +433,99 @@
 
 // calc_int_cost_list uses var to populate the costlist, which is more accurate
 // than sad but slightly slower.
-static INLINE void calc_int_cost_list(const MACROBLOCK *x,
-                                      const MV *const ref_mv,
-                                      const aom_variance_fn_ptr_t *fn_ptr,
-                                      const FULLPEL_MV *best_mv,
-                                      int *cost_list) {
+static AOM_FORCE_INLINE void calc_int_cost_list(
+    const FULLPEL_MV best_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+    int *cost_list) {
   static const FULLPEL_MV neighbors[4] = {
     { 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 }
   };
-  const struct buf_2d *const what = &x->plane[0].src;
-  const struct buf_2d *const in_what = &x->e_mbd.plane[0].pre[0];
-  const MV sub_best_mv = get_mv_from_fullmv(best_mv);
-  const int br = best_mv->row;
-  const int bc = best_mv->col;
-  const MV_COST_TYPE mv_cost_type = x->mv_cost_type;
-  unsigned int sse;
+  const int br = best_mv.row;
+  const int bc = best_mv.col;
 
-  cost_list[0] =
-      fn_ptr->vf(what->buf, what->stride, get_buf_from_mv(in_what, best_mv),
-                 in_what->stride, &sse) +
-      mv_err_cost(&sub_best_mv, ref_mv, x->nmv_vec_cost,
-                  CONVERT_TO_CONST_MVCOST(x->mv_cost_stack), x->errorperbit,
-                  mv_cost_type);
-  if (check_bounds(&x->mv_limits, br, bc, 1)) {
+  cost_list[0] = get_mvpred_var_cost(ms_params, &best_mv);
+
+  if (check_bounds(&ms_params->mv_limits, br, bc, 1)) {
     for (int i = 0; i < 4; i++) {
       const FULLPEL_MV neighbor_mv = { br + neighbors[i].row,
                                        bc + neighbors[i].col };
-      const MV sub_neighbor_mv = get_mv_from_fullmv(&neighbor_mv);
-      cost_list[i + 1] = fn_ptr->vf(what->buf, what->stride,
-                                    get_buf_from_mv(in_what, &neighbor_mv),
-                                    in_what->stride, &sse) +
-                         mv_err_cost(&sub_neighbor_mv, ref_mv, x->nmv_vec_cost,
-                                     CONVERT_TO_CONST_MVCOST(x->mv_cost_stack),
-                                     x->errorperbit, mv_cost_type);
+      cost_list[i + 1] = get_mvpred_var_cost(ms_params, &neighbor_mv);
     }
   } else {
     for (int i = 0; i < 4; i++) {
       const FULLPEL_MV neighbor_mv = { br + neighbors[i].row,
                                        bc + neighbors[i].col };
-      if (!av1_is_fullmv_in_range(&x->mv_limits, neighbor_mv)) {
+      if (!av1_is_fullmv_in_range(&ms_params->mv_limits, neighbor_mv)) {
         cost_list[i + 1] = INT_MAX;
       } else {
-        const MV sub_neighbor_mv = get_mv_from_fullmv(&neighbor_mv);
-        cost_list[i + 1] =
-            fn_ptr->vf(what->buf, what->stride,
-                       get_buf_from_mv(in_what, &neighbor_mv), in_what->stride,
-                       &sse) +
-            mv_err_cost(&sub_neighbor_mv, ref_mv, x->nmv_vec_cost,
-                        CONVERT_TO_CONST_MVCOST(x->mv_cost_stack),
-                        x->errorperbit, mv_cost_type);
+        cost_list[i + 1] = get_mvpred_var_cost(ms_params, &neighbor_mv);
       }
     }
   }
 }
 
-// calc_int_cost_list uses sad to populate the costlist, which is less accurate
+// calc_int_sad_list uses sad to populate the costlist, which is less accurate
 // than var but faster.
-static INLINE void calc_int_sad_list(const MACROBLOCK *x,
-                                     const MV *const ref_mv, int sadpb,
-                                     const aom_variance_fn_ptr_t *fn_ptr,
-                                     const FULLPEL_MV *best_mv, int *cost_list,
-                                     int costlist_has_sad) {
+static AOM_FORCE_INLINE void calc_int_sad_list(
+    const FULLPEL_MV best_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+    int *cost_list, int costlist_has_sad) {
   static const FULLPEL_MV neighbors[4] = {
     { 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 }
   };
-  const struct buf_2d *const what = &x->plane[0].src;
-  const struct buf_2d *const in_what = &x->e_mbd.plane[0].pre[0];
-  const int br = best_mv->row;
-  const int bc = best_mv->col;
-  const FULLPEL_MV full_ref_mv = get_fullmv_from_mv(ref_mv);
+  const struct buf_2d *const src = ms_params->src;
+  const struct buf_2d *const ref = ms_params->ref;
+  const int ref_stride = ref->stride;
+  const int br = best_mv.row;
+  const int bc = best_mv.col;
 
-  assert(av1_is_fullmv_in_range(&x->mv_limits, *best_mv));
+  assert(av1_is_fullmv_in_range(&ms_params->mv_limits, best_mv));
 
   // Refresh the costlist it does not contain valid sad
   if (!costlist_has_sad) {
-    cost_list[0] =
-        fn_ptr->sdf(what->buf, what->stride, get_buf_from_mv(in_what, best_mv),
-                    in_what->stride);
+    cost_list[0] = get_mvpred_sad(ms_params, src,
+                                  get_buf_from_mv(ref, &best_mv), ref_stride);
 
-    if (check_bounds(&x->mv_limits, br, bc, 1)) {
+    if (check_bounds(&ms_params->mv_limits, br, bc, 1)) {
       for (int i = 0; i < 4; i++) {
         const FULLPEL_MV this_mv = { br + neighbors[i].row,
                                      bc + neighbors[i].col };
-        cost_list[i + 1] =
-            fn_ptr->sdf(what->buf, what->stride,
-                        get_buf_from_mv(in_what, &this_mv), in_what->stride);
+        cost_list[i + 1] = get_mvpred_sad(
+            ms_params, src, get_buf_from_mv(ref, &this_mv), ref_stride);
       }
     } else {
       for (int i = 0; i < 4; i++) {
         const FULLPEL_MV this_mv = { br + neighbors[i].row,
                                      bc + neighbors[i].col };
-        if (!av1_is_fullmv_in_range(&x->mv_limits, this_mv)) {
+        if (!av1_is_fullmv_in_range(&ms_params->mv_limits, this_mv)) {
           cost_list[i + 1] = INT_MAX;
         } else {
-          cost_list[i + 1] =
-              fn_ptr->sdf(what->buf, what->stride,
-                          get_buf_from_mv(in_what, &this_mv), in_what->stride);
+          cost_list[i + 1] = get_mvpred_sad(
+              ms_params, src, get_buf_from_mv(ref, &this_mv), ref_stride);
         }
       }
     }
   }
 
-  cost_list[0] += mvsad_err_cost(x, best_mv, &full_ref_mv, sadpb);
+  const MV_COST_PARAMS *mv_cost_params = &ms_params->mv_cost_params;
+  cost_list[0] += mvsad_err_cost_(&best_mv, mv_cost_params);
 
   for (int idx = 0; idx < 4; idx++) {
     if (cost_list[idx + 1] != INT_MAX) {
       const FULLPEL_MV this_mv = { br + neighbors[idx].row,
                                    bc + neighbors[idx].col };
-      cost_list[idx + 1] += mvsad_err_cost(x, &this_mv, &full_ref_mv, sadpb);
+      cost_list[idx + 1] += mvsad_err_cost_(&this_mv, mv_cost_params);
     }
   }
 }
 
-#define CHECK_BETTER                                                     \
-  if (thissad < bestsad) {                                               \
-    int tmp_thissad = thissad;                                           \
-    if (use_mvcost)                                                      \
-      thissad += mvsad_err_cost(x, &this_mv, &full_ref_mv, sad_per_bit); \
-    if (thissad < bestsad) {                                             \
-      raw_bestsad = tmp_thissad;                                         \
-      bestsad = thissad;                                                 \
-      best_site = i;                                                     \
-    }                                                                    \
+#define CHECK_BETTER                                                      \
+  if (thissad < bestsad) {                                                \
+    int tmp_thissad = thissad;                                            \
+    if (use_mvcost) thissad += mvsad_err_cost_(&this_mv, mv_cost_params); \
+    if (thissad < bestsad) {                                              \
+      raw_bestsad = tmp_thissad;                                          \
+      bestsad = thissad;                                                  \
+      best_site = i;                                                      \
+    }                                                                     \
   }
 
 // Generic pattern search function that searches over multiple scales.
@@ -479,29 +533,30 @@
 // candidates as indicated in the num_candidates and candidates arrays
 // passed into this function
 static int pattern_search(
-    const MACROBLOCK *x, FULLPEL_MV start_mv, int search_param, int sad_per_bit,
-    int do_init_search, int *cost_list, const aom_variance_fn_ptr_t *vfp,
-    const MV *ref_mv, const int num_candidates[MAX_PATTERN_SCALES],
+    FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+    const int search_param, const int do_init_search,
+    const int num_candidates[MAX_PATTERN_SCALES],
     const MV candidates[MAX_PATTERN_SCALES][MAX_PATTERN_CANDIDATES],
-    FULLPEL_MV *best_mv) {
-  const MACROBLOCKD *const xd = &x->e_mbd;
+    int *cost_list, FULLPEL_MV *best_mv) {
   static const int search_param_to_steps[MAX_MVSEARCH_STEPS] = {
     10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
   };
   int i, s, t;
-  const struct buf_2d *const what = &x->plane[0].src;
-  const struct buf_2d *const in_what = &xd->plane[0].pre[0];
+
+  const struct buf_2d *const src = ms_params->src;
+  const struct buf_2d *const ref = ms_params->ref;
+  const int ref_stride = ref->stride;
   const int last_is_4 = num_candidates[0] == 4;
   int br, bc;
   int bestsad = INT_MAX, raw_bestsad = INT_MAX;
   int thissad;
   int k = -1;
-  const FULLPEL_MV full_ref_mv = get_fullmv_from_mv(ref_mv);
-  const int use_mvcost = x->mv_cost_type != MV_COST_NONE;
+  const int use_mvcost = ms_params->mv_cost_params.mv_cost_type != MV_COST_NONE;
+  const MV_COST_PARAMS *mv_cost_params = &ms_params->mv_cost_params;
   assert(search_param < MAX_MVSEARCH_STEPS);
   int best_init_s = search_param_to_steps[search_param];
   // adjust ref_mv to make sure it is within MV range
-  clamp_fullmv(&start_mv, &x->mv_limits);
+  clamp_fullmv(&start_mv, &ms_params->mv_limits);
   br = start_mv.row;
   bc = start_mv.col;
   if (cost_list != NULL) {
@@ -511,10 +566,9 @@
   int costlist_has_sad = 0;
 
   // Work out the start point for the search
-  raw_bestsad = vfp->sdf(what->buf, what->stride,
-                         get_buf_from_mv(in_what, &start_mv), in_what->stride);
-  bestsad =
-      raw_bestsad + mvsad_err_cost(x, &start_mv, &full_ref_mv, sad_per_bit);
+  raw_bestsad = get_mvpred_sad(ms_params, src, get_buf_from_mv(ref, &start_mv),
+                               ref_stride);
+  bestsad = raw_bestsad + mvsad_err_cost_(&start_mv, mv_cost_params);
 
   // Search all possible scales up to the search param around the center point
   // pick the scale of the point that is best as the starting scale of
@@ -524,23 +578,21 @@
     best_init_s = -1;
     for (t = 0; t <= s; ++t) {
       int best_site = -1;
-      if (check_bounds(&x->mv_limits, br, bc, 1 << t)) {
+      if (check_bounds(&ms_params->mv_limits, br, bc, 1 << t)) {
         for (i = 0; i < num_candidates[t]; i++) {
           const FULLPEL_MV this_mv = { br + candidates[t][i].row,
                                        bc + candidates[t][i].col };
-          thissad =
-              vfp->sdf(what->buf, what->stride,
-                       get_buf_from_mv(in_what, &this_mv), in_what->stride);
+          thissad = get_mvpred_sad(ms_params, src,
+                                   get_buf_from_mv(ref, &this_mv), ref_stride);
           CHECK_BETTER
         }
       } else {
         for (i = 0; i < num_candidates[t]; i++) {
           const FULLPEL_MV this_mv = { br + candidates[t][i].row,
                                        bc + candidates[t][i].col };
-          if (!av1_is_fullmv_in_range(&x->mv_limits, this_mv)) continue;
-          thissad =
-              vfp->sdf(what->buf, what->stride,
-                       get_buf_from_mv(in_what, &this_mv), in_what->stride);
+          if (!av1_is_fullmv_in_range(&ms_params->mv_limits, this_mv)) continue;
+          thissad = get_mvpred_sad(ms_params, src,
+                                   get_buf_from_mv(ref, &this_mv), ref_stride);
           CHECK_BETTER
         }
       }
@@ -567,23 +619,22 @@
     for (; s >= last_s; s--) {
       // No need to search all points the 1st time if initial search was used
       if (!do_init_search || s != best_init_s) {
-        if (check_bounds(&x->mv_limits, br, bc, 1 << s)) {
+        if (check_bounds(&ms_params->mv_limits, br, bc, 1 << s)) {
           for (i = 0; i < num_candidates[s]; i++) {
             const FULLPEL_MV this_mv = { br + candidates[s][i].row,
                                          bc + candidates[s][i].col };
-            thissad =
-                vfp->sdf(what->buf, what->stride,
-                         get_buf_from_mv(in_what, &this_mv), in_what->stride);
+            thissad = get_mvpred_sad(
+                ms_params, src, get_buf_from_mv(ref, &this_mv), ref_stride);
             CHECK_BETTER
           }
         } else {
           for (i = 0; i < num_candidates[s]; i++) {
             const FULLPEL_MV this_mv = { br + candidates[s][i].row,
                                          bc + candidates[s][i].col };
-            if (!av1_is_fullmv_in_range(&x->mv_limits, this_mv)) continue;
-            thissad =
-                vfp->sdf(what->buf, what->stride,
-                         get_buf_from_mv(in_what, &this_mv), in_what->stride);
+            if (!av1_is_fullmv_in_range(&ms_params->mv_limits, this_mv))
+              continue;
+            thissad = get_mvpred_sad(
+                ms_params, src, get_buf_from_mv(ref, &this_mv), ref_stride);
             CHECK_BETTER
           }
         }
@@ -604,15 +655,14 @@
         next_chkpts_indices[1] = k;
         next_chkpts_indices[2] = (k == num_candidates[s] - 1) ? 0 : k + 1;
 
-        if (check_bounds(&x->mv_limits, br, bc, 1 << s)) {
+        if (check_bounds(&ms_params->mv_limits, br, bc, 1 << s)) {
           for (i = 0; i < PATTERN_CANDIDATES_REF; i++) {
             const FULLPEL_MV this_mv = {
               br + candidates[s][next_chkpts_indices[i]].row,
               bc + candidates[s][next_chkpts_indices[i]].col
             };
-            thissad =
-                vfp->sdf(what->buf, what->stride,
-                         get_buf_from_mv(in_what, &this_mv), in_what->stride);
+            thissad = get_mvpred_sad(
+                ms_params, src, get_buf_from_mv(ref, &this_mv), ref_stride);
             CHECK_BETTER
           }
         } else {
@@ -621,10 +671,10 @@
               br + candidates[s][next_chkpts_indices[i]].row,
               bc + candidates[s][next_chkpts_indices[i]].col
             };
-            if (!av1_is_fullmv_in_range(&x->mv_limits, this_mv)) continue;
-            thissad =
-                vfp->sdf(what->buf, what->stride,
-                         get_buf_from_mv(in_what, &this_mv), in_what->stride);
+            if (!av1_is_fullmv_in_range(&ms_params->mv_limits, this_mv))
+              continue;
+            thissad = get_mvpred_sad(
+                ms_params, src, get_buf_from_mv(ref, &this_mv), ref_stride);
             CHECK_BETTER
           }
         }
@@ -642,23 +692,22 @@
       cost_list[0] = raw_bestsad;
       costlist_has_sad = 1;
       if (!do_init_search || s != best_init_s) {
-        if (check_bounds(&x->mv_limits, br, bc, 1 << s)) {
+        if (check_bounds(&ms_params->mv_limits, br, bc, 1 << s)) {
           for (i = 0; i < num_candidates[s]; i++) {
             const FULLPEL_MV this_mv = { br + candidates[s][i].row,
                                          bc + candidates[s][i].col };
-            cost_list[i + 1] = thissad =
-                vfp->sdf(what->buf, what->stride,
-                         get_buf_from_mv(in_what, &this_mv), in_what->stride);
+            cost_list[i + 1] = thissad = get_mvpred_sad(
+                ms_params, src, get_buf_from_mv(ref, &this_mv), ref_stride);
             CHECK_BETTER
           }
         } else {
           for (i = 0; i < num_candidates[s]; i++) {
             const FULLPEL_MV this_mv = { br + candidates[s][i].row,
                                          bc + candidates[s][i].col };
-            if (!av1_is_fullmv_in_range(&x->mv_limits, this_mv)) continue;
-            cost_list[i + 1] = thissad =
-                vfp->sdf(what->buf, what->stride,
-                         get_buf_from_mv(in_what, &this_mv), in_what->stride);
+            if (!av1_is_fullmv_in_range(&ms_params->mv_limits, this_mv))
+              continue;
+            cost_list[i + 1] = thissad = get_mvpred_sad(
+                ms_params, src, get_buf_from_mv(ref, &this_mv), ref_stride);
             CHECK_BETTER
           }
         }
@@ -679,15 +728,14 @@
         cost_list[((k + 2) % 4) + 1] = cost_list[0];
         cost_list[0] = raw_bestsad;
 
-        if (check_bounds(&x->mv_limits, br, bc, 1 << s)) {
+        if (check_bounds(&ms_params->mv_limits, br, bc, 1 << s)) {
           for (i = 0; i < PATTERN_CANDIDATES_REF; i++) {
             const FULLPEL_MV this_mv = {
               br + candidates[s][next_chkpts_indices[i]].row,
               bc + candidates[s][next_chkpts_indices[i]].col
             };
-            cost_list[next_chkpts_indices[i] + 1] = thissad =
-                vfp->sdf(what->buf, what->stride,
-                         get_buf_from_mv(in_what, &this_mv), in_what->stride);
+            cost_list[next_chkpts_indices[i] + 1] = thissad = get_mvpred_sad(
+                ms_params, src, get_buf_from_mv(ref, &this_mv), ref_stride);
             CHECK_BETTER
           }
         } else {
@@ -696,13 +744,12 @@
               br + candidates[s][next_chkpts_indices[i]].row,
               bc + candidates[s][next_chkpts_indices[i]].col
             };
-            if (!av1_is_fullmv_in_range(&x->mv_limits, this_mv)) {
+            if (!av1_is_fullmv_in_range(&ms_params->mv_limits, this_mv)) {
               cost_list[next_chkpts_indices[i] + 1] = INT_MAX;
               continue;
             }
-            cost_list[next_chkpts_indices[i] + 1] = thissad =
-                vfp->sdf(what->buf, what->stride,
-                         get_buf_from_mv(in_what, &this_mv), in_what->stride);
+            cost_list[next_chkpts_indices[i] + 1] = thissad = get_mvpred_sad(
+                ms_params, src, get_buf_from_mv(ref, &this_mv), ref_stride);
             CHECK_BETTER
           }
         }
@@ -727,14 +774,15 @@
   // cost_list[4]: cost/sad at delta {-1, 0} (top)    from the best integer pel
   if (cost_list) {
     if (USE_SAD_COSTLIST) {
-      calc_int_sad_list(x, ref_mv, sad_per_bit, vfp, best_mv, cost_list,
-                        costlist_has_sad);
+      calc_int_sad_list(*best_mv, ms_params, cost_list, costlist_has_sad);
     } else {
-      calc_int_cost_list(x, ref_mv, vfp, best_mv, cost_list);
+      calc_int_cost_list(*best_mv, ms_params, cost_list);
     }
   }
+  best_mv->row = br;
+  best_mv->col = bc;
 
-  const int var_cost = av1_get_mvpred_var(x, best_mv, ref_mv, vfp);
+  const int var_cost = get_mvpred_var_cost(ms_params, best_mv);
   return var_cost;
 }
 #undef CHECK_BETTER
@@ -753,10 +801,10 @@
 // vfp: a function pointer to the simd function so we can compute the cost
 //   efficiently
 // ref_mv: the reference mv used to compute the mv cost
-static int hex_search(const MACROBLOCK *x, const FULLPEL_MV start_mv,
-                      int search_param, int sad_per_bit, int do_init_search,
-                      int *cost_list, const aom_variance_fn_ptr_t *vfp,
-                      const MV *ref_mv, FULLPEL_MV *best_mv) {
+static int hex_search(const FULLPEL_MV start_mv,
+                      const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                      const int search_param, const int do_init_search,
+                      int *cost_list, FULLPEL_MV *best_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] = { 8, 6, 6, 6, 6, 6,
@@ -784,15 +832,14 @@
       { -512, 1024 }, { -1024, 0 } },
   };
   /* clang-format on */
-  return pattern_search(x, start_mv, search_param, sad_per_bit, do_init_search,
-                        cost_list, vfp, ref_mv, hex_num_candidates,
-                        hex_candidates, best_mv);
+  return pattern_search(start_mv, ms_params, search_param, do_init_search,
+                        hex_num_candidates, hex_candidates, cost_list, best_mv);
 }
 
-static int bigdia_search(const MACROBLOCK *x, const FULLPEL_MV start_mv,
-                         int search_param, int sad_per_bit, int do_init_search,
-                         int *cost_list, const aom_variance_fn_ptr_t *vfp,
-                         const MV *ref_mv, FULLPEL_MV *best_mv) {
+static int bigdia_search(const FULLPEL_MV start_mv,
+                         const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                         const int search_param, const int do_init_search,
+                         int *cost_list, FULLPEL_MV *best_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] = {
@@ -825,15 +872,15 @@
           { 512, 512 }, { 0, 1024 }, { -512, 512 }, { -1024, 0 } },
       };
   /* clang-format on */
-  return pattern_search(x, start_mv, search_param, sad_per_bit, do_init_search,
-                        cost_list, vfp, ref_mv, bigdia_num_candidates,
-                        bigdia_candidates, best_mv);
+  return pattern_search(start_mv, ms_params, search_param, do_init_search,
+                        bigdia_num_candidates, bigdia_candidates, cost_list,
+                        best_mv);
 }
 
-static int square_search(const MACROBLOCK *x, const FULLPEL_MV start_mv,
-                         int search_param, int sad_per_bit, int do_init_search,
-                         int *cost_list, const aom_variance_fn_ptr_t *vfp,
-                         const MV *ref_mv, FULLPEL_MV *best_mv) {
+static int square_search(const FULLPEL_MV start_mv,
+                         const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                         const int search_param, const int do_init_search,
+                         int *cost_list, FULLPEL_MV *best_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,
@@ -866,173 +913,120 @@
           { 1024, 1024 }, { 0, 1024 }, { -1024, 1024 }, { -1024, 0 } },
       };
   /* clang-format on */
-  return pattern_search(x, start_mv, search_param, sad_per_bit, do_init_search,
-                        cost_list, vfp, ref_mv, square_num_candidates,
-                        square_candidates, best_mv);
+  return pattern_search(start_mv, ms_params, search_param, do_init_search,
+                        square_num_candidates, square_candidates, cost_list,
+                        best_mv);
 }
 
-static int fast_hex_search(const MACROBLOCK *x, const FULLPEL_MV start_mv,
-                           int search_param, int sad_per_bit,
-                           int do_init_search,  // must be zero for fast_hex
-                           int *cost_list, const aom_variance_fn_ptr_t *vfp,
-                           const MV *ref_mv, FULLPEL_MV *best_mv) {
-  return hex_search(x, start_mv, AOMMAX(MAX_MVSEARCH_STEPS - 2, search_param),
-                    sad_per_bit, do_init_search, cost_list, vfp, ref_mv,
-                    best_mv);
+static int fast_hex_search(const FULLPEL_MV start_mv,
+                           const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                           const int search_param, const int do_init_search,
+                           int *cost_list, FULLPEL_MV *best_mv) {
+  return hex_search(start_mv, ms_params,
+                    AOMMAX(MAX_MVSEARCH_STEPS - 2, search_param),
+                    do_init_search, cost_list, best_mv);
 }
 
-static int fast_dia_search(const MACROBLOCK *x, const FULLPEL_MV start_mv,
-                           int search_param, int sad_per_bit,
-                           int do_init_search, int *cost_list,
-                           const aom_variance_fn_ptr_t *vfp, const MV *ref_mv,
-                           FULLPEL_MV *best_mv) {
-  return bigdia_search(
-      x, start_mv, AOMMAX(MAX_MVSEARCH_STEPS - 2, search_param), sad_per_bit,
-      do_init_search, cost_list, vfp, ref_mv, best_mv);
+static int fast_dia_search(const FULLPEL_MV start_mv,
+                           const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                           const int search_param, const int do_init_search,
+                           int *cost_list, FULLPEL_MV *best_mv) {
+  return bigdia_search(start_mv, ms_params,
+                       AOMMAX(MAX_MVSEARCH_STEPS - 2, search_param),
+                       do_init_search, cost_list, best_mv);
 }
 
-// Exhaustive motion search around a given centre position with a given
-// step size.
-static int exhuastive_mesh_search(const MACROBLOCK *x, FULLPEL_MV *ref_mv,
-                                  FULLPEL_MV *best_mv,
-                                  FULLPEL_MV *second_best_mv, int range,
-                                  int step, int sad_per_bit,
-                                  const aom_variance_fn_ptr_t *fn_ptr,
-                                  FULLPEL_MV start_mv) {
-  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];
-  unsigned int best_sad = INT_MAX;
-  int r, c, i;
-  int start_col, end_col, start_row, end_row;
-  int col_step = (step > 1) ? step : 4;
+static INLINE int get_mvpred_compound_var_cost(
+    const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const FULLPEL_MV *this_mv) {
+  const aom_variance_fn_ptr_t *vfp = ms_params->vfp;
+  const struct buf_2d *const src = ms_params->src;
+  const struct buf_2d *const ref = ms_params->ref;
+  const uint8_t *src_buf = src->buf;
+  const int src_stride = src->stride;
+  const int ref_stride = ref->stride;
 
-  assert(step >= 1);
+  const uint8_t *mask = ms_params->mask;
+  const uint8_t *second_pred = ms_params->second_pred;
+  const int mask_stride = ms_params->mask_stride;
+  const int invert_mask = ms_params->inv_mask;
+  unsigned unused;
+  int bestsme;
 
-  clamp_fullmv(&start_mv, &x->mv_limits);
-  *best_mv = start_mv;
-  best_sad = fn_ptr->sdf(what->buf, what->stride,
-                         get_buf_from_mv(in_what, &start_mv), in_what->stride) +
-             mvsad_err_cost(x, &start_mv, ref_mv, sad_per_bit);
-  start_row = AOMMAX(-range, x->mv_limits.row_min - start_mv.row);
-  start_col = AOMMAX(-range, x->mv_limits.col_min - start_mv.col);
-  end_row = AOMMIN(range, x->mv_limits.row_max - start_mv.row);
-  end_col = AOMMIN(range, x->mv_limits.col_max - start_mv.col);
-
-  for (r = start_row; r <= end_row; r += step) {
-    for (c = start_col; c <= end_col; c += col_step) {
-      // Step > 1 means we are not checking every location in this pass.
-      if (step > 1) {
-        const FULLPEL_MV mv = { start_mv.row + r, start_mv.col + c };
-        unsigned int sad =
-            fn_ptr->sdf(what->buf, what->stride, get_buf_from_mv(in_what, &mv),
-                        in_what->stride);
-        if (sad < best_sad) {
-          sad += mvsad_err_cost(x, &mv, ref_mv, sad_per_bit);
-          if (sad < best_sad) {
-            best_sad = sad;
-            if (second_best_mv) {
-              *second_best_mv = *best_mv;
-            }
-            *best_mv = mv;
-          }
-        }
-      } else {
-        // 4 sads in a single call if we are checking every location
-        if (c + 3 <= end_col) {
-          unsigned int sads[4];
-          const uint8_t *addrs[4];
-          for (i = 0; i < 4; ++i) {
-            const FULLPEL_MV mv = { start_mv.row + r, start_mv.col + c + i };
-            addrs[i] = get_buf_from_mv(in_what, &mv);
-          }
-          fn_ptr->sdx4df(what->buf, what->stride, addrs, in_what->stride, sads);
-
-          for (i = 0; i < 4; ++i) {
-            if (sads[i] < best_sad) {
-              const FULLPEL_MV mv = { start_mv.row + r, start_mv.col + c + i };
-              const unsigned int sad =
-                  sads[i] + mvsad_err_cost(x, &mv, ref_mv, sad_per_bit);
-              if (sad < best_sad) {
-                best_sad = sad;
-                if (second_best_mv) {
-                  *second_best_mv = *best_mv;
-                }
-                *best_mv = mv;
-              }
-            }
-          }
-        } else {
-          for (i = 0; i < end_col - c; ++i) {
-            const FULLPEL_MV mv = { start_mv.row + r, start_mv.col + c + i };
-            unsigned int sad =
-                fn_ptr->sdf(what->buf, what->stride,
-                            get_buf_from_mv(in_what, &mv), in_what->stride);
-            if (sad < best_sad) {
-              sad += mvsad_err_cost(x, &mv, ref_mv, sad_per_bit);
-              if (sad < best_sad) {
-                best_sad = sad;
-                if (second_best_mv) {
-                  *second_best_mv = *best_mv;
-                }
-                *best_mv = mv;
-              }
-            }
-          }
-        }
-      }
-    }
+  if (mask) {
+    bestsme = vfp->msvf(src_buf, src_stride, 0, 0,
+                        get_buf_from_mv(ref, this_mv), ref_stride, second_pred,
+                        mask, mask_stride, invert_mask, &unused);
+  } else if (second_pred) {
+    bestsme = vfp->svaf(get_buf_from_mv(ref, this_mv), ref_stride, 0, 0,
+                        src_buf, src_stride, &unused, second_pred);
+  } else {
+    bestsme = vfp->vf(src_buf, src_stride, get_buf_from_mv(ref, this_mv),
+                      ref_stride, &unused);
   }
 
-  return best_sad;
+  const MV sub_this_mv = get_mv_from_fullmv(this_mv);
+  bestsme += mv_err_cost_(&sub_this_mv, &ms_params->mv_cost_params);
+
+  return bestsme;
 }
 
-static int diamond_search_sad(const MACROBLOCK *x,
-                              const search_site_config *cfg,
-                              FULLPEL_MV start_mv, FULLPEL_MV *best_mv,
-                              FULLPEL_MV *second_best_mv, int search_param,
-                              int sad_per_bit, int *num00,
-                              const aom_variance_fn_ptr_t *fn_ptr,
-                              const MV *ref_mv, uint8_t *second_pred,
-                              uint8_t *mask, int mask_stride, int inv_mask) {
-  const MACROBLOCKD *const xd = &x->e_mbd;
-  uint8_t *what = x->plane[0].src.buf;
-  const int what_stride = x->plane[0].src.stride;
-  const uint8_t *in_what;
-  const int in_what_stride = xd->plane[0].pre[0].stride;
+static INLINE int get_mvpred_compound_sad(
+    const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+    const struct buf_2d *const src, const uint8_t *const ref_address,
+    const int ref_stride) {
+  const aom_variance_fn_ptr_t *vfp = ms_params->vfp;
+  const uint8_t *src_buf = src->buf;
+  const int src_stride = src->stride;
+
+  const uint8_t *mask = ms_params->mask;
+  const uint8_t *second_pred = ms_params->second_pred;
+  const int mask_stride = ms_params->mask_stride;
+  const int invert_mask = ms_params->inv_mask;
+
+  if (mask) {
+    return vfp->msdf(src_buf, src_stride, ref_address, ref_stride, second_pred,
+                     mask, mask_stride, invert_mask);
+  } else if (second_pred) {
+    return vfp->sdaf(src_buf, src_stride, ref_address, ref_stride, second_pred);
+  } else {
+    return vfp->sdf(src_buf, src_stride, ref_address, ref_stride);
+  }
+}
+
+static int diamond_search_sad(FULLPEL_MV start_mv,
+                              const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                              const int search_param, int *num00,
+                              FULLPEL_MV *best_mv, FULLPEL_MV *second_best_mv) {
+  const struct buf_2d *const src = ms_params->src;
+  const struct buf_2d *const ref = ms_params->ref;
+
+  const int ref_stride = ref->stride;
   const uint8_t *best_address;
 
+  const aom_variance_fn_ptr_t *vfp = ms_params->vfp;
+  const uint8_t *mask = ms_params->mask;
+  const uint8_t *second_pred = ms_params->second_pred;
+  const MV_COST_PARAMS *mv_cost_params = &ms_params->mv_cost_params;
+
+  const search_site_config *cfg = ms_params->search_sites;
+
   unsigned int bestsad = INT_MAX;
   int best_site = 0;
   int is_off_center = 0;
 
-  clamp_fullmv(&start_mv, &x->mv_limits);
+  clamp_fullmv(&start_mv, &ms_params->mv_limits);
 
   // search_param determines the length of the initial step and hence the number
   // of iterations.
   const int tot_steps = cfg->ss_count - search_param;
 
-  const FULLPEL_MV full_ref_mv = get_fullmv_from_mv(ref_mv);
   *num00 = 0;
   *best_mv = start_mv;
 
-  // Work out the start point for the search
-  in_what = get_buf_from_mv(&xd->plane[0].pre[0], &start_mv);
-  best_address = in_what;
-
   // Check the starting position
-  // TODO(jingning): unify the parameter interface for the following
-  // computation modes.
-  if (mask)
-    bestsad = fn_ptr->msdf(what, what_stride, in_what, in_what_stride,
-                           second_pred, mask, mask_stride, inv_mask);
-  else if (second_pred)
-    bestsad =
-        fn_ptr->sdaf(what, what_stride, in_what, in_what_stride, second_pred);
-  else
-    bestsad = fn_ptr->sdf(what, what_stride, in_what, in_what_stride);
-
-  bestsad += mvsad_err_cost(x, best_mv, &full_ref_mv, sad_per_bit);
+  best_address = get_buf_from_mv(ref, &start_mv);
+  bestsad = get_mvpred_compound_sad(ms_params, src, best_address, ref_stride);
+  bestsad += mvsad_err_cost_(best_mv, &ms_params->mv_cost_params);
 
   int next_step_size = tot_steps > 2 ? cfg->radius[tot_steps - 2] : 1;
   for (int step = tot_steps - 1; step >= 0; --step) {
@@ -1042,13 +1036,15 @@
 
     int all_in = 1, j;
     // Trap illegal vectors
-    all_in &= best_mv->row + ss[1].mv.row >= x->mv_limits.row_min;
-    all_in &= best_mv->row + ss[2].mv.row <= x->mv_limits.row_max;
-    all_in &= best_mv->col + ss[3].mv.col >= x->mv_limits.col_min;
-    all_in &= best_mv->col + ss[4].mv.col <= x->mv_limits.col_max;
+    all_in &= best_mv->row + ss[1].mv.row >= ms_params->mv_limits.row_min;
+    all_in &= best_mv->row + ss[2].mv.row <= ms_params->mv_limits.row_max;
+    all_in &= best_mv->col + ss[3].mv.col >= ms_params->mv_limits.col_min;
+    all_in &= best_mv->col + ss[4].mv.col <= ms_params->mv_limits.col_max;
 
     // TODO(anyone): Implement 4 points search for msdf&sdaf
     if (all_in && !mask && !second_pred) {
+      const uint8_t *src_buf = src->buf;
+      const int src_stride = src->stride;
       for (int idx = 1; idx <= cfg->searches_per_step[step]; idx += 4) {
         unsigned char const *block_offset[4];
         unsigned int sads[4];
@@ -1056,14 +1052,13 @@
         for (j = 0; j < 4; j++)
           block_offset[j] = ss[idx + j].offset + best_address;
 
-        fn_ptr->sdx4df(what, what_stride, block_offset, in_what_stride, sads);
+        vfp->sdx4df(src_buf, src_stride, block_offset, ref_stride, sads);
         for (j = 0; j < 4; j++) {
           if (sads[j] < bestsad) {
             const FULLPEL_MV this_mv = { best_mv->row + ss[idx + j].mv.row,
                                          best_mv->col + ss[idx + j].mv.col };
             unsigned int thissad =
-                sads[j] +
-                mvsad_err_cost(x, &this_mv, &full_ref_mv, sad_per_bit);
+                sads[j] + mvsad_err_cost_(&this_mv, mv_cost_params);
             if (thissad < bestsad) {
               bestsad = thissad;
               best_site = idx + j;
@@ -1076,23 +1071,15 @@
         const FULLPEL_MV this_mv = { best_mv->row + ss[idx].mv.row,
                                      best_mv->col + ss[idx].mv.col };
 
-        if (av1_is_fullmv_in_range(&x->mv_limits, this_mv)) {
+        if (av1_is_fullmv_in_range(&ms_params->mv_limits, this_mv)) {
           const uint8_t *const check_here = ss[idx].offset + best_address;
           unsigned int thissad;
 
-          if (mask)
-            thissad =
-                fn_ptr->msdf(what, what_stride, check_here, in_what_stride,
-                             second_pred, mask, mask_stride, inv_mask);
-          else if (second_pred)
-            thissad = fn_ptr->sdaf(what, what_stride, check_here,
-                                   in_what_stride, second_pred);
-          else
-            thissad =
-                fn_ptr->sdf(what, what_stride, check_here, in_what_stride);
+          thissad =
+              get_mvpred_compound_sad(ms_params, src, check_here, ref_stride);
 
           if (thissad < bestsad) {
-            thissad += mvsad_err_cost(x, &this_mv, &full_ref_mv, sad_per_bit);
+            thissad += mvsad_err_cost_(&this_mv, mv_cost_params);
             if (thissad < bestsad) {
               bestsad = thissad;
               best_site = idx;
@@ -1129,29 +1116,17 @@
 /* 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  */
-static int full_pixel_diamond(const MACROBLOCK *x, const FULLPEL_MV start_mv,
-                              int step_param, int sadpb, int *cost_list,
-                              const aom_variance_fn_ptr_t *fn_ptr,
-                              const MV *ref_mv, const search_site_config *cfg,
-                              uint8_t *second_pred, uint8_t *mask,
-                              int mask_stride, int inv_mask,
+static int full_pixel_diamond(const FULLPEL_MV start_mv,
+                              const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                              const int step_param, int *cost_list,
                               FULLPEL_MV *best_mv, FULLPEL_MV *second_best_mv) {
+  const search_site_config *cfg = ms_params->search_sites;
   int thissme, n, num00 = 0;
-  int bestsme = diamond_search_sad(x, cfg, start_mv, best_mv, second_best_mv,
-                                   step_param, sadpb, &n, fn_ptr, ref_mv,
-                                   second_pred, mask, mask_stride, inv_mask);
+  int bestsme = diamond_search_sad(start_mv, ms_params, step_param, &n, best_mv,
+                                   second_best_mv);
 
   if (bestsme < INT_MAX) {
-    if (mask)
-      bestsme = av1_get_mvpred_mask_var(
-          x, best_mv, ref_mv, second_pred, mask, mask_stride, inv_mask, fn_ptr,
-          &x->plane[0].src, &x->e_mbd.plane[0].pre[0]);
-    else if (second_pred)
-      bestsme =
-          av1_get_mvpred_av_var(x, best_mv, ref_mv, second_pred, fn_ptr,
-                                &x->plane[0].src, &x->e_mbd.plane[0].pre[0]);
-    else
-      bestsme = av1_get_mvpred_var(x, best_mv, ref_mv, fn_ptr);
+    bestsme = get_mvpred_compound_var_cost(ms_params, best_mv);
   }
 
   // If there won't be more n-step search, check to see if refining search is
@@ -1159,28 +1134,18 @@
   const int further_steps = cfg->ss_count - 1 - step_param;
   while (n < further_steps) {
     ++n;
-    FULLPEL_MV tmp_best_mv;
 
     if (num00) {
       num00--;
     } else {
       // TODO(chiyotsai@google.com): There is another bug here where the second
       // best mv gets incorrectly overwritten. Fix it later.
-      thissme = diamond_search_sad(
-          x, cfg, start_mv, &tmp_best_mv, second_best_mv, step_param + n, sadpb,
-          &num00, fn_ptr, ref_mv, second_pred, mask, mask_stride, inv_mask);
+      FULLPEL_MV tmp_best_mv;
+      thissme = diamond_search_sad(start_mv, ms_params, step_param + n, &num00,
+                                   &tmp_best_mv, second_best_mv);
 
       if (thissme < INT_MAX) {
-        if (mask)
-          thissme = av1_get_mvpred_mask_var(
-              x, &tmp_best_mv, ref_mv, second_pred, mask, mask_stride, inv_mask,
-              fn_ptr, &x->plane[0].src, &x->e_mbd.plane[0].pre[0]);
-        else if (second_pred)
-          thissme = av1_get_mvpred_av_var(x, &tmp_best_mv, ref_mv, second_pred,
-                                          fn_ptr, &x->plane[0].src,
-                                          &x->e_mbd.plane[0].pre[0]);
-        else
-          thissme = av1_get_mvpred_var(x, &tmp_best_mv, ref_mv, fn_ptr);
+        thissme = get_mvpred_compound_var_cost(ms_params, &tmp_best_mv);
       }
 
       if (thissme < bestsme) {
@@ -1194,26 +1159,120 @@
   if (cost_list) {
     if (USE_SAD_COSTLIST) {
       const int costlist_has_sad = 0;
-      calc_int_sad_list(x, ref_mv, sadpb, fn_ptr, &x->best_mv.as_fullmv,
-                        cost_list, costlist_has_sad);
+      calc_int_sad_list(*best_mv, ms_params, cost_list, costlist_has_sad);
     } else {
-      calc_int_cost_list(x, ref_mv, fn_ptr, &x->best_mv.as_fullmv, cost_list);
+      calc_int_cost_list(*best_mv, ms_params, cost_list);
     }
   }
   return bestsme;
 }
 
-#define MIN_RANGE 7
-#define MAX_RANGE 256
-#define MIN_INTERVAL 1
+// Exhaustive motion search around a given centre position with a given
+// step size.
+static int exhaustive_mesh_search(FULLPEL_MV start_mv,
+                                  const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                                  const int range, const int step,
+                                  FULLPEL_MV *best_mv,
+                                  FULLPEL_MV *second_best_mv) {
+  const aom_variance_fn_ptr_t *vfp = ms_params->vfp;
+  const MV_COST_PARAMS *mv_cost_params = &ms_params->mv_cost_params;
+  const struct buf_2d *const src = ms_params->src;
+  const struct buf_2d *const ref = ms_params->ref;
+  const int ref_stride = ref->stride;
+  unsigned int best_sad = INT_MAX;
+  int r, c, i;
+  int start_col, end_col, start_row, end_row;
+  int col_step = (step > 1) ? step : 4;
+
+  assert(step >= 1);
+
+  clamp_fullmv(&start_mv, &ms_params->mv_limits);
+  *best_mv = start_mv;
+  best_sad = get_mvpred_sad(ms_params, src, get_buf_from_mv(ref, &start_mv),
+                            ref_stride);
+  best_sad += mvsad_err_cost_(&start_mv, mv_cost_params);
+  start_row = AOMMAX(-range, ms_params->mv_limits.row_min - start_mv.row);
+  start_col = AOMMAX(-range, ms_params->mv_limits.col_min - start_mv.col);
+  end_row = AOMMIN(range, ms_params->mv_limits.row_max - start_mv.row);
+  end_col = AOMMIN(range, ms_params->mv_limits.col_max - start_mv.col);
+
+  for (r = start_row; r <= end_row; r += step) {
+    for (c = start_col; c <= end_col; c += col_step) {
+      // Step > 1 means we are not checking every location in this pass.
+      if (step > 1) {
+        const FULLPEL_MV mv = { start_mv.row + r, start_mv.col + c };
+        unsigned int sad = get_mvpred_sad(
+            ms_params, src, get_buf_from_mv(ref, &mv), ref_stride);
+        if (sad < best_sad) {
+          sad += mvsad_err_cost_(&mv, mv_cost_params);
+          if (sad < best_sad) {
+            best_sad = sad;
+            if (second_best_mv) {
+              *second_best_mv = *best_mv;
+            }
+            *best_mv = mv;
+          }
+        }
+      } else {
+        // 4 sads in a single call if we are checking every location
+        if (c + 3 <= end_col) {
+          unsigned int sads[4];
+          const uint8_t *addrs[4];
+          for (i = 0; i < 4; ++i) {
+            const FULLPEL_MV mv = { start_mv.row + r, start_mv.col + c + i };
+            addrs[i] = get_buf_from_mv(ref, &mv);
+          }
+          vfp->sdx4df(src->buf, src->stride, addrs, ref_stride, sads);
+
+          for (i = 0; i < 4; ++i) {
+            if (sads[i] < best_sad) {
+              const FULLPEL_MV mv = { start_mv.row + r, start_mv.col + c + i };
+              const unsigned int sad =
+                  sads[i] + mvsad_err_cost_(&mv, mv_cost_params);
+              if (sad < best_sad) {
+                best_sad = sad;
+                if (second_best_mv) {
+                  *second_best_mv = *best_mv;
+                }
+                *best_mv = mv;
+              }
+            }
+          }
+        } else {
+          for (i = 0; i < end_col - c; ++i) {
+            const FULLPEL_MV mv = { start_mv.row + r, start_mv.col + c + i };
+            unsigned int sad = get_mvpred_sad(
+                ms_params, src, get_buf_from_mv(ref, &mv), ref_stride);
+            if (sad < best_sad) {
+              sad += mvsad_err_cost_(&mv, mv_cost_params);
+              if (sad < best_sad) {
+                best_sad = sad;
+                if (second_best_mv) {
+                  *second_best_mv = *best_mv;
+                }
+                *best_mv = mv;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return best_sad;
+}
+
 // Runs an limited range exhaustive mesh search using a pattern set
 // according to the encode speed profile.
-static int full_pixel_exhaustive(
-    const MACROBLOCK *x, const FULLPEL_MV start_mv, int sadpb, int *cost_list,
-    const aom_variance_fn_ptr_t *fn_ptr, const MV *ref_mv, FULLPEL_MV *best_mv,
-    FULLPEL_MV *second_best_mv,
-    const struct MESH_PATTERN *const mesh_patterns) {
-  FULLPEL_MV full_ref_mv = get_fullmv_from_mv(ref_mv);
+static int full_pixel_exhaustive(const FULLPEL_MV start_mv,
+                                 const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                                 const struct MESH_PATTERN *const mesh_patterns,
+                                 int *cost_list, FULLPEL_MV *best_mv,
+                                 FULLPEL_MV *second_best_mv) {
+  const int kMinRange = 7;
+  const int kMaxRange = 256;
+  const int kMinInterval = 1;
+
   int bestsme;
   int i;
   int interval = mesh_patterns[0].interval;
@@ -1223,7 +1282,7 @@
   *best_mv = start_mv;
 
   // Trap illegal values for interval and range for this function.
-  if ((range < MIN_RANGE) || (range > MAX_RANGE) || (interval < MIN_INTERVAL) ||
+  if ((range < kMinRange) || (range > kMaxRange) || (interval < kMinInterval) ||
       (interval > range))
     return INT_MAX;
 
@@ -1232,37 +1291,37 @@
   // Check size of proposed first range against magnitude of the centre
   // value used as a starting point.
   range = AOMMAX(range, (5 * AOMMAX(abs(best_mv->row), abs(best_mv->col))) / 4);
-  range = AOMMIN(range, MAX_RANGE);
+  range = AOMMIN(range, kMaxRange);
   interval = AOMMAX(interval, range / baseline_interval_divisor);
 
   // initial search
-  bestsme = exhuastive_mesh_search(x, &full_ref_mv, best_mv, second_best_mv,
-                                   range, interval, sadpb, fn_ptr, *best_mv);
+  bestsme = exhaustive_mesh_search(*best_mv, ms_params, range, interval,
+                                   best_mv, second_best_mv);
 
-  if ((interval > MIN_INTERVAL) && (range > MIN_RANGE)) {
+  if ((interval > kMinInterval) && (range > kMinRange)) {
     // Progressive searches with range and step size decreasing each time
     // till we reach a step size of 1. Then break out.
     for (i = 1; i < MAX_MESH_STEP; ++i) {
       // First pass with coarser step and longer range
-      bestsme = exhuastive_mesh_search(
-          x, &full_ref_mv, best_mv, second_best_mv, mesh_patterns[i].range,
-          mesh_patterns[i].interval, sadpb, fn_ptr, *best_mv);
+      bestsme = exhaustive_mesh_search(
+          *best_mv, ms_params, mesh_patterns[i].range,
+          mesh_patterns[i].interval, best_mv, second_best_mv);
 
       if (mesh_patterns[i].interval == 1) break;
     }
   }
 
-  if (bestsme < INT_MAX)
-    bestsme = av1_get_mvpred_var(x, best_mv, ref_mv, fn_ptr);
+  if (bestsme < INT_MAX) {
+    bestsme = get_mvpred_var_cost(ms_params, best_mv);
+  }
 
   // Return cost list.
   if (cost_list) {
     if (USE_SAD_COSTLIST) {
       const int costlist_has_sad = 0;
-      calc_int_sad_list(x, ref_mv, sadpb, fn_ptr, best_mv, cost_list,
-                        costlist_has_sad);
+      calc_int_sad_list(*best_mv, ms_params, cost_list, costlist_has_sad);
     } else {
-      calc_int_cost_list(x, ref_mv, fn_ptr, best_mv, cost_list);
+      calc_int_cost_list(*best_mv, ms_params, cost_list);
     }
   }
   return bestsme;
@@ -1303,12 +1362,16 @@
     best_sad = fn_ptr->msdf(what->buf, what->stride,
                             get_buf_from_mv(in_what, best_mv), in_what->stride,
                             second_pred, mask, mask_stride, invert_mask) +
-               mvsad_err_cost(x, best_mv, &full_ref_mv, error_per_bit);
+               mvsad_err_cost(best_mv, &full_ref_mv, x->nmv_vec_cost,
+                              CONVERT_TO_CONST_MVCOST(x->mv_cost_stack),
+                              error_per_bit, x->mv_cost_type);
   } else {
     best_sad =
         fn_ptr->sdaf(what->buf, what->stride, get_buf_from_mv(in_what, best_mv),
                      in_what->stride, second_pred) +
-        mvsad_err_cost(x, best_mv, &full_ref_mv, error_per_bit);
+        mvsad_err_cost(best_mv, &full_ref_mv, x->nmv_vec_cost,
+                       CONVERT_TO_CONST_MVCOST(x->mv_cost_stack), error_per_bit,
+                       x->mv_cost_type);
   }
 
   do_refine_search_grid[grid_coord] = 1;
@@ -1337,7 +1400,10 @@
                              second_pred);
         }
         if (sad < best_sad) {
-          sad += mvsad_err_cost(x, &mv, &full_ref_mv, error_per_bit);
+          sad += mvsad_err_cost(&mv, &full_ref_mv, x->nmv_vec_cost,
+                                CONVERT_TO_CONST_MVCOST(x->mv_cost_stack),
+                                error_per_bit, x->mv_cost_type);
+
           if (sad < best_sad) {
             best_sad = sad;
             best_site = j;
@@ -1357,15 +1423,22 @@
   return best_sad;
 }
 
-int av1_full_pixel_search(const AV1_COMP *cpi, const MACROBLOCK *x,
-                          BLOCK_SIZE bsize, const FULLPEL_MV start_mv,
-                          int step_param, int method, int run_mesh_search,
-                          int error_per_bit, int *cost_list, const MV *ref_mv,
-                          int is_intra_mode, const search_site_config *cfg,
+int av1_full_pixel_search(const FULLPEL_MV start_mv,
+                          const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                          const int step_param, int *cost_list,
                           FULLPEL_MV *best_mv, FULLPEL_MV *second_best_mv) {
-  const SPEED_FEATURES *const sf = &cpi->sf;
-  const aom_variance_fn_ptr_t *fn_ptr = &cpi->fn_ptr[bsize];
-  int bestsme = 0;
+  const BLOCK_SIZE bsize = ms_params->bsize;
+
+  const SEARCH_METHODS search_method = ms_params->search_method;
+
+  const int is_intra_mode = ms_params->is_intra_mode;
+  int run_mesh_search = ms_params->run_mesh_search;
+
+  int var = 0;
+
+  assert(ms_params->second_pred == NULL && ms_params->mask == NULL &&
+         ms_params->mask_stride == 0 &&
+         "av1_full_pixel_search does not support compound pred");
 
   if (cost_list) {
     cost_list[0] = INT_MAX;
@@ -1375,48 +1448,46 @@
     cost_list[4] = INT_MAX;
   }
 
-  switch (method) {
+  switch (search_method) {
     case FAST_DIAMOND:
-      bestsme = fast_dia_search(x, start_mv, step_param, error_per_bit, 0,
-                                cost_list, fn_ptr, ref_mv, best_mv);
+      var = fast_dia_search(start_mv, ms_params, step_param, 0, cost_list,
+                            best_mv);
       break;
     case FAST_HEX:
-      bestsme = fast_hex_search(x, start_mv, step_param, error_per_bit, 0,
-                                cost_list, fn_ptr, ref_mv, best_mv);
+      var = fast_hex_search(start_mv, ms_params, step_param, 0, cost_list,
+                            best_mv);
       break;
     case HEX:
-      bestsme = hex_search(x, start_mv, step_param, error_per_bit, 1, cost_list,
-                           fn_ptr, ref_mv, best_mv);
+      var = hex_search(start_mv, ms_params, step_param, 1, cost_list, best_mv);
       break;
     case SQUARE:
-      bestsme = square_search(x, start_mv, step_param, error_per_bit, 1,
-                              cost_list, fn_ptr, ref_mv, best_mv);
+      var =
+          square_search(start_mv, ms_params, step_param, 1, cost_list, best_mv);
       break;
     case BIGDIA:
-      bestsme = bigdia_search(x, start_mv, step_param, error_per_bit, 1,
-                              cost_list, fn_ptr, ref_mv, best_mv);
+      var =
+          bigdia_search(start_mv, ms_params, step_param, 1, cost_list, best_mv);
       break;
     case NSTEP:
     case DIAMOND:
-      bestsme = full_pixel_diamond(x, start_mv, step_param, error_per_bit,
-                                   cost_list, fn_ptr, ref_mv, cfg, NULL, NULL,
-                                   0, 0, best_mv, second_best_mv);
+      var = full_pixel_diamond(start_mv, ms_params, step_param, cost_list,
+                               best_mv, second_best_mv);
       break;
     default: assert(0 && "Invalid search method.");
   }
 
   // Should we allow a follow on exhaustive search?
-  if (!run_mesh_search && method == NSTEP) {
-    int exhuastive_thr = sf->mv_sf.exhaustive_searches_thresh;
+  if (!run_mesh_search && search_method == NSTEP) {
+    int exhuastive_thr = ms_params->force_mesh_thresh;
     exhuastive_thr >>=
         10 - (mi_size_wide_log2[bsize] + mi_size_high_log2[bsize]);
     // Threshold variance for an exhaustive full search.
-    if (bestsme > exhuastive_thr) run_mesh_search = 1;
+    if (var > exhuastive_thr) run_mesh_search = 1;
   }
 
   // TODO(yunqing): the following is used to reduce mesh search in temporal
   // filtering. Can extend it to intrabc.
-  if (!is_intra_mode && sf->mv_sf.prune_mesh_search) {
+  if (!is_intra_mode && ms_params->prune_mesh_search) {
     const int full_pel_mv_diff = AOMMAX(abs(start_mv.row - best_mv->row),
                                         abs(start_mv.col - best_mv->col));
     if (full_pel_mv_diff <= 4) {
@@ -1429,21 +1500,21 @@
     FULLPEL_MV tmp_mv_ex;
     // Pick the mesh pattern for exhaustive search based on the toolset (intraBC
     // or non-intraBC)
-    const MESH_PATTERN *const mesh_patterns =
-        is_intra_mode ? sf->mv_sf.intrabc_mesh_patterns
-                      : sf->mv_sf.mesh_patterns;
     // TODO(chiyotsai@google.com):  There is a bug here where the second best mv
     // gets overwritten without actually comparing the rdcost.
-    var_ex = full_pixel_exhaustive(x, *best_mv, error_per_bit, cost_list,
-                                   fn_ptr, ref_mv, &tmp_mv_ex, second_best_mv,
-                                   mesh_patterns);
-    if (var_ex < bestsme) {
-      bestsme = var_ex;
+    const MESH_PATTERN *const mesh_patterns =
+        ms_params->mesh_patterns[is_intra_mode];
+    // TODO(chiyotsai@google.com): the second best mv is not set correctly by
+    // full_pixel_exhaustive, which can incorrectly override it.
+    var_ex = full_pixel_exhaustive(*best_mv, ms_params, mesh_patterns,
+                                   cost_list, &tmp_mv_ex, second_best_mv);
+    if (var_ex < var) {
+      var = var_ex;
       *best_mv = tmp_mv_ex;
     }
   }
 
-  return bestsme;
+  return var;
 }
 
 void av1_intrabc_hash_search(const AV1_COMP *cpi, MACROBLOCK *x,
@@ -1508,214 +1579,6 @@
   }
 }
 
-// =============================================================================
-//  Fullpixel Motion Search: OBMC
-// =============================================================================
-static int get_obmc_mvpred_var(const MACROBLOCK *x, const int32_t *wsrc,
-                               const int32_t *mask, const FULLPEL_MV *best_mv,
-                               const MV *ref_mv,
-                               const aom_variance_fn_ptr_t *vfp) {
-  const MACROBLOCKD *const xd = &x->e_mbd;
-  const struct buf_2d *const in_what = xd->plane[0].pre;
-  const MV mv = get_mv_from_fullmv(best_mv);
-  const MV_COST_TYPE mv_cost_type = x->mv_cost_type;
-  unsigned int unused;
-
-  return vfp->ovf(get_buf_from_mv(in_what, best_mv), in_what->stride, wsrc,
-                  mask, &unused) +
-         mv_err_cost(&mv, ref_mv, x->nmv_vec_cost,
-                     CONVERT_TO_CONST_MVCOST(x->mv_cost_stack), x->errorperbit,
-                     mv_cost_type);
-}
-
-static int obmc_refining_search_sad(const MACROBLOCK *x, const int32_t *wsrc,
-                                    const int32_t *mask, FULLPEL_MV *best_mv,
-                                    int error_per_bit, int search_range,
-                                    const aom_variance_fn_ptr_t *fn_ptr,
-                                    const MV *ref_mv) {
-  const MV neighbors[4] = { { -1, 0 }, { 0, -1 }, { 0, 1 }, { 1, 0 } };
-  const MACROBLOCKD *const xd = &x->e_mbd;
-  const struct buf_2d *const in_what = xd->plane[0].pre;
-  const FULLPEL_MV full_ref_mv = get_fullmv_from_mv(ref_mv);
-  unsigned int best_sad =
-      fn_ptr->osdf(get_buf_from_mv(in_what, best_mv), in_what->stride, wsrc,
-                   mask) +
-      mvsad_err_cost(x, best_mv, &full_ref_mv, error_per_bit);
-  int i, j;
-
-  for (i = 0; i < search_range; i++) {
-    int best_site = -1;
-
-    for (j = 0; j < 4; j++) {
-      const FULLPEL_MV mv = { best_mv->row + neighbors[j].row,
-                              best_mv->col + neighbors[j].col };
-      if (av1_is_fullmv_in_range(&x->mv_limits, mv)) {
-        unsigned int sad = fn_ptr->osdf(get_buf_from_mv(in_what, &mv),
-                                        in_what->stride, wsrc, mask);
-        if (sad < best_sad) {
-          sad += mvsad_err_cost(x, &mv, &full_ref_mv, error_per_bit);
-          if (sad < best_sad) {
-            best_sad = sad;
-            best_site = j;
-          }
-        }
-      }
-    }
-
-    if (best_site == -1) {
-      break;
-    } else {
-      best_mv->row += neighbors[best_site].row;
-      best_mv->col += neighbors[best_site].col;
-    }
-  }
-  return best_sad;
-}
-
-static int obmc_diamond_search_sad(
-    const MACROBLOCK *x, const search_site_config *cfg, const int32_t *wsrc,
-    const int32_t *mask, FULLPEL_MV start_mv, FULLPEL_MV *best_mv,
-    int search_param, int sad_per_bit, int *num00,
-    const aom_variance_fn_ptr_t *fn_ptr, const MV *ref_mv) {
-  const MACROBLOCKD *const xd = &x->e_mbd;
-  const struct buf_2d *const in_what = xd->plane[0].pre;
-  // search_param determines the length of the initial step and hence the number
-  // of iterations
-  // 0 = initial step (MAX_FIRST_STEP) pel : 1 = (MAX_FIRST_STEP/2) pel, 2 =
-  // (MAX_FIRST_STEP/4) pel... etc.
-
-  const int tot_steps = MAX_MVSEARCH_STEPS - 1 - search_param;
-  const FULLPEL_MV full_ref_mv = get_fullmv_from_mv(ref_mv);
-  const uint8_t *best_address, *in_what_ref;
-  int best_sad = INT_MAX;
-  int best_site = 0;
-  int step;
-
-  clamp_fullmv(&start_mv, &x->mv_limits);
-  in_what_ref = get_buf_from_mv(in_what, &start_mv);
-  best_address = in_what_ref;
-  *num00 = 0;
-  *best_mv = start_mv;
-
-  // Check the starting position
-  best_sad = fn_ptr->osdf(best_address, in_what->stride, wsrc, mask) +
-             mvsad_err_cost(x, best_mv, &full_ref_mv, sad_per_bit);
-
-  for (step = tot_steps; step >= 0; --step) {
-    const search_site *const ss = cfg->ss[step];
-    best_site = 0;
-    for (int idx = 1; idx <= cfg->searches_per_step[step]; ++idx) {
-      const FULLPEL_MV mv = { best_mv->row + ss[idx].mv.row,
-                              best_mv->col + ss[idx].mv.col };
-      if (av1_is_fullmv_in_range(&x->mv_limits, mv)) {
-        int sad = fn_ptr->osdf(best_address + ss[idx].offset, in_what->stride,
-                               wsrc, mask);
-        if (sad < best_sad) {
-          sad += mvsad_err_cost(x, &mv, &full_ref_mv, sad_per_bit);
-          if (sad < best_sad) {
-            best_sad = sad;
-            best_site = idx;
-          }
-        }
-      }
-    }
-
-    if (best_site != 0) {
-      best_mv->row += ss[best_site].mv.row;
-      best_mv->col += ss[best_site].mv.col;
-      best_address += ss[best_site].offset;
-    } else if (best_address == in_what_ref) {
-      (*num00)++;
-    }
-  }
-  return best_sad;
-}
-
-static int obmc_full_pixel_diamond(const AV1_COMP *cpi, const MACROBLOCK *x,
-                                   const FULLPEL_MV start_mv, int step_param,
-                                   int sadpb, int do_refine,
-                                   const aom_variance_fn_ptr_t *fn_ptr,
-                                   const MV *ref_mv, FULLPEL_MV *best_mv,
-                                   const search_site_config *cfg) {
-  (void)cpi;  // to silence compiler warning
-  const int32_t *wsrc = x->wsrc_buf;
-  const int32_t *mask = x->mask_buf;
-  FULLPEL_MV tmp_mv;
-  int thissme, n, num00 = 0;
-  int bestsme = obmc_diamond_search_sad(x, cfg, wsrc, mask, start_mv, &tmp_mv,
-                                        step_param, sadpb, &n, fn_ptr, ref_mv);
-  if (bestsme < INT_MAX)
-    bestsme = get_obmc_mvpred_var(x, wsrc, mask, &tmp_mv, ref_mv, fn_ptr);
-  *best_mv = tmp_mv;
-
-  // If there won't be more n-step search, check to see if refining search is
-  // needed.
-  const int further_steps = cfg->ss_count - 1 - step_param;
-  if (n > further_steps) do_refine = 0;
-
-  while (n < further_steps) {
-    ++n;
-
-    if (num00) {
-      num00--;
-    } else {
-      thissme = obmc_diamond_search_sad(x, cfg, wsrc, mask, start_mv, &tmp_mv,
-                                        step_param + n, sadpb, &num00, fn_ptr,
-                                        ref_mv);
-      if (thissme < INT_MAX)
-        thissme = get_obmc_mvpred_var(x, wsrc, mask, &tmp_mv, ref_mv, fn_ptr);
-
-      // check to see if refining search is needed.
-      if (num00 > further_steps - n) do_refine = 0;
-
-      if (thissme < bestsme) {
-        bestsme = thissme;
-        *best_mv = tmp_mv;
-      }
-    }
-  }
-
-  // final 1-away diamond refining search
-  if (do_refine) {
-    const int search_range = 8;
-    tmp_mv = *best_mv;
-    thissme = obmc_refining_search_sad(x, wsrc, mask, &tmp_mv, sadpb,
-                                       search_range, fn_ptr, ref_mv);
-    if (thissme < INT_MAX)
-      thissme = get_obmc_mvpred_var(x, wsrc, mask, &tmp_mv, ref_mv, fn_ptr);
-    if (thissme < bestsme) {
-      bestsme = thissme;
-      *best_mv = tmp_mv;
-    }
-  }
-  return bestsme;
-}
-
-int av1_obmc_full_pixel_search(const AV1_COMP *cpi, const MACROBLOCK *x,
-                               const FULLPEL_MV start_mv, int step_param,
-                               int sadpb, const aom_variance_fn_ptr_t *fn_ptr,
-                               const MV *ref_mv, FULLPEL_MV *best_mv,
-                               const search_site_config *cfg) {
-  if (cpi->sf.inter_sf.obmc_full_pixel_search_level == 0) {
-    const int do_refine = 1;
-    const int bestsme =
-        obmc_full_pixel_diamond(cpi, x, start_mv, step_param, sadpb, do_refine,
-                                fn_ptr, ref_mv, best_mv, cfg);
-    return bestsme;
-  } else {
-    const int32_t *wsrc = x->wsrc_buf;
-    const int32_t *mask = x->mask_buf;
-    const int search_range = 8;
-    *best_mv = start_mv;
-    clamp_fullmv(best_mv, &x->mv_limits);
-    int thissme = obmc_refining_search_sad(x, wsrc, mask, best_mv, sadpb,
-                                           search_range, fn_ptr, ref_mv);
-    if (thissme < INT_MAX)
-      thissme = get_obmc_mvpred_var(x, wsrc, mask, best_mv, ref_mv, fn_ptr);
-    return thissme;
-  }
-}
-
 static int vector_match(int16_t *ref, int16_t *src, int bwl) {
   int best_sad = INT_MAX;
   int this_sad;
@@ -1923,6 +1786,228 @@
 }
 
 // =============================================================================
+//  Fullpixel Motion Search: OBMC
+// =============================================================================
+static int get_obmc_mvpred_var(const MACROBLOCK *x, const int32_t *wsrc,
+                               const int32_t *mask, const FULLPEL_MV *best_mv,
+                               const MV *ref_mv,
+                               const aom_variance_fn_ptr_t *vfp) {
+  const MACROBLOCKD *const xd = &x->e_mbd;
+  const struct buf_2d *const in_what = xd->plane[0].pre;
+  const MV mv = get_mv_from_fullmv(best_mv);
+  const MV_COST_TYPE mv_cost_type = x->mv_cost_type;
+  unsigned int unused;
+
+  return vfp->ovf(get_buf_from_mv(in_what, best_mv), in_what->stride, wsrc,
+                  mask, &unused) +
+         mv_err_cost(&mv, ref_mv, x->nmv_vec_cost,
+                     CONVERT_TO_CONST_MVCOST(x->mv_cost_stack), x->errorperbit,
+                     mv_cost_type);
+}
+
+static int obmc_refining_search_sad(const MACROBLOCK *x, const int32_t *wsrc,
+                                    const int32_t *mask, FULLPEL_MV *best_mv,
+                                    int error_per_bit, int search_range,
+                                    const aom_variance_fn_ptr_t *fn_ptr,
+                                    const MV *ref_mv) {
+  const MV neighbors[4] = { { -1, 0 }, { 0, -1 }, { 0, 1 }, { 1, 0 } };
+  const MACROBLOCKD *const xd = &x->e_mbd;
+  const struct buf_2d *const in_what = xd->plane[0].pre;
+  const FULLPEL_MV full_ref_mv = get_fullmv_from_mv(ref_mv);
+  unsigned int best_sad =
+      fn_ptr->osdf(get_buf_from_mv(in_what, best_mv), in_what->stride, wsrc,
+                   mask) +
+      mvsad_err_cost(best_mv, &full_ref_mv, x->nmv_vec_cost,
+                     CONVERT_TO_CONST_MVCOST(x->mv_cost_stack), error_per_bit,
+                     x->mv_cost_type);
+
+  int i, j;
+
+  for (i = 0; i < search_range; i++) {
+    int best_site = -1;
+
+    for (j = 0; j < 4; j++) {
+      const FULLPEL_MV mv = { best_mv->row + neighbors[j].row,
+                              best_mv->col + neighbors[j].col };
+      if (av1_is_fullmv_in_range(&x->mv_limits, mv)) {
+        unsigned int sad = fn_ptr->osdf(get_buf_from_mv(in_what, &mv),
+                                        in_what->stride, wsrc, mask);
+        if (sad < best_sad) {
+          sad += mvsad_err_cost(&mv, &full_ref_mv, x->nmv_vec_cost,
+                                CONVERT_TO_CONST_MVCOST(x->mv_cost_stack),
+                                error_per_bit, x->mv_cost_type);
+
+          if (sad < best_sad) {
+            best_sad = sad;
+            best_site = j;
+          }
+        }
+      }
+    }
+
+    if (best_site == -1) {
+      break;
+    } else {
+      best_mv->row += neighbors[best_site].row;
+      best_mv->col += neighbors[best_site].col;
+    }
+  }
+  return best_sad;
+}
+
+static int obmc_diamond_search_sad(
+    const MACROBLOCK *x, const search_site_config *cfg, const int32_t *wsrc,
+    const int32_t *mask, FULLPEL_MV start_mv, FULLPEL_MV *best_mv,
+    int search_param, int sad_per_bit, int *num00,
+    const aom_variance_fn_ptr_t *fn_ptr, const MV *ref_mv) {
+  const MACROBLOCKD *const xd = &x->e_mbd;
+  const struct buf_2d *const in_what = xd->plane[0].pre;
+  // search_param determines the length of the initial step and hence the number
+  // of iterations
+  // 0 = initial step (MAX_FIRST_STEP) pel : 1 = (MAX_FIRST_STEP/2) pel, 2 =
+  // (MAX_FIRST_STEP/4) pel... etc.
+
+  const int tot_steps = MAX_MVSEARCH_STEPS - 1 - search_param;
+  const FULLPEL_MV full_ref_mv = get_fullmv_from_mv(ref_mv);
+  const uint8_t *best_address, *in_what_ref;
+  int best_sad = INT_MAX;
+  int best_site = 0;
+  int step;
+
+  clamp_fullmv(&start_mv, &x->mv_limits);
+  in_what_ref = get_buf_from_mv(in_what, &start_mv);
+  best_address = in_what_ref;
+  *num00 = 0;
+  *best_mv = start_mv;
+
+  // Check the starting position
+  best_sad = fn_ptr->osdf(best_address, in_what->stride, wsrc, mask) +
+             mvsad_err_cost(best_mv, &full_ref_mv, x->nmv_vec_cost,
+                            CONVERT_TO_CONST_MVCOST(x->mv_cost_stack),
+                            sad_per_bit, x->mv_cost_type);
+
+  for (step = tot_steps; step >= 0; --step) {
+    const search_site *const ss = cfg->ss[step];
+    best_site = 0;
+    for (int idx = 1; idx <= cfg->searches_per_step[step]; ++idx) {
+      const FULLPEL_MV mv = { best_mv->row + ss[idx].mv.row,
+                              best_mv->col + ss[idx].mv.col };
+      if (av1_is_fullmv_in_range(&x->mv_limits, mv)) {
+        int sad = fn_ptr->osdf(best_address + ss[idx].offset, in_what->stride,
+                               wsrc, mask);
+        if (sad < best_sad) {
+          sad += mvsad_err_cost(&mv, &full_ref_mv, x->nmv_vec_cost,
+                                CONVERT_TO_CONST_MVCOST(x->mv_cost_stack),
+                                sad_per_bit, x->mv_cost_type);
+
+          if (sad < best_sad) {
+            best_sad = sad;
+            best_site = idx;
+          }
+        }
+      }
+    }
+
+    if (best_site != 0) {
+      best_mv->row += ss[best_site].mv.row;
+      best_mv->col += ss[best_site].mv.col;
+      best_address += ss[best_site].offset;
+    } else if (best_address == in_what_ref) {
+      (*num00)++;
+    }
+  }
+  return best_sad;
+}
+
+static int obmc_full_pixel_diamond(const MACROBLOCK *x,
+                                   const FULLPEL_MV start_mv, int step_param,
+                                   int sadpb, int do_refine,
+                                   const aom_variance_fn_ptr_t *fn_ptr,
+                                   const MV *ref_mv, FULLPEL_MV *best_mv,
+                                   const search_site_config *cfg) {
+  const int32_t *wsrc = x->wsrc_buf;
+  const int32_t *mask = x->mask_buf;
+  FULLPEL_MV tmp_mv;
+  int thissme, n, num00 = 0;
+  int bestsme = obmc_diamond_search_sad(x, cfg, wsrc, mask, start_mv, &tmp_mv,
+                                        step_param, sadpb, &n, fn_ptr, ref_mv);
+  if (bestsme < INT_MAX)
+    bestsme = get_obmc_mvpred_var(x, wsrc, mask, &tmp_mv, ref_mv, fn_ptr);
+  *best_mv = tmp_mv;
+
+  // If there won't be more n-step search, check to see if refining search is
+  // needed.
+  const int further_steps = cfg->ss_count - 1 - step_param;
+  if (n > further_steps) do_refine = 0;
+
+  while (n < further_steps) {
+    ++n;
+
+    if (num00) {
+      num00--;
+    } else {
+      thissme = obmc_diamond_search_sad(x, cfg, wsrc, mask, start_mv, &tmp_mv,
+                                        step_param + n, sadpb, &num00, fn_ptr,
+                                        ref_mv);
+      if (thissme < INT_MAX)
+        thissme = get_obmc_mvpred_var(x, wsrc, mask, &tmp_mv, ref_mv, fn_ptr);
+
+      // check to see if refining search is needed.
+      if (num00 > further_steps - n) do_refine = 0;
+
+      if (thissme < bestsme) {
+        bestsme = thissme;
+        *best_mv = tmp_mv;
+      }
+    }
+  }
+
+  // final 1-away diamond refining search
+  if (do_refine) {
+    const int search_range = 8;
+    tmp_mv = *best_mv;
+    thissme = obmc_refining_search_sad(x, wsrc, mask, &tmp_mv, sadpb,
+                                       search_range, fn_ptr, ref_mv);
+    if (thissme < INT_MAX)
+      thissme = get_obmc_mvpred_var(x, wsrc, mask, &tmp_mv, ref_mv, fn_ptr);
+    if (thissme < bestsme) {
+      bestsme = thissme;
+      *best_mv = tmp_mv;
+    }
+  }
+  return bestsme;
+}
+
+int av1_obmc_full_pixel_search(const MACROBLOCK *x, const FULLPEL_MV start_mv,
+                               const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                               const int step_param, FULLPEL_MV *best_mv) {
+  const aom_variance_fn_ptr_t *fn_ptr = ms_params->vfp;
+  const int sadpb = ms_params->mv_cost_params.sad_per_bit;
+  const MV *ref_mv = ms_params->mv_cost_params.ref_mv;
+
+  if (!ms_params->fast_obmc_search) {
+    const search_site_config *search_sites = ms_params->search_sites;
+
+    const int do_refine = 1;
+    const int bestsme =
+        obmc_full_pixel_diamond(x, start_mv, step_param, sadpb, do_refine,
+                                fn_ptr, ref_mv, best_mv, search_sites);
+    return bestsme;
+  } else {
+    const int32_t *wsrc = x->wsrc_buf;
+    const int32_t *mask = x->mask_buf;
+    const int search_range = 8;
+    *best_mv = start_mv;
+    clamp_fullmv(best_mv, &x->mv_limits);
+    int thissme = obmc_refining_search_sad(x, wsrc, mask, best_mv, sadpb,
+                                           search_range, fn_ptr, ref_mv);
+    if (thissme < INT_MAX)
+      thissme = get_obmc_mvpred_var(x, wsrc, mask, best_mv, ref_mv, fn_ptr);
+    return thissme;
+  }
+}
+
+// =============================================================================
 //  Subpixel Motion Search: Translational
 // =============================================================================
 #define INIT_SUBPEL_STEP_SIZE (4)
diff --git a/av1/encoder/mcomp.h b/av1/encoder/mcomp.h
index a251d03..5d6f424 100644
--- a/av1/encoder/mcomp.h
+++ b/av1/encoder/mcomp.h
@@ -62,9 +62,11 @@
 // =============================================================================
 typedef struct {
   const MV *ref_mv;
+  FULLPEL_MV full_ref_mv;
   const int *mvjcost;
   const int *mvcost[2];
   int error_per_bit;
+  int sad_per_bit;
   MV_COST_TYPE mv_cost_type;
 } MV_COST_PARAMS;
 
@@ -92,6 +94,56 @@
 // =============================================================================
 //  Fullpixel Motion Search
 // =============================================================================
+enum {
+  DIAMOND = 0,
+  NSTEP = 1,
+  HEX = 2,
+  BIGDIA = 3,
+  SQUARE = 4,
+  FAST_HEX = 5,
+  FAST_DIAMOND = 6
+} UENUM1BYTE(SEARCH_METHODS);
+
+// This struct holds fullpixel motion search parameters that should be constant
+// during the search
+typedef struct {
+  BLOCK_SIZE bsize;
+  const aom_variance_fn_ptr_t *vfp;
+
+  SEARCH_METHODS search_method;
+  const search_site_config *search_sites;
+  FullMvLimits mv_limits;
+
+  int run_mesh_search;    // Sets mesh search unless it got pruned by
+                          // prune_mesh_search.
+  int prune_mesh_search;  // Disables mesh search if the best_mv after a normal
+                          // search if close to the start_mv.
+  int force_mesh_thresh;  // Forces mesh search if the residue variance is
+                          // higher than the threshold.
+  const struct MESH_PATTERN *mesh_patterns[2];
+
+  int is_intra_mode;
+
+  const struct buf_2d *src;
+  const struct buf_2d *ref;
+
+  const uint8_t *second_pred;
+  const uint8_t *mask;
+  int mask_stride;
+  int inv_mask;
+
+  int fast_obmc_search;
+
+  // For calculating mv cost
+  MV_COST_PARAMS mv_cost_params;
+} FULLPEL_MOTION_SEARCH_PARAMS;
+
+void av1_make_default_fullpel_ms_params(FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                                        const struct AV1_COMP *cpi,
+                                        const MACROBLOCK *x, BLOCK_SIZE bsize,
+                                        const MV *ref_mv,
+                                        const search_site_config *search_sites);
+
 // Sets up configs for fullpixel diamond search
 void av1_init_dsmotion_compensation(search_site_config *cfg, int stride);
 // Sets up configs for firstpass motion search
@@ -150,22 +202,18 @@
                              const struct buf_2d *src,
                              const struct buf_2d *pre);
 
-int av1_full_pixel_search(const struct AV1_COMP *cpi, const MACROBLOCK *x,
-                          BLOCK_SIZE bsize, const FULLPEL_MV start_mv,
-                          int step_param, int method, int run_mesh_search,
-                          int error_per_bit, int *cost_list, const MV *ref_mv,
-                          int is_intra_mode, const search_site_config *cfg,
+int av1_full_pixel_search(const FULLPEL_MV start_mv,
+                          const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                          const int step_param, int *cost_list,
                           FULLPEL_MV *best_mv, FULLPEL_MV *second_best_mv);
 
 void av1_intrabc_hash_search(const struct AV1_COMP *cpi, MACROBLOCK *x,
                              BLOCK_SIZE bsize, const MV *ref_mv, int *bestsme,
                              FULLPEL_MV *best_mv);
 
-int av1_obmc_full_pixel_search(const struct AV1_COMP *cpi, const MACROBLOCK *x,
-                               const FULLPEL_MV start_mv, int step_param,
-                               int sadpb, const aom_variance_fn_ptr_t *fn_ptr,
-                               const MV *ref_mv, FULLPEL_MV *best_mv,
-                               const search_site_config *cfg);
+int av1_obmc_full_pixel_search(const MACROBLOCK *x, const FULLPEL_MV start_mv,
+                               const FULLPEL_MOTION_SEARCH_PARAMS *ms_params,
+                               const int step_param, FULLPEL_MV *best_mv);
 
 unsigned int av1_refine_warped_mv(const struct AV1_COMP *cpi,
                                   MACROBLOCK *const x, BLOCK_SIZE bsize,
diff --git a/av1/encoder/motion_search_facade.c b/av1/encoder/motion_search_facade.c
index 43a7cf8..ea71088 100644
--- a/av1/encoder/motion_search_facade.c
+++ b/av1/encoder/motion_search_facade.c
@@ -14,6 +14,7 @@
 #include "av1/common/reconinter.h"
 
 #include "av1/encoder/encodemv.h"
+#include "av1/encoder/encoder.h"
 #include "av1/encoder/motion_search_facade.h"
 #include "av1/encoder/partition_strategy.h"
 #include "av1/encoder/reconinter_enc.h"
@@ -123,22 +124,24 @@
   else
     start_mv = get_fullmv_from_mv(&ref_mv);
 
-  const int sadpb = x->sadperbit;
   int cost_list[5];
   int_mv second_best_mv;
   x->best_mv.as_int = second_best_mv.as_int = INVALID_MV;
+
+  const search_site_config *src_search_sites = &cpi->ss_cfg[SS_CFG_SRC];
+  FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
+  av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
+                                     src_search_sites);
+
   switch (mbmi->motion_mode) {
     case SIMPLE_TRANSLATION:
       bestsme = av1_full_pixel_search(
-          cpi, x, bsize, start_mv, step_param, cpi->sf.mv_sf.search_method, 0,
-          sadpb, cond_cost_list(cpi, cost_list), &ref_mv, 0,
-          &cpi->ss_cfg[SS_CFG_SRC], &x->best_mv.as_fullmv,
-          &second_best_mv.as_fullmv);
+          start_mv, &full_ms_params, step_param, cond_cost_list(cpi, cost_list),
+          &x->best_mv.as_fullmv, &second_best_mv.as_fullmv);
       break;
     case OBMC_CAUSAL:
-      bestsme = av1_obmc_full_pixel_search(
-          cpi, x, start_mv, step_param, sadpb, &cpi->fn_ptr[bsize], &ref_mv,
-          &(x->best_mv.as_fullmv), &cpi->ss_cfg[SS_CFG_SRC]);
+      bestsme = av1_obmc_full_pixel_search(x, start_mv, &full_ms_params,
+                                           step_param, &(x->best_mv.as_fullmv));
       break;
     default: assert(0 && "Invalid motion mode!\n");
   }
@@ -690,9 +693,7 @@
   const MV ref_mv = kZeroMv;
   const int step_param = cpi->mv_step_param;
   const FullMvLimits tmp_mv_limits = x->mv_limits;
-  const SEARCH_METHODS search_methods = cpi->sf.mv_sf.search_method;
-  const int do_mesh_search = 0;
-  const int sadpb = x->sadperbit;
+  const search_site_config *src_search_sites = &cpi->ss_cfg[SS_CFG_SRC];
   int cost_list[5];
   const int ref_idx = 0;
   int var;
@@ -706,12 +707,16 @@
                          num_planes);
   }
 
+  FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
+  av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &ref_mv,
+                                     src_search_sites);
+
   // This overwrites the mv_limits so we will need to restore it later.
   av1_set_mv_search_range(&x->mv_limits, &ref_mv);
-  var = av1_full_pixel_search(
-      cpi, x, bsize, start_mv, step_param, search_methods, do_mesh_search,
-      sadpb, cond_cost_list(cpi, cost_list), &ref_mv, 0,
-      &cpi->ss_cfg[SS_CFG_SRC], &x->best_mv.as_fullmv, NULL);
+  var = av1_full_pixel_search(start_mv, &full_ms_params, step_param,
+                              cond_cost_list(cpi, cost_list),
+                              &x->best_mv.as_fullmv, NULL);
+
   // Restore
   x->mv_limits = tmp_mv_limits;
 
diff --git a/av1/encoder/nonrd_pickmode.c b/av1/encoder/nonrd_pickmode.c
index bcfd8d7..479304f 100644
--- a/av1/encoder/nonrd_pickmode.c
+++ b/av1/encoder/nonrd_pickmode.c
@@ -125,7 +125,6 @@
   MB_MODE_INFO *mi = xd->mi[0];
   struct buf_2d backup_yv12[MAX_MB_PLANE] = { { 0, 0, 0, 0, 0 } };
   int step_param = cpi->mv_step_param;
-  const int sadpb = x->sadperbit;
   FULLPEL_MV start_mv;
   const int ref = mi->ref_frame[0];
   const MV ref_mv = av1_get_ref_mv(x, mi->ref_mv_idx).as_mv;
@@ -156,10 +155,14 @@
   else
     center_mv = tmp_mv->as_mv;
 
-  av1_full_pixel_search(cpi, x, bsize, start_mv, step_param,
-                        cpi->sf.mv_sf.search_method, 0, sadpb,
-                        cond_cost_list(cpi, cost_list), &center_mv, 0,
-                        &cpi->ss_cfg[SS_CFG_SRC], &x->best_mv.as_fullmv, NULL);
+  const search_site_config *src_search_sites = &cpi->ss_cfg[SS_CFG_SRC];
+  FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
+  av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &center_mv,
+                                     src_search_sites);
+
+  av1_full_pixel_search(start_mv, &full_ms_params, step_param,
+                        cond_cost_list(cpi, cost_list), &x->best_mv.as_fullmv,
+                        NULL);
 
   x->mv_limits = tmp_mv_limits;
   *tmp_mv = x->best_mv;
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index c8c0f6d..d7f2c6d 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -2732,14 +2732,19 @@
       continue;
     }
 
-    int step_param = cpi->mv_step_param;
-    FULLPEL_MV start_mv = get_fullmv_from_mv(&dv_ref.as_mv);
-    const int sadpb = x->sadperbit;
+    const int step_param = cpi->mv_step_param;
+    const FULLPEL_MV start_mv = get_fullmv_from_mv(&dv_ref.as_mv);
+    const search_site_config *lookahead_search_sites =
+        &cpi->ss_cfg[SS_CFG_LOOKAHEAD];
+    FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
+    av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize,
+                                       &dv_ref.as_mv, lookahead_search_sites);
+    full_ms_params.is_intra_mode = 1;
     int cost_list[5];
-    int bestsme = av1_full_pixel_search(
-        cpi, x, bsize, start_mv, step_param, cpi->sf.mv_sf.search_method, 0,
-        sadpb, cond_cost_list(cpi, cost_list), &dv_ref.as_mv, 1,
-        &cpi->ss_cfg[SS_CFG_LOOKAHEAD], &x->best_mv.as_fullmv, NULL);
+
+    int bestsme = av1_full_pixel_search(start_mv, &full_ms_params, step_param,
+                                        cond_cost_list(cpi, cost_list),
+                                        &x->best_mv.as_fullmv, NULL);
     av1_intrabc_hash_search(cpi, x, bsize, &dv_ref.as_mv, &bestsme,
                             &x->best_mv.as_fullmv);
 
diff --git a/av1/encoder/speed_features.c b/av1/encoder/speed_features.c
index 4fe5cb0..0eb0241 100644
--- a/av1/encoder/speed_features.c
+++ b/av1/encoder/speed_features.c
@@ -335,11 +335,11 @@
     // speed feature accordingly
     sf->part_sf.simple_motion_search_split = allow_screen_content_tools ? 1 : 2;
 
-    sf->mv_sf.use_accurate_subpel_search = USE_4_TAPS;
     sf->mv_sf.exhaustive_searches_thresh <<= 1;
+    sf->mv_sf.obmc_full_pixel_search_level = 1;
+    sf->mv_sf.use_accurate_subpel_search = USE_4_TAPS;
 
     sf->inter_sf.disable_interinter_wedge_newmv_search = boosted ? 0 : 1;
-    sf->inter_sf.obmc_full_pixel_search_level = 1;
     sf->inter_sf.prune_comp_search_by_single_result = boosted ? 2 : 1;
     sf->inter_sf.prune_comp_type_by_comp_avg = 1;
     sf->inter_sf.prune_comp_type_by_model_rd = boosted ? 0 : 1;
@@ -645,9 +645,9 @@
     sf->part_sf.prune_ext_partition_types_search_level = 2;
     sf->part_sf.simple_motion_search_prune_rect = 1;
 
+    sf->mv_sf.obmc_full_pixel_search_level = 1;
     sf->mv_sf.use_accurate_subpel_search = USE_4_TAPS;
 
-    sf->inter_sf.obmc_full_pixel_search_level = 1;
     sf->inter_sf.prune_comp_search_by_single_result = 1;
     sf->inter_sf.reuse_inter_intra_mode = 1;
     sf->inter_sf.selective_ref_frame = 2;
@@ -933,16 +933,17 @@
 }
 
 static AOM_INLINE void init_mv_sf(MV_SPEED_FEATURES *mv_sf) {
-  mv_sf->search_method = NSTEP;
-  mv_sf->subpel_search_method = SUBPEL_TREE;
-  mv_sf->subpel_iters_per_step = 2;
-  mv_sf->subpel_force_stop = EIGHTH_PEL;
-  mv_sf->auto_mv_step_size = 0;
   mv_sf->adaptive_motion_search = 0;
-  mv_sf->use_accurate_subpel_search = USE_8_TAPS;
-  mv_sf->reduce_search_range = 0;
-  mv_sf->prune_mesh_search = 0;
+  mv_sf->auto_mv_step_size = 0;
   mv_sf->exhaustive_searches_thresh = 0;
+  mv_sf->obmc_full_pixel_search_level = 0;
+  mv_sf->prune_mesh_search = 0;
+  mv_sf->reduce_search_range = 0;
+  mv_sf->search_method = NSTEP;
+  mv_sf->subpel_force_stop = EIGHTH_PEL;
+  mv_sf->subpel_iters_per_step = 2;
+  mv_sf->subpel_search_method = SUBPEL_TREE;
+  mv_sf->use_accurate_subpel_search = USE_8_TAPS;
   mv_sf->use_fullpel_costlist = 0;
 }
 
@@ -973,7 +974,6 @@
   inter_sf->prune_compound_using_single_ref = 0;
   inter_sf->disable_onesided_comp = 0;
   inter_sf->prune_mode_search_simple_translation = 0;
-  inter_sf->obmc_full_pixel_search_level = 0;
   inter_sf->prune_comp_type_by_comp_avg = 0;
   inter_sf->disable_interinter_wedge_newmv_search = 0;
   inter_sf->enable_interinter_diffwtd_newmv_search = 0;
diff --git a/av1/encoder/speed_features.h b/av1/encoder/speed_features.h
index 36e0f71..923c0a5 100644
--- a/av1/encoder/speed_features.h
+++ b/av1/encoder/speed_features.h
@@ -124,16 +124,6 @@
 } UENUM1BYTE(DEV_SPEED_FEATURES);
 
 enum {
-  DIAMOND = 0,
-  NSTEP = 1,
-  HEX = 2,
-  BIGDIA = 3,
-  SQUARE = 4,
-  FAST_HEX = 5,
-  FAST_DIAMOND = 6
-} UENUM1BYTE(SEARCH_METHODS);
-
-enum {
   // No recode.
   DISALLOW_RECODE = 0,
   // Allow recode for KF and exceeding maximum frame bandwidth.
@@ -482,6 +472,11 @@
 
   // Use the rd cost around the best FULLPEL_MV to speed up subpel search
   int use_fullpel_costlist;
+
+  // Set the full pixel search level of obmc
+  // 0: obmc_full_pixel_diamond
+  // 1: obmc_refining_search_sad (faster)
+  int obmc_full_pixel_search_level;
 } MV_SPEED_FEATURES;
 
 typedef struct INTER_MODE_SPEED_FEATURES {
@@ -594,11 +589,6 @@
   // aggressiveness
   int prune_motion_mode_level;
 
-  // Set the full pixel search level of obmc
-  // 0: obmc_full_pixel_diamond
-  // 1: obmc_refining_search_sad (faster)
-  int obmc_full_pixel_search_level;
-
   // Prune obmc search using previous frame stats.
   int prune_obmc_prob_thresh;
 
diff --git a/av1/encoder/temporal_filter.c b/av1/encoder/temporal_filter.c
index 465cfb8..6dd6f91 100644
--- a/av1/encoder/temporal_filter.c
+++ b/av1/encoder/temporal_filter.c
@@ -87,9 +87,9 @@
   const int mask_stride = 0;
   const int invert_mask = 0;
   const int do_reset_fractional_mv = 1;
+  FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
   SUBPEL_MOTION_SEARCH_PARAMS ms_params;
 
-  const int sadperbit = mb->sadperbit;
   const search_site_config ss_cfg = cpi->ss_cfg[SS_CFG_LOOKAHEAD];
   const SEARCH_METHODS full_search_method = NSTEP;
   const int step_param = av1_init_search_range(
@@ -122,10 +122,15 @@
   // searched result will be stored in `mb->best_mv`.
   int block_error = INT_MAX;
   mb->mv_cost_type = mv_cost_type;
-  av1_full_pixel_search(cpi, mb, block_size, start_mv, step_param,
-                        full_search_method, 1, sadperbit,
-                        cond_cost_list(cpi, cost_list), &baseline_mv, 0,
-                        &ss_cfg, &mb->best_mv.as_fullmv, NULL);
+
+  av1_make_default_fullpel_ms_params(&full_ms_params, cpi, mb, block_size,
+                                     &baseline_mv, &ss_cfg);
+  full_ms_params.run_mesh_search = 1;
+  full_ms_params.search_method = full_search_method;
+  av1_full_pixel_search(start_mv, &full_ms_params, step_param,
+                        cond_cost_list(cpi, cost_list), &mb->best_mv.as_fullmv,
+                        NULL);
+
   // Since we are merely refining the result from full pixel search, we don't
   // need regularization for subpel search
   mb->mv_cost_type = MV_COST_NONE;
@@ -164,10 +169,15 @@
         mbd->plane[0].pre[0].buf = ref_frame->y_buffer + y_offset + offset;
         av1_set_mv_search_range(&mb->mv_limits, &baseline_mv);
         mb->mv_cost_type = mv_cost_type;
-        av1_full_pixel_search(cpi, mb, subblock_size, start_mv, step_param,
-                              full_search_method, 1, sadperbit,
-                              cond_cost_list(cpi, cost_list), &baseline_mv, 0,
-                              &ss_cfg, &mb->best_mv.as_fullmv, NULL);
+
+        av1_make_default_fullpel_ms_params(
+            &full_ms_params, cpi, mb, subblock_size, &baseline_mv, &ss_cfg);
+        full_ms_params.run_mesh_search = 1;
+        full_ms_params.search_method = full_search_method;
+        av1_full_pixel_search(start_mv, &full_ms_params, step_param,
+                              cond_cost_list(cpi, cost_list),
+                              &mb->best_mv.as_fullmv, NULL);
+
         // Since we are merely refining the result from full pixel search, we
         // don't need regularization for subpel search
         mb->mv_cost_type = MV_COST_NONE;
diff --git a/av1/encoder/tpl_model.c b/av1/encoder/tpl_model.c
index fe7649e..60facf8 100644
--- a/av1/encoder/tpl_model.c
+++ b/av1/encoder/tpl_model.c
@@ -125,11 +125,8 @@
                                   MV center_mv) {
   AV1_COMMON *cm = &cpi->common;
   MACROBLOCKD *const xd = &x->e_mbd;
-  MV_SPEED_FEATURES *const mv_sf = &cpi->sf.mv_sf;
   TPL_SPEED_FEATURES *tpl_sf = &cpi->sf.tpl_sf;
-  const SEARCH_METHODS search_method = mv_sf->search_method;
   int step_param;
-  int sadpb = x->sadperbit;
   uint32_t bestsme = UINT_MAX;
   int distortion;
   uint32_t sse;
@@ -153,9 +150,13 @@
 
   assert(ss_cfg->stride == stride_ref);
 
-  av1_full_pixel_search(cpi, x, bsize, start_mv, step_param, search_method, 0,
-                        sadpb, cond_cost_list(cpi, cost_list), &center_mv, 0,
-                        ss_cfg, &x->best_mv.as_fullmv, NULL);
+  FULLPEL_MOTION_SEARCH_PARAMS full_ms_params;
+  av1_make_default_fullpel_ms_params(&full_ms_params, cpi, x, bsize, &center_mv,
+                                     ss_cfg);
+
+  av1_full_pixel_search(start_mv, &full_ms_params, step_param,
+                        cond_cost_list(cpi, cost_list), &x->best_mv.as_fullmv,
+                        NULL);
 
   /* restore UMV window */
   x->mv_limits = tmp_mv_limits;