diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c
index a1a0eb0..055c95a 100644
--- a/av1/encoder/mcomp.c
+++ b/av1/encoder/mcomp.c
@@ -2569,55 +2569,55 @@
 }
 
 /* returns subpixel variance error function */
-#define DIST(r, c) \
-  vfp->osvf(pre(y, y_stride, r, c), y_stride, sp(c), sp(r), z, mask, &sse)
+#define DIST(r, c)                                                             \
+  vfp->osvf(pre(y, y_stride, r, c), y_stride, sp(c), sp(r), src_address, mask, \
+            &sse)
 
 /* checks if (r, c) has better score than previous best */
-#define MVC(r, c)                                                              \
-  (unsigned int)(mvcost                                                        \
-                     ? ((mvjcost[((r) != rr) * 2 + ((c) != rc)] +              \
-                         mvcost[0][((r)-rr)] + (int64_t)mvcost[1][((c)-rc)]) * \
-                            error_per_bit +                                    \
-                        4096) >>                                               \
-                           13                                                  \
+#define MVC(diff_mv)                                                          \
+  (unsigned int)(mvcost                                                       \
+                     ? (mv_cost((diff_mv), mvjcost, mvcost) * error_per_bit + \
+                        4096) >>                                              \
+                           13                                                 \
                      : 0)
 
-#define CHECK_BETTER(v, r, c)                             \
-  if (c >= minc && c <= maxc && r >= minr && r <= maxr) { \
-    thismse = (DIST(r, c));                               \
-    if ((v = MVC(r, c) + thismse) < besterr) {            \
-      besterr = v;                                        \
-      br = r;                                             \
-      bc = c;                                             \
-      *distortion = thismse;                              \
-      *sse1 = sse;                                        \
-    }                                                     \
-  } else {                                                \
-    v = INT_MAX;                                          \
+#define CHECK_BETTER(v, r, c)                                \
+  if (c >= minc && c <= maxc && r >= minr && r <= maxr) {    \
+    const MV diff_mv = { r - ref_mv->row, c - ref_mv->col }; \
+    thismse = (DIST(r, c));                                  \
+    if ((v = MVC(&diff_mv) + thismse) < besterr) {           \
+      besterr = v;                                           \
+      br = r;                                                \
+      bc = c;                                                \
+      *distortion = thismse;                                 \
+      *sse1 = sse;                                           \
+    }                                                        \
+  } else {                                                   \
+    v = INT_MAX;                                             \
   }
 
 #undef CHECK_BETTER0
 #define CHECK_BETTER0(v, r, c) CHECK_BETTER(v, r, c)
 
 #undef CHECK_BETTER1
-#define CHECK_BETTER1(v, r, c)                                                \
-  if (c >= minc && c <= maxc && r >= minr && r <= maxr) {                     \
-    MV this_mv = { r, c };                                                    \
-    thismse = upsampled_obmc_pref_error(xd, cm, mi_row, mi_col, &this_mv,     \
-                                        mask, vfp, z, pre(y, y_stride, r, c), \
-                                        y_stride, sp(c), sp(r), w, h, &sse,   \
-                                        use_accurate_subpel_search);          \
-    v = mv_err_cost(&this_mv, ref_mv, mvjcost, mvcost, error_per_bit,         \
-                    mv_cost_type);                                            \
-    if ((v + thismse) < besterr) {                                            \
-      besterr = v + thismse;                                                  \
-      br = r;                                                                 \
-      bc = c;                                                                 \
-      *distortion = thismse;                                                  \
-      *sse1 = sse;                                                            \
-    }                                                                         \
-  } else {                                                                    \
-    v = INT_MAX;                                                              \
+#define CHECK_BETTER1(v, r, c)                                        \
+  if (c >= minc && c <= maxc && r >= minr && r <= maxr) {             \
+    MV this_mv = { r, c };                                            \
+    thismse = upsampled_obmc_pref_error(                              \
+        xd, cm, mi_row, mi_col, &this_mv, mask, vfp, src_address,     \
+        pre(y, y_stride, r, c), y_stride, sp(c), sp(r), w, h, &sse,   \
+        use_accurate_subpel_search);                                  \
+    v = mv_err_cost(&this_mv, ref_mv, mvjcost, mvcost, error_per_bit, \
+                    mv_cost_type);                                    \
+    if ((v + thismse) < besterr) {                                    \
+      besterr = v + thismse;                                          \
+      br = r;                                                         \
+      bc = c;                                                         \
+      *distortion = thismse;                                          \
+      *sse1 = sse;                                                    \
+    }                                                                 \
+  } else {                                                            \
+    v = INT_MAX;                                                      \
   }
 
 static unsigned int setup_obmc_center_error(
@@ -2683,64 +2683,55 @@
 
 int av1_find_best_obmc_sub_pixel_tree_up(
     MACROBLOCK *x, const AV1_COMMON *const cm, int mi_row, int mi_col,
-    MV *bestmv, const MV *ref_mv, int allow_hp, int error_per_bit,
+    const MV *ref_mv, int allow_hp, int error_per_bit,
     const aom_variance_fn_ptr_t *vfp, int forced_stop, int iters_per_step,
-    int *mvjcost, int *mvcost[2], int *distortion, unsigned int *sse1,
-    int is_second, int use_accurate_subpel_search) {
+    int *mvjcost, int *mvcost[2], int *distortion, unsigned int *sse1, int w,
+    int h, int use_accurate_subpel_search) {
   const int32_t *wsrc = x->wsrc_buf;
   const int32_t *mask = x->mask_buf;
-  const int *const z = wsrc;
-  const int *const src_address = z;
-  const MV_COST_TYPE mv_cost_type = x->mv_cost_type;
+
+  const int32_t *const src_address = wsrc;
   MACROBLOCKD *xd = &x->e_mbd;
   struct macroblockd_plane *const pd = &xd->plane[0];
-  MB_MODE_INFO *mbmi = xd->mi[0];
   unsigned int besterr = INT_MAX;
   unsigned int sse;
   unsigned int thismse;
+  const int y_stride = pd->pre[0].stride;
+  const int offset =
+      x->best_mv.as_fullmv.row * y_stride + x->best_mv.as_fullmv.col;
+  const uint8_t *y = pd->pre[0].buf;
+  const MV_COST_TYPE mv_cost_type = x->mv_cost_type;
+  x->best_mv.as_mv = get_mv_from_fullmv(&x->best_mv.as_fullmv);
+  MV *bestmv = &x->best_mv.as_mv;
 
-  int rr = ref_mv->row;
-  int rc = ref_mv->col;
-  int br = bestmv->row * 8;
-  int bc = bestmv->col * 8;
+  int br = bestmv->row;
+  int bc = bestmv->col;
   int hstep = 4;
-  int iter;
-  int round = 3 - forced_stop;
+  int iter, round = 3 - forced_stop;
   int tr = br;
   int tc = bc;
   const MV *search_step = search_step_table;
   int idx, best_idx = -1;
   unsigned int cost_array[5];
   int kr, kc;
-  const int w = block_size_wide[mbmi->sb_type];
-  const int h = block_size_high[mbmi->sb_type];
-  int offset;
-  int y_stride;
-  const uint8_t *y;
 
   int minc, maxc, minr, maxr;
 
   set_subpel_mv_search_range(&x->mv_limits, &minc, &maxc, &minr, &maxr, ref_mv);
 
-  y = pd->pre[is_second].buf;
-  y_stride = pd->pre[is_second].stride;
-  offset = bestmv->row * y_stride + bestmv->col;
-
   if (!allow_hp)
     if (round == 3) round = 2;
 
-  bestmv->row *= 8;
-  bestmv->col *= 8;
   // use_accurate_subpel_search can be 0 or 1 or 2
   if (use_accurate_subpel_search)
     besterr = upsampled_setup_obmc_center_error(
-        xd, cm, mi_row, mi_col, mask, bestmv, ref_mv, error_per_bit, vfp, z, y,
-        y_stride, w, h, offset, mvjcost, mvcost, sse1, distortion,
-        use_accurate_subpel_search, mv_cost_type);
+        xd, cm, mi_row, mi_col, mask, bestmv, ref_mv, error_per_bit, vfp,
+        src_address, y, y_stride, w, h, offset, mvjcost, mvcost, sse1,
+        distortion, use_accurate_subpel_search, mv_cost_type);
   else
     besterr = setup_obmc_center_error(mask, bestmv, ref_mv, error_per_bit, vfp,
-                                      z, y, y_stride, offset, mvjcost, mvcost,
-                                      sse1, distortion, mv_cost_type);
+                                      src_address, y, y_stride, offset, mvjcost,
+                                      mvcost, sse1, distortion, mv_cost_type);
 
   for (iter = 0; iter < round; ++iter) {
     // Check vertical and horizontal sub-pixel positions.
@@ -2847,10 +2838,9 @@
 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,
-                               int is_second) {
+                               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[is_second];
+  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;
@@ -2865,10 +2855,10 @@
                                     const int32_t *mask, FULLPEL_MV *start_mv,
                                     int error_per_bit, int search_range,
                                     const aom_variance_fn_ptr_t *fn_ptr,
-                                    const MV *ref_mv, int is_second) {
+                                    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[is_second];
+  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, start_mv), in_what->stride, wsrc,
@@ -2909,9 +2899,9 @@
     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, int is_second) {
+    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[is_second];
+  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 =
@@ -2970,19 +2960,16 @@
                                    int sadpb, int further_steps, int do_refine,
                                    const aom_variance_fn_ptr_t *fn_ptr,
                                    const MV *ref_mv, FULLPEL_MV *best_mv,
-                                   int is_second,
                                    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, is_second);
+  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, is_second);
+    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
@@ -2997,10 +2984,9 @@
     } else {
       thissme = obmc_diamond_search_sad(x, cfg, wsrc, mask, start_mv, &tmp_mv,
                                         step_param + n, sadpb, &num00, fn_ptr,
-                                        ref_mv, is_second);
+                                        ref_mv);
       if (thissme < INT_MAX)
-        thissme = get_obmc_mvpred_var(x, wsrc, mask, &tmp_mv, ref_mv, fn_ptr,
-                                      is_second);
+        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;
@@ -3017,10 +3003,9 @@
     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, is_second);
+                                       search_range, fn_ptr, ref_mv);
     if (thissme < INT_MAX)
-      thissme = get_obmc_mvpred_var(x, wsrc, mask, &tmp_mv, ref_mv, fn_ptr,
-                                    is_second);
+      thissme = get_obmc_mvpred_var(x, wsrc, mask, &tmp_mv, ref_mv, fn_ptr);
     if (thissme < bestsme) {
       bestsme = thissme;
       *best_mv = tmp_mv;
@@ -3034,11 +3019,11 @@
                                int further_steps, int do_refine,
                                const aom_variance_fn_ptr_t *fn_ptr,
                                const MV *ref_mv, FULLPEL_MV *best_mv,
-                               int is_second, const search_site_config *cfg) {
+                               const search_site_config *cfg) {
   if (cpi->sf.inter_sf.obmc_full_pixel_search_level == 0) {
-    const int bestsme = obmc_full_pixel_diamond(
-        cpi, x, start_mv, step_param, sadpb, further_steps, do_refine, fn_ptr,
-        ref_mv, best_mv, is_second, cfg);
+    const int bestsme = obmc_full_pixel_diamond(cpi, x, start_mv, step_param,
+                                                sadpb, further_steps, do_refine,
+                                                fn_ptr, ref_mv, best_mv, cfg);
     return bestsme;
   } else {
     const int32_t *wsrc = x->wsrc_buf;
@@ -3047,11 +3032,10 @@
     *best_mv = *start_mv;
     clamp_fullmv(best_mv, x->mv_limits.col_min, x->mv_limits.col_max,
                  x->mv_limits.row_min, x->mv_limits.row_max);
-    int thissme = obmc_refining_search_sad(
-        x, wsrc, mask, best_mv, sadpb, search_range, fn_ptr, ref_mv, is_second);
+    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,
-                                    is_second);
+      thissme = get_obmc_mvpred_var(x, wsrc, mask, best_mv, ref_mv, fn_ptr);
     return thissme;
   }
 }
diff --git a/av1/encoder/mcomp.h b/av1/encoder/mcomp.h
index 43f1ad8..1621a34 100644
--- a/av1/encoder/mcomp.h
+++ b/av1/encoder/mcomp.h
@@ -150,13 +150,13 @@
                                int further_steps, int do_refine,
                                const aom_variance_fn_ptr_t *fn_ptr,
                                const MV *ref_mv, FULLPEL_MV *dst_mv,
-                               int is_second, const search_site_config *cfg);
+                               const search_site_config *cfg);
 int av1_find_best_obmc_sub_pixel_tree_up(
     MACROBLOCK *x, const AV1_COMMON *const cm, int mi_row, int mi_col,
-    MV *bestmv, const MV *ref_mv, int allow_hp, int error_per_bit,
+    const MV *ref_mv, int allow_hp, int error_per_bit,
     const aom_variance_fn_ptr_t *vfp, int forced_stop, int iters_per_step,
-    int *mvjcost, int *mvcost[2], int *distortion, unsigned int *sse1,
-    int is_second, int use_accurate_subpel_search);
+    int *mvjcost, int *mvcost[2], int *distortion, unsigned int *sse1, int w,
+    int h, int use_accurate_subpel_search);
 
 unsigned int av1_compute_motion_cost(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 2050a3c..80c003e 100644
--- a/av1/encoder/motion_search_facade.c
+++ b/av1/encoder/motion_search_facade.c
@@ -134,7 +134,7 @@
       bestsme = av1_obmc_full_pixel_search(
           cpi, x, &start_mv, step_param, sadpb,
           MAX_MVSEARCH_STEPS - 1 - step_param, 1, &cpi->fn_ptr[bsize], &ref_mv,
-          &(x->best_mv.as_fullmv), 0, &cpi->ss_cfg[SS_CFG_SRC]);
+          &(x->best_mv.as_fullmv), &cpi->ss_cfg[SS_CFG_SRC]);
       break;
     default: assert(0 && "Invalid motion mode!\n");
   }
@@ -156,13 +156,13 @@
       bestsme < INT_MAX && cpi->common.cur_frame_force_integer_mv == 0;
   if (use_fractional_mv) {
     int dis; /* TODO: use dis in distortion calculation later. */
+    const int pw = block_size_wide[bsize];
+    const int ph = block_size_high[bsize];
     switch (mbmi->motion_mode) {
       case SIMPLE_TRANSLATION:
         if (cpi->sf.mv_sf.use_accurate_subpel_search) {
           const int try_second = x->second_best_mv.as_int != INVALID_MV &&
                                  x->second_best_mv.as_int != x->best_mv.as_int;
-          const int pw = block_size_wide[bsize];
-          const int ph = block_size_high[bsize];
           const int best_mv_var = cpi->find_fractional_mv_step(
               x, cm, mi_row, mi_col, &ref_mv, cm->allow_high_precision_mv,
               x->errorperbit, &cpi->fn_ptr[bsize],
@@ -212,11 +212,11 @@
         break;
       case OBMC_CAUSAL:
         av1_find_best_obmc_sub_pixel_tree_up(
-            x, cm, mi_row, mi_col, &x->best_mv.as_mv, &ref_mv,
-            cm->allow_high_precision_mv, x->errorperbit, &cpi->fn_ptr[bsize],
+            x, cm, mi_row, mi_col, &ref_mv, cm->allow_high_precision_mv,
+            x->errorperbit, &cpi->fn_ptr[bsize],
             cpi->sf.mv_sf.subpel_force_stop,
             cpi->sf.mv_sf.subpel_iters_per_step, x->nmv_vec_cost,
-            x->mv_cost_stack, &dis, &x->pred_sse[ref], 0,
+            x->mv_cost_stack, &dis, &x->pred_sse[ref], pw, ph,
             cpi->sf.mv_sf.use_accurate_subpel_search);
         break;
       default: assert(0 && "Invalid motion mode!\n");