diff --git a/vp9/common/vp9_alloccommon.c b/vp9/common/vp9_alloccommon.c
index 73f26f6b8..ef14e1ab6 100644
--- a/vp9/common/vp9_alloccommon.c
+++ b/vp9/common/vp9_alloccommon.c
@@ -202,8 +202,6 @@ void vp9_create_common(VP9_COMMON *oci) {
 
   vp9_init_mbmode_probs(oci);
 
-  vp9_default_bmode_probs(oci->fc.bmode_prob);
-
   oci->txfm_mode = ONLY_4X4;
   oci->comp_pred_mode = HYBRID_PREDICTION;
   oci->no_lpf = 0;
@@ -212,8 +210,6 @@ void vp9_create_common(VP9_COMMON *oci) {
 
   // Initialize reference frame sign bias structure to defaults
   vpx_memset(oci->ref_frame_sign_bias, 0, sizeof(oci->ref_frame_sign_bias));
-
-  oci->kf_ymode_probs_update = 0;
 }
 
 void vp9_remove_common(VP9_COMMON *oci) {
diff --git a/vp9/common/vp9_entropymode.c b/vp9/common/vp9_entropymode.c
index 9c390dfd0..f45877580 100644
--- a/vp9/common/vp9_entropymode.c
+++ b/vp9/common/vp9_entropymode.c
@@ -89,7 +89,7 @@ const vp9_prob vp9_partition_probs[NUM_PARTITION_CONTEXTS]
 };
 
 /* Array indices are identical to previously-existing INTRAMODECONTEXTNODES. */
-const vp9_tree_index vp9_bmode_tree[VP9_BINTRAMODES * 2 - 2] = {
+const vp9_tree_index vp9_intra_mode_tree[VP9_BINTRAMODES * 2 - 2] = {
   -DC_PRED, 2,                      /* 0 = DC_NODE */
   -TM_PRED, 4,                      /* 1 = TM_NODE */
   -V_PRED, 6,                       /* 2 = V_NODE */
@@ -101,46 +101,6 @@ const vp9_tree_index vp9_bmode_tree[VP9_BINTRAMODES * 2 - 2] = {
   -D153_PRED, -D27_PRED             /* 8 = D153_NODE */
 };
 
-/* Again, these trees use the same probability indices as their
-   explicitly-programmed predecessors. */
-const vp9_tree_index vp9_ymode_tree[VP9_YMODES * 2 - 2] = {
-  2, 14,
-  -DC_PRED, 4,
-  6, 8,
-  -D45_PRED, -D135_PRED,
-  10, 12,
-  -D117_PRED, -D153_PRED,
-  -D27_PRED, -D63_PRED,
-  16, 18,
-  -V_PRED, -H_PRED,
-  -TM_PRED, -I4X4_PRED
-};
-
-const vp9_tree_index vp9_kf_ymode_tree[VP9_YMODES * 2 - 2] = {
-  2, 14,
-  -DC_PRED, 4,
-  6, 8,
-  -D45_PRED, -D135_PRED,
-  10, 12,
-  -D117_PRED, -D153_PRED,
-  -D27_PRED, -D63_PRED,
-  16, 18,
-  -V_PRED, -H_PRED,
-  -TM_PRED, -I4X4_PRED
-};
-
-const vp9_tree_index vp9_uv_mode_tree[VP9_UV_MODES * 2 - 2] = {
-  2, 14,
-  -DC_PRED, 4,
-  6, 8,
-  -D45_PRED, -D135_PRED,
-  10, 12,
-  -D117_PRED, -D153_PRED,
-  -D27_PRED, -D63_PRED,
-  -V_PRED, 16,
-  -H_PRED, -TM_PRED
-};
-
 const vp9_tree_index vp9_sb_mv_ref_tree[6] = {
   -ZEROMV, 2,
   -NEARESTMV, 4,
@@ -153,13 +113,7 @@ const vp9_tree_index vp9_partition_tree[6] = {
   -PARTITION_VERT, -PARTITION_SPLIT
 };
 
-struct vp9_token vp9_bmode_encodings[VP9_BINTRAMODES];
-struct vp9_token vp9_kf_bmode_encodings[VP9_BINTRAMODES];
-struct vp9_token vp9_ymode_encodings[VP9_YMODES];
-struct vp9_token vp9_sb_ymode_encodings[VP9_I32X32_MODES];
-struct vp9_token vp9_sb_kf_ymode_encodings[VP9_I32X32_MODES];
-struct vp9_token vp9_kf_ymode_encodings[VP9_YMODES];
-struct vp9_token vp9_uv_mode_encodings[VP9_UV_MODES];
+struct vp9_token vp9_intra_mode_encodings[VP9_BINTRAMODES];
 
 struct vp9_token vp9_sb_mv_ref_encoding_array[VP9_MVREFS];
 
@@ -169,22 +123,13 @@ void vp9_init_mbmode_probs(VP9_COMMON *x) {
   unsigned int bct[VP9_YMODES][2];  // num Ymodes > num UV modes
   int i;
 
-  vp9_tree_probs_from_distribution(vp9_ymode_tree, x->fc.ymode_prob,
+  vp9_tree_probs_from_distribution(vp9_intra_mode_tree, x->fc.y_mode_prob,
                                    bct, y_mode_cts, 0);
-  vp9_tree_probs_from_distribution(vp9_sb_ymode_tree, x->fc.sb_ymode_prob,
-                                   bct, y_mode_cts, 0);
-  for (i = 0; i < 8; i++) {
-    vp9_tree_probs_from_distribution(vp9_kf_ymode_tree, x->kf_ymode_prob[i],
-                                     bct, kf_y_mode_cts[i], 0);
-    vp9_tree_probs_from_distribution(vp9_sb_kf_ymode_tree,
-                                     x->sb_kf_ymode_prob[i], bct,
-                                     kf_y_mode_cts[i], 0);
-  }
 
   for (i = 0; i < VP9_YMODES; i++) {
-    vp9_tree_probs_from_distribution(vp9_uv_mode_tree, x->kf_uv_mode_prob[i],
+    vp9_tree_probs_from_distribution(vp9_intra_mode_tree, x->kf_uv_mode_prob[i],
                                      bct, kf_uv_mode_cts[i], 0);
-    vp9_tree_probs_from_distribution(vp9_uv_mode_tree, x->fc.uv_mode_prob[i],
+    vp9_tree_probs_from_distribution(vp9_intra_mode_tree, x->fc.uv_mode_prob[i],
                                      bct, uv_mode_cts[i], 0);
   }
 
@@ -199,19 +144,6 @@ void vp9_init_mbmode_probs(VP9_COMMON *x) {
   x->ref_pred_probs[2] = DEFAULT_PRED_PROB_2;
 }
 
-
-static void intra_bmode_probs_from_distribution(
-  vp9_prob p[VP9_BINTRAMODES - 1],
-  unsigned int branch_ct[VP9_BINTRAMODES - 1][2],
-  const unsigned int events[VP9_BINTRAMODES]) {
-  vp9_tree_probs_from_distribution(vp9_bmode_tree, p, branch_ct, events, 0);
-}
-
-void vp9_default_bmode_probs(vp9_prob p[VP9_BINTRAMODES - 1]) {
-  unsigned int branch_ct[VP9_BINTRAMODES - 1][2];
-  intra_bmode_probs_from_distribution(p, branch_ct, bmode_cts);
-}
-
 #if VP9_SWITCHABLE_FILTERS == 3
 const vp9_tree_index vp9_switchable_interp_tree[VP9_SWITCHABLE_FILTERS*2-2] = {
   -0, 2,
@@ -246,13 +178,7 @@ const int vp9_switchable_interp_map[SWITCHABLE+1] = {-1, 0, 1, -1, -1};
 const int vp9_is_interpolating_filter[SWITCHABLE + 1] = {0, 1, 1, 1, -1};
 
 void vp9_entropy_mode_init() {
-  vp9_tokens_from_tree(vp9_kf_bmode_encodings,   vp9_bmode_tree);
-  vp9_tokens_from_tree(vp9_bmode_encodings,   vp9_bmode_tree);
-  vp9_tokens_from_tree(vp9_ymode_encodings,   vp9_ymode_tree);
-  vp9_tokens_from_tree(vp9_kf_ymode_encodings, vp9_kf_ymode_tree);
-  vp9_tokens_from_tree(vp9_sb_ymode_encodings, vp9_sb_ymode_tree);
-  vp9_tokens_from_tree(vp9_sb_kf_ymode_encodings, vp9_sb_kf_ymode_tree);
-  vp9_tokens_from_tree(vp9_uv_mode_encodings,  vp9_uv_mode_tree);
+  vp9_tokens_from_tree(vp9_intra_mode_encodings, vp9_intra_mode_tree);
   vp9_tokens_from_tree(vp9_switchable_interp_encodings,
                        vp9_switchable_interp_tree);
   vp9_tokens_from_tree(vp9_partition_encodings, vp9_partition_tree);
@@ -375,22 +301,15 @@ void vp9_adapt_mode_probs(VP9_COMMON *cm) {
   printf("};\n");
 #endif
 
-  update_mode_probs(VP9_YMODES, vp9_ymode_tree,
-                    fc->ymode_counts, fc->pre_ymode_prob,
-                    fc->ymode_prob, 0);
-  update_mode_probs(VP9_I32X32_MODES, vp9_sb_ymode_tree,
-                    fc->sb_ymode_counts, fc->pre_sb_ymode_prob,
-                    fc->sb_ymode_prob, 0);
+  update_mode_probs(VP9_YMODES, vp9_intra_mode_tree,
+                    fc->y_mode_counts, fc->pre_y_mode_prob,
+                    fc->y_mode_prob, 0);
 
   for (i = 0; i < VP9_YMODES; ++i)
-    update_mode_probs(VP9_UV_MODES, vp9_uv_mode_tree,
+    update_mode_probs(VP9_UV_MODES, vp9_intra_mode_tree,
                       fc->uv_mode_counts[i], fc->pre_uv_mode_prob[i],
                       fc->uv_mode_prob[i], 0);
 
-  update_mode_probs(VP9_BINTRAMODES, vp9_bmode_tree,
-                    fc->bmode_counts, fc->pre_bmode_prob,
-                    fc->bmode_prob, 0);
-
   for (i = 0; i < NUM_PARTITION_CONTEXTS; i++)
     update_mode_probs(PARTITION_TYPES, vp9_partition_tree,
                       fc->partition_counts[i], fc->pre_partition_prob[i],
@@ -428,8 +347,7 @@ void vp9_setup_past_independence(VP9_COMMON *cm, MACROBLOCKD *xd) {
 
   vp9_default_coef_probs(cm);
   vp9_init_mbmode_probs(cm);
-  vp9_default_bmode_probs(cm->fc.bmode_prob);
-  vpx_memcpy(cm->kf_bmode_prob, vp9_kf_default_bmode_probs,
+  vpx_memcpy(cm->kf_y_mode_prob, vp9_kf_default_bmode_probs,
              sizeof(vp9_kf_default_bmode_probs));
   vp9_init_mv_probs(cm);
 
diff --git a/vp9/common/vp9_entropymode.h b/vp9/common/vp9_entropymode.h
index 7a83c702e..120c81d4c 100644
--- a/vp9/common/vp9_entropymode.h
+++ b/vp9/common/vp9_entropymode.h
@@ -23,21 +23,10 @@ extern const vp9_prob vp9_kf_default_bmode_probs[VP9_BINTRAMODES]
                                                 [VP9_BINTRAMODES]
                                                 [VP9_BINTRAMODES -1 ];
 
-extern const vp9_tree_index vp9_bmode_tree[];
-extern const vp9_tree_index  vp9_ymode_tree[];
-extern const vp9_tree_index  vp9_kf_ymode_tree[];
-extern const vp9_tree_index  vp9_uv_mode_tree[];
-#define vp9_sb_ymode_tree vp9_uv_mode_tree
-#define vp9_sb_kf_ymode_tree vp9_uv_mode_tree
+extern const vp9_tree_index vp9_intra_mode_tree[];
 extern const vp9_tree_index  vp9_sb_mv_ref_tree[];
 
-extern struct vp9_token vp9_bmode_encodings[VP9_BINTRAMODES];
-extern struct vp9_token vp9_kf_bmode_encodings[VP9_BINTRAMODES];
-extern struct vp9_token vp9_ymode_encodings[VP9_YMODES];
-extern struct vp9_token vp9_sb_ymode_encodings[VP9_I32X32_MODES];
-extern struct vp9_token vp9_sb_kf_ymode_encodings[VP9_I32X32_MODES];
-extern struct vp9_token vp9_kf_ymode_encodings[VP9_YMODES];
-extern struct vp9_token vp9_uv_mode_encodings[VP9_UV_MODES];
+extern struct vp9_token vp9_intra_mode_encodings[VP9_BINTRAMODES];
 
 /* Inter mode values do not start at zero */
 
@@ -64,8 +53,6 @@ extern void vp9_accum_mv_refs(struct VP9Common *pc,
                               MB_PREDICTION_MODE m,
                               const int context);
 
-void vp9_default_bmode_probs(vp9_prob dest[VP9_BINTRAMODES - 1]);
-
 void vp9_adapt_mode_probs(struct VP9Common *);
 
 #define VP9_SWITCHABLE_FILTERS 3 /* number of switchable filters */
diff --git a/vp9/common/vp9_onyxc_int.h b/vp9/common/vp9_onyxc_int.h
index b148a6377..946c33dd5 100644
--- a/vp9/common/vp9_onyxc_int.h
+++ b/vp9/common/vp9_onyxc_int.h
@@ -47,22 +47,16 @@ void vp9_initialize_common(void);
 #define MAX_LAG_BUFFERS 25
 
 typedef struct frame_contexts {
-  vp9_prob bmode_prob[VP9_BINTRAMODES - 1];
-  vp9_prob ymode_prob[VP9_YMODES - 1]; /* interframe intra mode probs */
-  vp9_prob sb_ymode_prob[VP9_I32X32_MODES - 1];
+  vp9_prob y_mode_prob[VP9_YMODES - 1]; /* interframe intra mode probs */
   vp9_prob uv_mode_prob[VP9_YMODES][VP9_UV_MODES - 1];
   vp9_prob partition_prob[NUM_PARTITION_CONTEXTS][PARTITION_TYPES - 1];
 
   nmv_context nmvc;
   nmv_context pre_nmvc;
-  vp9_prob pre_bmode_prob[VP9_BINTRAMODES - 1];
-  vp9_prob pre_ymode_prob[VP9_YMODES - 1]; /* interframe intra mode probs */
-  vp9_prob pre_sb_ymode_prob[VP9_I32X32_MODES - 1];
+  vp9_prob pre_y_mode_prob[VP9_YMODES - 1]; /* interframe intra mode probs */
   vp9_prob pre_uv_mode_prob[VP9_YMODES][VP9_UV_MODES - 1];
   vp9_prob pre_partition_prob[NUM_PARTITION_CONTEXTS][PARTITION_TYPES - 1];
-  unsigned int bmode_counts[VP9_BINTRAMODES];
-  unsigned int ymode_counts[VP9_YMODES];   /* interframe intra mode probs */
-  unsigned int sb_ymode_counts[VP9_I32X32_MODES];
+  unsigned int y_mode_counts[VP9_YMODES];   /* interframe intra mode probs */
   unsigned int uv_mode_counts[VP9_YMODES][VP9_UV_MODES];
   unsigned int partition_counts[NUM_PARTITION_CONTEXTS][PARTITION_TYPES];
 
@@ -217,13 +211,9 @@ typedef struct VP9Common {
 
   /* keyframe block modes are predicted by their above, left neighbors */
 
-  vp9_prob kf_bmode_prob[VP9_BINTRAMODES]
-                        [VP9_BINTRAMODES]
-                        [VP9_BINTRAMODES - 1];
-  vp9_prob kf_ymode_prob[8][VP9_YMODES - 1]; /* keyframe "" */
-  vp9_prob sb_kf_ymode_prob[8][VP9_I32X32_MODES - 1];
-  int kf_ymode_probs_index;
-  int kf_ymode_probs_update;
+  vp9_prob kf_y_mode_prob[VP9_BINTRAMODES]
+                         [VP9_BINTRAMODES]
+                         [VP9_BINTRAMODES - 1];
   vp9_prob kf_uv_mode_prob[VP9_YMODES] [VP9_UV_MODES - 1];
 
   vp9_prob prob_intra_coded;
diff --git a/vp9/decoder/vp9_decodemv.c b/vp9/decoder/vp9_decodemv.c
index 813a26cdc..aa8726ffe 100644
--- a/vp9/decoder/vp9_decodemv.c
+++ b/vp9/decoder/vp9_decodemv.c
@@ -35,35 +35,11 @@ int dec_mvcount = 0;
 extern int dec_debug;
 #endif
 
-static MB_PREDICTION_MODE read_bmode(vp9_reader *r, const vp9_prob *p) {
-  MB_PREDICTION_MODE m = treed_read(r, vp9_bmode_tree, p);
+static MB_PREDICTION_MODE read_intra_mode(vp9_reader *r, const vp9_prob *p) {
+  MB_PREDICTION_MODE m = treed_read(r, vp9_intra_mode_tree, p);
   return m;
 }
 
-static MB_PREDICTION_MODE read_kf_bmode(vp9_reader *r, const vp9_prob *p) {
-  return (MB_PREDICTION_MODE)treed_read(r, vp9_bmode_tree, p);
-}
-
-static MB_PREDICTION_MODE read_ymode(vp9_reader *r, const vp9_prob *p) {
-  return (MB_PREDICTION_MODE)treed_read(r, vp9_ymode_tree, p);
-}
-
-static MB_PREDICTION_MODE read_sb_ymode(vp9_reader *r, const vp9_prob *p) {
-  return (MB_PREDICTION_MODE)treed_read(r, vp9_sb_ymode_tree, p);
-}
-
-static MB_PREDICTION_MODE read_kf_sb_ymode(vp9_reader *r, const vp9_prob *p) {
-  return (MB_PREDICTION_MODE)treed_read(r, vp9_uv_mode_tree, p);
-}
-
-static MB_PREDICTION_MODE read_kf_mb_ymode(vp9_reader *r, const vp9_prob *p) {
-  return (MB_PREDICTION_MODE)treed_read(r, vp9_kf_ymode_tree, p);
-}
-
-static MB_PREDICTION_MODE read_uv_mode(vp9_reader *r, const vp9_prob *p) {
-  return (MB_PREDICTION_MODE)treed_read(r, vp9_uv_mode_tree, p);
-}
-
 static int read_mb_segid(vp9_reader *r, MACROBLOCKD *xd) {
   return treed_read(r, vp9_segment_tree, xd->mb_segment_tree_probs);
 }
@@ -137,22 +113,18 @@ static void kfread_modes(VP9D_COMP *pbi, MODE_INFO *m,
   }
 
   // luma mode
+  m->mbmi.ref_frame = INTRA_FRAME;
   if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
     const MB_PREDICTION_MODE A = above_block_mode(m, 0, mis);
     const MB_PREDICTION_MODE L = xd->left_available ?
                                   left_block_mode(m, 0) : DC_PRED;
-    m->mbmi.mode = read_kf_bmode(r, cm->kf_bmode_prob[A][L]);
+    m->mbmi.mode = read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
   } else {
-     m->mbmi.mode = I4X4_PRED;
-  }
-
-  m->mbmi.ref_frame = INTRA_FRAME;
-
-  if (m->mbmi.sb_type < BLOCK_SIZE_SB8X8) {
     int idx, idy;
     int bw = 1 << b_width_log2(m->mbmi.sb_type);
     int bh = 1 << b_height_log2(m->mbmi.sb_type);
 
+    m->mbmi.mode = I4X4_PRED;
     for (idy = 0; idy < 2; idy += bh) {
       for (idx = 0; idx < 2; idx += bw) {
         int ib = idy * 2 + idx;
@@ -161,7 +133,7 @@ static void kfread_modes(VP9D_COMP *pbi, MODE_INFO *m,
         const MB_PREDICTION_MODE L = (xd->left_available || idx) ?
                                       left_block_mode(m, ib) : DC_PRED;
         m->bmi[ib].as_mode.first =
-            read_kf_bmode(r, cm->kf_bmode_prob[A][L]);
+            read_intra_mode(r, cm->kf_y_mode_prob[A][L]);
         for (k = 1; k < bh; ++k)
           m->bmi[ib + k * 2].as_mode.first = m->bmi[ib].as_mode.first;
         for (k = 1; k < bw; ++k)
@@ -170,7 +142,7 @@ static void kfread_modes(VP9D_COMP *pbi, MODE_INFO *m,
     }
   }
 
-  m->mbmi.uv_mode = read_uv_mode(r, cm->kf_uv_mode_prob[m->mbmi.mode]);
+  m->mbmi.uv_mode = read_intra_mode(r, cm->kf_uv_mode_prob[m->mbmi.mode]);
 }
 
 static int read_mv_component(vp9_reader *r,
@@ -390,10 +362,7 @@ static INLINE COMPPREDMODE_TYPE read_comp_pred_mode(vp9_reader *r) {
 static void mb_mode_mv_init(VP9D_COMP *pbi, vp9_reader *r) {
   VP9_COMMON *const cm = &pbi->common;
 
-  if (cm->frame_type == KEY_FRAME) {
-    if (!cm->kf_ymode_probs_update)
-      cm->kf_ymode_probs_index = vp9_read_literal(r, 3);
-  } else {
+  if (cm->frame_type != KEY_FRAME) {
     nmv_context *const nmvc = &pbi->common.fc.nmvc;
     MACROBLOCKD *const xd = &pbi->mb;
     int i, j;
@@ -418,12 +387,7 @@ static void mb_mode_mv_init(VP9D_COMP *pbi, vp9_reader *r) {
     // VP9_YMODES
     if (vp9_read_bit(r))
       for (i = 0; i < VP9_YMODES - 1; ++i)
-        cm->fc.ymode_prob[i] = vp9_read_prob(r);
-
-    // VP9_I32X32_MODES
-    if (vp9_read_bit(r))
-      for (i = 0; i < VP9_I32X32_MODES - 1; ++i)
-        cm->fc.sb_ymode_prob[i] = vp9_read_prob(r);
+        cm->fc.y_mode_prob[i] = vp9_read_prob(r);
 
     for (j = 0; j < NUM_PARTITION_CONTEXTS; ++j)
       if (vp9_read_bit(r))
@@ -805,21 +769,17 @@ static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
     mv0->as_int = 0;
 
     if (bsize >= BLOCK_SIZE_SB8X8) {
-      mbmi->mode = read_sb_ymode(r, cm->fc.sb_ymode_prob);
-      cm->fc.sb_ymode_counts[mbmi->mode]++;
+      mbmi->mode = read_intra_mode(r, cm->fc.y_mode_prob);
+      cm->fc.y_mode_counts[mbmi->mode]++;
     } else {
-      mbmi->mode = I4X4_PRED;
-    }
-
-    // If MB mode is I4X4_PRED read the block modes
-    if (bsize < BLOCK_SIZE_SB8X8) {
       int idx, idy;
+      mbmi->mode = I4X4_PRED;
       for (idy = 0; idy < 2; idy += bh) {
         for (idx = 0; idx < 2; idx += bw) {
           int ib = idy * 2 + idx, k;
-          int m = read_sb_ymode(r, cm->fc.sb_ymode_prob);
+          int m = read_intra_mode(r, cm->fc.y_mode_prob);
           mi->bmi[ib].as_mode.first = m;
-          cm->fc.sb_ymode_counts[m]++;
+          cm->fc.y_mode_counts[m]++;
           for (k = 1; k < bh; ++k)
             mi->bmi[ib + k * 2].as_mode.first = m;
           for (k = 1; k < bw; ++k)
@@ -828,7 +788,7 @@ static void read_mb_modes_mv(VP9D_COMP *pbi, MODE_INFO *mi, MB_MODE_INFO *mbmi,
       }
     }
 
-    mbmi->uv_mode = read_uv_mode(r, cm->fc.uv_mode_prob[mbmi->mode]);
+    mbmi->uv_mode = read_intra_mode(r, cm->fc.uv_mode_prob[mbmi->mode]);
     cm->fc.uv_mode_counts[mbmi->mode][mbmi->uv_mode]++;
   }
 }
diff --git a/vp9/decoder/vp9_decodframe.c b/vp9/decoder/vp9_decodframe.c
index 4e78ebf30..ccc82e23b 100644
--- a/vp9/decoder/vp9_decodframe.c
+++ b/vp9/decoder/vp9_decodframe.c
@@ -806,10 +806,8 @@ static void update_frame_context(FRAME_CONTEXT *fc) {
   vp9_copy(fc->pre_coef_probs_8x8, fc->coef_probs_8x8);
   vp9_copy(fc->pre_coef_probs_16x16, fc->coef_probs_16x16);
   vp9_copy(fc->pre_coef_probs_32x32, fc->coef_probs_32x32);
-  vp9_copy(fc->pre_ymode_prob, fc->ymode_prob);
-  vp9_copy(fc->pre_sb_ymode_prob, fc->sb_ymode_prob);
+  vp9_copy(fc->pre_y_mode_prob, fc->y_mode_prob);
   vp9_copy(fc->pre_uv_mode_prob, fc->uv_mode_prob);
-  vp9_copy(fc->pre_bmode_prob, fc->bmode_prob);
   vp9_copy(fc->pre_partition_prob, fc->partition_prob);
   fc->pre_nmvc = fc->nmvc;
 
@@ -818,10 +816,8 @@ static void update_frame_context(FRAME_CONTEXT *fc) {
   vp9_zero(fc->coef_counts_16x16);
   vp9_zero(fc->coef_counts_32x32);
   vp9_zero(fc->eob_branch_counts);
-  vp9_zero(fc->ymode_counts);
-  vp9_zero(fc->sb_ymode_counts);
+  vp9_zero(fc->y_mode_counts);
   vp9_zero(fc->uv_mode_counts);
-  vp9_zero(fc->bmode_counts);
   vp9_zero(fc->NMVcount);
   vp9_zero(fc->mv_ref_ct);
   vp9_zero(fc->partition_counts);
diff --git a/vp9/encoder/vp9_bitstream.c b/vp9/encoder/vp9_bitstream.c
index e4db5c1dc..aede81a04 100644
--- a/vp9/encoder/vp9_bitstream.c
+++ b/vp9/encoder/vp9_bitstream.c
@@ -248,12 +248,9 @@ static void update_mbintra_mode_probs(VP9_COMP* const cpi,
   vp9_prob pnew[VP9_YMODES - 1];
   unsigned int bct[VP9_YMODES - 1][2];
 
-  update_mode(bc, VP9_YMODES, vp9_ymode_encodings, vp9_ymode_tree, pnew,
-              cm->fc.ymode_prob, bct, (unsigned int *)cpi->ymode_count);
-
-  update_mode(bc, VP9_I32X32_MODES, vp9_sb_ymode_encodings,
-              vp9_sb_ymode_tree, pnew, cm->fc.sb_ymode_prob, bct,
-              (unsigned int *)cpi->sb_ymode_count);
+  update_mode(bc, VP9_YMODES, vp9_intra_mode_encodings,
+              vp9_intra_mode_tree, pnew,
+              cm->fc.y_mode_prob, bct, (unsigned int *)cpi->y_mode_count);
 }
 
 void vp9_update_skip_probs(VP9_COMP *cpi) {
@@ -350,28 +347,8 @@ static void update_inter_mode_probs(VP9_COMMON *cm,
   }
 }
 
-static void write_ymode(vp9_writer *bc, int m, const vp9_prob *p) {
-  write_token(bc, vp9_ymode_tree, p, vp9_ymode_encodings + m);
-}
-
-static void kfwrite_ymode(vp9_writer *bc, int m, const vp9_prob *p) {
-  write_token(bc, vp9_kf_ymode_tree, p, vp9_kf_ymode_encodings + m);
-}
-
-static void write_sb_ymode(vp9_writer *bc, int m, const vp9_prob *p) {
-  write_token(bc, vp9_sb_ymode_tree, p, vp9_sb_ymode_encodings + m);
-}
-
-static void sb_kfwrite_ymode(vp9_writer *bc, int m, const vp9_prob *p) {
-  write_token(bc, vp9_uv_mode_tree, p, vp9_sb_kf_ymode_encodings + m);
-}
-
-static void write_uv_mode(vp9_writer *bc, int m, const vp9_prob *p) {
-  write_token(bc, vp9_uv_mode_tree, p, vp9_uv_mode_encodings + m);
-}
-
-static void write_kf_bmode(vp9_writer *bc, int m, const vp9_prob *p) {
-  write_token(bc, vp9_bmode_tree, p, vp9_kf_bmode_encodings + m);
+static void write_intra_mode(vp9_writer *bc, int m, const vp9_prob *p) {
+  write_token(bc, vp9_intra_mode_tree, p, vp9_intra_mode_encodings + m);
 }
 
 static int prob_update_savings(const unsigned int *ct,
@@ -716,20 +693,19 @@ static void pack_inter_mode_mvs(VP9_COMP *cpi, MODE_INFO *m,
     active_section = 6;
 #endif
 
-    if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8)
-      write_sb_ymode(bc, mode, pc->fc.sb_ymode_prob);
-
-    if (m->mbmi.sb_type < BLOCK_SIZE_SB8X8) {
+    if (m->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
+      write_intra_mode(bc, mode, pc->fc.y_mode_prob);
+    } else {
       int idx, idy;
       int bw = 1 << b_width_log2(mi->sb_type);
       int bh = 1 << b_height_log2(mi->sb_type);
       for (idy = 0; idy < 2; idy += bh)
         for (idx = 0; idx < 2; idx += bw)
-          write_sb_ymode(bc, m->bmi[idy * 2 + idx].as_mode.first,
-                         pc->fc.sb_ymode_prob);
+          write_intra_mode(bc, m->bmi[idy * 2 + idx].as_mode.first,
+                           pc->fc.y_mode_prob);
     }
-    write_uv_mode(bc, mi->uv_mode,
-                  pc->fc.uv_mode_prob[mode]);
+    write_intra_mode(bc, mi->uv_mode,
+                     pc->fc.uv_mode_prob[mode]);
   } else {
     vp9_prob mv_ref_p[VP9_MVREFS - 1];
 
@@ -855,10 +831,8 @@ static void write_mb_modes_kf(const VP9_COMP *cpi,
     const MB_PREDICTION_MODE A = above_block_mode(m, 0, mis);
     const MB_PREDICTION_MODE L = xd->left_available ?
                                  left_block_mode(m, 0) : DC_PRED;
-    write_kf_bmode(bc, ym, c->kf_bmode_prob[A][L]);
-  }
-
-  if (m->mbmi.sb_type < BLOCK_SIZE_SB8X8) {
+    write_intra_mode(bc, ym, c->kf_y_mode_prob[A][L]);
+  } else {
     int idx, idy;
     int bw = 1 << b_width_log2(m->mbmi.sb_type);
     int bh = 1 << b_height_log2(m->mbmi.sb_type);
@@ -872,12 +846,12 @@ static void write_mb_modes_kf(const VP9_COMP *cpi,
 #ifdef ENTROPY_STATS
         ++intra_mode_stats[A][L][bm];
 #endif
-        write_kf_bmode(bc, bm, c->kf_bmode_prob[A][L]);
+        write_intra_mode(bc, bm, c->kf_y_mode_prob[A][L]);
       }
     }
   }
 
-  write_uv_mode(bc, m->mbmi.uv_mode, c->kf_uv_mode_prob[ym]);
+  write_intra_mode(bc, m->mbmi.uv_mode, c->kf_uv_mode_prob[ym]);
 }
 
 static void write_modes_b(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc,
@@ -1290,33 +1264,6 @@ static void update_coef_probs(VP9_COMP* const cpi, vp9_writer* const bc) {
   }
 }
 
-static void decide_kf_ymode_entropy(VP9_COMP *cpi) {
-  int mode_cost[MB_MODE_COUNT];
-  int bestcost = INT_MAX;
-  int bestindex = 0;
-  int i, j;
-
-  for (i = 0; i < 8; i++) {
-    int cost = 0;
-
-    vp9_cost_tokens(mode_cost, cpi->common.kf_ymode_prob[i], vp9_kf_ymode_tree);
-
-    for (j = 0; j < VP9_YMODES; j++)
-      cost += mode_cost[j] * cpi->ymode_count[j];
-
-    vp9_cost_tokens(mode_cost, cpi->common.sb_kf_ymode_prob[i],
-                    vp9_sb_ymode_tree);
-    for (j = 0; j < VP9_I32X32_MODES; j++)
-      cost += mode_cost[j] * cpi->sb_ymode_count[j];
-
-    if (cost < bestcost) {
-      bestindex = i;
-      bestcost = cost;
-    }
-  }
-  cpi->common.kf_ymode_probs_index = bestindex;
-
-}
 static void segment_reference_frames(VP9_COMP *cpi) {
   VP9_COMMON *oci = &cpi->common;
   MODE_INFO *mi = oci->mi;
@@ -1734,10 +1681,8 @@ void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, unsigned long *size) {
   vp9_copy(cpi->common.fc.pre_coef_probs_32x32,
            cpi->common.fc.coef_probs_32x32);
 
-  vp9_copy(cpi->common.fc.pre_sb_ymode_prob, cpi->common.fc.sb_ymode_prob);
-  vp9_copy(cpi->common.fc.pre_ymode_prob, cpi->common.fc.ymode_prob);
+  vp9_copy(cpi->common.fc.pre_y_mode_prob, cpi->common.fc.y_mode_prob);
   vp9_copy(cpi->common.fc.pre_uv_mode_prob, cpi->common.fc.uv_mode_prob);
-  vp9_copy(cpi->common.fc.pre_bmode_prob, cpi->common.fc.bmode_prob);
   vp9_copy(cpi->common.fc.pre_partition_prob, cpi->common.fc.partition_prob);
   cpi->common.fc.pre_nmvc = cpi->common.fc.nmvc;
   vp9_zero(cpi->common.fc.mv_ref_ct);
@@ -1753,11 +1698,7 @@ void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, unsigned long *size) {
     vp9_write_prob(&header_bc, pc->mbskip_pred_probs[i]);
   }
 
-  if (pc->frame_type == KEY_FRAME) {
-    if (!pc->kf_ymode_probs_update) {
-      vp9_write_literal(&header_bc, pc->kf_ymode_probs_index, 3);
-    }
-  } else {
+  if (pc->frame_type != KEY_FRAME) {
     // Update the probabilities used to encode reference frame data
     update_ref_probs(cpi);
 
@@ -1829,14 +1770,6 @@ void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, unsigned long *size) {
   vp9_wb_write_literal(&first_partition_size_wb, header_bc.pos, 16);
   *size = bytes_packed + header_bc.pos;
 
-  if (pc->frame_type == KEY_FRAME) {
-    decide_kf_ymode_entropy(cpi);
-  } else {
-    /* This is not required if the counts in cpi are consistent with the
-     * final packing pass */
-    // if (!cpi->dummy_packing) vp9_zero(cpi->NMVcount);
-  }
-
   {
     int tile_row, tile_col, total_size = 0;
     unsigned char *data_ptr = cx_data + header_bc.pos;
diff --git a/vp9/encoder/vp9_block.h b/vp9/encoder/vp9_block.h
index cf34cc1f7..a57d3efd3 100644
--- a/vp9/encoder/vp9_block.h
+++ b/vp9/encoder/vp9_block.h
@@ -114,9 +114,9 @@ struct macroblock {
   int *nmvsadcost_hp[2];
   int **mvsadcost;
 
-  int mbmode_cost[2][MB_MODE_COUNT];
+  int mbmode_cost[MB_MODE_COUNT];
   int intra_uv_mode_cost[2][MB_MODE_COUNT];
-  int bmode_costs[VP9_BINTRAMODES][VP9_BINTRAMODES][VP9_BINTRAMODES];
+  int y_mode_costs[VP9_BINTRAMODES][VP9_BINTRAMODES][VP9_BINTRAMODES];
   int switchable_interp_costs[VP9_SWITCHABLE_FILTERS + 1]
                              [VP9_SWITCHABLE_FILTERS];
 
diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c
index fb8a790f5..e67c0fed0 100644
--- a/vp9/encoder/vp9_encodeframe.c
+++ b/vp9/encoder/vp9_encodeframe.c
@@ -1090,11 +1090,9 @@ static void init_encode_frame_mb_context(VP9_COMP *cpi) {
   xd->mode_info_context->mbmi.uv_mode = DC_PRED;
 
   vp9_zero(cpi->count_mb_ref_frame_usage)
-  vp9_zero(cpi->bmode_count)
-  vp9_zero(cpi->ymode_count)
+  vp9_zero(cpi->y_mode_count)
   vp9_zero(cpi->y_uv_mode_count)
   vp9_zero(cpi->common.fc.mv_ref_ct)
-  vp9_zero(cpi->sb_ymode_count)
   vp9_zero(cpi->partition_count);
 
   // Note: this memset assumes above_context[0], [1] and [2]
@@ -1545,20 +1543,17 @@ static void sum_intra_stats(VP9_COMP *cpi, MACROBLOCK *x) {
   const MB_PREDICTION_MODE m = xd->mode_info_context->mbmi.mode;
   const MB_PREDICTION_MODE uvm = xd->mode_info_context->mbmi.uv_mode;
 
+  ++cpi->y_uv_mode_count[m][uvm];
   if (xd->mode_info_context->mbmi.sb_type >= BLOCK_SIZE_SB8X8) {
-    ++cpi->sb_ymode_count[m];
+    ++cpi->y_mode_count[m];
   } else {
-    ++cpi->ymode_count[m];
-  }
-    ++cpi->y_uv_mode_count[m][uvm];
-  if (m == I4X4_PRED) {
     int idx, idy;
     int bw = 1 << b_width_log2(xd->mode_info_context->mbmi.sb_type);
     int bh = 1 << b_height_log2(xd->mode_info_context->mbmi.sb_type);
     for (idy = 0; idy < 2; idy += bh) {
       for (idx = 0; idx < 2; idx += bw) {
         int m = xd->mode_info_context->bmi[idy * 2 + idx].as_mode.first;
-        ++cpi->sb_ymode_count[m];
+        ++cpi->y_mode_count[m];
       }
     }
   }
diff --git a/vp9/encoder/vp9_modecosts.c b/vp9/encoder/vp9_modecosts.c
index 67658f575..407ebe115 100644
--- a/vp9/encoder/vp9_modecosts.c
+++ b/vp9/encoder/vp9_modecosts.c
@@ -17,26 +17,23 @@
 
 void vp9_init_mode_costs(VP9_COMP *c) {
   VP9_COMMON *x = &c->common;
-  const vp9_tree_p KT = vp9_bmode_tree;
+  const vp9_tree_p KT = vp9_intra_mode_tree;
   int i, j;
 
   for (i = 0; i < VP9_BINTRAMODES; i++) {
     for (j = 0; j < VP9_BINTRAMODES; j++) {
-      vp9_cost_tokens((int *)c->mb.bmode_costs[i][j],
-                      x->kf_bmode_prob[i][j], KT);
+      vp9_cost_tokens((int *)c->mb.y_mode_costs[i][j],
+                      x->kf_y_mode_prob[i][j], KT);
     }
   }
 
   // TODO(rbultje) separate tables for superblock costing?
-  vp9_cost_tokens(c->mb.mbmode_cost[1], x->fc.sb_ymode_prob,
-                  vp9_sb_ymode_tree);
-  vp9_cost_tokens(c->mb.mbmode_cost[0],
-                  x->sb_kf_ymode_prob[c->common.kf_ymode_probs_index],
-                  vp9_sb_ymode_tree);
+  vp9_cost_tokens(c->mb.mbmode_cost, x->fc.y_mode_prob,
+                  vp9_intra_mode_tree);
   vp9_cost_tokens(c->mb.intra_uv_mode_cost[1],
-                  x->fc.uv_mode_prob[VP9_YMODES - 1], vp9_uv_mode_tree);
+                  x->fc.uv_mode_prob[VP9_YMODES - 1], vp9_intra_mode_tree);
   vp9_cost_tokens(c->mb.intra_uv_mode_cost[0],
-                  x->kf_uv_mode_prob[VP9_YMODES - 1], vp9_uv_mode_tree);
+                  x->kf_uv_mode_prob[VP9_YMODES - 1], vp9_intra_mode_tree);
 
   for (i = 0; i <= VP9_SWITCHABLE_FILTERS; ++i)
     vp9_cost_tokens((int *)c->mb.switchable_interp_costs[i],
diff --git a/vp9/encoder/vp9_onyx_if.c b/vp9/encoder/vp9_onyx_if.c
index d9c34fe9b..a38adaade 100644
--- a/vp9/encoder/vp9_onyx_if.c
+++ b/vp9/encoder/vp9_onyx_if.c
@@ -3205,10 +3205,8 @@ static void encode_frame_to_data_rate(VP9_COMP *cpi,
   }
 
   if (cpi->common.frame_type != KEY_FRAME) {
-    vp9_copy(cpi->common.fc.sb_ymode_counts, cpi->sb_ymode_count);
-    vp9_copy(cpi->common.fc.ymode_counts, cpi->ymode_count);
+    vp9_copy(cpi->common.fc.y_mode_counts, cpi->y_mode_count);
     vp9_copy(cpi->common.fc.uv_mode_counts, cpi->y_uv_mode_count);
-    vp9_copy(cpi->common.fc.bmode_counts, cpi->bmode_count);
     vp9_copy(cpi->common.fc.partition_counts, cpi->partition_count);
     cpi->common.fc.NMVcount = cpi->NMVcount;
     if (!cpi->common.error_resilient_mode &&
diff --git a/vp9/encoder/vp9_onyx_int.h b/vp9/encoder/vp9_onyx_int.h
index 24a2acbd5..da3179aa2 100644
--- a/vp9/encoder/vp9_onyx_int.h
+++ b/vp9/encoder/vp9_onyx_int.h
@@ -81,10 +81,8 @@ typedef struct {
   vp9_coeff_probs_model coef_probs_16x16[BLOCK_TYPES];
   vp9_coeff_probs_model coef_probs_32x32[BLOCK_TYPES];
 
-  vp9_prob sb_ymode_prob[VP9_I32X32_MODES - 1];
-  vp9_prob ymode_prob[VP9_YMODES - 1]; /* interframe intra mode probs */
+  vp9_prob y_mode_prob[VP9_YMODES - 1]; /* interframe intra mode probs */
   vp9_prob uv_mode_prob[VP9_YMODES][VP9_UV_MODES - 1];
-  vp9_prob bmode_prob[VP9_BINTRAMODES - 1];
   vp9_prob partition_prob[NUM_PARTITION_CONTEXTS][PARTITION_TYPES - 1];
 
   vp9_prob switchable_interp_prob[VP9_SWITCHABLE_FILTERS + 1]
@@ -413,9 +411,7 @@ typedef struct VP9_COMP {
 
   int cq_target_quality;
 
-  int sb_ymode_count [VP9_I32X32_MODES];
-  int ymode_count[VP9_YMODES];        /* intra MB type cts this frame */
-  int bmode_count[VP9_BINTRAMODES];
+  int y_mode_count[VP9_YMODES];
   int y_uv_mode_count[VP9_YMODES][VP9_UV_MODES];
   unsigned int partition_count[NUM_PARTITION_CONTEXTS][PARTITION_TYPES];
 
diff --git a/vp9/encoder/vp9_ratectrl.c b/vp9/encoder/vp9_ratectrl.c
index cf1132e3a..f4426adaa 100644
--- a/vp9/encoder/vp9_ratectrl.c
+++ b/vp9/encoder/vp9_ratectrl.c
@@ -124,9 +124,7 @@ void vp9_save_coding_context(VP9_COMP *cpi) {
 
   vp9_copy(cc->vp9_mode_contexts, cm->fc.vp9_mode_contexts);
 
-  vp9_copy(cc->ymode_prob, cm->fc.ymode_prob);
-  vp9_copy(cc->sb_ymode_prob, cm->fc.sb_ymode_prob);
-  vp9_copy(cc->bmode_prob, cm->fc.bmode_prob);
+  vp9_copy(cc->y_mode_prob, cm->fc.y_mode_prob);
   vp9_copy(cc->uv_mode_prob, cm->fc.uv_mode_prob);
   vp9_copy(cc->partition_prob, cm->fc.partition_prob);
 
@@ -163,9 +161,7 @@ void vp9_restore_coding_context(VP9_COMP *cpi) {
 
   vp9_copy(cm->fc.vp9_mode_contexts, cc->vp9_mode_contexts);
 
-  vp9_copy(cm->fc.ymode_prob, cc->ymode_prob);
-  vp9_copy(cm->fc.sb_ymode_prob, cc->sb_ymode_prob);
-  vp9_copy(cm->fc.bmode_prob, cc->bmode_prob);
+  vp9_copy(cm->fc.y_mode_prob, cc->y_mode_prob);
   vp9_copy(cm->fc.uv_mode_prob, cc->uv_mode_prob);
   vp9_copy(cm->fc.partition_prob, cc->partition_prob);
 
diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c
index 87d560d4d..f30d07270 100644
--- a/vp9/encoder/vp9_rdopt.c
+++ b/vp9/encoder/vp9_rdopt.c
@@ -264,7 +264,6 @@ void vp9_initialize_rd_consts(VP9_COMP *cpi, int qindex) {
                     vp9_partition_tree);
 
   /*rough estimate for costing*/
-  cpi->common.kf_ymode_probs_index = cpi->common.base_qindex >> 4;
   vp9_init_mode_costs(cpi);
 
   if (cpi->common.frame_type != KEY_FRAME) {
@@ -676,10 +675,7 @@ static int64_t rd_pick_intra4x4block(VP9_COMP *cpi, MACROBLOCK *x, int ib,
     int64_t this_rd;
     int ratey = 0;
 
-    if (cm->frame_type == KEY_FRAME)
-      rate = bmode_costs[mode];
-    else
-      rate = x->mbmode_cost[cm->frame_type][mode];
+    rate = bmode_costs[mode];
     distortion = 0;
 
     vpx_memcpy(tempa, ta, sizeof(ta));
@@ -792,7 +788,7 @@ static int64_t rd_pick_intra4x4mby_modes(VP9_COMP *cpi, MACROBLOCK *mb,
   vpx_memcpy(t_left, xd->plane[0].left_context, sizeof(t_left));
 
   xd->mode_info_context->mbmi.mode = I4X4_PRED;
-  bmode_costs = mb->mbmode_cost[cpi->common.frame_type];
+  bmode_costs = mb->mbmode_cost;
 
   for (idy = 0; idy < 2; idy += bh) {
     for (idx = 0; idx < 2; idx += bw) {
@@ -808,7 +804,7 @@ static int64_t rd_pick_intra4x4mby_modes(VP9_COMP *cpi, MACROBLOCK *mb,
         const MB_PREDICTION_MODE L = (xd->left_available || idx) ?
                                      left_block_mode(mic, i) : DC_PRED;
 
-        bmode_costs  = mb->bmode_costs[A][L];
+        bmode_costs  = mb->y_mode_costs[A][L];
       }
 
       total_rd += rd_pick_intra4x4block(cpi, mb, i, &best_mode, bmode_costs,
@@ -852,6 +848,7 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
   int64_t best_rd = INT64_MAX, this_rd;
   TX_SIZE UNINITIALIZED_IS_SAFE(best_tx);
   int i;
+  int *bmode_costs = x->mbmode_cost;
 
   if (bsize < BLOCK_SIZE_SB8X8) {
     x->e_mbd.mode_info_context->mbmi.txfm_size = TX_4X4;
@@ -866,11 +863,14 @@ static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
     int64_t local_txfm_cache[NB_TXFM_MODES];
     MODE_INFO *const mic = xd->mode_info_context;
     const int mis = xd->mode_info_stride;
-    const MB_PREDICTION_MODE A = above_block_mode(mic, 0, mis);
-    const MB_PREDICTION_MODE L = xd->left_available ?
-                                 left_block_mode(mic, 0) : DC_PRED;
 
-    int *bmode_costs  = x->bmode_costs[A][L];
+    if (cpi->common.frame_type == KEY_FRAME) {
+      const MB_PREDICTION_MODE A = above_block_mode(mic, 0, mis);
+      const MB_PREDICTION_MODE L = xd->left_available ?
+                                   left_block_mode(mic, 0) : DC_PRED;
+
+      bmode_costs = x->y_mode_costs[A][L];
+    }
 
     x->e_mbd.mode_info_context->mbmi.mode = mode;
     vp9_build_intra_predictors_sby_s(&x->e_mbd, bsize);
@@ -2767,7 +2767,7 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
       skippable = skippable && skip_uv[uv_tx];
       mbmi->uv_mode = mode_uv[uv_tx];
 
-      rate2 = rate_y + x->mbmode_cost[cm->frame_type][mbmi->mode] + rate_uv;
+      rate2 = rate_y + x->mbmode_cost[mbmi->mode] + rate_uv;
       if (mbmi->mode != DC_PRED && mbmi->mode != TM_PRED)
         rate2 += intra_cost_penalty;
       distortion2 = distortion_y + distortion_uv;