diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 668b1c5..657a45b 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -774,15 +774,13 @@
 #define TXSIZEMAX(t1, t2) (tx_size_2d[(t1)] >= tx_size_2d[(t2)] ? (t1) : (t2))
 #define TXSIZEMIN(t1, t2) (tx_size_2d[(t1)] <= tx_size_2d[(t2)] ? (t1) : (t2))
 
-static INLINE TX_SIZE get_max_rect_tx_size(BLOCK_SIZE bsize, int is_inter) {
-  (void)is_inter;
+static INLINE TX_SIZE get_max_rect_tx_size(BLOCK_SIZE bsize) {
   return max_txsize_rect_lookup[bsize];
 }
 
-static INLINE TX_SIZE tx_size_from_tx_mode(BLOCK_SIZE bsize, TX_MODE tx_mode,
-                                           int is_inter) {
+static INLINE TX_SIZE tx_size_from_tx_mode(BLOCK_SIZE bsize, TX_MODE tx_mode) {
   const TX_SIZE largest_tx_size = tx_mode_to_biggest_tx_size[tx_mode];
-  const TX_SIZE max_rect_tx_size = get_max_rect_tx_size(bsize, is_inter);
+  const TX_SIZE max_rect_tx_size = get_max_rect_tx_size(bsize);
   if (bsize == BLOCK_4X4)
     return AOMMIN(max_txsize_lookup[bsize], largest_tx_size);
   if (txsize_sqr_map[max_rect_tx_size] <= largest_tx_size)
@@ -805,7 +803,7 @@
 
 static INLINE TX_SIZE av1_max_tx_size_for_filter_intra(BLOCK_SIZE bsize,
                                                        TX_MODE tx_mode) {
-  const TX_SIZE max_tx_size = tx_size_from_tx_mode(bsize, tx_mode, 0);
+  const TX_SIZE max_tx_size = tx_size_from_tx_mode(bsize, tx_mode);
 
   if (tx_mode != TX_MODE_SELECT) return max_tx_size;
 
@@ -956,7 +954,7 @@
                             const int num_planes);
 
 static INLINE int bsize_to_max_depth(BLOCK_SIZE bsize, int is_inter) {
-  TX_SIZE tx_size = get_max_rect_tx_size(bsize, is_inter);
+  TX_SIZE tx_size = get_max_rect_tx_size(bsize);
   int depth = 0;
   while (depth < MAX_TX_DEPTH && tx_size != TX_4X4) {
     depth++;
@@ -966,7 +964,7 @@
 }
 
 static INLINE int bsize_to_tx_size_cat(BLOCK_SIZE bsize, int is_inter) {
-  TX_SIZE tx_size = get_max_rect_tx_size(bsize, is_inter);
+  TX_SIZE tx_size = get_max_rect_tx_size(bsize);
   assert(tx_size != TX_4X4);
   int depth = 0;
   while (tx_size != TX_4X4) {
@@ -980,17 +978,16 @@
 
 static INLINE TX_SIZE depth_to_tx_size(int depth, BLOCK_SIZE bsize,
                                        int is_inter) {
-  TX_SIZE max_tx_size = get_max_rect_tx_size(bsize, is_inter);
+  TX_SIZE max_tx_size = get_max_rect_tx_size(bsize);
   TX_SIZE tx_size = max_tx_size;
   for (int d = 0; d < depth; ++d) tx_size = sub_tx_size_map[is_inter][tx_size];
   return tx_size;
 }
 
-static INLINE TX_SIZE av1_get_max_uv_txsize(BLOCK_SIZE bsize, int is_inter,
-                                            int ss_x, int ss_y) {
+static INLINE TX_SIZE av1_get_max_uv_txsize(BLOCK_SIZE bsize, int ss_x,
+                                            int ss_y) {
   const BLOCK_SIZE plane_bsize = ss_size_lookup[bsize][ss_x][ss_y];
   assert(plane_bsize < BLOCK_SIZES_ALL);
-  (void)is_inter;
   TX_SIZE uv_tx = max_txsize_rect_lookup[plane_bsize];
   switch (uv_tx) {
     case TX_64X64:
@@ -1005,7 +1002,7 @@
 
 static INLINE TX_SIZE av1_get_uv_tx_size(const MB_MODE_INFO *mbmi, int ss_x,
                                          int ss_y) {
-  return av1_get_max_uv_txsize(mbmi->sb_type, is_inter_block(mbmi), ss_x, ss_y);
+  return av1_get_max_uv_txsize(mbmi->sb_type, ss_x, ss_y);
 }
 
 static INLINE TX_SIZE av1_get_tx_size(int plane, const MACROBLOCKD *xd) {
@@ -1078,10 +1075,9 @@
 
 static INLINE int get_vartx_max_txsize(const MACROBLOCKD *xd, BLOCK_SIZE bsize,
                                        int subsampled) {
-  TX_SIZE max_txsize =
-      xd->lossless[xd->mi[0]->mbmi.segment_id]
-          ? TX_4X4
-          : get_max_rect_tx_size(bsize, is_inter_block(&xd->mi[0]->mbmi));
+  TX_SIZE max_txsize = xd->lossless[xd->mi[0]->mbmi.segment_id]
+                           ? TX_4X4
+                           : get_max_rect_tx_size(bsize);
 
 #if CONFIG_EXT_PARTITION
   // The decoder is designed so that it can process 64x64 luma pixels at a
diff --git a/av1/common/pred_common.h b/av1/common/pred_common.h
index 9cbee02..9cd2f07 100644
--- a/av1/common/pred_common.h
+++ b/av1/common/pred_common.h
@@ -319,9 +319,8 @@
 // The mode info data structure has a one element border above and to the
 // left of the entries corresponding to real blocks.
 // The prediction flags in these dummy entries are initialized to 0.
-static INLINE int get_tx_size_context(const MACROBLOCKD *xd, int is_inter) {
+static INLINE int get_tx_size_context(const MACROBLOCKD *xd) {
   const MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
-  (void)is_inter;
   const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
   const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
   const TX_SIZE max_tx_size = max_txsize_rect_lookup[mbmi->sb_type];
diff --git a/av1/common/reconinter.c b/av1/common/reconinter.c
index 1fdec97..0b08503 100644
--- a/av1/common/reconinter.c
+++ b/av1/common/reconinter.c
@@ -2334,7 +2334,7 @@
 #endif
 
   av1_predict_intra_block(
-      cm, xd, pd->width, pd->height, get_max_rect_tx_size(plane_bsize, 0), mode,
+      cm, xd, pd->width, pd->height, get_max_rect_tx_size(plane_bsize), mode,
       ctx->plane[plane], ctx->stride[plane], dst, dst_stride, 0, 0, plane);
 }
 
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index dbdb168..40833bd 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -419,7 +419,7 @@
   const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
   const int32_t tx_size_cat = bsize_to_tx_size_cat(bsize, is_inter);
   const int max_depths = bsize_to_max_depth(bsize, 0);
-  const int ctx = get_tx_size_context(xd, is_inter);
+  const int ctx = get_tx_size_context(xd);
   FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
   const int depth = aom_read_symbol(r, ec_ctx->tx_size_cdf[tx_size_cat][ctx],
                                     max_depths + 1, ACCT_STR);
@@ -439,11 +439,11 @@
       const TX_SIZE coded_tx_size = read_selected_tx_size(xd, is_inter, r);
       return coded_tx_size;
     } else {
-      return tx_size_from_tx_mode(bsize, tx_mode, is_inter);
+      return tx_size_from_tx_mode(bsize, tx_mode);
     }
   } else {
     assert(IMPLIES(tx_mode == ONLY_4X4, bsize == BLOCK_4X4));
-    return get_max_rect_tx_size(bsize, is_inter);
+    return get_max_rect_tx_size(bsize);
   }
 }
 
@@ -790,8 +790,7 @@
   MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
   const int inter_block = is_inter_block(mbmi);
 #if !CONFIG_TXK_SEL
-  const TX_SIZE mtx_size =
-      get_max_rect_tx_size(xd->mi[0]->mbmi.sb_type, inter_block);
+  const TX_SIZE mtx_size = get_max_rect_tx_size(xd->mi[0]->mbmi.sb_type);
   const TX_SIZE tx_size =
       inter_block ? AOMMAX(sub_tx_size_map[1][mtx_size], mbmi->min_tx_size)
                   : mbmi->tx_size;
@@ -885,7 +884,7 @@
     const int height = block_size_high[bsize] >> tx_size_high_log2[0];
     if ((cm->tx_mode == TX_MODE_SELECT && block_signals_txsize(bsize) &&
          !xd->lossless[mbmi->segment_id] && !mbmi->skip)) {
-      const TX_SIZE max_tx_size = get_max_rect_tx_size(bsize, 0);
+      const TX_SIZE max_tx_size = get_max_rect_tx_size(bsize);
       const int bh = tx_size_high_unit[max_tx_size];
       const int bw = tx_size_wide_unit[max_tx_size];
       mbmi->min_tx_size = TX_SIZES_LARGEST;
@@ -2094,7 +2093,7 @@
 
   if (cm->tx_mode == TX_MODE_SELECT && block_signals_txsize(bsize) &&
       !mbmi->skip && inter_block && !xd->lossless[mbmi->segment_id]) {
-    const TX_SIZE max_tx_size = get_max_rect_tx_size(bsize, inter_block);
+    const TX_SIZE max_tx_size = get_max_rect_tx_size(bsize);
     const int bh = tx_size_high_unit[max_tx_size];
     const int bw = tx_size_wide_unit[max_tx_size];
     const int width = block_size_wide[bsize] >> tx_size_wide_log2[0];
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index b2a816b..6220340 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -209,7 +209,7 @@
   (void)cm;
   if (block_signals_txsize(bsize)) {
     const TX_SIZE tx_size = mbmi->tx_size;
-    const int tx_size_ctx = get_tx_size_context(xd, 0);
+    const int tx_size_ctx = get_tx_size_context(xd);
     const int depth = tx_size_to_depth(tx_size, bsize, 0);
     const int max_depths = bsize_to_max_depth(bsize, 0);
     const int32_t tx_size_cat = bsize_to_tx_size_cat(bsize, 0);
@@ -857,8 +857,7 @@
   MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
   const int is_inter = is_inter_block(mbmi);
 #if !CONFIG_TXK_SEL
-  const TX_SIZE mtx_size =
-      get_max_rect_tx_size(xd->mi[0]->mbmi.sb_type, is_inter);
+  const TX_SIZE mtx_size = get_max_rect_tx_size(xd->mi[0]->mbmi.sb_type);
   const TX_SIZE tx_size =
       is_inter ? TXSIZEMAX(sub_tx_size_map[1][mtx_size], mbmi->min_tx_size)
                : mbmi->tx_size;
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 49509b7..95b3e66 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -417,7 +417,7 @@
 
 static INLINE int tx_size_to_depth(TX_SIZE tx_size, BLOCK_SIZE bsize,
                                    int is_inter) {
-  TX_SIZE ctx_size = get_max_rect_tx_size(bsize, is_inter);
+  TX_SIZE ctx_size = get_max_rect_tx_size(bsize);
   int depth = 0;
   while (tx_size != ctx_size) {
     depth++;
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 6b5acc1..dd9a944 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -378,8 +378,7 @@
   if (xd->lossless[mbmi->segment_id]) {
     mbmi->tx_size = TX_4X4;
   } else if (tx_mode != TX_MODE_SELECT) {
-    mbmi->tx_size =
-        tx_size_from_tx_mode(mbmi->sb_type, tx_mode, is_inter_block(mbmi));
+    mbmi->tx_size = tx_size_from_tx_mode(mbmi->sb_type, tx_mode);
   } else {
     BLOCK_SIZE bsize = mbmi->sb_type;
     TX_SIZE min_tx_size =
@@ -4970,7 +4969,7 @@
         tx_partition_count_update(cm, x, bsize, mi_row, mi_col, td->counts,
                                   tile_data->allow_update_cdf);
       } else {
-        if (tx_size != get_max_rect_tx_size(bsize, 0)) ++x->txb_split_count;
+        if (tx_size != get_max_rect_tx_size(bsize)) ++x->txb_split_count;
       }
       assert(IMPLIES(is_rect_tx(tx_size), is_rect_tx_allowed(xd, mbmi)));
     } else {
@@ -4981,13 +4980,13 @@
         if (xd->lossless[mbmi->segment_id]) {
           intra_tx_size = TX_4X4;
         } else {
-          intra_tx_size = tx_size_from_tx_mode(bsize, cm->tx_mode, 1);
+          intra_tx_size = tx_size_from_tx_mode(bsize, cm->tx_mode);
         }
       } else {
         intra_tx_size = tx_size;
         if (block_signals_txsize(bsize) && !xd->lossless[mbmi->segment_id] &&
             tile_data->allow_update_cdf) {
-          const int tx_size_ctx = get_tx_size_context(xd, 0);
+          const int tx_size_ctx = get_tx_size_context(xd);
           const int32_t tx_size_cat = bsize_to_tx_size_cat(bsize, 0);
           const int depth = tx_size_to_depth(tx_size, bsize, 0);
           const int max_depths = bsize_to_max_depth(bsize, 0);
@@ -5002,8 +5001,7 @@
             mi_8x8[mis * j + i]->mbmi.tx_size = intra_tx_size;
 
       mbmi->min_tx_size = intra_tx_size;
-      if (intra_tx_size != get_max_rect_tx_size(bsize, is_inter))
-        ++x->txb_split_count;
+      if (intra_tx_size != get_max_rect_tx_size(bsize)) ++x->txb_split_count;
     }
 
 #if !CONFIG_TXK_SEL
@@ -5023,7 +5021,7 @@
       if (xd->lossless[mbmi->segment_id]) {
         tx_size = TX_4X4;
       } else {
-        tx_size = tx_size_from_tx_mode(bsize, cm->tx_mode, is_inter);
+        tx_size = tx_size_from_tx_mode(bsize, cm->tx_mode);
       }
     } else {
       tx_size = (bsize > BLOCK_4X4) ? tx_size : TX_4X4;
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 98232d7..3c9bd7a 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -2322,7 +2322,7 @@
     const int is_inter = is_inter_block(mbmi);
     const int32_t tx_size_cat = bsize_to_tx_size_cat(bsize, is_inter);
     const int depth = tx_size_to_depth(tx_size, bsize, is_inter);
-    const int tx_size_ctx = get_tx_size_context(xd, is_inter);
+    const int tx_size_ctx = get_tx_size_context(xd);
     int r_tx_size = x->tx_size_cost[tx_size_cat][tx_size_ctx][depth];
     return r_tx_size;
   } else {
@@ -2483,7 +2483,7 @@
   const int is_inter = is_inter_block(mbmi);
   av1_invalid_rd_stats(rd_stats);
 
-  mbmi->tx_size = tx_size_from_tx_mode(bs, cm->tx_mode, is_inter);
+  mbmi->tx_size = tx_size_from_tx_mode(bs, cm->tx_mode);
   mbmi->min_tx_size = mbmi->tx_size;
   const TxSetType tx_set_type =
       get_ext_tx_set_type(mbmi->tx_size, bs, is_inter, cm->reduced_tx_set_used);
@@ -2595,8 +2595,7 @@
   int start_tx;
   int depth;
   int64_t best_rd = INT64_MAX, last_rd = INT64_MAX;
-  const int is_inter = is_inter_block(mbmi);
-  const TX_SIZE max_rect_tx_size = get_max_rect_tx_size(bs, is_inter);
+  const TX_SIZE max_rect_tx_size = get_max_rect_tx_size(bs);
   TX_SIZE best_tx_size = max_rect_tx_size;
   TX_TYPE best_tx_type = DCT_DCT;
 #if CONFIG_TXK_SEL
@@ -2612,8 +2611,7 @@
     start_tx = max_rect_tx_size;
     depth = get_search_init_depth(mi_size_wide[bs], mi_size_high[bs], &cpi->sf);
   } else {
-    const TX_SIZE chosen_tx_size =
-        tx_size_from_tx_mode(bs, cm->tx_mode, is_inter);
+    const TX_SIZE chosen_tx_size = tx_size_from_tx_mode(bs, cm->tx_mode);
     start_tx = chosen_tx_size;
     depth = MAX_TX_DEPTH;
   }
@@ -2855,7 +2853,7 @@
   RD_STATS this_rd_stats;
   int row, col;
   int64_t temp_sse, this_rd;
-  TX_SIZE tx_size = tx_size_from_tx_mode(bsize, cm->tx_mode, 0);
+  TX_SIZE tx_size = tx_size_from_tx_mode(bsize, cm->tx_mode);
 #if CONFIG_FILTER_INTRA
   if (mbmi->filter_intra_mode_info.use_filter_intra) {
     tx_size = av1_max_tx_size_for_filter_intra(bsize, cm->tx_mode);
@@ -4246,7 +4244,7 @@
     const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
     const int mi_width = mi_size_wide[plane_bsize];
     const int mi_height = mi_size_high[plane_bsize];
-    const TX_SIZE max_tx_size = get_max_rect_tx_size(plane_bsize, 1);
+    const TX_SIZE max_tx_size = get_max_rect_tx_size(plane_bsize);
     const int bh = tx_size_high_unit[max_tx_size];
     const int bw = tx_size_wide_unit[max_tx_size];
     int idx, idy;
@@ -4789,8 +4787,7 @@
 // The sse value is stored in dist.
 static int predict_skip_flag(MACROBLOCK *x, BLOCK_SIZE bsize, int64_t *dist,
                              int reduced_tx_set) {
-  int max_tx_size =
-      get_max_rect_tx_size(bsize, is_inter_block(&x->e_mbd.mi[0]->mbmi));
+  int max_tx_size = get_max_rect_tx_size(bsize);
   if (tx_size_high[max_tx_size] > 16 || tx_size_wide[max_tx_size] > 16)
     max_tx_size = AOMMIN(max_txsize_lookup[bsize], TX_16X16);
   const int tx_h = tx_size_high[max_tx_size];
@@ -4852,7 +4849,7 @@
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
   const int n4 = bsize_to_num_blk(bsize);
-  const TX_SIZE tx_size = get_max_rect_tx_size(bsize, is_inter_block(mbmi));
+  const TX_SIZE tx_size = get_max_rect_tx_size(bsize);
   mbmi->tx_type = DCT_DCT;
 #if CONFIG_TXK_SEL
   memset(mbmi->txk_type, DCT_DCT, sizeof(mbmi->txk_type[0]) * TXK_TYPE_BUF_LEN);
@@ -7956,7 +7953,7 @@
     } else {
       x->skip = 1;
       *disable_skip = 1;
-      mbmi->tx_size = tx_size_from_tx_mode(bsize, cm->tx_mode, 1);
+      mbmi->tx_size = tx_size_from_tx_mode(bsize, cm->tx_mode);
 
       // The cost of skip bit needs to be added.
       mbmi->skip = 0;
@@ -10558,7 +10555,7 @@
 
       // Set up tx_size related variables for skip-specific loop filtering.
       best_mbmode.tx_size = block_signals_txsize(bsize)
-                                ? tx_size_from_tx_mode(bsize, cm->tx_mode, 1)
+                                ? tx_size_from_tx_mode(bsize, cm->tx_mode)
                                 : max_txsize_rect_lookup[bsize];
       memset(best_mbmode.inter_tx_size, best_mbmode.tx_size,
              sizeof(best_mbmode.inter_tx_size));