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