diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c
index 1a77dad..df5f1b3 100644
--- a/av1/encoder/mcomp.c
+++ b/av1/encoder/mcomp.c
@@ -35,6 +35,21 @@
 
 // #define NEW_DIAMOND_SEARCH
 
+// TODO(any): Adaptively adjust the regularization strength based on image size
+// and motion activity instead of using hard-coded values. It seems like we
+// roughly half the lambda for each increase in resolution
+// These are multiplier used to perform regularization in motion compensation
+// when x->mv_cost_type is set to MV_COST_L1.
+// LOWRES
+#define SSE_LAMBDA_LOWRES 2   // Used by mv_cost_err_fn
+#define SAD_LAMBDA_LOWRES 32  // Used by mvsad_err_cost during full pixel search
+// MIDRES
+#define SSE_LAMBDA_MIDRES 0   // Used by mv_cost_err_fn
+#define SAD_LAMBDA_MIDRES 15  // Used by mvsad_err_cost during full pixel search
+// HDRES
+#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
+
 static INLINE const uint8_t *get_buf_from_mv(const struct buf_2d *buf,
                                              const MV *mv) {
   return &buf->buf[mv->row * buf->stride + mv->col];
@@ -70,37 +85,77 @@
   return sr;
 }
 
+// Returns the rate of encoding the current motion vector based on the
+// joint_cost and comp_cost. joint_costs covers the cost of transimitting
+// JOINT_MV, and comp_cost covers the cost of transitting the actual motoin
+// vector.
 static INLINE int mv_cost(const MV *mv, const int *joint_cost,
                           int *const comp_cost[2]) {
   return joint_cost[av1_get_mv_joint(mv)] + comp_cost[0][mv->row] +
          comp_cost[1][mv->col];
 }
 
+// Returns the cost of encoding the motion vector diff := mv - *ref. The cost is
+// defined as the rate reqjuired to encode diff * weight, rounded to the nearest
+// 2 ** 7.
+// This is NOT used during motion compensation.
 int av1_mv_bit_cost(const MV *mv, const MV *ref, const int *mvjcost,
                     int *mvcost[2], int weight) {
   const MV diff = { mv->row - ref->row, mv->col - ref->col };
   return ROUND_POWER_OF_TWO(mv_cost(&diff, mvjcost, mvcost) * weight, 7);
 }
 
+// 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, const int *mvjcost,
-                       int *mvcost[2], int error_per_bit) {
-  if (mvcost) {
-    const MV diff = { mv->row - ref->row, mv->col - ref->col };
-    return (int)ROUND_POWER_OF_TWO_64(
-        (int64_t)mv_cost(&diff, mvjcost, mvcost) * error_per_bit,
-        RDDIV_BITS + AV1_PROB_COST_SHIFT - RD_EPB_SHIFT +
-            PIXEL_TRANSFORM_ERROR_SCALE);
+                       int *mvcost[2], int error_per_bit,
+                       MV_COST_TYPE mv_cost_type) {
+  const MV diff = { mv->row - ref->row, mv->col - ref->col };
+  const MV abs_diff = { abs(diff.row), abs(diff.col) };
+
+  switch (mv_cost_type) {
+    case MV_COST_ENTROPY:
+      if (mvcost) {
+        return (int)ROUND_POWER_OF_TWO_64(
+            (int64_t)mv_cost(&diff, mvjcost, mvcost) * error_per_bit,
+            RDDIV_BITS + AV1_PROB_COST_SHIFT - RD_EPB_SHIFT +
+                PIXEL_TRANSFORM_ERROR_SCALE);
+      }
+      return 0;
+    case MV_COST_L1_LOWRES:
+      return (SSE_LAMBDA_LOWRES * (abs_diff.row + abs_diff.col)) >> 3;
+    case MV_COST_L1_MIDRES:
+      return (SSE_LAMBDA_MIDRES * (abs_diff.row + abs_diff.col)) >> 3;
+    case MV_COST_L1_HDRES:
+      return (SSE_LAMBDA_HDRES * (abs_diff.row + abs_diff.col)) >> 3;
+    case MV_COST_NONE: return 0;
+    default: assert(0 && "Invalid rd_cost_type"); return 0;
   }
-  return 0;
 }
 
+// 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 MV *mv, const MV *ref,
                           int sad_per_bit) {
   const MV diff = { (mv->row - ref->row) * 8, (mv->col - ref->col) * 8 };
-  return ROUND_POWER_OF_TWO(
-      (unsigned)mv_cost(&diff, x->nmv_vec_cost, x->mv_cost_stack) * sad_per_bit,
-      AV1_PROB_COST_SHIFT);
+  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, x->mv_cost_stack) *
+              sad_per_bit,
+          AV1_PROB_COST_SHIFT);
+    case MV_COST_L1_LOWRES:
+      return (SAD_LAMBDA_LOWRES * (abs(diff.row) + abs(diff.col))) >> 3;
+    case MV_COST_L1_MIDRES:
+      return (SAD_LAMBDA_MIDRES * (abs(diff.row) + abs(diff.col))) >> 3;
+    case MV_COST_L1_HDRES:
+      return (SAD_LAMBDA_HDRES * (abs(diff.row) + abs(diff.col))) >> 3;
+    case MV_COST_NONE: return 0;
+    default: assert(0 && "Invalid rd_cost_type"); return 0;
+  }
 }
 
 void av1_init_dsmotion_compensation(search_site_config *cfg, int stride) {
@@ -242,7 +297,8 @@
 #define CHECK_BETTER(v, r, c)                                             \
   if (c >= minc && c <= maxc && r >= minr && r <= maxr) {                 \
     MV this_mv = { r, c };                                                \
-    v = mv_err_cost(&this_mv, ref_mv, mvjcost, mvcost, error_per_bit);    \
+    v = mv_err_cost(&this_mv, ref_mv, mvjcost, mvcost, error_per_bit,     \
+                    mv_cost_type);                                        \
     if (second_pred == NULL) {                                            \
       thismse = vfp->svf(pre(y, y_stride, r, c), y_stride, sp(c), sp(r),  \
                          src_address, src_stride, &sse);                  \
@@ -276,7 +332,8 @@
         xd, cm, mi_row, mi_col, &this_mv, vfp, src_address, src_stride,    \
         pre(y, y_stride, r, c), y_stride, sp(c), sp(r), second_pred, mask, \
         mask_stride, invert_mask, w, h, &sse, use_accurate_subpel_search); \
-    v = mv_err_cost(&this_mv, ref_mv, mvjcost, mvcost, error_per_bit);     \
+    v = mv_err_cost(&this_mv, ref_mv, mvjcost, mvcost, error_per_bit,      \
+                    mv_cost_type);                                         \
     v += thismse;                                                          \
     if (v < besterr) {                                                     \
       besterr = v;                                                         \
@@ -373,6 +430,7 @@
   const int y_stride = xd->plane[0].pre[0].stride;                      \
   const int offset = bestmv->row * y_stride + bestmv->col;              \
   const uint8_t *const y = xd->plane[0].pre[0].buf;                     \
+  const MV_COST_TYPE mv_cost_type = x->mv_cost_type;                    \
                                                                         \
   int br = bestmv->row * 8;                                             \
   int bc = bestmv->col * 8;                                             \
@@ -393,7 +451,8 @@
     const uint8_t *const src, const int src_stride, const uint8_t *const y,
     int y_stride, const uint8_t *second_pred, const uint8_t *mask,
     int mask_stride, int invert_mask, int w, int h, int offset, int *mvjcost,
-    int *mvcost[2], unsigned int *sse1, int *distortion) {
+    int *mvcost[2], unsigned int *sse1, int *distortion,
+    const MV_COST_TYPE mv_cost_type) {
   unsigned int besterr;
   if (second_pred != NULL) {
 #if CONFIG_AV1_HIGHBITDEPTH
@@ -433,7 +492,8 @@
     besterr = vfp->vf(y + offset, y_stride, src, src_stride, sse1);
   }
   *distortion = besterr;
-  besterr += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit);
+  besterr +=
+      mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit, mv_cost_type);
   return besterr;
 }
 
@@ -471,10 +531,10 @@
     int mask_stride, int invert_mask, int w, int h,
     int use_accurate_subpel_search, const int do_reset_fractional_mv) {
   SETUP_SUBPEL_SEARCH;
-  besterr = setup_center_error(xd, bestmv, ref_mv, error_per_bit, vfp,
-                               src_address, src_stride, y, y_stride,
-                               second_pred, mask, mask_stride, invert_mask, w,
-                               h, offset, mvjcost, mvcost, sse1, distortion);
+  besterr = setup_center_error(
+      xd, bestmv, ref_mv, error_per_bit, vfp, src_address, src_stride, y,
+      y_stride, second_pred, mask, mask_stride, invert_mask, w, h, offset,
+      mvjcost, mvcost, sse1, distortion, mv_cost_type);
   (void)halfiters;
   (void)quarteriters;
   (void)eighthiters;
@@ -550,10 +610,10 @@
   (void)mi_col;
   (void)do_reset_fractional_mv;
 
-  besterr = setup_center_error(xd, bestmv, ref_mv, error_per_bit, vfp,
-                               src_address, src_stride, y, y_stride,
-                               second_pred, mask, mask_stride, invert_mask, w,
-                               h, offset, mvjcost, mvcost, sse1, distortion);
+  besterr = setup_center_error(
+      xd, bestmv, ref_mv, error_per_bit, vfp, src_address, src_stride, y,
+      y_stride, second_pred, mask, mask_stride, invert_mask, w, h, offset,
+      mvjcost, mvcost, sse1, distortion, mv_cost_type);
   if (cost_list && cost_list[0] != INT_MAX && cost_list[1] != INT_MAX &&
       cost_list[2] != INT_MAX && cost_list[3] != INT_MAX &&
       cost_list[4] != INT_MAX && is_cost_list_wellbehaved(cost_list)) {
@@ -619,10 +679,10 @@
   (void)mi_col;
   (void)do_reset_fractional_mv;
 
-  besterr = setup_center_error(xd, bestmv, ref_mv, error_per_bit, vfp,
-                               src_address, src_stride, y, y_stride,
-                               second_pred, mask, mask_stride, invert_mask, w,
-                               h, offset, mvjcost, mvcost, sse1, distortion);
+  besterr = setup_center_error(
+      xd, bestmv, ref_mv, error_per_bit, vfp, src_address, src_stride, y,
+      y_stride, second_pred, mask, mask_stride, invert_mask, w, h, offset,
+      mvjcost, mvcost, sse1, distortion, mv_cost_type);
   if (cost_list && cost_list[0] != INT_MAX && cost_list[1] != INT_MAX &&
       cost_list[2] != INT_MAX && cost_list[3] != INT_MAX &&
       cost_list[4] != INT_MAX) {
@@ -785,13 +845,15 @@
     const int src_stride, const uint8_t *const y, int y_stride,
     const uint8_t *second_pred, const uint8_t *mask, int mask_stride,
     int invert_mask, int w, int h, int offset, int *mvjcost, int *mvcost[2],
-    unsigned int *sse1, int *distortion, int subpel_search) {
+    unsigned int *sse1, int *distortion, int subpel_search,
+    MV_COST_TYPE mv_cost_type) {
   unsigned int besterr =
       upsampled_pref_error(xd, cm, mi_row, mi_col, bestmv, vfp, src, src_stride,
                            y + offset, y_stride, 0, 0, second_pred, mask,
                            mask_stride, invert_mask, w, h, sse1, subpel_search);
   *distortion = besterr;
-  besterr += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit);
+  besterr +=
+      mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit, mv_cost_type);
   return besterr;
 }
 
@@ -831,6 +893,7 @@
   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;
+  const MV_COST_TYPE mv_cost_type = x->mv_cost_type;
 
   int br = bestmv->row * 8;
   int bc = bestmv->col * 8;
@@ -857,12 +920,12 @@
         xd, cm, mi_row, mi_col, bestmv, ref_mv, error_per_bit, vfp, src_address,
         src_stride, y, y_stride, second_pred, mask, mask_stride, invert_mask, w,
         h, offset, mvjcost, mvcost, sse1, distortion,
-        use_accurate_subpel_search);
+        use_accurate_subpel_search, mv_cost_type);
   else
-    besterr = setup_center_error(xd, bestmv, ref_mv, error_per_bit, vfp,
-                                 src_address, src_stride, y, y_stride,
-                                 second_pred, mask, mask_stride, invert_mask, w,
-                                 h, offset, mvjcost, mvcost, sse1, distortion);
+    besterr = setup_center_error(
+        xd, bestmv, ref_mv, error_per_bit, vfp, src_address, src_stride, y,
+        y_stride, second_pred, mask, mask_stride, invert_mask, w, h, offset,
+        mvjcost, mvcost, sse1, distortion, mv_cost_type);
 
   (void)cost_list;  // to silence compiler warning
 
@@ -896,8 +959,9 @@
               &sse);
         }
 
-        cost_array[idx] = thismse + mv_err_cost(&this_mv, ref_mv, mvjcost,
-                                                mvcost, error_per_bit);
+        cost_array[idx] =
+            thismse + mv_err_cost(&this_mv, ref_mv, mvjcost, mvcost,
+                                  error_per_bit, mv_cost_type);
 
         if (cost_array[idx] < besterr) {
           best_idx = idx;
@@ -932,7 +996,7 @@
       }
 
       cost_array[4] = thismse + mv_err_cost(&this_mv, ref_mv, mvjcost, mvcost,
-                                            error_per_bit);
+                                            error_per_bit, mv_cost_type);
 
       if (cost_array[4] < besterr) {
         best_idx = 4;
@@ -993,12 +1057,13 @@
   unsigned int sse;
   const int mi_row = xd->mi_row;
   const int mi_col = xd->mi_col;
+  const MV_COST_TYPE mv_cost_type = x->mv_cost_type;
 
   av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize,
                                 AOM_PLANE_Y, AOM_PLANE_Y);
   mse = vfp->vf(dst, dst_stride, src, src_stride, &sse);
   mse += mv_err_cost(this_mv, &ref_mv.as_mv, x->nmv_vec_cost, x->mv_cost_stack,
-                     x->errorperbit);
+                     x->errorperbit, mv_cost_type);
   return mse;
 }
 
@@ -1122,6 +1187,7 @@
   const MV fcenter_mv = { ref_mv->row >> 3, ref_mv->col >> 3 };
   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;
 
   cost_list[0] =
@@ -1138,7 +1204,7 @@
                      get_buf_from_mv(in_what, &neighbor_mv), in_what->stride,
                      &sse) +
           mv_err_cost(&neighbor_mv_subpel, ref_mv, x->nmv_vec_cost,
-                      x->mv_cost_stack, x->errorperbit);
+                      x->mv_cost_stack, x->errorperbit, mv_cost_type);
     }
   } else {
     for (int i = 0; i < 4; i++) {
@@ -1153,7 +1219,7 @@
                        get_buf_from_mv(in_what, &neighbor_mv), in_what->stride,
                        &sse) +
             mv_err_cost(&neighbor_mv_subpel, ref_mv, x->nmv_vec_cost,
-                        x->mv_cost_stack, x->errorperbit);
+                        x->mv_cost_stack, x->errorperbit, mv_cost_type);
       }
     }
   }
@@ -1472,6 +1538,7 @@
   const struct buf_2d *const what = &x->plane[0].src;
   const struct buf_2d *const in_what = &xd->plane[0].pre[0];
   const MV mv = { best_mv->row * 8, best_mv->col * 8 };
+  const MV_COST_TYPE mv_cost_type = x->mv_cost_type;
   unsigned int sse, var;
 
   var = vfp->vf(what->buf, what->stride, get_buf_from_mv(in_what, best_mv),
@@ -1480,7 +1547,7 @@
   if (!use_var) var = sse;
 
   return var + mv_err_cost(&mv, center_mv, x->nmv_vec_cost, x->mv_cost_stack,
-                           x->errorperbit);
+                           x->errorperbit, mv_cost_type);
 }
 
 int av1_get_mvpred_av_var(const MACROBLOCK *x, const MV *best_mv,
@@ -1491,13 +1558,15 @@
   const struct buf_2d *const what = src;
   const struct buf_2d *const in_what = pre;
   const MV mv = { best_mv->row * 8, best_mv->col * 8 };
+  const MV_COST_TYPE mv_cost_type = x->mv_cost_type;
   unsigned int unused;
 
   return vfp->svaf(get_buf_from_mv(in_what, best_mv), in_what->stride, 0, 0,
                    what->buf, what->stride, &unused, second_pred) +
-         (use_mvcost ? mv_err_cost(&mv, center_mv, x->nmv_vec_cost,
-                                   x->mv_cost_stack, x->errorperbit)
-                     : 0);
+         (use_mvcost
+              ? mv_err_cost(&mv, center_mv, x->nmv_vec_cost, x->mv_cost_stack,
+                            x->errorperbit, mv_cost_type)
+              : 0);
 }
 
 int av1_get_mvpred_mask_var(const MACROBLOCK *x, const MV *best_mv,
@@ -1509,14 +1578,16 @@
   const struct buf_2d *const what = src;
   const struct buf_2d *const in_what = pre;
   const MV mv = { best_mv->row * 8, best_mv->col * 8 };
+  const MV_COST_TYPE mv_cost_type = x->mv_cost_type;
   unsigned int unused;
 
   return vfp->msvf(what->buf, what->stride, 0, 0,
                    get_buf_from_mv(in_what, best_mv), in_what->stride,
                    second_pred, mask, mask_stride, invert_mask, &unused) +
-         (use_mvcost ? mv_err_cost(&mv, center_mv, x->nmv_vec_cost,
-                                   x->mv_cost_stack, x->errorperbit)
-                     : 0);
+         (use_mvcost
+              ? mv_err_cost(&mv, center_mv, x->nmv_vec_cost, x->mv_cost_stack,
+                            x->errorperbit, mv_cost_type)
+              : 0);
 }
 
 int av1_hex_search(MACROBLOCK *x, MV *start_mv, int search_param,
@@ -2531,7 +2602,8 @@
                                         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);        \
+    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;                                                                 \
@@ -2547,11 +2619,13 @@
     const int32_t *mask, const MV *bestmv, const MV *ref_mv, int error_per_bit,
     const aom_variance_fn_ptr_t *vfp, const int32_t *const wsrc,
     const uint8_t *const y, int y_stride, int offset, int *mvjcost,
-    int *mvcost[2], unsigned int *sse1, int *distortion) {
+    int *mvcost[2], unsigned int *sse1, int *distortion,
+    MV_COST_TYPE mv_cost_type) {
   unsigned int besterr;
   besterr = vfp->ovf(y + offset, y_stride, wsrc, mask, sse1);
   *distortion = besterr;
-  besterr += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit);
+  besterr +=
+      mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit, mv_cost_type);
   return besterr;
 }
 
@@ -2592,12 +2666,13 @@
     const aom_variance_fn_ptr_t *vfp, const int32_t *const wsrc,
     const uint8_t *const y, int y_stride, int w, int h, int offset,
     int *mvjcost, int *mvcost[2], unsigned int *sse1, int *distortion,
-    int subpel_search) {
+    int subpel_search, MV_COST_TYPE mv_cost_type) {
   unsigned int besterr = upsampled_obmc_pref_error(
       xd, cm, mi_row, mi_col, bestmv, mask, vfp, wsrc, y + offset, y_stride, 0,
       0, w, h, sse1, subpel_search);
   *distortion = besterr;
-  besterr += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit);
+  besterr +=
+      mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit, mv_cost_type);
   return besterr;
 }
 
@@ -2611,6 +2686,7 @@
   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;
   MACROBLOCKD *xd = &x->e_mbd;
   struct macroblockd_plane *const pd = &xd->plane[0];
   MB_MODE_INFO *mbmi = xd->mi[0];
@@ -2655,11 +2731,11 @@
     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);
+        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);
+                                      sse1, distortion, mv_cost_type);
 
   for (iter = 0; iter < round; ++iter) {
     // Check vertical and horizontal sub-pixel positions.
@@ -2678,8 +2754,9 @@
                               sp(tr), src_address, mask, &sse);
         }
 
-        cost_array[idx] = thismse + mv_err_cost(&this_mv, ref_mv, mvjcost,
-                                                mvcost, error_per_bit);
+        cost_array[idx] =
+            thismse + mv_err_cost(&this_mv, ref_mv, mvjcost, mvcost,
+                                  error_per_bit, mv_cost_type);
         if (cost_array[idx] < besterr) {
           best_idx = idx;
           besterr = cost_array[idx];
@@ -2711,7 +2788,7 @@
       }
 
       cost_array[4] = thismse + mv_err_cost(&this_mv, ref_mv, mvjcost, mvcost,
-                                            error_per_bit);
+                                            error_per_bit, mv_cost_type);
 
       if (cost_array[4] < besterr) {
         best_idx = 4;
@@ -2770,13 +2847,15 @@
   const MACROBLOCKD *const xd = &x->e_mbd;
   const struct buf_2d *const in_what = &xd->plane[0].pre[is_second];
   const MV mv = { best_mv->row * 8, best_mv->col * 8 };
+  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) +
-         (use_mvcost ? mv_err_cost(&mv, center_mv, x->nmv_vec_cost,
-                                   x->mv_cost_stack, x->errorperbit)
-                     : 0);
+         (use_mvcost
+              ? mv_err_cost(&mv, center_mv, x->nmv_vec_cost, x->mv_cost_stack,
+                            x->errorperbit, mv_cost_type)
+              : 0);
 }
 
 static int obmc_refining_search_sad(const MACROBLOCK *x, const int32_t *wsrc,
@@ -3027,6 +3106,7 @@
   (void)mi_row;
   (void)mi_col;
   (void)do_reset_fractional_mv;
+  (void)mv_cost_type;
 
   bestmv->row = maxr;
   bestmv->col = maxc;
@@ -3056,6 +3136,7 @@
   (void)mi_row;
   (void)mi_col;
   (void)do_reset_fractional_mv;
+  (void)mv_cost_type;
 
   bestmv->row = minr;
   bestmv->col = minc;