diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index b13d16f..3f24901 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -96,17 +96,16 @@
 }
 
 static void write_drl_idx(FRAME_CONTEXT *ec_ctx, const MB_MODE_INFO *mbmi,
-                          const MB_MODE_INFO_EXT *mbmi_ext, aom_writer *w) {
-  uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
-
+                          const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame,
+                          aom_writer *w) {
   assert(mbmi->ref_mv_idx < 3);
 
   const int new_mv = mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV;
   if (new_mv) {
     int idx;
     for (idx = 0; idx < 2; ++idx) {
-      if (mbmi_ext->ref_mv_count[ref_frame_type] > idx + 1) {
-        uint8_t drl_ctx = av1_drl_ctx(mbmi_ext->weight[ref_frame_type], idx);
+      if (mbmi_ext_frame->ref_mv_count > idx + 1) {
+        uint8_t drl_ctx = av1_drl_ctx(mbmi_ext_frame->weight, idx);
 
         aom_write_symbol(w, mbmi->ref_mv_idx != idx, ec_ctx->drl_cdf[drl_ctx],
                          2);
@@ -120,8 +119,8 @@
     int idx;
     // TODO(jingning): Temporary solution to compensate the NEARESTMV offset.
     for (idx = 1; idx < 3; ++idx) {
-      if (mbmi_ext->ref_mv_count[ref_frame_type] > idx + 1) {
-        uint8_t drl_ctx = av1_drl_ctx(mbmi_ext->weight[ref_frame_type], idx);
+      if (mbmi_ext_frame->ref_mv_count > idx + 1) {
+        uint8_t drl_ctx = av1_drl_ctx(mbmi_ext_frame->weight, idx);
         aom_write_symbol(w, mbmi->ref_mv_idx != (idx - 1),
                          ec_ctx->drl_cdf[drl_ctx], 2);
         if (mbmi->ref_mv_idx == (idx - 1)) return;
@@ -369,9 +368,9 @@
   if (tx_size == plane_tx_size || plane) {
     const CB_COEFF_BUFFER *cb_coef_buff = x->cb_coef_buff;
     const int txb_offset =
-        x->mbmi_ext->cb_offset / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
+        x->mbmi_ext_frame->cb_offset / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
     const tran_low_t *tcoeff_txb =
-        cb_coef_buff->tcoeff[plane] + x->mbmi_ext->cb_offset;
+        cb_coef_buff->tcoeff[plane] + x->mbmi_ext_frame->cb_offset;
     const uint16_t *eob_txb = cb_coef_buff->eobs[plane] + txb_offset;
     const uint8_t *txb_skip_ctx_txb =
         cb_coef_buff->txb_skip_ctx[plane] + txb_offset;
@@ -1032,27 +1031,22 @@
 }
 
 static INLINE int16_t mode_context_analyzer(
-    const int16_t *const mode_context, const MV_REFERENCE_FRAME *const rf) {
-  const int8_t ref_frame = av1_ref_frame_type(rf);
+    const int16_t mode_context, const MV_REFERENCE_FRAME *const rf) {
+  if (rf[1] <= INTRA_FRAME) return mode_context;
 
-  if (rf[1] <= INTRA_FRAME) return mode_context[ref_frame];
-
-  const int16_t newmv_ctx = mode_context[ref_frame] & NEWMV_CTX_MASK;
-  const int16_t refmv_ctx =
-      (mode_context[ref_frame] >> REFMV_OFFSET) & REFMV_CTX_MASK;
+  const int16_t newmv_ctx = mode_context & NEWMV_CTX_MASK;
+  const int16_t refmv_ctx = (mode_context >> REFMV_OFFSET) & REFMV_CTX_MASK;
 
   const int16_t comp_ctx = compound_mode_ctx_map[refmv_ctx >> 1][AOMMIN(
       newmv_ctx, COMP_NEWMV_CTXS - 1)];
   return comp_ctx;
 }
 
-static INLINE int_mv get_ref_mv_from_stack(int ref_idx,
-                                           const MV_REFERENCE_FRAME *ref_frame,
-                                           int ref_mv_idx,
-                                           const MB_MODE_INFO_EXT *mbmi_ext) {
+static INLINE int_mv get_ref_mv_from_stack(
+    int ref_idx, const MV_REFERENCE_FRAME *ref_frame, int ref_mv_idx,
+    const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame) {
   const int8_t ref_frame_type = av1_ref_frame_type(ref_frame);
-  const CANDIDATE_MV *curr_ref_mv_stack =
-      mbmi_ext->ref_mv_stack[ref_frame_type];
+  const CANDIDATE_MV *curr_ref_mv_stack = mbmi_ext_frame->ref_mv_stack;
 
   if (ref_frame[1] > INTRA_FRAME) {
     assert(ref_idx == 0 || ref_idx == 1);
@@ -1061,9 +1055,9 @@
   }
 
   assert(ref_idx == 0);
-  return ref_mv_idx < mbmi_ext->ref_mv_count[ref_frame_type]
+  return ref_mv_idx < mbmi_ext_frame->ref_mv_count
              ? curr_ref_mv_stack[ref_mv_idx].this_mv
-             : mbmi_ext->global_mvs[ref_frame_type];
+             : mbmi_ext_frame->global_mvs[ref_frame_type];
 }
 
 static INLINE int_mv get_ref_mv(const MACROBLOCK *x, int ref_idx) {
@@ -1075,7 +1069,7 @@
     ref_mv_idx += 1;
   }
   return get_ref_mv_from_stack(ref_idx, mbmi->ref_frame, ref_mv_idx,
-                               x->mbmi_ext);
+                               x->mbmi_ext_frame);
 }
 
 static void pack_inter_mode_mvs(AV1_COMP *cpi, const int mi_row,
@@ -1087,7 +1081,7 @@
   const struct segmentation *const seg = &cm->seg;
   struct segmentation_probs *const segp = &ec_ctx->seg;
   const MB_MODE_INFO *const mbmi = xd->mi[0];
-  const MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
+  const MB_MODE_INFO_EXT_FRAME *const mbmi_ext_frame = x->mbmi_ext_frame;
   const PREDICTION_MODE mode = mbmi->mode;
   const int segment_id = mbmi->segment_id;
   const BLOCK_SIZE bsize = mbmi->sb_type;
@@ -1123,7 +1117,8 @@
 
     write_ref_frames(cm, xd, w);
 
-    mode_ctx = mode_context_analyzer(mbmi_ext->mode_context, mbmi->ref_frame);
+    mode_ctx =
+        mode_context_analyzer(mbmi_ext_frame->mode_context, mbmi->ref_frame);
 
     // If segment skip is not enabled code the mode.
     if (!segfeature_active(seg, segment_id, SEG_LVL_SKIP)) {
@@ -1133,7 +1128,7 @@
         write_inter_mode(w, mode, ec_ctx, mode_ctx);
 
       if (mode == NEWMV || mode == NEW_NEWMV || have_nearmv_in_inter_mode(mode))
-        write_drl_idx(ec_ctx, mbmi, mbmi_ext, w);
+        write_drl_idx(ec_ctx, mbmi, mbmi_ext_frame, w);
       else
         assert(mbmi->ref_mv_idx == 0);
     }
@@ -1235,7 +1230,7 @@
 }
 
 static void write_intrabc_info(MACROBLOCKD *xd,
-                               const MB_MODE_INFO_EXT *mbmi_ext,
+                               const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame,
                                aom_writer *w) {
   const MB_MODE_INFO *const mbmi = xd->mi[0];
   int use_intrabc = is_intrabc_block(mbmi);
@@ -1245,13 +1240,13 @@
     assert(mbmi->mode == DC_PRED);
     assert(mbmi->uv_mode == UV_DC_PRED);
     assert(mbmi->motion_mode == SIMPLE_TRANSLATION);
-    int_mv dv_ref = mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv;
+    int_mv dv_ref = mbmi_ext_frame->ref_mv_stack[0].this_mv;
     av1_encode_dv(w, &mbmi->mv[0].as_mv, &dv_ref.as_mv, &ec_ctx->ndvc);
   }
 }
 
 static void write_mb_modes_kf(AV1_COMP *cpi, MACROBLOCKD *xd,
-                              const MB_MODE_INFO_EXT *mbmi_ext,
+                              const MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame,
                               const int mi_row, const int mi_col,
                               aom_writer *w) {
   AV1_COMMON *const cm = &cpi->common;
@@ -1273,7 +1268,7 @@
   write_delta_q_params(cpi, mi_row, mi_col, skip, w);
 
   if (av1_allow_intrabc(cm)) {
-    write_intrabc_info(xd, mbmi_ext, w);
+    write_intrabc_info(xd, mbmi_ext_frame, w);
     if (is_intrabc_block(mbmi)) return;
   }
 
@@ -1319,10 +1314,10 @@
 #if ENC_MISMATCH_DEBUG
 static void enc_dump_logs(AV1_COMP *cpi, int mi_row, int mi_col) {
   AV1_COMMON *const cm = &cpi->common;
-  const MB_MODE_INFO *const *mbmi =
+  const MB_MODE_INFO *const mbmi =
       *(cm->mi_grid_base + (mi_row * cm->mi_stride + mi_col));
-  const MB_MODE_INFO_EXT *const *mbmi_ext =
-      cpi->mbmi_ext_base + get_mi_ext_idx(cm, mi_row, mi_col);
+  const MB_MODE_INFO_EXT_FRAME *const mbmi_ext_frame_base =
+      cpi->mbmi_ext_frame_base + get_mi_ext_idx(cm, mi_row, mi_col);
   if (is_inter_block(mbmi)) {
 #define FRAME_TO_CHECK 11
     if (cm->current_frame.frame_number == FRAME_TO_CHECK &&
@@ -1340,9 +1335,9 @@
       }
 
       const int16_t mode_ctx =
-          is_comp_ref
-              ? 0
-              : mode_context_analyzer(mbmi_ext->mode_context, mbmi->ref_frame);
+          is_comp_ref ? 0
+                      : mode_context_analyzer(mbmi_ext_frame->mode_context,
+                                              mbmi->ref_frame);
 
       const int16_t newmv_ctx = mode_ctx & NEWMV_CTX_MASK;
       int16_t zeromv_ctx = -1;
@@ -1376,7 +1371,7 @@
   MB_MODE_INFO *m = xd->mi[0];
 
   if (frame_is_intra_only(cm)) {
-    write_mb_modes_kf(cpi, xd, cpi->td.mb.mbmi_ext, mi_row, mi_col, w);
+    write_mb_modes_kf(cpi, xd, cpi->td.mb.mbmi_ext_frame, mi_row, mi_col, w);
   } else {
     // has_subpel_mv_component needs the ref frame buffers set up to look
     // up if they are scaled. has_subpel_mv_component is in turn needed by
@@ -1508,7 +1503,8 @@
   const AV1_COMMON *cm = &cpi->common;
   MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
   xd->mi = cm->mi_grid_base + (mi_row * cm->mi_stride + mi_col);
-  cpi->td.mb.mbmi_ext = cpi->mbmi_ext_base + get_mi_ext_idx(cm, mi_row, mi_col);
+  cpi->td.mb.mbmi_ext_frame =
+      cpi->mbmi_ext_frame_base + get_mi_ext_idx(cm, mi_row, mi_col);
 
   const MB_MODE_INFO *mbmi = xd->mi[0];
   const BLOCK_SIZE bsize = mbmi->sb_type;
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 503889e..468de1a 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -87,11 +87,24 @@
   CANDIDATE_MV ref_mv_stack[MODE_CTX_REF_FRAMES][MAX_REF_MV_STACK_SIZE];
   uint16_t weight[MODE_CTX_REF_FRAMES][MAX_REF_MV_STACK_SIZE];
   int_mv global_mvs[REF_FRAMES];
+  // TODO(Ravi/Remya): Check if this variable is still needed at block level
   int cb_offset;
   int16_t mode_context[MODE_CTX_REF_FRAMES];
   uint8_t ref_mv_count[MODE_CTX_REF_FRAMES];
 } MB_MODE_INFO_EXT;
 
+// Structure to store winner reference mode information at frame level. This
+// frame level information will be used during bitstream preparation stage.
+typedef struct {
+  CANDIDATE_MV ref_mv_stack[MAX_REF_MV_STACK_SIZE];
+  uint16_t weight[MAX_REF_MV_STACK_SIZE];
+  // TODO(Ravi/Remya): Reduce the buffer size of global_mvs
+  int_mv global_mvs[REF_FRAMES];
+  int cb_offset;
+  int16_t mode_context;
+  uint8_t ref_mv_count;
+} MB_MODE_INFO_EXT_FRAME;
+
 typedef struct {
   int col_min;
   int col_max;
@@ -226,6 +239,7 @@
 
   MACROBLOCKD e_mbd;
   MB_MODE_INFO_EXT *mbmi_ext;
+  MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame;
   int skip_block;
   int qindex;
 
diff --git a/av1/encoder/encode_strategy.c b/av1/encoder/encode_strategy.c
index e15f879..8803cac 100644
--- a/av1/encoder/encode_strategy.c
+++ b/av1/encoder/encode_strategy.c
@@ -999,7 +999,6 @@
 
   xd->mi = cm->mi_grid_base;
   xd->mi[0] = cm->mi;
-  x->mbmi_ext = cpi->mbmi_ext_base;
 }
 
 // Apply temporal filtering to key frames and encode the filtered frame.
@@ -1046,7 +1045,8 @@
     setup_mi(cpi, frame_input->source);
     av1_init_macroblockd(cm, xd, NULL);
     const int ext_mi_size = cm->mi_alloc_rows * cm->mi_alloc_cols;
-    memset(cpi->mbmi_ext_base, 0, ext_mi_size * sizeof(*cpi->mbmi_ext_base));
+    memset(cpi->mbmi_ext_frame_base, 0,
+           ext_mi_size * sizeof(*cpi->mbmi_ext_frame_base));
 
     av1_set_speed_features_framesize_independent(cpi, oxcf->speed);
     av1_set_speed_features_framesize_dependent(cpi, oxcf->speed);
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 630ab96..4e587a7 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -577,6 +577,25 @@
   return 0 && !frame_is_intra_only(&cpi->common);
 }
 
+// This function will copy the winner reference mode information from block
+// level (x->mbmi_ext) to frame level (cpi->mbmi_ext_frame_base). This frame
+// level buffer (cpi->mbmi_ext_frame_base) will be used during bitstream
+// preparation.
+static INLINE void copy_winner_ref_mode_from_mbmi_ext(MACROBLOCK *const x) {
+  MACROBLOCKD *const xd = &x->e_mbd;
+  MB_MODE_INFO *mbmi = xd->mi[0];
+  uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
+  memcpy(x->mbmi_ext_frame->ref_mv_stack,
+         x->mbmi_ext->ref_mv_stack[ref_frame_type],
+         sizeof(x->mbmi_ext->ref_mv_stack[MAX_REF_MV_STACK_SIZE]));
+  memcpy(x->mbmi_ext_frame->weight, x->mbmi_ext->weight[ref_frame_type],
+         sizeof(x->mbmi_ext->weight[MAX_REF_MV_STACK_SIZE]));
+  x->mbmi_ext_frame->mode_context = x->mbmi_ext->mode_context[ref_frame_type];
+  x->mbmi_ext_frame->ref_mv_count = x->mbmi_ext->ref_mv_count[ref_frame_type];
+  memcpy(x->mbmi_ext_frame->global_mvs, x->mbmi_ext->global_mvs,
+         sizeof(x->mbmi_ext->global_mvs));
+}
+
 static void pick_sb_modes(AV1_COMP *const cpi, TileDataEnc *tile_data,
                           MACROBLOCK *const x, int mi_row, int mi_col,
                           RD_STATS *rd_cost, PARTITION_TYPE partition,
@@ -1441,6 +1460,7 @@
 
   if (!dry_run) {
     x->mbmi_ext->cb_offset = x->cb_offset;
+    x->mbmi_ext_frame->cb_offset = x->cb_offset;
     assert(x->cb_offset <
            (1 << num_pels_log2_lookup[cpi->common.seq_params.sb_size]));
   }
@@ -1522,7 +1542,8 @@
       update_stats(&cpi->common, td, mi_row, mi_col);
     }
   }
-
+  // TODO(Ravi/Remya): Move this copy function to a better logical place
+  copy_winner_ref_mode_from_mbmi_ext(x);
   x->rdmult = origin_mult;
 }
 
@@ -3912,6 +3933,7 @@
   const int mib_size = cm->seq_params.mib_size;
   const int mib_size_log2 = cm->seq_params.mib_size_log2;
   const int sb_row = (mi_row - tile_info->mi_row_start) >> mib_size_log2;
+  int sb_mi_size = av1_get_sb_mi_size(cm);
 
 #if CONFIG_COLLECT_COMPONENT_TIMING
   start_timing(cpi, encode_sb_time);
@@ -3933,6 +3955,7 @@
   // Code each SB in the row
   for (int mi_col = tile_info->mi_col_start, sb_col_in_tile = 0;
        mi_col < tile_info->mi_col_end; mi_col += mib_size, sb_col_in_tile++) {
+    memset(x->mbmi_ext, 0, sb_mi_size * sizeof(*x->mbmi_ext));
     (*(cpi->row_mt_sync_read_ptr))(&tile_data->row_mt_sync, sb_row,
                                    sb_col_in_tile);
     if (tile_data->allow_update_cdf && (cpi->row_mt == 1) &&
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index f2ea5bf..1cca1a5 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -458,9 +458,9 @@
 }
 
 static void dealloc_context_buffers_ext(AV1_COMP *cpi) {
-  if (cpi->mbmi_ext_base) {
-    aom_free(cpi->mbmi_ext_base);
-    cpi->mbmi_ext_base = NULL;
+  if (cpi->mbmi_ext_frame_base) {
+    aom_free(cpi->mbmi_ext_frame_base);
+    cpi->mbmi_ext_frame_base = NULL;
   }
 }
 
@@ -470,8 +470,9 @@
 
   if (new_ext_mi_size > cpi->mi_ext_alloc_size) {
     dealloc_context_buffers_ext(cpi);
-    CHECK_MEM_ERROR(cm, cpi->mbmi_ext_base,
-                    aom_calloc(new_ext_mi_size, sizeof(*cpi->mbmi_ext_base)));
+    CHECK_MEM_ERROR(
+        cm, cpi->mbmi_ext_frame_base,
+        aom_calloc(new_ext_mi_size, sizeof(*cpi->mbmi_ext_frame_base)));
     cpi->mi_ext_alloc_size = new_ext_mi_size;
   }
 }
@@ -577,6 +578,9 @@
   aom_free(cm->tpl_mvs);
   cm->tpl_mvs = NULL;
 
+  aom_free(cpi->td.mb.mbmi_ext);
+  cpi->td.mb.mbmi_ext = NULL;
+
   av1_free_ref_frame_buffers(cm->buffer_pool);
   av1_free_txb_buf(cpi);
   av1_free_context_buffers(cm);
@@ -988,7 +992,8 @@
 
   const int ext_mi_size = cm->mi_alloc_rows * cm->mi_alloc_cols;
   alloc_context_buffers_ext(cpi);
-  memset(cpi->mbmi_ext_base, 0, ext_mi_size * sizeof(*cpi->mbmi_ext_base));
+  memset(cpi->mbmi_ext_frame_base, 0,
+         ext_mi_size * sizeof(*cpi->mbmi_ext_frame_base));
   set_tile_info(cpi);
 }
 
@@ -2789,6 +2794,8 @@
   }
 #endif
 
+  int sb_mi_size = av1_get_sb_mi_size(cm);
+
   CHECK_MEM_ERROR(
       cm, cpi->td.mb.above_pred_buf,
       (uint8_t *)aom_memalign(16, MAX_MB_PLANE * MAX_SB_SQUARE *
@@ -2819,6 +2826,9 @@
                   (int32_t *)aom_memalign(
                       16, MAX_SB_SQUARE * sizeof(*cpi->td.mb.mask_buf)));
 
+  CHECK_MEM_ERROR(cm, cpi->td.mb.mbmi_ext,
+                  aom_calloc(sb_mi_size, sizeof(*cpi->td.mb.mbmi_ext)));
+
   av1_set_speed_features_framesize_independent(cpi, oxcf->speed);
   av1_set_speed_features_framesize_dependent(cpi, oxcf->speed);
 
@@ -3227,6 +3237,7 @@
       aom_free(thread_data->td->mask_buf);
       aom_free(thread_data->td->counts);
       av1_free_pc_tree(thread_data->td, num_planes);
+      aom_free(thread_data->td->mbmi_ext);
       aom_free(thread_data->td);
     }
   }
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 87f70de..d511c51 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -627,6 +627,7 @@
   int intrabc_used;
   int deltaq_used;
   FRAME_CONTEXT *tctx;
+  MB_MODE_INFO_EXT *mbmi_ext;
 } ThreadData;
 
 struct EncWorkerData;
@@ -744,7 +745,7 @@
   QUANTS quants;
   ThreadData td;
   FRAME_COUNTS counts;
-  MB_MODE_INFO_EXT *mbmi_ext_base;
+  MB_MODE_INFO_EXT_FRAME *mbmi_ext_frame_base;
   CB_COEFF_BUFFER *coeff_buffer_base;
   Dequants dequants;
   AV1_COMMON common;
@@ -1365,7 +1366,7 @@
   xd->mi = cm->mi_grid_base + grid_idx;
   xd->mi[0] = cm->mi + mi_idx;
 
-  x->mbmi_ext = cpi->mbmi_ext_base + ext_idx;
+  x->mbmi_ext_frame = cpi->mbmi_ext_frame_base + ext_idx;
 }
 
 // Check to see if the given partition size is allowed for a specified number
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index 8431f4b..20956a8 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c
@@ -640,9 +640,9 @@
   MACROBLOCKD *xd = &x->e_mbd;
   const CB_COEFF_BUFFER *cb_coef_buff = x->cb_coef_buff;
   const int txb_offset =
-      x->mbmi_ext->cb_offset / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
+      x->mbmi_ext_frame->cb_offset / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
   const tran_low_t *tcoeff_txb =
-      cb_coef_buff->tcoeff[plane] + x->mbmi_ext->cb_offset;
+      cb_coef_buff->tcoeff[plane] + x->mbmi_ext_frame->cb_offset;
   const uint16_t *eob_txb = cb_coef_buff->eobs[plane] + txb_offset;
   const uint8_t *txb_skip_ctx_txb =
       cb_coef_buff->txb_skip_ctx[plane] + txb_offset;
@@ -2042,7 +2042,7 @@
 
   CB_COEFF_BUFFER *cb_coef_buff = x->cb_coef_buff;
   const int txb_offset =
-      x->mbmi_ext->cb_offset / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
+      x->mbmi_ext_frame->cb_offset / (TX_SIZE_W_MIN * TX_SIZE_H_MIN);
   uint16_t *eob_txb = cb_coef_buff->eobs[plane] + txb_offset;
   uint8_t *txb_skip_ctx_txb = cb_coef_buff->txb_skip_ctx[plane] + txb_offset;
   txb_skip_ctx_txb[block] = txb_ctx.txb_skip_ctx;
@@ -2053,7 +2053,8 @@
     return;
   }
 
-  tran_low_t *tcoeff_txb = cb_coef_buff->tcoeff[plane] + x->mbmi_ext->cb_offset;
+  tran_low_t *tcoeff_txb =
+      cb_coef_buff->tcoeff[plane] + x->mbmi_ext_frame->cb_offset;
   tran_low_t *tcoeff = BLOCK_OFFSET(tcoeff_txb, block);
   const int segment_id = mbmi->segment_id;
   const int seg_eob = av1_get_tx_eob(&cpi->common.seg, segment_id, tx_size);
diff --git a/av1/encoder/ethread.c b/av1/encoder/ethread.c
index 13b5b76..18a2ef3 100644
--- a/av1/encoder/ethread.c
+++ b/av1/encoder/ethread.c
@@ -377,6 +377,7 @@
 static void create_enc_workers(AV1_COMP *cpi, int num_workers) {
   AV1_COMMON *const cm = &cpi->common;
   const AVxWorkerInterface *const winterface = aom_get_worker_interface();
+  int sb_mi_size = av1_get_sb_mi_size(cm);
 
   CHECK_MEM_ERROR(cm, cpi->workers,
                   aom_malloc(num_workers * sizeof(*cpi->workers)));
@@ -467,6 +468,10 @@
                                  sizeof(*thread_data->td->tmp_obmc_bufs[j])));
       }
 
+      CHECK_MEM_ERROR(
+          cm, thread_data->td->mbmi_ext,
+          aom_calloc(sb_mi_size, sizeof(*thread_data->td->mbmi_ext)));
+
       // Create threads
       if (!winterface->reset(worker))
         aom_internal_error(&cm->error, AOM_CODEC_ERROR,
@@ -567,6 +572,7 @@
         }
       }
       thread_data->td->mb.mask_buf = thread_data->td->mask_buf;
+      thread_data->td->mb.mbmi_ext = thread_data->td->mbmi_ext;
     }
     if (thread_data->td->counts != &cpi->counts) {
       memcpy(thread_data->td->counts, &cpi->counts, sizeof(cpi->counts));
diff --git a/av1/encoder/rdopt.h b/av1/encoder/rdopt.h
index 8031bfc..99358c7 100644
--- a/av1/encoder/rdopt.h
+++ b/av1/encoder/rdopt.h
@@ -192,6 +192,19 @@
   return (a - b);
 }
 
+// This function will return number of mi's in a superblock.
+static INLINE int av1_get_sb_mi_size(const AV1_COMMON *const cm) {
+  const int mi_alloc_size_1d = mi_size_wide[cm->mi_alloc_bsize];
+  int sb_mi_rows =
+      (mi_size_wide[cm->seq_params.sb_size] + mi_alloc_size_1d - 1) /
+      mi_alloc_size_1d;
+  assert(mi_size_wide[cm->seq_params.sb_size] ==
+         mi_size_high[cm->seq_params.sb_size]);
+  int sb_mi_size = sb_mi_rows * sb_mi_rows;
+
+  return sb_mi_size;
+}
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif