diff --git a/av1/common/av1_loopfilter.c b/av1/common/av1_loopfilter.c
index 611ef74..2976422 100644
--- a/av1/common/av1_loopfilter.c
+++ b/av1/common/av1_loopfilter.c
@@ -385,11 +385,9 @@
 //  00000000
 //  00000000
 static const uint64_t left_prediction_mask[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   0x0000000000000001ULL,  // BLOCK_2X2,
   0x0000000000000001ULL,  // BLOCK_2X4,
   0x0000000000000001ULL,  // BLOCK_4X2,
-#endif
   0x0000000000000001ULL,  // BLOCK_4X4,
   0x0000000000000001ULL,  // BLOCK_4X8,
   0x0000000000000001ULL,  // BLOCK_8X4,
@@ -413,11 +411,9 @@
 
 // 64 bit mask to shift and set for each prediction size.
 static const uint64_t above_prediction_mask[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   0x0000000000000001ULL,  // BLOCK_2X2
   0x0000000000000001ULL,  // BLOCK_2X4
   0x0000000000000001ULL,  // BLOCK_4X2
-#endif
   0x0000000000000001ULL,  // BLOCK_4X4
   0x0000000000000001ULL,  // BLOCK_4X8
   0x0000000000000001ULL,  // BLOCK_8X4
@@ -442,11 +438,9 @@
 // each 8x8 block that would be in the top left most block of the given block
 // size in the 64x64 block.
 static const uint64_t size_mask[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   0x0000000000000001ULL,  // BLOCK_2X2
   0x0000000000000001ULL,  // BLOCK_2X4
   0x0000000000000001ULL,  // BLOCK_4X2
-#endif
   0x0000000000000001ULL,  // BLOCK_4X4
   0x0000000000000001ULL,  // BLOCK_4X8
   0x0000000000000001ULL,  // BLOCK_8X4
@@ -495,11 +489,9 @@
 
 // 16 bit left mask to shift and set for each uv prediction size.
 static const uint16_t left_prediction_mask_uv[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   0x0001,  // BLOCK_2X2,
   0x0001,  // BLOCK_2X4,
   0x0001,  // BLOCK_4X2,
-#endif
   0x0001,  // BLOCK_4X4,
   0x0001,  // BLOCK_4X8,
   0x0001,  // BLOCK_8X4,
@@ -523,11 +515,9 @@
 
 // 16 bit above mask to shift and set for uv each prediction size.
 static const uint16_t above_prediction_mask_uv[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   0x0001,  // BLOCK_2X2
   0x0001,  // BLOCK_2X4
   0x0001,  // BLOCK_4X2
-#endif
   0x0001,  // BLOCK_4X4
   0x0001,  // BLOCK_4X8
   0x0001,  // BLOCK_8X4
@@ -551,11 +541,9 @@
 
 // 64 bit mask to shift and set for each uv prediction size
 static const uint16_t size_mask_uv[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   0x0001,  // BLOCK_2X2
   0x0001,  // BLOCK_2X4
   0x0001,  // BLOCK_4X2
-#endif
   0x0001,  // BLOCK_4X4
   0x0001,  // BLOCK_4X8
   0x0001,  // BLOCK_8X4
@@ -2144,12 +2132,8 @@
           (blk_row * mi_size_high[BLOCK_8X8] << TX_UNIT_HIGH_LOG2) >> 1;
       const int tx_col_idx =
           (blk_col * mi_size_wide[BLOCK_8X8] << TX_UNIT_WIDE_LOG2) >> 1;
-#if CONFIG_CHROMA_SUB8X8
       const BLOCK_SIZE bsize =
           AOMMAX(BLOCK_4X4, get_plane_block_size(mbmi->sb_type, plane));
-#else
-      const BLOCK_SIZE bsize = get_plane_block_size(mbmi->sb_type, plane);
-#endif
       const TX_SIZE mb_tx_size = mbmi->inter_tx_size[tx_row_idx][tx_col_idx];
       tx_size = (plane->plane_type == PLANE_TYPE_UV)
                     ? uv_txsize_lookup[bsize][mb_tx_size][0][0]
@@ -2628,11 +2612,9 @@
 static const uint32_t av1_prediction_masks[NUM_EDGE_DIRS][BLOCK_SIZES_ALL] = {
   // mask for vertical edges filtering
   {
-#if CONFIG_CHROMA_SUB8X8
       2 - 1,   // BLOCK_2X2
       2 - 1,   // BLOCK_2X4
       4 - 1,   // BLOCK_4X2
-#endif         // CONFIG_CHROMA_SUB8X8
       4 - 1,   // BLOCK_4X4
       4 - 1,   // BLOCK_4X8
       8 - 1,   // BLOCK_8X4
@@ -2664,11 +2646,9 @@
   },
   // mask for horizontal edges filtering
   {
-#if CONFIG_CHROMA_SUB8X8
       2 - 1,   // BLOCK_2X2
       4 - 1,   // BLOCK_2X4
       2 - 1,   // BLOCK_4X2
-#endif         // CONFIG_CHROMA_SUB8X8
       4 - 1,   // BLOCK_4X4
       8 - 1,   // BLOCK_4X8
       4 - 1,   // BLOCK_8X4
@@ -2779,13 +2759,8 @@
         (blk_row * mi_size_high[BLOCK_8X8] << TX_UNIT_HIGH_LOG2) >> 1;
     const int tx_col_idx =
         (blk_col * mi_size_wide[BLOCK_8X8] << TX_UNIT_WIDE_LOG2) >> 1;
-
-#if CONFIG_CHROMA_SUB8X8
     const BLOCK_SIZE bsize =
         AOMMAX(BLOCK_4X4, ss_size_lookup[sb_type][scale_horz][scale_vert]);
-#else
-    const BLOCK_SIZE bsize = ss_size_lookup[sb_type][scale_horz][scale_vert];
-#endif
     const TX_SIZE mb_tx_size = mbmi->inter_tx_size[tx_row_idx][tx_col_idx];
 
     assert(mb_tx_size < TX_SIZES_ALL);
diff --git a/av1/common/blockd.c b/av1/common/blockd.c
index 89a4caf..45a560e 100644
--- a/av1/common/blockd.c
+++ b/av1/common/blockd.c
@@ -128,12 +128,8 @@
   // 4x4=0, 8x8=2, 16x16=4, 32x32=6, 64x64=8
   // transform size varies per plane, look it up in a common way.
   const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
-#if CONFIG_CHROMA_SUB8X8
   const BLOCK_SIZE plane_bsize =
       AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
-  const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif
   const uint8_t txw_unit = tx_size_wide_unit[tx_size];
   const uint8_t txh_unit = tx_size_high_unit[tx_size];
   const int step = txw_unit * txh_unit;
@@ -235,12 +231,8 @@
   nplanes = 1 + (MAX_MB_PLANE - 1) * chroma_ref;
   for (i = 0; i < nplanes; i++) {
     struct macroblockd_plane *const pd = &xd->plane[i];
-#if CONFIG_CHROMA_SUB8X8
     const BLOCK_SIZE plane_bsize =
         AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
-    const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif
     const int txs_wide = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
     const int txs_high = block_size_high[plane_bsize] >> tx_size_high_log2[0];
     memset(pd->above_context, 0, sizeof(ENTROPY_CONTEXT) * txs_wide);
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 1c50596..64f6e1e 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -31,12 +31,6 @@
 extern "C" {
 #endif
 
-#if (CONFIG_CHROMA_SUB8X8)
-#define SUB8X8_COMP_REF 0
-#else
-#define SUB8X8_COMP_REF 1
-#endif
-
 #define MAX_MB_PLANE 3
 
 #if CONFIG_COMPOUND_SEGMENT
@@ -72,11 +66,7 @@
 
 static INLINE int is_comp_ref_allowed(BLOCK_SIZE bsize) {
   (void)bsize;
-#if SUB8X8_COMP_REF
-  return 1;
-#else
   return AOMMIN(block_size_wide[bsize], block_size_high[bsize]) >= 8;
-#endif  // SUB8X8_COMP_REF
 }
 
 static INLINE int is_inter_mode(PREDICTION_MODE mode) {
@@ -611,11 +601,11 @@
 #endif  // CONFIG_LOOP_RESTORATION
 
 #if CONFIG_CFL
-#if CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_DEBUG
 #define CFL_SUB8X8_VAL_MI_SIZE (4)
 #define CFL_SUB8X8_VAL_MI_SQUARE \
   (CFL_SUB8X8_VAL_MI_SIZE * CFL_SUB8X8_VAL_MI_SIZE)
-#endif  // CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif  // CONFIG_DEBUG
 typedef struct cfl_ctx {
   // The CfL prediction buffer is used in two steps:
   //   1. Stores Q3 reconstructed luma pixels
@@ -644,12 +634,12 @@
   int store_y;
 
   int is_chroma_reference;
-#if CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_DEBUG
   // The prediction used for sub8x8 blocks originates from multiple luma blocks,
   // this array is used to validate that cfl_store() is called only once for
   // each luma block
   uint8_t sub8x8_val[CFL_SUB8X8_VAL_MI_SQUARE];
-#endif  // CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif  // CONFIG_DEBUG
 } CFL_CTX;
 #endif  // CONFIG_CFL
 
@@ -671,10 +661,8 @@
 
   int up_available;
   int left_available;
-#if CONFIG_CHROMA_SUB8X8
   int chroma_up_available;
   int chroma_left_available;
-#endif
 
   const aom_prob (*partition_probs)[PARTITION_TYPES - 1];
 
@@ -1027,11 +1015,9 @@
 #if CONFIG_RECT_TX
 static INLINE int is_rect_tx_allowed_bsize(BLOCK_SIZE bsize) {
   static const char LUT[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
     0,  // BLOCK_2X2
     0,  // BLOCK_2X4
     0,  // BLOCK_4X2
-#endif
     0,  // BLOCK_4X4
     1,  // BLOCK_4X8
     1,  // BLOCK_8X4
@@ -1076,11 +1062,9 @@
 #if CONFIG_RECT_TX_EXT
 static INLINE int is_quarter_tx_allowed_bsize(BLOCK_SIZE bsize) {
   static const char LUT_QTTX[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
     0,  // BLOCK_2X2
     0,  // BLOCK_2X4
     0,  // BLOCK_4X2
-#endif
     0,  // BLOCK_4X4
     0,  // BLOCK_4X8
     0,  // BLOCK_8X4
diff --git a/av1/common/cfl.c b/av1/common/cfl.c
index f9acfcb..e286eb3 100644
--- a/av1/common/cfl.c
+++ b/av1/common/cfl.c
@@ -24,9 +24,9 @@
   cfl->subsampling_y = cm->subsampling_y;
   cfl->are_parameters_computed = 0;
   cfl->store_y = 0;
-#if CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_DEBUG
   cfl_clear_sub8x8_val(cfl);
-#endif  // CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif  // CONFIG_DEBUG
 }
 
 // Due to frame boundary issues, it is possible that the total area covered by
@@ -169,20 +169,16 @@
   int sum_u = 0;
   int sum_v = 0;
 
-// Match behavior of build_intra_predictors_high (reconintra.c) at superblock
-// boundaries:
-// base-1 base-1 base-1 .. base-1 base-1 base-1 base-1 base-1 base-1
-// base+1   A      B  ..     Y      Z
-// base+1   C      D  ..     W      X
-// base+1   E      F  ..     U      V
-// base+1   G      H  ..     S      T      T      T      T      T
-// ..
+  // Match behavior of build_intra_predictors_high (reconintra.c) at superblock
+  // boundaries:
+  // base-1 base-1 base-1 .. base-1 base-1 base-1 base-1 base-1 base-1
+  // base+1   A      B  ..     Y      Z
+  // base+1   C      D  ..     W      X
+  // base+1   E      F  ..     U      V
+  // base+1   G      H  ..     S      T      T      T      T      T
+  // ..
 
-#if CONFIG_CHROMA_SUB8X8
   if (xd->chroma_up_available && xd->mb_to_right_edge >= 0) {
-#else
-  if (xd->up_available && xd->mb_to_right_edge >= 0) {
-#endif
     sum_above_row(xd, width, &sum_u, &sum_v);
   } else {
     const int base = 128 << (xd->bd - 8);
@@ -190,11 +186,7 @@
     sum_v = width * (base - 1);
   }
 
-#if CONFIG_CHROMA_SUB8X8
   if (xd->chroma_left_available && xd->mb_to_bottom_edge >= 0) {
-#else
-  if (xd->left_available && xd->mb_to_bottom_edge >= 0) {
-#endif
     sum_left_col(xd, height, &sum_u, &sum_v);
   } else {
     const int base = 128 << (xd->bd - 8);
@@ -454,7 +446,6 @@
   }
 }
 
-#if CONFIG_CHROMA_SUB8X8
 // Adjust the row and column of blocks smaller than 8X8, as chroma-referenced
 // and non-chroma-referenced blocks are stored together in the CfL buffer.
 static INLINE void sub8x8_adjust_offset(const CFL_CTX *cfl, int *row_out,
@@ -485,7 +476,6 @@
   }
 }
 #endif  // CONFIG_DEBUG
-#endif  // CONFIG_CHROMA_SUB8X8
 
 void cfl_store_tx(MACROBLOCKD *const xd, int row, int col, TX_SIZE tx_size,
                   BLOCK_SIZE bsize) {
@@ -494,8 +484,6 @@
   uint8_t *dst =
       &pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]];
   (void)bsize;
-#if CONFIG_CHROMA_SUB8X8
-
   if (block_size_high[bsize] == 4 || block_size_wide[bsize] == 4) {
     // Only dimensions of size 4 can have an odd offset.
     assert(!((col & 1) && tx_size_wide[tx_size] != 4));
@@ -506,7 +494,6 @@
                    tx_size_wide_unit[tx_size]);
 #endif  // CONFIG_DEBUG
   }
-#endif
   cfl_store(cfl, dst, pd->dst.stride, row, col, tx_size_wide[tx_size],
             tx_size_high[tx_size], get_bitdepth_data_path_index(xd));
 }
@@ -516,7 +503,6 @@
   struct macroblockd_plane *const pd = &xd->plane[AOM_PLANE_Y];
   int row = 0;
   int col = 0;
-#if CONFIG_CHROMA_SUB8X8
   bsize = AOMMAX(BLOCK_4X4, bsize);
   if (block_size_high[bsize] == 4 || block_size_wide[bsize] == 4) {
     sub8x8_adjust_offset(cfl, &row, &col);
@@ -524,7 +510,6 @@
     sub8x8_set_val(cfl, row, col, mi_size_high[bsize], mi_size_wide[bsize]);
 #endif  // CONFIG_DEBUG
   }
-#endif  // CONFIG_CHROMA_SUB8X8
   const int width = max_intra_block_width(xd, bsize, AOM_PLANE_Y, tx_size);
   const int height = max_intra_block_height(xd, bsize, AOM_PLANE_Y, tx_size);
   cfl_store(cfl, pd->dst.buf, pd->dst.stride, row, col, width, height,
@@ -538,7 +523,6 @@
   // Do not call cfl_compute_parameters multiple time on the same values.
   assert(cfl->are_parameters_computed == 0);
 
-#if CONFIG_CHROMA_SUB8X8
   const BLOCK_SIZE plane_bsize = AOMMAX(
       BLOCK_4X4, get_plane_block_size(mbmi->sb_type, &xd->plane[AOM_PLANE_U]));
 #if CONFIG_DEBUG
@@ -551,10 +535,6 @@
     cfl_clear_sub8x8_val(cfl);
   }
 #endif  // CONFIG_DEBUG
-#else
-  const BLOCK_SIZE plane_bsize =
-      get_plane_block_size(mbmi->sb_type, &xd->plane[AOM_PLANE_U]);
-#endif
   // AOM_PLANE_U is used, but both planes will have the same sizes.
   cfl->uv_width = max_intra_block_width(xd, plane_bsize, AOM_PLANE_U, tx_size);
   cfl->uv_height =
diff --git a/av1/common/common_data.h b/av1/common/common_data.h
index 522ac28..f487bb8 100644
--- a/av1/common/common_data.h
+++ b/av1/common/common_data.h
@@ -28,253 +28,373 @@
 
 // Log 2 conversion lookup tables for block width and height
 static const uint8_t b_width_log2_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  0, 0,
   0,
-#endif
-  0, 0,
-  1, 1,
-  1, 2,
-  2, 2,
-  3, 3,
-  3, 4,
-  4, IF_EXT_PARTITION(4, 5, 5) 0,
-  2, 1,
-  3, 2,
-  4, IF_EXT_PARTITION(3, 5)
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  4,
+  4,
+  IF_EXT_PARTITION(4, 5, 5) 0,
+  2,
+  1,
+  3,
+  2,
+  4,
+  IF_EXT_PARTITION(3, 5)
 };
 static const uint8_t b_height_log2_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  0, 0,
   0,
-#endif
-  0, 1,
-  0, 1,
-  2, 1,
-  2, 3,
-  2, 3,
-  4, 3,
-  4, IF_EXT_PARTITION(5, 4, 5) 2,
-  0, 3,
-  1, 4,
-  2, IF_EXT_PARTITION(5, 3)
+  0,
+  0,
+  0,
+  1,
+  0,
+  1,
+  2,
+  1,
+  2,
+  3,
+  2,
+  3,
+  4,
+  3,
+  4,
+  IF_EXT_PARTITION(5, 4, 5) 2,
+  0,
+  3,
+  1,
+  4,
+  2,
+  IF_EXT_PARTITION(5, 3)
 };
 // Log 2 conversion lookup tables for modeinfo width and height
 static const uint8_t mi_width_log2_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  0, 0,
   0,
-#endif
-  0, 0,
-  1, 1,
-  1, 2,
-  2, 2,
-  3, 3,
-  3, 4,
-  4, IF_EXT_PARTITION(4, 5, 5) 0,
-  2, 1,
-  3, 2,
-  4, IF_EXT_PARTITION(3, 5)
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  4,
+  4,
+  IF_EXT_PARTITION(4, 5, 5) 0,
+  2,
+  1,
+  3,
+  2,
+  4,
+  IF_EXT_PARTITION(3, 5)
 };
 static const uint8_t mi_height_log2_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  0, 0,
   0,
-#endif
-  0, 1,
-  0, 1,
-  2, 1,
-  2, 3,
-  2, 3,
-  4, 3,
-  4, IF_EXT_PARTITION(5, 4, 5) 2,
-  0, 3,
-  1, 4,
-  2, IF_EXT_PARTITION(5, 3)
+  0,
+  0,
+  0,
+  1,
+  0,
+  1,
+  2,
+  1,
+  2,
+  3,
+  2,
+  3,
+  4,
+  3,
+  4,
+  IF_EXT_PARTITION(5, 4, 5) 2,
+  0,
+  3,
+  1,
+  4,
+  2,
+  IF_EXT_PARTITION(5, 3)
 };
 
 /* clang-format off */
 static const uint8_t mi_size_wide[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  1, 1, 1,
-#endif
-  1, 1, 2, 2, 2, 4, 4, 4, 8, 8, 8, 16, 16,
+  1, 1, 1, 1, 1, 2, 2, 2, 4, 4, 4, 8, 8, 8, 16, 16,
   IF_EXT_PARTITION(16, 32, 32)  1, 4, 2, 8, 4, 16, IF_EXT_PARTITION(8, 32)
 };
 static const uint8_t mi_size_high[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  1, 1, 1,
-#endif
-  1, 2, 1, 2, 4, 2, 4, 8, 4, 8, 16, 8, 16,
+  1, 1, 1, 1, 2, 1, 2, 4, 2, 4, 8, 4, 8, 16, 8, 16,
   IF_EXT_PARTITION(32, 16, 32)  4, 1, 8, 2, 16, 4, IF_EXT_PARTITION(32, 8)
 };
 /* clang-format on */
 
 // Width/height lookup tables in units of various block sizes
 static const uint8_t block_size_wide[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  2,  2,
+  2,
+  2,
   4,
-#endif
-  4,  4,
-  8,  8,
-  8,  16,
-  16, 16,
-  32, 32,
-  32, 64,
-  64, IF_EXT_PARTITION(64, 128, 128) 4,
-  16, 8,
-  32, 16,
-  64, IF_EXT_PARTITION(32, 128)
+  4,
+  4,
+  8,
+  8,
+  8,
+  16,
+  16,
+  16,
+  32,
+  32,
+  32,
+  64,
+  64,
+  IF_EXT_PARTITION(64, 128, 128) 4,
+  16,
+  8,
+  32,
+  16,
+  64,
+  IF_EXT_PARTITION(32, 128)
 };
 
 static const uint8_t block_size_high[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  2,  4,
   2,
-#endif
-  4,  8,
-  4,  8,
-  16, 8,
-  16, 32,
-  16, 32,
-  64, 32,
-  64, IF_EXT_PARTITION(128, 64, 128) 16,
-  4,  32,
-  8,  64,
-  16, IF_EXT_PARTITION(128, 32)
+  4,
+  2,
+  4,
+  8,
+  4,
+  8,
+  16,
+  8,
+  16,
+  32,
+  16,
+  32,
+  64,
+  32,
+  64,
+  IF_EXT_PARTITION(128, 64, 128) 16,
+  4,
+  32,
+  8,
+  64,
+  16,
+  IF_EXT_PARTITION(128, 32)
 };
 
 static const uint8_t num_4x4_blocks_wide_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  1,  1,
   1,
-#endif
-  1,  1,
-  2,  2,
-  2,  4,
-  4,  4,
-  8,  8,
-  8,  16,
-  16, IF_EXT_PARTITION(16, 32, 32) 1,
-  4,  2,
-  8,  4,
-  16, IF_EXT_PARTITION(8, 32)
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  4,
+  4,
+  4,
+  8,
+  8,
+  8,
+  16,
+  16,
+  IF_EXT_PARTITION(16, 32, 32) 1,
+  4,
+  2,
+  8,
+  4,
+  16,
+  IF_EXT_PARTITION(8, 32)
 };
 static const uint8_t num_4x4_blocks_high_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  1,  1,
   1,
-#endif
-  1,  2,
-  1,  2,
-  4,  2,
-  4,  8,
-  4,  8,
-  16, 8,
-  16, IF_EXT_PARTITION(32, 16, 32) 4,
-  1,  8,
-  2,  16,
-  4,  IF_EXT_PARTITION(32, 8)
+  1,
+  1,
+  1,
+  2,
+  1,
+  2,
+  4,
+  2,
+  4,
+  8,
+  4,
+  8,
+  16,
+  8,
+  16,
+  IF_EXT_PARTITION(32, 16, 32) 4,
+  1,
+  8,
+  2,
+  16,
+  4,
+  IF_EXT_PARTITION(32, 8)
 };
 static const uint8_t num_8x8_blocks_wide_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  1, 1,
   1,
-#endif
-  1, 1,
-  1, 1,
-  1, 2,
-  2, 2,
-  4, 4,
-  4, 8,
-  8, IF_EXT_PARTITION(8, 16, 16) 1,
-  2, 1,
-  4, 2,
-  8, IF_EXT_PARTITION(4, 16)
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  4,
+  4,
+  4,
+  8,
+  8,
+  IF_EXT_PARTITION(8, 16, 16) 1,
+  2,
+  1,
+  4,
+  2,
+  8,
+  IF_EXT_PARTITION(4, 16)
 };
 static const uint8_t num_8x8_blocks_high_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  1, 1,
   1,
-#endif
-  1, 1,
-  1, 1,
-  2, 1,
-  2, 4,
-  2, 4,
-  8, 4,
-  8, IF_EXT_PARTITION(16, 8, 16) 2,
-  1, 4,
-  1, 8,
-  2, IF_EXT_PARTITION(16, 4)
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  2,
+  1,
+  2,
+  4,
+  2,
+  4,
+  8,
+  4,
+  8,
+  IF_EXT_PARTITION(16, 8, 16) 2,
+  1,
+  4,
+  1,
+  8,
+  2,
+  IF_EXT_PARTITION(16, 4)
 };
 static const uint8_t num_16x16_blocks_wide_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  1, 1,
   1,
-#endif
-  1, 1,
-  1, 1,
-  1, 1,
-  1, 1,
-  2, 2,
-  2, 4,
-  4, IF_EXT_PARTITION(4, 8, 8) 1,
-  1, 1,
-  2, 2,
-  4, IF_EXT_PARTITION(2, 8)
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  4,
+  4,
+  IF_EXT_PARTITION(4, 8, 8) 1,
+  1,
+  1,
+  2,
+  2,
+  4,
+  IF_EXT_PARTITION(2, 8)
 };
 static const uint8_t num_16x16_blocks_high_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  1, 1,
   1,
-#endif
-  1, 1,
-  1, 1,
-  1, 1,
-  1, 2,
-  1, 2,
-  4, 2,
-  4, IF_EXT_PARTITION(8, 4, 8) 1,
-  1, 2,
-  1, 4,
-  2, IF_EXT_PARTITION(8, 2)
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  2,
+  1,
+  2,
+  4,
+  2,
+  4,
+  IF_EXT_PARTITION(8, 4, 8) 1,
+  1,
+  2,
+  1,
+  4,
+  2,
+  IF_EXT_PARTITION(8, 2)
 };
 
 // AOMMIN(3, AOMMIN(b_width_log2(bsize), b_height_log2(bsize)))
 static const uint8_t size_group_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  0, 0,
   0,
-#endif
-  0, 0,
-  0, 1,
-  1, 1,
-  2, 2,
-  2, 3,
-  3, 3,
-  3, IF_EXT_PARTITION(3, 3, 3) 0,
-  0, 1,
-  1, 2,
-  2, IF_EXT_PARTITION(3, 3)
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  IF_EXT_PARTITION(3, 3, 3) 0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  IF_EXT_PARTITION(3, 3)
 };
 
 static const uint8_t num_pels_log2_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  2,  3,
+  2,
   3,
-#endif
-  4,  5,
-  5,  6,
-  7,  7,
-  8,  9,
-  9,  10,
-  11, 11,
-  12, IF_EXT_PARTITION(13, 13, 14) 6,
-  6,  8,
-  8,  10,
-  10, IF_EXT_PARTITION(12, 12)
+  3,
+  4,
+  5,
+  5,
+  6,
+  7,
+  7,
+  8,
+  9,
+  9,
+  10,
+  11,
+  11,
+  12,
+  IF_EXT_PARTITION(13, 13, 14) 6,
+  6,
+  8,
+  8,
+  10,
+  10,
+  IF_EXT_PARTITION(12, 12)
 };
 
 /* clang-format off */
@@ -285,10 +405,8 @@
 #endif  // CONFIG_EXT_PARTITION_TYPES
 {
   {     // PARTITION_NONE
-#if CONFIG_CHROMA_SUB8X8
     // 2X2,        2X4,           4X2,
     BLOCK_2X2,     BLOCK_2X4,     BLOCK_4X2,
-#endif
     //                            4X4
                                   BLOCK_4X4,
     // 4X8,        8X4,           8X8
@@ -312,15 +430,10 @@
     BLOCK_32X128,  BLOCK_128X32
 #endif  // CONFIG_EXT_PARTITION
   }, {  // PARTITION_HORZ
-#if CONFIG_CHROMA_SUB8X8
     // 2X2,        2X4,           4X2,
     BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
     //                            4X4
                                   BLOCK_4X2,
-#else
-    //                            4X4
-                                  BLOCK_INVALID,
-#endif
     // 4X8,        8X4,           8X8
     BLOCK_INVALID, BLOCK_INVALID, BLOCK_8X4,
     // 8X16,       16X8,          16X16
@@ -342,15 +455,10 @@
     BLOCK_INVALID, BLOCK_INVALID
 #endif  // CONFIG_EXT_PARTITION
   }, {  // PARTITION_VERT
-#if CONFIG_CHROMA_SUB8X8
     // 2X2,        2X4,           4X2,
     BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
     //                            4X4
                                   BLOCK_2X4,
-#else
-    //                            4X4
-                                  BLOCK_INVALID,
-#endif
     // 4X8,        8X4,           8X8
     BLOCK_INVALID, BLOCK_INVALID, BLOCK_4X8,
     // 8X16,       16X8,          16X16
@@ -372,10 +480,8 @@
     BLOCK_INVALID, BLOCK_INVALID
 #endif  // CONFIG_EXT_PARTITION
   }, {  // PARTITION_SPLIT
-#if CONFIG_CHROMA_SUB8X8
     // 2X2,        2X4,           4X2,
     BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
     //                            4X4
                                   BLOCK_INVALID,
     // 4X8,        8X4,           8X8
@@ -400,10 +506,8 @@
 #endif  // CONFIG_EXT_PARTITION
 #if CONFIG_EXT_PARTITION_TYPES
   }, {  // PARTITION_HORZ_A
-#if CONFIG_CHROMA_SUB8X8
     // 2X2,        2X4,           4X2,
     BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
     //                            4X4
                                   BLOCK_INVALID,
     // 4X8,        8X4,           8X8
@@ -427,10 +531,8 @@
     BLOCK_INVALID, BLOCK_INVALID
 #endif  // CONFIG_EXT_PARTITION
   }, {  // PARTITION_HORZ_B
-#if CONFIG_CHROMA_SUB8X8
     // 2X2,        2X4,           4X2,
     BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
     //                            4X4
                                   BLOCK_INVALID,
     // 4X8,        8X4,           8X8
@@ -454,10 +556,8 @@
     BLOCK_INVALID, BLOCK_INVALID
 #endif  // CONFIG_EXT_PARTITION
   }, {  // PARTITION_VERT_A
-#if CONFIG_CHROMA_SUB8X8
     // 2X2,        2X4,           4X2,
     BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
     //                            4X4
                                   BLOCK_INVALID,
     // 4X8,        8X4,           8X8
@@ -481,10 +581,8 @@
     BLOCK_INVALID, BLOCK_INVALID
 #endif  // CONFIG_EXT_PARTITION
   }, {  // PARTITION_VERT_B
-#if CONFIG_CHROMA_SUB8X8
     // 2X2,        2X4,           4X2,
     BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
     //                            4X4
                                   BLOCK_INVALID,
     // 4X8,        8X4,           8X8
@@ -508,10 +606,8 @@
     BLOCK_INVALID, BLOCK_INVALID
 #endif  // CONFIG_EXT_PARTITION
   }, {  // PARTITION_HORZ_4
-#if CONFIG_CHROMA_SUB8X8
     // 2X2,        2X4,           4X2,
     BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
     //                            4X4
                                   BLOCK_INVALID,
     // 4X8,        8X4,           8X8
@@ -535,10 +631,8 @@
     BLOCK_INVALID, BLOCK_INVALID
 #endif  // CONFIG_EXT_PARTITION
   }, {  // PARTITION_VERT_4
-#if CONFIG_CHROMA_SUB8X8
     // 2X2,        2X4,           4X2,
     BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
     //                            4X4
                                   BLOCK_INVALID,
     // 4X8,        8X4,           8X8
@@ -567,9 +661,7 @@
 
 static const TX_SIZE max_txsize_lookup[BLOCK_SIZES_ALL] = {
   // 2X2,    2X4,      4X2,
-#if   CONFIG_CHROMA_SUB8X8
   TX_4X4,    TX_4X4,   TX_4X4,
-#endif
   //                   4X4
                        TX_4X4,
   // 4X8,    8X4,      8X8
@@ -608,9 +700,7 @@
 #if CONFIG_RECT_TX
 static const TX_SIZE max_txsize_rect_lookup[BLOCK_SIZES_ALL] = {
   // 2X2,    2X4,      4X2,
-#if   CONFIG_CHROMA_SUB8X8
   TX_4X4,    TX_4X4,   TX_4X4,
-#endif  // CONFIG_CHROMA_SUB8X8
   //                   4X4
                        TX_4X4,
   // 4X8,    8X4,      8X8
@@ -659,10 +749,8 @@
 
 #if CONFIG_RECT_TX_EXT
 static const TX_SIZE quarter_txsize_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   //     2X2,        2X4,        4X2,
   TX_INVALID, TX_INVALID, TX_INVALID,
-#endif
   //                             4x4,
                           TX_INVALID,
   //     4x8,        8x4,        8x8,
@@ -712,10 +800,8 @@
 // block which may use a rectangular transform, in which  case it is
 // "(max_txsize_lookup[bsize] + 1) - TX_8X8", invalid for bsize < 8X8
 static const int32_t intra_tx_size_cat_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   // 2X2,             2X4,                4X2,
   INT32_MIN,          INT32_MIN,          INT32_MIN,
-#endif
   //                                      4X4,
                                           INT32_MIN,
   // 4X8,             8X4,                8X8,
@@ -757,10 +843,8 @@
 #else
 // Same as "max_txsize_lookup[bsize] - TX_8X8", invalid for bsize < 8X8
 static const int32_t intra_tx_size_cat_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   // 2X2,             2X4,                4X2,
   INT32_MIN,          INT32_MIN,          INT32_MIN,
-#endif
   //                                      4X4
                                           INT32_MIN,
   // 4X8,             8X4,                8X8
@@ -1046,20 +1130,14 @@
 /* clang-format on */
 
 static const BLOCK_SIZE ss_size_lookup[BLOCK_SIZES_ALL][2][2] = {
-//  ss_x == 0    ss_x == 0        ss_x == 1      ss_x == 1
-//  ss_y == 0    ss_y == 1        ss_y == 0      ss_y == 1
-#if CONFIG_CHROMA_SUB8X8
+  //  ss_x == 0    ss_x == 0        ss_x == 1      ss_x == 1
+  //  ss_y == 0    ss_y == 1        ss_y == 0      ss_y == 1
   { { BLOCK_2X2, BLOCK_INVALID }, { BLOCK_INVALID, BLOCK_INVALID } },
   { { BLOCK_2X4, BLOCK_INVALID }, { BLOCK_INVALID, BLOCK_INVALID } },
   { { BLOCK_4X2, BLOCK_INVALID }, { BLOCK_INVALID, BLOCK_INVALID } },
   { { BLOCK_4X4, BLOCK_4X2 }, { BLOCK_2X4, BLOCK_2X2 } },
   { { BLOCK_4X8, BLOCK_4X4 }, { BLOCK_INVALID, BLOCK_2X4 } },
   { { BLOCK_8X4, BLOCK_INVALID }, { BLOCK_4X4, BLOCK_4X2 } },
-#else
-  { { BLOCK_4X4, BLOCK_4X4 }, { BLOCK_4X4, BLOCK_4X4 } },
-  { { BLOCK_4X8, BLOCK_4X4 }, { BLOCK_INVALID, BLOCK_4X4 } },
-  { { BLOCK_8X4, BLOCK_INVALID }, { BLOCK_4X4, BLOCK_4X4 } },
-#endif  // CONFIG_CHROMA_SUB8X8
   { { BLOCK_8X8, BLOCK_8X4 }, { BLOCK_4X8, BLOCK_4X4 } },
   { { BLOCK_8X16, BLOCK_8X8 }, { BLOCK_INVALID, BLOCK_4X8 } },
   { { BLOCK_16X8, BLOCK_INVALID }, { BLOCK_8X8, BLOCK_8X4 } },
@@ -1088,9 +1166,8 @@
 };
 
 static const TX_SIZE uv_txsize_lookup[BLOCK_SIZES_ALL][TX_SIZES_ALL][2][2] = {
-//  ss_x == 0    ss_x == 0        ss_x == 1      ss_x == 1
-//  ss_y == 0    ss_y == 1        ss_y == 0      ss_y == 1
-#if CONFIG_CHROMA_SUB8X8
+  //  ss_x == 0    ss_x == 0        ss_x == 1      ss_x == 1
+  //  ss_y == 0    ss_y == 1        ss_y == 0      ss_y == 1
   {
       // BLOCK_2x2
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
@@ -1163,7 +1240,6 @@
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
   },
-#endif
   {
       // BLOCK_4X4
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
@@ -1747,11 +1823,9 @@
   PARTITION_CONTEXT left;
 } partition_context_lookup[BLOCK_SIZES_ALL] = {
 #if CONFIG_EXT_PARTITION
-#if CONFIG_CHROMA_SUB8X8
   { 31, 31 },  // 2X2   - {0b11111, 0b11111}
   { 31, 31 },  // 2X4   - {0b11111, 0b11111}
   { 31, 31 },  // 4X2   - {0b11111, 0b11111}
-#endif
   { 31, 31 },  // 4X4   - {0b11111, 0b11111}
   { 31, 30 },  // 4X8   - {0b11111, 0b11110}
   { 30, 31 },  // 8X4   - {0b11110, 0b11111}
@@ -1778,11 +1852,9 @@
   { 24, 0 },   // 32X128- {0b11000, 0b00000}
   { 0, 24 },   // 128X32- {0b00000, 0b11000}
 #else
-#if CONFIG_CHROMA_SUB8X8
   { 15, 15 },  // 2X2   - {0b1111, 0b1111}
   { 15, 15 },  // 2X4   - {0b1111, 0b1111}
   { 15, 15 },  // 4X2   - {0b1111, 0b1111}
-#endif
   { 15, 15 },  // 4X4   - {0b1111, 0b1111}
   { 15, 14 },  // 4X8   - {0b1111, 0b1110}
   { 14, 15 },  // 8X4   - {0b1110, 0b1111}
@@ -1820,11 +1892,9 @@
 #if CONFIG_NCOBMC_ADAPT_WEIGHT
 // NCOBMC_ADAPT_INTRPL only supports block size >= BLOCK_8X8 and <= BLOCK_64X64
 static const ADAPT_OVERLAP_BLOCK adapt_overlap_block_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   ADAPT_OVERLAP_BLOCK_INVALID,  // BLOCK_2X2
   ADAPT_OVERLAP_BLOCK_INVALID,  // BLOCK_2X4
   ADAPT_OVERLAP_BLOCK_INVALID,  // BLOCK_4X2
-#endif
   ADAPT_OVERLAP_BLOCK_INVALID,  // BLOCK_4X4
   ADAPT_OVERLAP_BLOCK_INVALID,  // BLOCK_4X8
   ADAPT_OVERLAP_BLOCK_INVALID,  // BLOCK_8X4
@@ -1849,12 +1919,9 @@
 };
 
 static const BLOCK_SIZE bsize_2_sqr_bsize[BLOCK_SIZES] = {
-#if CONFIG_CHROMA_SUB8X8
-  BLOCK_2X2,   BLOCK_2X2,   BLOCK_2X2,
-#endif
-  BLOCK_4X4,   BLOCK_4X4,   BLOCK_4X4,   BLOCK_8X8,   BLOCK_8X8,
-  BLOCK_8X8,   BLOCK_16X16, BLOCK_16X16, BLOCK_16X16, BLOCK_32X32,
-  BLOCK_32X32, BLOCK_32X32, BLOCK_64X64,
+  BLOCK_2X2,   BLOCK_2X2,   BLOCK_2X2,   BLOCK_4X4,   BLOCK_4X4,   BLOCK_4X4,
+  BLOCK_8X8,   BLOCK_8X8,   BLOCK_8X8,   BLOCK_16X16, BLOCK_16X16, BLOCK_16X16,
+  BLOCK_32X32, BLOCK_32X32, BLOCK_32X32, BLOCK_64X64,
 #if CONFIG_EXT_PARTITION
   BLOCK_64X64, BLOCK_64X64,
 #endif
diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index 54da782..c324cbb 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -890,17 +890,15 @@
 #if CONFIG_COMPOUND_SEGMENT && CONFIG_WEDGE
 static const aom_prob
     default_compound_type_probs[BLOCK_SIZES_ALL][COMPOUND_TYPES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
-      { 128, 128 }, { 128, 128 }, { 128, 128 },
-#endif
-      { 128, 128 }, { 255, 128 }, { 255, 128 }, { 66, 51 },   { 72, 35 },
-      { 79, 29 },   { 71, 18 },   { 81, 29 },   { 81, 26 },   { 69, 19 },
-      { 104, 1 },   { 99, 1 },    { 75, 1 },
+      { 128, 128 }, { 128, 128 }, { 128, 128 }, { 128, 128 },
+      { 255, 128 }, { 255, 128 }, { 66, 51 },   { 72, 35 },
+      { 79, 29 },   { 71, 18 },   { 81, 29 },   { 81, 26 },
+      { 69, 19 },   { 104, 1 },   { 99, 1 },    { 75, 1 },
 #if CONFIG_EXT_PARTITION
       { 255, 1 },   { 255, 1 },   { 255, 1 },
 #endif  // CONFIG_EXT_PARTITION
-      { 208, 128 }, { 208, 128 }, { 208, 128 }, { 208, 128 }, { 208, 1 },
-      { 208, 1 },
+      { 208, 128 }, { 208, 128 }, { 208, 128 }, { 208, 128 },
+      { 208, 1 },   { 208, 1 },
 #if CONFIG_EXT_PARTITION
       { 208, 1 },   { 208, 1 }
 #endif  // CONFIG_EXT_PARTITION
@@ -908,11 +906,8 @@
 #elif !CONFIG_COMPOUND_SEGMENT && CONFIG_WEDGE
 static const aom_prob
     default_compound_type_probs[BLOCK_SIZES_ALL][COMPOUND_TYPES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
-      { 255 }, { 255 }, { 255 },
-#endif
-      { 208 }, { 208 }, { 208 }, { 208 }, { 208 }, { 208 }, { 216 },
-      { 216 }, { 216 }, { 224 }, { 224 }, { 240 }, { 240 },
+      { 255 }, { 255 }, { 255 }, { 208 }, { 208 }, { 208 }, { 208 }, { 208 },
+      { 208 }, { 216 }, { 216 }, { 216 }, { 224 }, { 224 }, { 240 }, { 240 },
 #if CONFIG_EXT_PARTITION
       { 255 }, { 255 }, { 255 },
 #endif  // CONFIG_EXT_PARTITION
@@ -924,11 +919,8 @@
 #elif CONFIG_COMPOUND_SEGMENT && !CONFIG_WEDGE
 static const aom_prob
     default_compound_type_probs[BLOCK_SIZES_ALL][COMPOUND_TYPES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
-      { 255 }, { 255 }, { 255 },
-#endif
-      { 208 }, { 208 }, { 208 }, { 208 }, { 208 }, { 208 }, { 216 },
-      { 216 }, { 216 }, { 224 }, { 224 }, { 240 }, { 240 },
+      { 255 }, { 255 }, { 255 }, { 208 }, { 208 }, { 208 }, { 208 }, { 208 },
+      { 208 }, { 216 }, { 216 }, { 216 }, { 224 }, { 224 }, { 240 }, { 240 },
 #if CONFIG_EXT_PARTITION
       { 255 }, { 255 }, { 255 },
 #endif  // CONFIG_EXT_PARTITION
@@ -945,11 +937,9 @@
 #if CONFIG_COMPOUND_SEGMENT && CONFIG_WEDGE
 static const aom_cdf_prob
     default_compound_type_cdf[BLOCK_SIZES_ALL][CDF_SIZE(COMPOUND_TYPES)] = {
-#if CONFIG_CHROMA_SUB8X8
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
-#endif
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
       { AOM_ICDF(32640), AOM_ICDF(32704), AOM_ICDF(32768), 0 },
       { AOM_ICDF(32640), AOM_ICDF(32704), AOM_ICDF(32768), 0 },
@@ -982,11 +972,9 @@
 #elif !CONFIG_COMPOUND_SEGMENT && CONFIG_WEDGE
 static const aom_cdf_prob
     default_compound_type_cdf[BLOCK_SIZES_ALL][CDF_SIZE(COMPOUND_TYPES)] = {
-#if CONFIG_CHROMA_SUB8X8
       { AOM_ICDF(32640), AOM_ICDF(32768), 0 },  // 255
       { AOM_ICDF(32640), AOM_ICDF(32768), 0 },
       { AOM_ICDF(32640), AOM_ICDF(32768), 0 },
-#endif
       { AOM_ICDF(26624), AOM_ICDF(32768), 0 },  // 208
       { AOM_ICDF(26624), AOM_ICDF(32768), 0 },
       { AOM_ICDF(26624), AOM_ICDF(32768), 0 },
@@ -1019,11 +1007,9 @@
 #elif CONFIG_COMPOUND_SEGMENT && !CONFIG_WEDGE
 static const aom_cdf_prob
     default_compound_type_cdf[BLOCK_SIZES_ALL][CDF_SIZE(COMPOUND_TYPES)] = {
-#if CONFIG_CHROMA_SUB8X8
       { AOM_ICDF(32640), AOM_ICDF(32768), 0 },  // 255
       { AOM_ICDF(32640), AOM_ICDF(32768), 0 },
       { AOM_ICDF(32640), AOM_ICDF(32768), 0 },
-#endif
       { AOM_ICDF(26624), AOM_ICDF(32768), 0 },  // 208
       { AOM_ICDF(26624), AOM_ICDF(32768), 0 },
       { AOM_ICDF(26624), AOM_ICDF(32768), 0 },
@@ -1084,10 +1070,8 @@
     };
 
 static const aom_prob default_wedge_interintra_prob[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  128, 128, 128,
-#endif
-  128, 128, 128, 194, 213, 217, 222, 224, 226, 220, 128, 128, 128,
+  128, 128, 128, 128, 128, 128, 194, 213,
+  217, 222, 224, 226, 220, 128, 128, 128,
 #if CONFIG_EXT_PARTITION
   255, 255, 255,
 #endif  // CONFIG_EXT_PARTITION
@@ -1100,11 +1084,9 @@
 #if CONFIG_NEW_MULTISYMBOL
 static const aom_cdf_prob
     default_wedge_interintra_cdf[BLOCK_SIZES_ALL][CDF_SIZE(2)] = {
-#if CONFIG_CHROMA_SUB8X8
       { AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
       { AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
       { AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
-#endif
       { AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
       { AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
       { AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
@@ -1199,11 +1181,9 @@
 };
 static const aom_prob
     default_motion_mode_prob[BLOCK_SIZES_ALL][MOTION_MODES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
       { 255, 255 },
       { 255, 255 },
       { 255, 255 },
-#endif
       { 255, 255 },
       { 255, 255 },
       { 255, 255 },
@@ -1236,11 +1216,9 @@
     };
 static const aom_cdf_prob
     default_motion_mode_cdf[BLOCK_SIZES_ALL][CDF_SIZE(MOTION_MODES)] = {
-#if CONFIG_CHROMA_SUB8X8
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0, 0 },
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0, 0 },
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0, 0 },
-#endif
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0, 0 },
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0, 0 },
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0, 0 },
@@ -1279,11 +1257,8 @@
 
 static const aom_prob
     default_motion_mode_prob[BLOCK_SIZES_ALL][MOTION_MODES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
-      { 255 }, { 255 }, { 255 },
-#endif
-      { 255 }, { 255 }, { 255 }, { 151 }, { 153 }, { 144 }, { 178 },
-      { 165 }, { 160 }, { 207 }, { 195 }, { 168 }, { 244 },
+      { 255 }, { 255 }, { 255 }, { 255 }, { 255 }, { 255 }, { 151 }, { 153 },
+      { 144 }, { 178 }, { 165 }, { 160 }, { 207 }, { 195 }, { 168 }, { 244 },
 #if CONFIG_EXT_PARTITION
       { 252 }, { 252 }, { 252 },
 #endif  // CONFIG_EXT_PARTITION
@@ -1295,11 +1270,9 @@
 
 static const aom_cdf_prob
     default_motion_mode_cdf[BLOCK_SIZES_ALL][CDF_SIZE(MOTION_MODES)] = {
-#if CONFIG_CHROMA_SUB8X8
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
-#endif
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
@@ -1338,11 +1311,8 @@
 
 static const aom_prob
     default_motion_mode_prob[BLOCK_SIZES_ALL][MOTION_MODES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
-      { 255 }, { 255 }, { 255 },
-#endif
-      { 255 }, { 255 }, { 255 }, { 151 }, { 153 }, { 144 }, { 178 },
-      { 165 }, { 160 }, { 207 }, { 195 }, { 168 }, { 244 },
+      { 255 }, { 255 }, { 255 }, { 255 }, { 255 }, { 255 }, { 151 }, { 153 },
+      { 144 }, { 178 }, { 165 }, { 160 }, { 207 }, { 195 }, { 168 }, { 244 },
 #if CONFIG_EXT_PARTITION
       { 252 }, { 252 }, { 252 },
 #endif  // CONFIG_EXT_PARTITION
@@ -1354,11 +1324,9 @@
 
 static const aom_cdf_prob
     default_motion_mode_cdf[BLOCK_SIZES_ALL][CDF_SIZE(MOTION_MODES)] = {
-#if CONFIG_CHROMA_SUB8X8
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
-#endif
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
       { AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
@@ -1397,13 +1365,10 @@
 
 static const aom_prob default_motion_mode_prob[BLOCK_SIZES_ALL][MOTION_MODES -
                                                                 1] = {
-#if CONFIG_CHROMA_SUB8X8
-  { 128, 128, 255 }, { 128, 128, 128 }, { 128, 128, 128 },
-#endif
-  { 128, 128, 128 }, { 128, 128, 128 }, { 128, 128, 128 }, { 62, 115, 128 },
-  { 39, 131, 128 },  { 39, 132, 128 },  { 118, 94, 128 },  { 77, 125, 128 },
-  { 100, 121, 128 }, { 190, 66, 128 },  { 207, 102, 128 }, { 197, 100, 128 },
-  { 239, 76, 128 },
+  { 128, 128, 255 }, { 128, 128, 128 }, { 128, 128, 128 }, { 128, 128, 128 },
+  { 128, 128, 128 }, { 128, 128, 128 }, { 62, 115, 128 },  { 39, 131, 128 },
+  { 39, 132, 128 },  { 118, 94, 128 },  { 77, 125, 128 },  { 100, 121, 128 },
+  { 190, 66, 128 },  { 207, 102, 128 }, { 197, 100, 128 }, { 239, 76, 128 },
 #if CONFIG_EXT_PARTITION
   { 252, 200, 128 }, { 252, 200, 128 }, { 252, 200, 128 },
 #endif  // CONFIG_EXT_PARTITION
@@ -1411,11 +1376,9 @@
 };
 static const aom_cdf_prob
     default_motion_mode_cdf[BLOCK_SIZES_ALL][CDF_SIZE(MOTION_MODES)] = {
-#if CONFIG_CHROMA_SUB8X8
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
-#endif
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
@@ -1450,12 +1413,10 @@
 
 static const aom_prob
     default_ncobmc_prob[BLOCK_SIZES_ALL][OBMC_FAMILY_MODES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
-      { 128, 255 }, { 128, 255 }, { 128, 255 },
-#endif
-      { 128, 255 }, { 128, 255 }, { 128, 255 }, { 45, 255 },  { 79, 255 },
-      { 75, 255 },  { 130, 255 }, { 141, 255 }, { 144, 255 }, { 208, 255 },
-      { 201, 255 }, { 186, 255 }, { 231, 255 },
+      { 128, 255 }, { 128, 255 }, { 128, 255 }, { 128, 255 },
+      { 128, 255 }, { 128, 255 }, { 45, 255 },  { 79, 255 },
+      { 75, 255 },  { 130, 255 }, { 141, 255 }, { 144, 255 },
+      { 208, 255 }, { 201, 255 }, { 186, 255 }, { 231, 255 },
 #if CONFIG_EXT_PARTITION
       { 252, 255 }, { 252, 255 }, { 252, 255 },
 #endif  // CONFIG_EXT_PARTITION
@@ -1464,11 +1425,9 @@
 
 static const aom_cdf_prob
     default_ncobmc_cdf[BLOCK_SIZES_ALL][CDF_SIZE(OBMC_FAMILY_MODES)] = {
-#if CONFIG_CHROMA_SUB8X8
       { AOM_ICDF(128 * 128), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
       { AOM_ICDF(128 * 128), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
       { AOM_ICDF(128 * 128), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
-#endif
       { AOM_ICDF(128 * 128), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
       { AOM_ICDF(128 * 128), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
       { AOM_ICDF(128 * 128), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
@@ -1503,28 +1462,24 @@
 
 static const aom_prob
     default_motion_mode_prob[BLOCK_SIZES_ALL][MOTION_MODES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
-      { 128, 128 }, { 128, 128 }, { 128, 128 },
-#endif
-      { 128, 128 }, { 128, 128 }, { 128, 128 }, { 62, 115 },  { 39, 131 },
-      { 39, 132 },  { 118, 94 },  { 77, 125 },  { 100, 121 }, { 190, 66 },
-      { 207, 102 }, { 197, 100 }, { 239, 76 },
+      { 128, 128 }, { 128, 128 }, { 128, 128 }, { 128, 128 },
+      { 128, 128 }, { 128, 128 }, { 62, 115 },  { 39, 131 },
+      { 39, 132 },  { 118, 94 },  { 77, 125 },  { 100, 121 },
+      { 190, 66 },  { 207, 102 }, { 197, 100 }, { 239, 76 },
 #if CONFIG_EXT_PARTITION
       { 252, 200 }, { 252, 200 }, { 252, 200 },
 #endif  // CONFIG_EXT_PARTITION
-      { 208, 200 }, { 208, 200 }, { 208, 200 }, { 208, 200 }, { 208, 200 },
-      { 208, 200 },
+      { 208, 200 }, { 208, 200 }, { 208, 200 }, { 208, 200 },
+      { 208, 200 }, { 208, 200 },
 #if CONFIG_EXT_PARTITION
       { 252, 200 }, { 252, 200 }
 #endif  // CONFIG_EXT_PARTITION
     };
 static const aom_cdf_prob
     default_motion_mode_cdf[BLOCK_SIZES_ALL][CDF_SIZE(MOTION_MODES)] = {
-#if CONFIG_CHROMA_SUB8X8
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
-#endif
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
       { AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
@@ -1557,10 +1512,7 @@
 #endif  // CONFIG_NCOBMC_ADAPT_WEIGHT
 // Probability for the case that only 1 additional motion mode is allowed
 static const aom_prob default_obmc_prob[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  128, 128, 128,
-#endif
-  128, 128, 128, 45,  79,  75,  130, 141, 144, 208, 201, 186, 231,
+  128, 128, 128, 128, 128, 128, 45, 79, 75, 130, 141, 144, 208, 201, 186, 231,
 #if CONFIG_EXT_PARTITION
   252, 252, 252,
 #endif  // CONFIG_EXT_PARTITION
@@ -1572,11 +1524,9 @@
 
 #if CONFIG_NEW_MULTISYMBOL || CONFIG_NCOBMC_ADAPT_WEIGHT
 static const aom_cdf_prob default_obmc_cdf[BLOCK_SIZES_ALL][CDF_SIZE(2)] = {
-#if CONFIG_CHROMA_SUB8X8
   { AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
   { AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
   { AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
-#endif
   { AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
   { AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
   { AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
diff --git a/av1/common/enums.h b/av1/common/enums.h
index 4c3d908..91f1f16 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -122,11 +122,9 @@
 // type, so that we can save memory when they are used in structs/arrays.
 
 typedef enum ATTRIBUTE_PACKED {
-#if CONFIG_CHROMA_SUB8X8
   BLOCK_2X2,
   BLOCK_2X4,
   BLOCK_4X2,
-#endif
   BLOCK_4X4,
   BLOCK_4X8,
   BLOCK_8X4,
diff --git a/av1/common/obmc.h b/av1/common/obmc.h
index f394049..dbab733 100644
--- a/av1/common/obmc.h
+++ b/av1/common/obmc.h
@@ -36,7 +36,6 @@
     MODE_INFO **above_mi = prev_row_mi + above_mi_col;
     mi_step = AOMMIN(mi_size_wide[above_mi[0]->mbmi.sb_type],
                      mi_size_wide[BLOCK_64X64]);
-#if CONFIG_CHROMA_SUB8X8
     // If we're considering a block with width 4, it should be treated as
     // half of a pair of blocks with chroma information in the second. Move
     // above_mi_col back to the start of the pair if needed, set above_mbmi
@@ -47,7 +46,6 @@
       above_mi = prev_row_mi + above_mi_col + 1;
       mi_step = 2;
     }
-#endif  // CONFIG_CHROMA_SUB8X8
     MB_MODE_INFO *above_mbmi = &above_mi[0]->mbmi;
     if (is_neighbor_overlappable(above_mbmi)) {
       ++nb_count;
@@ -76,13 +74,11 @@
     MODE_INFO **left_mi = prev_col_mi + left_mi_row * xd->mi_stride;
     mi_step = AOMMIN(mi_size_high[left_mi[0]->mbmi.sb_type],
                      mi_size_high[BLOCK_64X64]);
-#if CONFIG_CHROMA_SUB8X8
     if (mi_step == 1) {
       left_mi_row &= ~1;
       left_mi = prev_col_mi + (left_mi_row + 1) * xd->mi_stride;
       mi_step = 2;
     }
-#endif  // CONFIG_CHROMA_SUB8X8
     MB_MODE_INFO *left_mbmi = &left_mi[0]->mbmi;
     if (is_neighbor_overlappable(left_mbmi)) {
       ++nb_count;
diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index 15db2ab..699c404 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -674,11 +674,11 @@
 }
 
 #if CONFIG_CFL
-#if CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_DEBUG
 static INLINE void cfl_clear_sub8x8_val(CFL_CTX *cfl) {
   memset(cfl->sub8x8_val, 0, sizeof(cfl->sub8x8_val));
 }
-#endif  // CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif  // CONFIG_DEBUG
 void cfl_init(CFL_CTX *cfl, AV1_COMMON *cm);
 #endif  // CONFIG_CFL
 
@@ -729,14 +729,12 @@
   int col_offset = mi_col;
   for (i = 0; i < MAX_MB_PLANE; ++i) {
     struct macroblockd_plane *const pd = &xd->plane[i];
-#if CONFIG_CHROMA_SUB8X8
     // Offset the buffer pointer
     const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
     if (pd->subsampling_y && (mi_row & 0x01) && (mi_size_high[bsize] == 1))
       row_offset = mi_row - 1;
     if (pd->subsampling_x && (mi_col & 0x01) && (mi_size_wide[bsize] == 1))
       col_offset = mi_col - 1;
-#endif
     int above_idx = col_offset << (MI_SIZE_LOG2 - tx_size_wide_log2[0]);
     int left_idx = (row_offset & MAX_MIB_MASK)
                    << (MI_SIZE_LOG2 - tx_size_high_log2[0]);
@@ -787,14 +785,12 @@
 #endif  // CONFIG_DEPENDENT_HORZTILES
 
   xd->left_available = (mi_col > tile->mi_col_start);
-#if CONFIG_CHROMA_SUB8X8
   xd->chroma_up_available = xd->up_available;
   xd->chroma_left_available = xd->left_available;
   if (xd->plane[1].subsampling_x && bw < mi_size_wide[BLOCK_8X8])
     xd->chroma_left_available = (mi_col - 1) > tile->mi_col_start;
   if (xd->plane[1].subsampling_y && bh < mi_size_high[BLOCK_8X8])
     xd->chroma_up_available = (mi_row - 1) > tile->mi_row_start;
-#endif
   if (xd->up_available) {
     xd->above_mi = xd->mi[-xd->mi_stride];
     // above_mi may be NULL in encoder's first pass.
@@ -876,22 +872,11 @@
 
 static INLINE int is_chroma_reference(int mi_row, int mi_col, BLOCK_SIZE bsize,
                                       int subsampling_x, int subsampling_y) {
-#if CONFIG_CHROMA_SUB8X8
   const int bw = mi_size_wide[bsize];
   const int bh = mi_size_high[bsize];
-
   int ref_pos = ((mi_row & 0x01) || !(bh & 0x01) || !subsampling_y) &&
                 ((mi_col & 0x01) || !(bw & 0x01) || !subsampling_x);
-
   return ref_pos;
-#else
-  int ref_pos = !(((mi_row & 0x01) && subsampling_y) ||
-                  ((mi_col & 0x01) && subsampling_x));
-
-  if (AOMMIN(block_size_wide[bsize], block_size_high[bsize]) >= 8) ref_pos = 1;
-
-  return ref_pos;
-#endif
 }
 
 static INLINE BLOCK_SIZE scale_chroma_bsize(BLOCK_SIZE bsize, int subsampling_x,
diff --git a/av1/common/reconinter.c b/av1/common/reconinter.c
index ac1059d..5eba691 100644
--- a/av1/common/reconinter.c
+++ b/av1/common/reconinter.c
@@ -343,11 +343,9 @@
 };
 
 const wedge_params_type wedge_params_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   { 0, NULL, NULL, 0, NULL },
   { 0, NULL, NULL, 0, NULL },
   { 0, NULL, NULL, 0, NULL },
-#endif  // CONFIG_CHROMA_SUB8X8
   { 0, NULL, NULL, 0, NULL },
   { 0, NULL, NULL, 0, NULL },
   { 0, NULL, NULL, 0, NULL },
@@ -1140,7 +1138,6 @@
   (void)block;
   (void)cm;
 
-#if CONFIG_CHROMA_SUB8X8
   const BLOCK_SIZE bsize = mi->mbmi.sb_type;
   const int ss_x = pd->subsampling_x;
   const int ss_y = pd->subsampling_y;
@@ -1347,9 +1344,6 @@
     for (ref = 0; ref < 2; ++ref) pd->pre[ref] = orig_pred_buf[ref];
     return;
   }
-#else
-  (void)cm;
-#endif  // CONFIG_CHROMA_SUB8X8
 
   {
     struct buf_2d *const dst_buf = &pd->dst;
@@ -1751,9 +1745,7 @@
 
   BLOCK_SIZE bsize_plane =
       ss_size_lookup[bsize][pd->subsampling_x][pd->subsampling_y];
-#if CONFIG_CHROMA_SUB8X8
   if (bsize_plane < BLOCK_4X4) return 1;
-#endif
   switch (bsize_plane) {
 #if DISABLE_CHROMA_U8X8_OBMC
     case BLOCK_4X4:
@@ -2503,9 +2495,7 @@
   1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1
 };
 static int ii_size_scales[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
     32, 32, 32,
-#endif
     32, 16, 16, 16, 8, 8, 8, 4,
     4,  4,  2,  2,  2, 1, 1, 1,
     16, 16, 8, 8, 4, 4, 2, 2
@@ -2518,9 +2508,7 @@
   2,  2,  2,  2,  2,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1
 };
 static int ii_size_scales[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
     16, 16, 16,
-#endif
     16, 8, 8, 8, 4, 4, 4,
     2,  2, 2, 1, 1, 1,
     8, 8, 4, 4, 2, 2,
diff --git a/av1/common/reconinter.h b/av1/common/reconinter.h
index d0cd27d..7fbd8c3 100644
--- a/av1/common/reconinter.h
+++ b/av1/common/reconinter.h
@@ -221,11 +221,7 @@
                                               BLOCK_SIZE sb_type) {
   (void)sb_type;
   switch (type) {
-#if CONFIG_CHROMA_SUB8X8
     case COMPOUND_AVERAGE: return sb_type >= BLOCK_4X4;
-#else   // CONFIG_CHROMA_SUB8X8
-    case COMPOUND_AVERAGE: return 1;
-#endif  // CONFIG_CHROMA_SUB8X8
 #if CONFIG_WEDGE
     case COMPOUND_WEDGE: return wedge_params_lookup[sb_type].bits > 0;
 #endif  // CONFIG_WEDGE
@@ -239,9 +235,7 @@
 
 static INLINE int is_any_masked_compound_used(BLOCK_SIZE sb_type) {
   COMPOUND_TYPE comp_type;
-#if CONFIG_CHROMA_SUB8X8
   if (sb_type < BLOCK_4X4) return 0;
-#endif  // CONFIG_CHROMA_SUB8X8
   for (comp_type = 0; comp_type < COMPOUND_TYPES; comp_type++) {
     if (is_masked_compound_type(comp_type) &&
         is_interinter_compound_used(comp_type, sb_type))
@@ -410,15 +404,11 @@
                                     int stride, int mi_row, int mi_col,
                                     const struct scale_factors *scale,
                                     int subsampling_x, int subsampling_y) {
-#if CONFIG_CHROMA_SUB8X8
   // Offset the buffer pointer
   if (subsampling_y && (mi_row & 0x01) && (mi_size_high[bsize] == 1))
     mi_row -= 1;
   if (subsampling_x && (mi_col & 0x01) && (mi_size_wide[bsize] == 1))
     mi_col -= 1;
-#else
-  (void)bsize;
-#endif
 
   const int x = (MI_SIZE * mi_col) >> subsampling_x;
   const int y = (MI_SIZE * mi_row) >> subsampling_y;
diff --git a/av1/common/reconintra.c b/av1/common/reconintra.c
index a6d8efa..8523c2d 100644
--- a/av1/common/reconintra.c
+++ b/av1/common/reconintra.c
@@ -367,10 +367,8 @@
 #if CONFIG_EXT_PARTITION
 /* clang-format off */
 static const uint16_t *const orders[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   // 2X2,         2X4,            4X2
   orders_4x4,     orders_4x4,     orders_4x4,
-#endif
   //                              4X4
                                   orders_4x4,
   // 4X8,         8X4,            8X8
@@ -394,10 +392,8 @@
 #else
 /* clang-format off */
 static const uint16_t *const orders[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   // 2X2,         2X4,            4X2
   orders_8x8,     orders_8x8,     orders_8x8,
-#endif
   //                              4X4
                                   orders_8x8,
   // 4X8,         8X4,            8X8
@@ -453,10 +449,8 @@
 #if CONFIG_EXT_PARTITION
 /* clang-format off */
 static const uint16_t *const orders_verta[BLOCK_SIZES] = {
-#if CONFIG_CHROMA_SUB8X8
   // 2X2,           2X4,              4X2
   orders_4x4,       orders_4x4,       orders_4x4,
-#endif
   //                                  4X4
                                       orders_verta_8x8,
   // 4X8,           8X4,              8X8
@@ -475,10 +469,8 @@
 #else
 /* clang-format off */
 static const uint16_t *const orders_verta[BLOCK_SIZES] = {
-#if CONFIG_CHROMA_SUB8X8
   // 2X2,             2X4,                4X2
   orders_verta_8x8,   orders_verta_8x8,   orders_verta_8x8,
-#endif
   //                                      4X4
                                           orders_verta_8x8,
   // 4X8,             8X4,                8X8
@@ -2579,16 +2571,11 @@
   BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
   const struct macroblockd_plane *const pd = &xd->plane[plane];
   const int txw = tx_size_wide_unit[tx_size];
-#if CONFIG_CHROMA_SUB8X8
   const int have_top = row_off || (pd->subsampling_y ? xd->chroma_up_available
                                                      : xd->up_available);
   const int have_left =
       col_off ||
       (pd->subsampling_x ? xd->chroma_left_available : xd->left_available);
-#else
-  const int have_top = row_off || xd->up_available;
-  const int have_left = col_off || xd->left_available;
-#endif
   const int x = col_off << tx_size_wide_log2[0];
   const int y = row_off << tx_size_high_log2[0];
   const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);
@@ -2598,13 +2585,8 @@
 #if !INTRA_USES_RECT_TRANSFORMS
   assert(txwpx == txhpx);
 #endif  // !INTRA_USES_RECT_TRANSFORMS
-#if !CONFIG_CHROMA_SUB8X8
-  const int xr_chr_offset = (pd->subsampling_x && bsize < BLOCK_8X8) ? 2 : 0;
-  const int yd_chr_offset = (pd->subsampling_y && bsize < BLOCK_8X8) ? 2 : 0;
-#else
   const int xr_chr_offset = 0;
   const int yd_chr_offset = 0;
-#endif
 
   // Distance between the right edge of this prediction block to
   // the frame right edge
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index be57c15..62a0861 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -257,12 +257,8 @@
 static int get_block_idx(const MACROBLOCKD *xd, int plane, int row, int col) {
   const int bsize = xd->mi[0]->mbmi.sb_type;
   const struct macroblockd_plane *pd = &xd->plane[plane];
-#if CONFIG_CHROMA_SUB8X8
   const BLOCK_SIZE plane_bsize =
       AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
-  const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif  // CONFIG_CHROMA_SUB8X8
   const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
   const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
   const uint8_t txh_unit = tx_size_high_unit[tx_size];
@@ -612,11 +608,11 @@
 
   set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis);
   MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8
+#if CONFIG_CFL
   CFL_CTX *const cfl = xd->cfl;
   cfl->is_chroma_reference = is_chroma_reference(
       mi_row, mi_col, bsize, cfl->subsampling_x, cfl->subsampling_y);
-#endif  // CONFIG_CFL && CONFIG_CHROMA_SUB8X8
+#endif  // CONFIG_CFL
 
   if (cm->delta_q_present_flag) {
     int i;
@@ -769,12 +765,8 @@
       const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
       const int stepr = tx_size_high_unit[tx_size];
       const int stepc = tx_size_wide_unit[tx_size];
-#if CONFIG_CHROMA_SUB8X8
       const BLOCK_SIZE plane_bsize =
           AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
-      const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif  // CONFIG_CHROMA_SUB8X8
       int row, col;
       const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
       const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
@@ -864,12 +856,8 @@
 
       for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
         const struct macroblockd_plane *const pd = &xd->plane[plane];
-#if CONFIG_CHROMA_SUB8X8
         const BLOCK_SIZE plane_bsize =
             AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
-        const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif  // CONFIG_CHROMA_SUB8X8
         const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
         const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
         int row, col;
@@ -915,7 +903,7 @@
       }
     }
   }
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8
+#if CONFIG_CFL
   if (mbmi->uv_mode != UV_CFL_PRED) {
 #if CONFIG_DEBUG
     if (cfl->is_chroma_reference) {
@@ -926,7 +914,7 @@
       cfl_store_block(xd, mbmi->sb_type, mbmi->tx_size);
     }
   }
-#endif  // CONFIG_CFL && CONFIG_CHROMA_SUB8X8
+#endif  // CONFIG_CFL
 #endif  // CONFIG_COEF_INTERLEAVE
 
   int reader_corrupted_flag = aom_reader_has_error(r);
diff --git a/av1/decoder/decodetxb.c b/av1/decoder/decodetxb.c
index 33418fc..8e21a7f 100644
--- a/av1/decoder/decodetxb.c
+++ b/av1/decoder/decodetxb.c
@@ -626,12 +626,8 @@
   struct macroblockd_plane *pd = &xd->plane[plane];
 
   const BLOCK_SIZE bsize = mbmi->sb_type;
-#if CONFIG_CHROMA_SUB8X8
   const BLOCK_SIZE plane_bsize =
       AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
-  const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif  // CONFIG_CHROMA_SUB8X8
 
   TXB_CTX txb_ctx;
   get_txb_ctx(plane_bsize, tx_size, plane, pd->above_context + col,
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 58b8fb4..c73f022 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -2252,12 +2252,8 @@
       }
       const struct macroblockd_plane *const pd = &xd->plane[plane];
       BLOCK_SIZE bsize = mbmi->sb_type;
-#if CONFIG_CHROMA_SUB8X8
       const BLOCK_SIZE plane_bsize =
           AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
-      const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif  // CONFIG_CHROMA_SUB8X8
 
       const int num_4x4_w =
           block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index cd36fac..597b73d 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -2076,9 +2076,7 @@
 
 /* clang-format off */
 static const BLOCK_SIZE min_partition_size[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   BLOCK_2X2,   BLOCK_2X2,   BLOCK_2X2,    //    2x2,    2x4,     4x2
-#endif
                             BLOCK_4X4,    //                     4x4
   BLOCK_4X4,   BLOCK_4X4,   BLOCK_4X4,    //    4x8,    8x4,     8x8
   BLOCK_4X4,   BLOCK_4X4,   BLOCK_8X8,    //   8x16,   16x8,   16x16
@@ -2095,9 +2093,7 @@
 };
 
 static const BLOCK_SIZE max_partition_size[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   BLOCK_4X4,     BLOCK_4X4,       BLOCK_4X4,    //    2x2,    2x4,     4x2
-#endif
                                   BLOCK_8X8,    //                     4x4
   BLOCK_16X16,   BLOCK_16X16,   BLOCK_16X16,    //    4x8,    8x4,     8x8
   BLOCK_32X32,   BLOCK_32X32,   BLOCK_32X32,    //   8x16,   16x8,   16x16
@@ -2115,9 +2111,7 @@
 
 // Next square block size less or equal than current block size.
 static const BLOCK_SIZE next_square_size[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
   BLOCK_2X2,   BLOCK_2X2,     BLOCK_2X2,    //    2x2,    2x4,     4x2
-#endif
                               BLOCK_4X4,    //                     4x4
   BLOCK_4X4,   BLOCK_4X4,     BLOCK_8X8,    //    4x8,    8x4,     8x8
   BLOCK_8X8,   BLOCK_8X8,     BLOCK_16X16,  //   8x16,   16x8,   16x16
@@ -2505,13 +2499,8 @@
     uint8_t *src_uv = x->plane[plane].src.buf;
     uint8_t *dst_uv = xd->plane[plane].dst.buf;
     unsigned sse;
-#if CONFIG_CHROMA_SUB8X8
     const BLOCK_SIZE plane_bsize =
         AOMMAX(BLOCK_4X4, get_plane_block_size(BLOCK_8X8, &xd->plane[plane]));
-#else
-    const BLOCK_SIZE plane_bsize =
-        get_plane_block_size(BLOCK_8X8, &xd->plane[plane]);
-#endif
     cpi->fn_ptr[plane_bsize].vf(src_uv, src_stride_uv, dst_uv, dst_stride_uv,
                                 &sse);
     dist_8x8_uv += (int64_t)sse << 4;
@@ -2810,11 +2799,11 @@
 
     restore_context(x, &x_ctx, mi_row, mi_col, bsize);
 
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_CFL && CONFIG_DEBUG
     if (!x->skip_chroma_rd) {
       cfl_clear_sub8x8_val(xd->cfl);
     }
-#endif  // CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif  // CONFIG_CFL && CONFIG_DEBUG
   }
 
   // store estimated motion vector
@@ -2866,10 +2855,10 @@
     }
 #endif  // CONFIG_DIST_8X8
 
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_CFL && CONFIG_DEBUG
     if (!reached_last_index && sum_rdc.rdcost >= best_rdc.rdcost)
       cfl_clear_sub8x8_val(xd->cfl);
-#endif  // CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif  // CONFIG_CFL && CONFIG_DEBUG
 
     if (reached_last_index && sum_rdc.rdcost < best_rdc.rdcost) {
       sum_rdc.rate += partition_cost[PARTITION_SPLIT];
@@ -2954,9 +2943,9 @@
 #endif  // CONFIG_DIST_8X8
     }
 
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_CFL && CONFIG_DEBUG
     cfl_clear_sub8x8_val(xd->cfl);
-#endif  // CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif  // CONFIG_CFL && CONFIG_DEBUG
     if (sum_rdc.rdcost < best_rdc.rdcost) {
       sum_rdc.rate += partition_cost[PARTITION_HORZ];
       sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, sum_rdc.dist);
@@ -3034,9 +3023,9 @@
 #endif  // CONFIG_DIST_8X8
     }
 
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_CFL && CONFIG_DEBUG
     cfl_clear_sub8x8_val(xd->cfl);
-#endif  // CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif  // CONFIG_CFL && CONFIG_DEBUG
 
     if (sum_rdc.rdcost < best_rdc.rdcost) {
       sum_rdc.rate += partition_cost[PARTITION_VERT];
@@ -4622,13 +4611,13 @@
     }
 #if CONFIG_CFL
     xd->cfl->store_y = 0;
-#if CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_DEBUG
     if (is_chroma_reference(mi_row, mi_col, bsize, xd->cfl->subsampling_x,
                             xd->cfl->subsampling_y) &&
         !xd->cfl->are_parameters_computed) {
       cfl_clear_sub8x8_val(xd->cfl);
     }
-#endif  // CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif  // CONFIG_DEBUG
 #endif  // CONFIG_CFL
     if (!dry_run) {
       sum_intra_stats(td->counts, xd, mi, xd->above_mi, xd->left_mi,
@@ -4817,7 +4806,7 @@
     mbmi->tx_size = tx_size;
     set_txfm_ctxs(tx_size, xd->n8_w, xd->n8_h, (mbmi->skip || seg_skip), xd);
   }
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8
+#if CONFIG_CFL
   CFL_CTX *const cfl = xd->cfl;
 #if CONFIG_DEBUG
   if (is_chroma_reference(mi_row, mi_col, bsize, cfl->subsampling_x,
@@ -4831,5 +4820,5 @@
                            cfl->subsampling_y)) {
     cfl_store_block(xd, mbmi->sb_type, mbmi->tx_size);
   }
-#endif  // CONFIG_CFL && CONFIG_CHROMA_SUB8X8
+#endif  // CONFIG_CFL
 }
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 95bae67..105eb92 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -1599,14 +1599,12 @@
             aom_highbd_8_sub_pixel_avg_variance4x4, aom_highbd_sad4x4x3_bits8,
             aom_highbd_sad4x4x8_bits8, aom_highbd_sad4x4x4d_bits8)
 
-#if CONFIG_CHROMA_SUB8X8
         HIGHBD_BFP(BLOCK_2X2, NULL, NULL, aom_highbd_8_variance2x2, NULL, NULL,
                    NULL, NULL, NULL)
         HIGHBD_BFP(BLOCK_4X2, NULL, NULL, aom_highbd_8_variance4x2, NULL, NULL,
                    NULL, NULL, NULL)
         HIGHBD_BFP(BLOCK_2X4, NULL, NULL, aom_highbd_8_variance2x4, NULL, NULL,
                    NULL, NULL, NULL)
-#endif
 
 #if CONFIG_EXT_PARTITION
         HIGHBD_BFP(BLOCK_128X128, aom_highbd_sad128x128_bits8,
@@ -1918,14 +1916,12 @@
             aom_highbd_10_sub_pixel_avg_variance4x4, aom_highbd_sad4x4x3_bits10,
             aom_highbd_sad4x4x8_bits10, aom_highbd_sad4x4x4d_bits10)
 
-#if CONFIG_CHROMA_SUB8X8
         HIGHBD_BFP(BLOCK_2X2, NULL, NULL, aom_highbd_10_variance2x2, NULL, NULL,
                    NULL, NULL, NULL)
         HIGHBD_BFP(BLOCK_4X2, NULL, NULL, aom_highbd_10_variance4x2, NULL, NULL,
                    NULL, NULL, NULL)
         HIGHBD_BFP(BLOCK_2X4, NULL, NULL, aom_highbd_10_variance2x4, NULL, NULL,
                    NULL, NULL, NULL)
-#endif
 
 #if CONFIG_EXT_PARTITION
         HIGHBD_BFP(
@@ -2239,14 +2235,12 @@
             aom_highbd_12_sub_pixel_avg_variance4x4, aom_highbd_sad4x4x3_bits12,
             aom_highbd_sad4x4x8_bits12, aom_highbd_sad4x4x4d_bits12)
 
-#if CONFIG_CHROMA_SUB8X8
         HIGHBD_BFP(BLOCK_2X2, NULL, NULL, aom_highbd_12_variance2x2, NULL, NULL,
                    NULL, NULL, NULL)
         HIGHBD_BFP(BLOCK_4X2, NULL, NULL, aom_highbd_12_variance4x2, NULL, NULL,
                    NULL, NULL, NULL)
         HIGHBD_BFP(BLOCK_2X4, NULL, NULL, aom_highbd_12_variance2x4, NULL, NULL,
                    NULL, NULL, NULL)
-#endif
 
 #if CONFIG_EXT_PARTITION
         HIGHBD_BFP(
@@ -2912,11 +2906,9 @@
       aom_sub_pixel_variance4x4, aom_sub_pixel_avg_variance4x4, aom_sad4x4x3,
       aom_sad4x4x8, aom_sad4x4x4d)
 
-#if CONFIG_CHROMA_SUB8X8
   BFP(BLOCK_2X2, NULL, NULL, aom_variance2x2, NULL, NULL, NULL, NULL, NULL)
   BFP(BLOCK_2X4, NULL, NULL, aom_variance2x4, NULL, NULL, NULL, NULL, NULL)
   BFP(BLOCK_4X2, NULL, NULL, aom_variance4x2, NULL, NULL, NULL, NULL, NULL)
-#endif
 
 #if CONFIG_MOTION_VAR
 #define OBFP(BT, OSDF, OVF, OSVF) \
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index 059680e..aad2038 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c
@@ -681,13 +681,8 @@
   MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
   BLOCK_SIZE bsize = mbmi->sb_type;
   struct macroblockd_plane *pd = &xd->plane[plane];
-
-#if CONFIG_CHROMA_SUB8X8
   const BLOCK_SIZE plane_bsize =
       AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
-  const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif  // CONFIG_CHROMA_SUB8X8
   const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
   const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
   const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 9da59fd..0753e3d 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -54,10 +54,7 @@
 // This table is used to correct for block size.
 // The factors here are << 2 (2 = x0.5, 32 = x8 etc).
 static const uint8_t rd_thresh_block_size_factor[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
-  2,  2,  2,
-#endif
-  2,  3,  3,  4, 6,  6,  8, 12, 12, 16, 24, 24, 32,
+  2,  2,  2,  2, 3,  3,  4, 6, 6, 8, 12, 12, 16, 24, 24, 32,
 #if CONFIG_EXT_PARTITION
   48, 48, 64,
 #endif  // CONFIG_EXT_PARTITION
@@ -1034,12 +1031,8 @@
                               const struct macroblockd_plane *pd,
                               ENTROPY_CONTEXT t_above[2 * MAX_MIB_SIZE],
                               ENTROPY_CONTEXT t_left[2 * MAX_MIB_SIZE]) {
-#if CONFIG_CHROMA_SUB8X8
   const BLOCK_SIZE plane_bsize =
       AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
-  const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif
   get_entropy_contexts_plane(plane_bsize, tx_size, pd, t_above, t_left);
 }
 
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 8a9e2da..c5a3d8b 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -1505,12 +1505,7 @@
   for (plane = plane_from; plane <= plane_to; ++plane) {
     struct macroblock_plane *const p = &x->plane[plane];
     struct macroblockd_plane *const pd = &xd->plane[plane];
-#if CONFIG_CHROMA_SUB8X8
     const BLOCK_SIZE bs = AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
-    const BLOCK_SIZE bs = get_plane_block_size(bsize, pd);
-#endif  // CONFIG_CHROMA_SUB8X8
-
     unsigned int sse;
     int rate;
     int64_t dist;
@@ -1727,20 +1722,15 @@
 #endif
   return cost_coeffs(cm, x, plane, block, tx_size, scan_order, a, l,
                      use_fast_coef_costing);
-#else  // !CONFIG_LV_MAP
+#else   // !CONFIG_LV_MAP
   (void)scan_order;
   (void)use_fast_coef_costing;
   const MACROBLOCKD *xd = &x->e_mbd;
   const MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
   const struct macroblockd_plane *pd = &xd->plane[plane];
   const BLOCK_SIZE bsize = mbmi->sb_type;
-#if CONFIG_CHROMA_SUB8X8
   const BLOCK_SIZE plane_bsize =
       AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
-  const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif  // CONFIG_CHROMA_SUB8X8
-
   TXB_CTX txb_ctx;
   get_txb_ctx(plane_bsize, tx_size, plane, a, l, &txb_ctx);
   return av1_cost_coeffs_txb(cm, x, plane, blk_row, blk_col, block, tx_size,
@@ -2122,11 +2112,7 @@
   }
 #if CONFIG_CFL
   if (plane == AOM_PLANE_Y && xd->cfl->store_y) {
-#if CONFIG_CHROMA_SUB8X8
     assert(!is_inter_block(mbmi) || plane_bsize < BLOCK_8X8);
-#else
-    assert(!is_inter_block(mbmi));
-#endif  // CONFIG_CHROMA_SUB8X8
     cfl_store_tx(xd, blk_row, blk_col, tx_size, plane_bsize);
   }
 #endif  // CONFIG_CFL
diff --git a/av1/encoder/tokenize.c b/av1/encoder/tokenize.c
index 072c7f5..e4ea8ef 100644
--- a/av1/encoder/tokenize.c
+++ b/av1/encoder/tokenize.c
@@ -686,12 +686,8 @@
       continue;
     }
     const struct macroblockd_plane *const pd = &xd->plane[plane];
-#if CONFIG_CHROMA_SUB8X8
     const BLOCK_SIZE plane_bsize =
         AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
-    const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif
     const int mi_width = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
     const int mi_height = block_size_high[plane_bsize] >> tx_size_wide_log2[0];
     const TX_SIZE max_tx_size = get_vartx_max_txsize(
diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake
index b75d935..4a8e027 100644
--- a/build/cmake/aom_config_defaults.cmake
+++ b/build/cmake/aom_config_defaults.cmake
@@ -113,7 +113,6 @@
 set(CONFIG_CDEF 1 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_CDEF_SINGLEPASS 0 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_CFL 0 CACHE NUMBER "AV1 experiment flag.")
-set(CONFIG_CHROMA_SUB8X8 1 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_COEF_INTERLEAVE 0 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_COLORSPACE_HEADERS 0 CACHE NUMBER "AV1 experiment flag.")
 set(CONFIG_COMPOUND_ROUND 0 CACHE NUMBER "AV1 experiment flag.")
diff --git a/configure b/configure
index 7e75870..3a26a4b 100755
--- a/configure
+++ b/configure
@@ -291,7 +291,6 @@
     daala_tx16
     daala_tx32
     daala_tx64
-    chroma_sub8x8
     frame_size
     ext_delta_q
     adapt_scan
@@ -503,7 +502,6 @@
     # Enable adopted experiments by default
     soft_enable adopted_experiments
     if enabled adopted_experiments; then
-      soft_enable chroma_sub8x8
       soft_enable rect_tx
       soft_enable global_motion
       soft_enable ext_tx
diff --git a/examples/inspect.c b/examples/inspect.c
index 087b943..dafcad8 100644
--- a/examples/inspect.c
+++ b/examples/inspect.c
@@ -141,9 +141,7 @@
                                ENUM(ALTREF_FRAME), LAST_ENUM };
 
 const map_entry block_size_map[] = {
-#if CONFIG_CHROMA_SUB8X8
   ENUM(BLOCK_2X2),    ENUM(BLOCK_2X4),    ENUM(BLOCK_4X2),
-#endif
   ENUM(BLOCK_4X4),    ENUM(BLOCK_4X8),    ENUM(BLOCK_8X4),
   ENUM(BLOCK_8X8),    ENUM(BLOCK_8X16),   ENUM(BLOCK_16X8),
   ENUM(BLOCK_16X16),  ENUM(BLOCK_16X32),  ENUM(BLOCK_32X16),