diff --git a/vp10/encoder/rdopt.c b/vp10/encoder/rdopt.c
index 416c11c..ff07489 100644
--- a/vp10/encoder/rdopt.c
+++ b/vp10/encoder/rdopt.c
@@ -44,6 +44,10 @@
 #include "vp10/encoder/rdopt.h"
 #include "vp10/encoder/aq_variance.h"
 
+// TODO(geza.lore) Update this when the extended coding unit size experiment
+// have been ported.
+#define CU_SIZE 64
+
 #if CONFIG_EXT_REFS
 
 #define LAST_FRAME_MODE_MASK    ((1 << GOLDEN_FRAME) | (1 << ALTREF_FRAME) | \
@@ -260,6 +264,40 @@
   {D63_PRED,  {INTRA_FRAME,  NONE}},
   {D117_PRED, {INTRA_FRAME,  NONE}},
   {D45_PRED,  {INTRA_FRAME,  NONE}},
+
+#if CONFIG_EXT_INTER
+  {ZEROMV,    {LAST_FRAME,   INTRA_FRAME}},
+  {NEARESTMV, {LAST_FRAME,   INTRA_FRAME}},
+  {NEARMV,    {LAST_FRAME,   INTRA_FRAME}},
+  {NEWMV,     {LAST_FRAME,   INTRA_FRAME}},
+
+#if CONFIG_EXT_REFS
+  {ZEROMV,    {LAST2_FRAME,  INTRA_FRAME}},
+  {NEARESTMV, {LAST2_FRAME,  INTRA_FRAME}},
+  {NEARMV,    {LAST2_FRAME,  INTRA_FRAME}},
+  {NEWMV,     {LAST2_FRAME,  INTRA_FRAME}},
+
+  {ZEROMV,    {LAST3_FRAME,  INTRA_FRAME}},
+  {NEARESTMV, {LAST3_FRAME,  INTRA_FRAME}},
+  {NEARMV,    {LAST3_FRAME,  INTRA_FRAME}},
+  {NEWMV,     {LAST3_FRAME,  INTRA_FRAME}},
+
+  {ZEROMV,    {LAST4_FRAME,  INTRA_FRAME}},
+  {NEARESTMV, {LAST4_FRAME,  INTRA_FRAME}},
+  {NEARMV,    {LAST4_FRAME,  INTRA_FRAME}},
+  {NEWMV,     {LAST4_FRAME,  INTRA_FRAME}},
+#endif  // CONFIG_EXT_REFS
+
+  {ZEROMV,    {GOLDEN_FRAME, INTRA_FRAME}},
+  {NEARESTMV, {GOLDEN_FRAME, INTRA_FRAME}},
+  {NEARMV,    {GOLDEN_FRAME, INTRA_FRAME}},
+  {NEWMV,     {GOLDEN_FRAME, INTRA_FRAME}},
+
+  {ZEROMV,    {ALTREF_FRAME, INTRA_FRAME}},
+  {NEARESTMV, {ALTREF_FRAME, INTRA_FRAME}},
+  {NEARMV,    {ALTREF_FRAME, INTRA_FRAME}},
+  {NEWMV,     {ALTREF_FRAME, INTRA_FRAME}},
+#endif  // CONFIG_EXT_INTER
 };
 
 static const REF_DEFINITION vp10_ref_order[MAX_REFS] = {
@@ -1056,33 +1094,6 @@
                    rate, distortion, skip,
                    sse, ref_best_rd, 0, bs,
                    mbmi->tx_size, cpi->sf.use_fast_coef_costing);
-
-#if CONFIG_EXT_TX
-  if (get_ext_tx_types(mbmi->tx_size, bs, is_inter) > 1 &&
-      !xd->lossless[mbmi->segment_id] && *rate != INT_MAX) {
-    int ext_tx_set = get_ext_tx_set(mbmi->tx_size, bs, is_inter);
-    if (is_inter) {
-      if (ext_tx_set > 0)
-        *rate += cpi->inter_tx_type_costs[ext_tx_set][mbmi->tx_size]
-                                                     [mbmi->tx_type];
-    } else {
-      if (ext_tx_set > 0 && ALLOW_INTRA_EXT_TX)
-        *rate +=
-            cpi->intra_tx_type_costs[ext_tx_set][mbmi->tx_size]
-                                                [mbmi->mode][mbmi->tx_type];
-    }
-  }
-#else
-  if (mbmi->tx_size < TX_32X32 && !xd->lossless[mbmi->segment_id] &&
-      *rate != INT_MAX) {
-    if (is_inter)
-      *rate += cpi->inter_tx_type_costs[mbmi->tx_size][mbmi->tx_type];
-    else
-      *rate += cpi->intra_tx_type_costs[mbmi->tx_size]
-          [intra_mode_to_tx_type_context[mbmi->mode]]
-          [mbmi->tx_type];
-  }
-#endif  // CONFIG_EXT_TX
 }
 
 static void choose_smallest_tx_size(VP10_COMP *cpi, MACROBLOCK *x,
@@ -3818,9 +3829,14 @@
     int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES], int this_mode,
     const MV_REFERENCE_FRAME ref_frames[2],
     const BLOCK_SIZE bsize, int block) {
+
+#if !CONFIG_EXT_INTER
+  assert(ref_frames[1] != INTRA_FRAME);  // Just sanity check
+#endif
+
   if ((this_mode == NEARMV || this_mode == NEARESTMV || this_mode == ZEROMV) &&
       frame_mv[this_mode][ref_frames[0]].as_int == 0 &&
-      (ref_frames[1] == NONE ||
+      (ref_frames[1] <= INTRA_FRAME ||
        frame_mv[this_mode][ref_frames[1]].as_int == 0)) {
 #if CONFIG_REF_MV
     int16_t rfc = vp10_mode_context_analyzer(mode_context,
@@ -3849,7 +3865,7 @@
       if (c2 > c3) return 0;
     } else {
       assert(this_mode == ZEROMV);
-      if (ref_frames[1] == NONE) {
+      if (ref_frames[1] <= INTRA_FRAME) {
         if ((c3 >= c2 && frame_mv[NEARESTMV][ref_frames[0]].as_int == 0) ||
             (c3 >= c1 && frame_mv[NEARMV][ref_frames[0]].as_int == 0))
           return 0;
@@ -3889,26 +3905,16 @@
       if (c4 > c3) return 0;
     } else {
       assert(this_mode == ZERO_ZEROMV);
-      if (ref_frames[1] == NONE) {
-        if ((c3 >= c2 &&
-             frame_mv[NEAREST_NEARESTMV][ref_frames[0]].as_int == 0) ||
-            (c3 >= c1 &&
-             frame_mv[NEAREST_NEARMV][ref_frames[0]].as_int == 0) ||
-            (c3 >= c4 &&
-             frame_mv[NEAR_NEARESTMV][ref_frames[0]].as_int == 0))
-          return 0;
-      } else {
-        if ((c3 >= c2 &&
-             frame_mv[NEAREST_NEARESTMV][ref_frames[0]].as_int == 0 &&
-             frame_mv[NEAREST_NEARESTMV][ref_frames[1]].as_int == 0) ||
-            (c3 >= c1 &&
-             frame_mv[NEAREST_NEARMV][ref_frames[0]].as_int == 0 &&
-             frame_mv[NEAREST_NEARMV][ref_frames[1]].as_int == 0) ||
-            (c3 >= c4 &&
-             frame_mv[NEAR_NEARESTMV][ref_frames[0]].as_int == 0 &&
-             frame_mv[NEAR_NEARESTMV][ref_frames[1]].as_int == 0))
-          return 0;
-      }
+      if ((c3 >= c2 &&
+           frame_mv[NEAREST_NEARESTMV][ref_frames[0]].as_int == 0 &&
+           frame_mv[NEAREST_NEARESTMV][ref_frames[1]].as_int == 0) ||
+          (c3 >= c1 &&
+           frame_mv[NEAREST_NEARMV][ref_frames[0]].as_int == 0 &&
+           frame_mv[NEAREST_NEARMV][ref_frames[1]].as_int == 0) ||
+          (c3 >= c4 &&
+           frame_mv[NEAR_NEARESTMV][ref_frames[0]].as_int == 0 &&
+           frame_mv[NEAR_NEARESTMV][ref_frames[1]].as_int == 0))
+        return 0;
     }
   }
 #endif  // CONFIG_EXT_INTER
@@ -5160,6 +5166,8 @@
 #endif  // CONFIG_OBMC
 #if CONFIG_EXT_INTER
                                  int_mv single_newmvs[2][MAX_REF_FRAMES],
+                                 int single_newmvs_rate[2][MAX_REF_FRAMES],
+                                 int *compmode_interintra_cost,
 #else
                                  int_mv single_newmv[MAX_REF_FRAMES],
 #endif  // CONFIG_EXT_INTER
@@ -5183,6 +5191,9 @@
 #if CONFIG_EXT_INTER
   int mv_idx = (this_mode == NEWFROMNEARMV) ? 1 : 0;
   int_mv single_newmv[MAX_REF_FRAMES];
+  const int * const intra_mode_cost =
+    cpi->mbmode_cost[size_group_lookup[bsize]];
+  const int is_comp_interintra_pred = (mbmi->ref_frame[1] == INTRA_FRAME);
 #if CONFIG_REF_MV
   uint8_t ref_frame_type = vp10_ref_frame_type(mbmi->ref_frame);
 #endif
@@ -5193,6 +5204,9 @@
 #else
   DECLARE_ALIGNED(16, uint8_t, tmp_buf[MAX_MB_PLANE * 64 * 64]);
 #endif  // CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_EXT_INTER
+  const int tmp_buf_sz = CU_SIZE * CU_SIZE;
+#endif  // CONFIG_EXT_INTER
 #if CONFIG_OBMC
   int allow_obmc = is_obmc_allowed(mbmi);
   int best_obmc_flag = 0;
@@ -5243,6 +5257,15 @@
   int64_t distortion_y = 0, distortion_uv = 0;
   int16_t mode_ctx = mbmi_ext->mode_context[refs[0]];
 
+#if CONFIG_EXT_INTER
+  *compmode_interintra_cost = 0;
+
+  // is_comp_interintra_pred implies !is_comp_pred
+  assert(!is_comp_interintra_pred || (!is_comp_pred));
+  // is_comp_interintra_pred implies is_interintra_allowed(mbmi->sb_type)
+  assert(!is_comp_interintra_pred || is_interintra_allowed(mbmi));
+#endif  // CONFIG_EXT_INTER
+
 #if CONFIG_OBMC
   tmp_rd = 0;
 #endif  // CONFIG_OBMC
@@ -5345,35 +5368,39 @@
                                    x->nmvjointcost, x->mvcost, MV_COST_WEIGHT);
       }
 #endif  // CONFIG_EXT_INTER
-      *rate2 += rate_mv;
     } else {
       int_mv tmp_mv;
-      single_motion_search(cpi, x, bsize, mi_row, mi_col,
+
 #if CONFIG_EXT_INTER
-                           0, mv_idx,
+      if (is_comp_interintra_pred) {
+        tmp_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;
+        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;
 #endif  // CONFIG_EXT_INTER
-                           &tmp_mv, &rate_mv);
+
       if (tmp_mv.as_int == INVALID_MV)
         return INT64_MAX;
 
-      frame_mv[refs[0]].as_int =
-          xd->mi[0]->bmi[0].as_mv[0].as_int = tmp_mv.as_int;
-#if CONFIG_EXT_INTER
-      single_newmvs[mv_idx][refs[0]].as_int = tmp_mv.as_int;
-#else
-      single_newmv[refs[0]].as_int = tmp_mv.as_int;
-#endif  // CONFIG_EXT_INTER
+      frame_mv[refs[0]] = tmp_mv;
+      xd->mi[0]->bmi[0].as_mv[0] = tmp_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])) {
-        *rate2 += VPXMAX((rate_mv / NEW_MV_DISCOUNT_FACTOR), 1);
-      } else {
-        *rate2 += rate_mv;
+        rate_mv = VPXMAX((rate_mv / NEW_MV_DISCOUNT_FACTOR), 1);
       }
     }
+    *rate2 += rate_mv;
   }
 
   for (i = 0; i < is_comp_pred + 1; ++i) {
@@ -5586,6 +5613,9 @@
 
         if ((cm->interp_filter == SWITCHABLE &&
              (!i || best_needs_copy)) ||
+#if CONFIG_EXT_INTER
+            is_comp_interintra_pred ||
+#endif  // CONFIG_EXT_INTER
             (cm->interp_filter != SWITCHABLE &&
              (cm->interp_filter == mbmi->interp_filter ||
               (i == 0 && intpel_mv && IsInterpolatingFilter(i))))) {
@@ -5714,6 +5744,63 @@
   mbmi->interp_filter = cm->interp_filter != SWITCHABLE ?
       cm->interp_filter : best_filter;
   rs = cm->interp_filter == SWITCHABLE ? vp10_get_switchable_rate(cpi, xd) : 0;
+
+#if CONFIG_EXT_INTER
+  if (is_comp_interintra_pred) {
+    PREDICTION_MODE interintra_mode, best_interintra_mode = DC_PRED;
+    int64_t best_interintra_rd = INT64_MAX;
+    int rmode, rate_sum;
+    int64_t dist_sum;
+    int j;
+    mbmi->ref_frame[1] = NONE;
+    for (j = 0; j < MAX_MB_PLANE; j++) {
+      xd->plane[j].dst.buf = tmp_buf + j * tmp_buf_sz;
+      xd->plane[j].dst.stride = CU_SIZE;
+    }
+    vp10_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
+    restore_dst_buf(xd, orig_dst, orig_dst_stride);
+    mbmi->ref_frame[1] = INTRA_FRAME;
+
+    for (interintra_mode = DC_PRED; interintra_mode <= TM_PRED;
+         ++interintra_mode) {
+      mbmi->interintra_mode = interintra_mode;
+      mbmi->interintra_uv_mode = interintra_mode;
+      rmode = intra_mode_cost[mbmi->interintra_mode];
+      vp10_build_interintra_predictors(xd,
+                                      tmp_buf,
+                                      tmp_buf + tmp_buf_sz,
+                                      tmp_buf + 2 * tmp_buf_sz,
+                                      CU_SIZE,
+                                      CU_SIZE,
+                                      CU_SIZE,
+                                      bsize);
+      model_rd_for_sb(cpi, bsize, x, xd, &rate_sum, &dist_sum,
+                      &skip_txfm_sb, &skip_sse_sb);
+      rd = RDCOST(x->rdmult, x->rddiv, rmode + rate_sum, dist_sum);
+      if (rd < best_interintra_rd) {
+        best_interintra_rd = rd;
+        best_interintra_mode = interintra_mode;
+      }
+    }
+    mbmi->interintra_mode = best_interintra_mode;
+    mbmi->interintra_uv_mode = best_interintra_mode;
+    if (ref_best_rd < INT64_MAX &&
+        best_interintra_rd / 2 > ref_best_rd) {
+      return INT64_MAX;
+    }
+
+    pred_exists = 0;
+    tmp_rd = best_interintra_rd;
+
+    *compmode_interintra_cost =
+      vp10_cost_bit(cm->fc->interintra_prob[bsize], 1);
+    *compmode_interintra_cost += intra_mode_cost[mbmi->interintra_mode];
+  } else if (is_interintra_allowed(mbmi)) {
+    *compmode_interintra_cost =
+      vp10_cost_bit(cm->fc->interintra_prob[bsize], 0);
+  }
+#endif  // CONFIG_EXT_INTER
+
 #if CONFIG_OBMC
   if (allow_obmc)
     mbmi->obmc = best_obmc_flag;
@@ -6303,6 +6390,7 @@
   struct buf_2d yv12_mb[MAX_REF_FRAMES][MAX_MB_PLANE];
 #if CONFIG_EXT_INTER
   int_mv single_newmvs[2][MAX_REF_FRAMES] = { { { 0 } },  { { 0 } } };
+  int single_newmvs_rate[2][MAX_REF_FRAMES] = { { 0 }, { 0 } };
 #else
   int_mv single_newmv[MAX_REF_FRAMES] = { { 0 } };
 #endif  // CONFIG_EXT_INTER
@@ -6325,9 +6413,6 @@
   int64_t best_filter_rd[SWITCHABLE_FILTER_CONTEXTS];
   int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS];
   MB_MODE_INFO best_mbmode;
-#if CONFIG_REF_MV
-  uint8_t best_ref_mv_idx[MODE_CTX_REF_FRAMES] = { 0 };
-#endif
   int best_mode_skippable = 0;
   int midx, best_mode_index = -1;
   unsigned int ref_costs_single[MAX_REF_FRAMES], ref_costs_comp[MAX_REF_FRAMES];
@@ -6594,6 +6679,9 @@
     int64_t this_rd = INT64_MAX;
     int disable_skip = 0;
     int compmode_cost = 0;
+#if CONFIG_EXT_INTER
+    int compmode_interintra_cost = 0;
+#endif  // CONFIG_EXT_INTER
     int rate2 = 0, rate_y = 0, rate_uv = 0;
     int64_t distortion2 = 0, distortion_y = 0, distortion_uv = 0;
     int skippable = 0;
@@ -6609,6 +6697,14 @@
     second_ref_frame = vp10_mode_order[mode_index].ref_frame[1];
 
 #if CONFIG_EXT_INTER
+    if (ref_frame > INTRA_FRAME && second_ref_frame == INTRA_FRAME) {
+      // Mode must by compatible
+      assert(is_interintra_allowed_mode(this_mode));
+
+      if (!is_interintra_allowed_bsize(bsize))
+        continue;
+    }
+
     if (this_mode == NEAREST_NEARESTMV) {
       frame_mv[NEAREST_NEARESTMV][ref_frame].as_int =
           frame_mv[NEARESTMV][ref_frame].as_int;
@@ -6792,6 +6888,11 @@
         xd->plane[i].pre[1] = yv12_mb[second_ref_frame][i];
     }
 
+#if CONFIG_EXT_INTER
+    mbmi->interintra_mode = (PREDICTION_MODE)(DC_PRED - 1);
+    mbmi->interintra_uv_mode = (PREDICTION_MODE)(DC_PRED - 1);
+#endif  // CONFIG_EXT_INTER
+
     if (ref_frame == INTRA_FRAME) {
       TX_SIZE uv_tx;
       struct macroblockd_plane *const pd = &xd->plane[1];
@@ -6936,6 +7037,21 @@
         rate2 += intra_cost_penalty;
       distortion2 = distortion_y + distortion_uv;
     } else {
+#if CONFIG_EXT_INTER
+      if (second_ref_frame == INTRA_FRAME) {
+        mbmi->interintra_mode = best_intra_mode;
+        mbmi->interintra_uv_mode = best_intra_mode;
+#if CONFIG_EXT_INTRA
+        // TODO(debargha|geza.lore):
+        // Should we use ext_intra modes for interintra?
+        mbmi->ext_intra_mode_info.use_ext_intra_mode[0] = 0;
+        mbmi->ext_intra_mode_info.use_ext_intra_mode[1] = 0;
+        mbmi->angle_delta[0] = 0;
+        mbmi->angle_delta[1] = 0;
+        mbmi->intra_filter = INTRA_FILTER_LINEAR;
+#endif  // CONFIG_EXT_INTRA
+      }
+#endif  // CONFIG_EXT_INTER
 #if CONFIG_REF_MV
       mbmi->ref_mv_idx = 0;
       ref_frame_type = vp10_ref_frame_type(mbmi->ref_frame);
@@ -6951,11 +7067,14 @@
 #endif  // CONFIG_OBMC
 #if CONFIG_EXT_INTER
                                   single_newmvs,
+                                  single_newmvs_rate,
+                                  &compmode_interintra_cost,
 #else
                                   single_newmv,
 #endif  // CONFIG_EXT_INTER
                                   single_inter_filter,
-                                  single_skippable, &total_sse, best_rd,
+                                  single_skippable,
+                                  &total_sse, best_rd,
                                   &mask_filter, filter_cache);
 
 #if CONFIG_REF_MV
@@ -7008,6 +7127,9 @@
 #if CONFIG_EXT_INTER
             int_mv dummy_single_newmvs[2][MAX_REF_FRAMES] =
                                           { { { 0 } },  { { 0 } } };
+            int dummy_single_newmvs_rate[2][MAX_REF_FRAMES] =
+                                          { { 0 }, { 0 } };
+            int dummy_compmode_interintra_cost = 0;
 #else
             int_mv dummy_single_newmv[MAX_REF_FRAMES] = { { 0 } };
 #endif
@@ -7027,6 +7149,8 @@
 #endif  // CONFIG_OBMC
 #if CONFIG_EXT_INTER
                                            dummy_single_newmvs,
+                                           dummy_single_newmvs_rate,
+                                           &dummy_compmode_interintra_cost,
 #else
                                            dummy_single_newmv,
 #endif
@@ -7071,8 +7195,6 @@
             rate_uv = tmp_rate_uv;
             total_sse = tmp_sse;
             this_rd = tmp_alt_rd;
-            // Indicator of the effective nearmv reference motion vector.
-            best_ref_mv_idx[ref_frame_type] = 1 + ref_idx;
             tmp_ref_rd = tmp_alt_rd;
             backup_mbmi = *mbmi;
           } else {
@@ -7082,7 +7204,7 @@
 
         frame_mv[NEARMV][ref_frame] = backup_mv;
       }
-#endif
+#endif  // CONFIG_REF_MV
 
       if (this_rd == INT64_MAX)
         continue;
@@ -7093,6 +7215,10 @@
         rate2 += compmode_cost;
     }
 
+#if CONFIG_EXT_INTER
+    rate2 += compmode_interintra_cost;
+#endif  // CONFIG_EXT_INTER
+
     // Estimate the reference frame signaling cost and add it
     // to the rolling cost variable.
     if (comp_pred) {
@@ -7308,12 +7434,11 @@
         best_mbmode.ref_frame[1]};
     int comp_pred_mode = refs[1] > INTRA_FRAME;
 #if CONFIG_REF_MV
+    const uint8_t rf_type = vp10_ref_frame_type(best_mbmode.ref_frame);
     if (!comp_pred_mode) {
-      if (best_ref_mv_idx[best_mbmode.ref_frame[0]] > 0 &&
-          best_mbmode.ref_frame[1] == NONE) {
-        int idx = best_ref_mv_idx[best_mbmode.ref_frame[0]] + 1;
-        int_mv cur_mv =
-            mbmi_ext->ref_mv_stack[best_mbmode.ref_frame[0]][idx].this_mv;
+      if (best_mbmode.ref_mv_idx > 0 && refs[1] == NONE) {
+        int idx = best_mbmode.ref_mv_idx + 1;
+        int_mv cur_mv = mbmi_ext->ref_mv_stack[refs[0]][idx].this_mv;
         lower_mv_precision(&cur_mv.as_mv, cm->allow_high_precision_mv);
         frame_mv[NEARMV][refs[0]] = cur_mv;
       }
@@ -7325,7 +7450,6 @@
       else if (best_mbmode.mv[0].as_int == 0)
         best_mbmode.mode = ZEROMV;
     } else {
-      uint8_t rf_type = vp10_ref_frame_type(best_mbmode.ref_frame);
       int i;
       const int allow_hp = cm->allow_high_precision_mv;
       int_mv nearestmv[2] = { frame_mv[NEARESTMV][refs[0]],
@@ -7340,7 +7464,7 @@
       }
 
       if (mbmi_ext->ref_mv_count[rf_type] > 1) {
-        int ref_mv_idx = best_ref_mv_idx[rf_type] + 1;
+        int ref_mv_idx = best_mbmode.ref_mv_idx + 1;
         nearmv[0] = mbmi_ext->ref_mv_stack[rf_type][ref_mv_idx].this_mv;
         nearmv[1] = mbmi_ext->ref_mv_stack[rf_type][ref_mv_idx].comp_mv;
       }
@@ -7417,10 +7541,11 @@
   if (best_mbmode.ref_frame[0] > INTRA_FRAME &&
       best_mbmode.mv[0].as_int == 0 &&
 #if CONFIG_EXT_INTER
-      best_mbmode.ref_frame[1] == NONE) {
+      (best_mbmode.ref_frame[1] <= INTRA_FRAME)
 #else
-      (best_mbmode.ref_frame[1] == NONE || best_mbmode.mv[1].as_int == 0)) {
+      (best_mbmode.ref_frame[1] == NONE || best_mbmode.mv[1].as_int == 0)
 #endif  // CONFIG_EXT_INTER
+     ) {
     int16_t mode_ctx = mbmi_ext->mode_context[best_mbmode.ref_frame[0]];
 #if !CONFIG_EXT_INTER
     if (best_mbmode.ref_frame[1] > NONE)
@@ -7430,11 +7555,6 @@
     if (mode_ctx & (1 << ALL_ZERO_FLAG_OFFSET))
       best_mbmode.mode = ZEROMV;
   }
-
-  if (best_mbmode.mode == NEARMV) {
-    uint8_t ref_frame_type = vp10_ref_frame_type(best_mbmode.ref_frame);
-    best_mbmode.ref_mv_idx = best_ref_mv_idx[ref_frame_type];
-  }
 #endif
 
   if (best_mode_index < 0 || best_rd >= best_rd_so_far) {