diff --git a/av1/common/av1_common_int.h b/av1/common/av1_common_int.h
index 06123ba..cfded4d 100644
--- a/av1/common/av1_common_int.h
+++ b/av1/common/av1_common_int.h
@@ -2230,10 +2230,12 @@
   // 'xd->tx_type_map' should point to an offset in 'mi_params->tx_type_map'.
   if (xd->tree_type != CHROMA_PART) {
     xd->tx_type_map = mi_params->tx_type_map + mi_grid_idx;
-#if CONFIG_CROSS_CHROMA_TX
-    xd->cctx_type_map = mi_params->cctx_type_map + mi_grid_idx;
-#endif  // CONFIG_CROSS_CHROMA_TX
   }
+#if CONFIG_CROSS_CHROMA_TX
+  if (xd->tree_type != LUMA_PART) {
+    xd->cctx_type_map = mi_params->cctx_type_map + mi_grid_idx;
+  }
+#endif  // CONFIG_CROSS_CHROMA_TX
   xd->tx_type_map_stride = mi_params->mi_stride;
 }
 
diff --git a/av1/common/av1_txfm.c b/av1/common/av1_txfm.c
index 267c59e..6c2e2c9 100644
--- a/av1/common/av1_txfm.c
+++ b/av1/common/av1_txfm.c
@@ -202,54 +202,34 @@
 // stores two values: cos(t) and sin(t) for each rotation angle.
 const int32_t cctx_mtx[CCTX_TYPES - 1][2] = {
 #if CCTX_ANGLE_CONFIG == 0
-#if CCTX_POS_ANGLES
-  { 181, 181 },  // t = 45 degrees
-  { 222, 128 },  // t = 30 degrees
-  { 128, 222 },  // t = 60 degrees
-#endif           // CCTX_POS_ANGLES
-#if CCTX_NEG_ANGLES
+  { 181, 181 },   // t = 45 degrees
+  { 222, 128 },   // t = 30 degrees
+  { 128, 222 },   // t = 60 degrees
   { 181, -181 },  // t = -45 degrees
   { 222, -128 },  // t = -30 degrees
   { 128, -222 },  // t = -60 degrees
-#endif            // CCTX_NEG_ANGLES
 #elif CCTX_ANGLE_CONFIG == 1
-#if CCTX_POS_ANGLES
   { 181, 181 },   // t = 45 degrees
   { 236, 98 },    // t = 22.5 degrees
   { 98, 236 },    // t = 67.5 degrees
-#endif  // CCTX_POS_ANGLES
-#if CCTX_NEG_ANGLES
   { 181, -181 },  // t = -45 degrees
   { 236, -98 },   // t = -22.5 degrees
   { 98, -236 },   // t = -67.5 degrees
-#endif  // CCTX_NEG_ANGLES
 #elif CCTX_ANGLE_CONFIG == 2
-#if CCTX_POS_ANGLES
   { 181, 181 },   // t = 45 degrees
   { 232, 108 },   // t = 25 degrees
   { 108, 232 },   // t = 65 degrees
-#endif  // CCTX_POS_ANGLES
-#if CCTX_NEG_ANGLES
   { 181, -181 },  // t = -45 degrees
   { 232, -108 },  // t = -25 degrees
   { 108, -232 },  // t = -65 degrees
-#endif  // CCTX_NEG_ANGLES
 #elif CCTX_ANGLE_CONFIG == 3
-#if CCTX_POS_ANGLES
   { 222, 128 },   // t = 30 degrees
   { 128, 222 },   // t = 60 degrees
-#endif  // CCTX_POS_ANGLES
-#if CCTX_NEG_ANGLES
   { 222, -128 },  // t = -30 degrees
   { 128, -222 },  // t = -60 degrees
-#endif  // CCTX_NEG_ANGLES
 #elif CCTX_ANGLE_CONFIG == 4
-#if CCTX_POS_ANGLES
   { 181, 181 },   // t = 45 degrees
-#endif  // CCTX_POS_ANGLES
-#if CCTX_NEG_ANGLES
   { 181, -181 },  // t = -45 degrees
-#endif  // CCTX_NEG_ANGLES
 #endif
 };
 #endif  // CONFIG_CROSS_CHROMA_TX
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index aee81be..9f22162 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -1564,38 +1564,56 @@
 #if CONFIG_CROSS_CHROMA_TX
 #if CCTX_C2_DROPPED
 static INLINE int keep_chroma_c2(CctxType cctx_type) {
-  return
-#if CCTX_NEG_ANGLES
-      cctx_type == CCTX_M30 || cctx_type == CCTX_M60 ||
-#endif
-#if CCTX_POS_ANGLES
-      cctx_type == CCTX_30 || cctx_type == CCTX_60 ||
-#endif
-      cctx_type == CCTX_NONE;
+  return cctx_type == CCTX_M30 || cctx_type == CCTX_M60 ||
+         cctx_type == CCTX_30 || cctx_type == CCTX_60 || cctx_type == CCTX_NONE;
 }
 #endif
 
+// When the current block is sub 8x8, obtain amounts of offset to its parent
+// 8x8 block. Otherwise set the offsets to 0.
+static INLINE void get_offsets_to_8x8(MACROBLOCKD *const xd, TX_SIZE tx_size,
+                                      int *row_offset, int *col_offset) {
+  const struct macroblockd_plane *const pd = &xd->plane[AOM_PLANE_U];
+  const int ss_x = pd->subsampling_x;
+  const int ss_y = pd->subsampling_y;
+  *row_offset =
+      (xd->mi_row & 0x01) && (tx_size_high_unit[tx_size] & 0x01) && ss_y;
+  *col_offset =
+      (xd->mi_col & 0x01) && (tx_size_wide_unit[tx_size] & 0x01) && ss_x;
+}
+
 static INLINE void update_cctx_array(MACROBLOCKD *const xd, int blk_row,
-                                     int blk_col, TX_SIZE tx_size,
+                                     int blk_col, int blk_row_offset,
+                                     int blk_col_offset, TX_SIZE tx_size,
                                      CctxType cctx_type) {
   const int stride = xd->tx_type_map_stride;
-  xd->cctx_type_map[blk_row * stride + blk_col] = cctx_type;
+  const struct macroblockd_plane *const pd = &xd->plane[AOM_PLANE_U];
+  const int ss_x = pd->subsampling_x;
+  const int ss_y = pd->subsampling_y;
+  assert(xd->is_chroma_ref);
 
-  const int txw = tx_size_wide_unit[tx_size];
-  const int txh = tx_size_high_unit[tx_size];
-  // The 16x16 unit is due to the constraint from tx_64x64 which sets the
-  // maximum tx size for chroma as 32x32. Coupled with 4x1 transform block
-  // size, the constraint takes effect in 32x16 / 16x32 size too. To solve
-  // the intricacy, cover all the 16x16 units inside a 64 level transform.
-  if (txw == tx_size_wide_unit[TX_64X64] ||
-      txh == tx_size_high_unit[TX_64X64]) {
-    const int tx_unit = tx_size_wide_unit[TX_16X16];
-    for (int idy = 0; idy < txh; idy += tx_unit) {
-      for (int idx = 0; idx < txw; idx += tx_unit) {
-        xd->cctx_type_map[(blk_row + idy) * stride + blk_col + idx] = cctx_type;
-      }
-    }
-  }
+  // For sub 8x8 block, offsets will be applied to reach the mi_row and mi_col
+  // of the >= 8x8 block area. Transform block size is upscaled to match the
+  // luma block size.
+  const int br = (blk_row << ss_y) - blk_row_offset;
+  const int bc = (blk_col << ss_x) - blk_col_offset;
+  const int txw = tx_size_wide_unit[tx_size] << ss_x;
+  const int txh = tx_size_high_unit[tx_size] << ss_y;
+
+  // To make cctx_type available for its right and bottom neighbors, cover
+  // all elements in cctx_type_map within the transform block range with the
+  // current cctx type
+  for (int idy = 0; idy < txh; idy++)
+    memset(&xd->cctx_type_map[(br + idy) * stride + bc], cctx_type,
+           txw * sizeof(xd->cctx_type_map[0]));
+}
+
+static INLINE CctxType av1_get_cctx_type(const MACROBLOCKD *xd, int blk_row,
+                                         int blk_col) {
+  const struct macroblockd_plane *const pd = &xd->plane[AOM_PLANE_U];
+  const int br = blk_row << pd->subsampling_y;
+  const int bc = blk_col << pd->subsampling_x;
+  return xd->cctx_type_map[br * xd->tx_type_map_stride + bc];
 }
 #endif  // CONFIG_CROSS_CHROMA_TX
 
@@ -1777,13 +1795,6 @@
   return tx_type;
 }
 
-#if CONFIG_CROSS_CHROMA_TX
-static INLINE CctxType av1_get_cctx_type(const MACROBLOCKD *xd, int blk_row,
-                                         int blk_col) {
-  return xd->cctx_type_map[blk_row * xd->tx_type_map_stride + blk_col];
-}
-#endif  // CONFIG_CROSS_CHROMA_TX
-
 void av1_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y,
                             const int num_planes);
 
diff --git a/av1/common/entropy.c b/av1/common/entropy.c
index 86b6465..b6933d5 100644
--- a/av1/common/entropy.c
+++ b/av1/common/entropy.c
@@ -296,6 +296,6 @@
   RESET_CDF_COUNTER_STRIDE(fc->stx_cdf, STX_TYPES, CDF_SIZE(STX_TYPES));
 #endif
 #if CONFIG_CROSS_CHROMA_TX
-  RESET_CDF_COUNTER(fc->cctx_type_cdf, CCTX_TYPES);
+  RESET_CDF_COUNTER(fc->cctx_type_cdf, CCTX_TYPES_ALLOWED);
 #endif  // CONFIG_CROSS_CHROMA_TX
 }
diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index e48fea4..f00070d 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -684,62 +684,77 @@
 #endif  // CONFIG_DDT_INTER
 
 #if CONFIG_CROSS_CHROMA_TX
-static const aom_cdf_prob default_cctx_type_cdf[EXT_TX_SIZES]
-                                               [CDF_SIZE(CCTX_TYPES)] = {
+static const aom_cdf_prob
+    default_cctx_type_cdf[EXT_TX_SIZES][CCTX_CONTEXTS]
+                         [CDF_SIZE(CCTX_TYPES_ALLOWED)] = {
 #if CCTX_ANGLE_CONFIG == 4
-#if CCTX_POS_ANGLES && CCTX_NEG_ANGLES
-                                                 { AOM_CDF3(10923, 21845) },
-                                                 { AOM_CDF3(10923, 21845) },
-                                                 { AOM_CDF3(10923, 21845) },
-                                                 { AOM_CDF3(10923, 21845) },
-#else
-                                                 { AOM_CDF2(16384) },
-                                                 { AOM_CDF2(16384) },
-                                                 { AOM_CDF2(16384) },
-                                                 { AOM_CDF2(16384) },
-#endif  // CCTX_POS_ANGLES && CCTX_NEG_ANGLES
+                           { { AOM_CDF3(10923, 21845) },
+                             { AOM_CDF3(10923, 21845) },
+                             { AOM_CDF3(10923, 21845) } },
+                           { { AOM_CDF3(10923, 21845) },
+                             { AOM_CDF3(10923, 21845) },
+                             { AOM_CDF3(10923, 21845) } },
+                           { { AOM_CDF3(10923, 21845) },
+                             { AOM_CDF3(10923, 21845) },
+                             { AOM_CDF3(10923, 21845) } },
+                           { { AOM_CDF3(10923, 21845) },
+                             { AOM_CDF3(10923, 21845) },
+                             { AOM_CDF3(10923, 21845) } },
 #elif CCTX_ANGLE_CONFIG == 3
-#if CCTX_POS_ANGLES && CCTX_NEG_ANGLES
-                                                 { AOM_CDF5(6554, 13107, 19661,
-                                                            26214) },
-                                                 { AOM_CDF5(6554, 13107, 19661,
-                                                            26214) },
-                                                 { AOM_CDF5(6554, 13107, 19661,
-                                                            26214) },
-                                                 { AOM_CDF5(6554, 13107, 19661,
-                                                            26214) },
+                           { { AOM_CDF5(6554, 13107, 19661, 26214) },
+                             { AOM_CDF5(6554, 13107, 19661, 26214) },
+                             { AOM_CDF5(6554, 13107, 19661, 26214) } },
+                           { { AOM_CDF5(6554, 13107, 19661, 26214) },
+                             { AOM_CDF5(6554, 13107, 19661, 26214) },
+                             { AOM_CDF5(6554, 13107, 19661, 26214) } },
+                           { { AOM_CDF5(6554, 13107, 19661, 26214) },
+                             { AOM_CDF5(6554, 13107, 19661, 26214) },
+                             { AOM_CDF5(6554, 13107, 19661, 26214) } },
+                           { { AOM_CDF5(6554, 13107, 19661, 26214) },
+                             { AOM_CDF5(6554, 13107, 19661, 26214) },
+                             { AOM_CDF5(6554, 13107, 19661, 26214) } },
 #else
-                                                 { AOM_CDF3(10923, 21845) },
-                                                 { AOM_CDF3(10923, 21845) },
-                                                 { AOM_CDF3(10923, 21845) },
-                                                 { AOM_CDF3(10923, 21845) },
-#endif  // CCTX_POS_ANGLES && CCTX_NEG_ANGLES
+#if CCTX_ADAPT_REDUCED_SET
+                           { { AOM_CDF3(21092, 22824) },
+                             { AOM_CDF3(23150, 29387) },
+                             { AOM_CDF3(12029, 25649) } },
+                           { { AOM_CDF3(17069, 19010) },
+                             { AOM_CDF3(22591, 27810) },
+                             { AOM_CDF3(10803, 24548) } },
+                           { { AOM_CDF3(16209, 18900) },
+                             { AOM_CDF3(21703, 27555) },
+                             { AOM_CDF3(8605, 23810) } },
+                           { { AOM_CDF3(15354, 17963) },
+                             { AOM_CDF3(22686, 27727) },
+                             { AOM_CDF3(9173, 22932) } }
 #else
-#if CCTX_POS_ANGLES && CCTX_NEG_ANGLES
-                                                 { AOM_CDF7(4681, 9362, 14043,
-                                                            18725, 23406,
-                                                            28087) },
-                                                 { AOM_CDF7(4681, 9362, 14043,
-                                                            18725, 23406,
-                                                            28087) },
-                                                 { AOM_CDF7(4681, 9362, 14043,
-                                                            18725, 23406,
-                                                            28087) },
-                                                 { AOM_CDF7(4681, 9362, 14043,
-                                                            18725, 23406,
-                                                            28087) },
-#else
-                                                 { AOM_CDF4(8192, 16384,
-                                                            24576) },
-                                                 { AOM_CDF4(8192, 16384,
-                                                            24576) },
-                                                 { AOM_CDF4(8192, 16384,
-                                                            24576) },
-                                                 { AOM_CDF4(8192, 16384,
-                                                            24576) },
-#endif  // CCTX_POS_ANGLES && CCTX_NEG_ANGLES
+                           { { AOM_CDF7(19143, 19642, 20876, 21362, 23684,
+                                        30645) },
+                             { AOM_CDF7(15852, 17519, 22430, 24276, 26473,
+                                        30362) },
+                             { AOM_CDF7(9981, 10351, 11021, 11340, 16893,
+                                        28901) } },
+                           { { AOM_CDF7(13312, 14068, 15345, 16249, 20082,
+                                        29648) },
+                             { AOM_CDF7(11802, 14635, 17918, 20493, 23927,
+                                        29206) },
+                             { AOM_CDF7(8348, 8915, 9727, 10347, 16584,
+                                        27923) } },
+                           { { AOM_CDF7(10604, 11887, 13486, 14485, 19798,
+                                        28529) },
+                             { AOM_CDF7(10790, 13346, 16867, 18854, 23398,
+                                        29133) },
+                             { AOM_CDF7(6538, 7104, 7997, 8723, 15658,
+                                        26864) } },
+                           { { AOM_CDF7(13226, 13959, 14918, 15707, 21009,
+                                        29328) },
+                             { AOM_CDF7(10336, 13195, 15614, 17813, 21992,
+                                        29469) },
+                             { AOM_CDF7(7769, 8772, 9617, 10150, 16729,
+                                        28132) } }
 #endif
-                                               };
+#endif
+                         };
 #endif  // CONFIG_CROSS_CHROMA_TX
 
 static const aom_cdf_prob default_cfl_sign_cdf[CDF_SIZE(CFL_JOINT_SIGNS)] = {
diff --git a/av1/common/entropymode.h b/av1/common/entropymode.h
index c2267a0..af9a7f2 100644
--- a/av1/common/entropymode.h
+++ b/av1/common/entropymode.h
@@ -273,7 +273,8 @@
   aom_cdf_prob stx_cdf[TX_SIZES][CDF_SIZE(STX_TYPES)];
 #endif
 #if CONFIG_CROSS_CHROMA_TX
-  aom_cdf_prob cctx_type_cdf[EXT_TX_SIZES][CDF_SIZE(CCTX_TYPES)];
+  aom_cdf_prob cctx_type_cdf[EXT_TX_SIZES][CCTX_CONTEXTS]
+                            [CDF_SIZE(CCTX_TYPES_ALLOWED)];
 #endif  // CONFIG_CROSS_CHROMA_TX
   int initialized;
 } FRAME_CONTEXT;
diff --git a/av1/common/enums.h b/av1/common/enums.h
index 9f33c0c..aef609b 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -404,14 +404,9 @@
 } UENUM1BYTE(TX_TYPE);
 
 #if CONFIG_CROSS_CHROMA_TX
-#define CCTX_NEG_ANGLES 1
-#define CCTX_POS_ANGLES 1
-// Always signal C1 coefficients for some cctx (i.e., both C1 and C2 nonzero
-// or C1 nonzero and C2 zero). This requires CCTX_NEG_ANGLES to be on.
-#define CCTX_C1_NONZERO 1
-// Drop C2 channel for some cctx_types. This macro requires CCTX_C1_NONZERO to
-// be on.
+#define CCTX_CONTEXTS 3
 #define CCTX_C2_DROPPED 0
+#define CCTX_ADAPT_REDUCED_SET 0
 // Configuration for the set of rotation angles
 // 0: { 45, 30, 60 }
 // 1: { 45, 22.5, 67.5 }
@@ -421,7 +416,6 @@
 #define CCTX_ANGLE_CONFIG 0
 enum {
   CCTX_NONE,  // No cross chroma transform
-#if CCTX_POS_ANGLES
 #if CCTX_ANGLE_CONFIG != 3
   CCTX_45,  // 45 degrees rotation (Haar transform)
 #endif
@@ -429,8 +423,6 @@
   CCTX_30,  // 30 degrees rotation
   CCTX_60,  // 60 degrees rotation
 #endif
-#endif  // CCTX_POS_ANGLES
-#if CCTX_NEG_ANGLES
 #if CCTX_ANGLE_CONFIG != 3
   CCTX_M45,  // -45 degrees rotation
 #endif
@@ -438,10 +430,16 @@
   CCTX_M30,  // -30 degrees rotation
   CCTX_M60,  // -60 degrees rotation
 #endif
-#endif  // CCTX_NEG_ANGLES
   CCTX_TYPES,
   CCTX_START = CCTX_NONE + 1,
 } UENUM1BYTE(CctxType);
+
+#if CCTX_ADAPT_REDUCED_SET
+#define CCTX_TYPES_ALLOWED 3
+#else
+#define CCTX_TYPES_ALLOWED CCTX_TYPES
+#endif
+
 #endif  // CONFIG_CROSS_CHROMA_TX
 
 enum {
diff --git a/av1/common/pred_common.h b/av1/common/pred_common.h
index 3491536..b614df3 100644
--- a/av1/common/pred_common.h
+++ b/av1/common/pred_common.h
@@ -357,6 +357,145 @@
 #endif  // CONFIG_SKIP_MODE_ENHANCEMENT
 }
 
+#if CONFIG_CROSS_CHROMA_TX
+#if CCTX_ADAPT_REDUCED_SET
+// The closest nonzero neighboring cctx type of the current cctx type
+static const CctxType closest_nonzero_cctx[CCTX_TYPES] = {
+#if 1
+  CCTX_30, CCTX_30, CCTX_45, CCTX_30, CCTX_M30, CCTX_M45, CCTX_M30
+#else
+  CCTX_30, CCTX_30, CCTX_45, CCTX_45, CCTX_M30, CCTX_M45, CCTX_M45
+#endif
+};
+
+// Return the set of 3 allowed cctx types given the above and left cctx types.
+// Since CCTX_NONE will always be allowed, so we add the above and left
+// to the allowed list only when they are valid (not -1) and not CCTX_NONE.
+// Then we add their closest cctx types if there is any available slot.
+static INLINE uint8_t get_allowed_cctx_mask(int above, int left) {
+  if (above <= CCTX_NONE && left <= CCTX_NONE)
+    return (1 << CCTX_NONE) + (1 << CCTX_30) + (1 << CCTX_M30);
+  else if (above <= CCTX_NONE)
+    return (1 << CCTX_NONE) + (1 << left) + (1 << closest_nonzero_cctx[left]);
+  else if (left <= CCTX_NONE || above == left)
+    return (1 << CCTX_NONE) + (1 << above) + (1 << closest_nonzero_cctx[above]);
+  else
+    return (1 << CCTX_NONE) + (1 << above) + (1 << left);
+}
+
+static INLINE void get_allowed_cctx_arr(const int above, const int left,
+                                        CctxType *cctxarr) {
+  cctxarr[0] = CCTX_NONE;
+  if (above <= CCTX_NONE && left <= CCTX_NONE) {
+    cctxarr[1] = CCTX_30;
+    cctxarr[2] = CCTX_M30;
+  } else if (above <= CCTX_NONE) {
+    cctxarr[1] = left;
+    cctxarr[2] = closest_nonzero_cctx[left];
+  } else if (left <= CCTX_NONE || above == left) {
+    cctxarr[1] = above;
+    cctxarr[2] = closest_nonzero_cctx[above];
+  } else {
+    cctxarr[1] = above;
+    cctxarr[2] = left;
+  }
+}
+
+static INLINE CctxType cctx_idx_to_type(const int cctx_idx, const int above,
+                                        const int left) {
+  CctxType cctx_arr[CCTX_TYPES_ALLOWED] = { 0 };
+  get_allowed_cctx_arr(above, left, cctx_arr);
+  return cctx_arr[cctx_idx];
+}
+
+static INLINE uint8_t cctx_type_to_idx(const CctxType ctype, const int above,
+                                       const int left) {
+  CctxType cctx_arr[CCTX_TYPES_ALLOWED] = { 0 };
+  get_allowed_cctx_arr(above, left, cctx_arr);
+  if (ctype == cctx_arr[0]) return 0;
+  if (ctype == cctx_arr[1]) return 1;
+  if (ctype == cctx_arr[2]) return 2;
+  assert(0);
+  return 0;
+}
+#endif
+// TODO(kslu) remove it
+// static INLINE void get_above_and_left_cctx_type(const MACROBLOCKD *xd,
+//                                                int blk_row, int blk_col,
+//                                                TX_SIZE tx_size,
+//                                                int *above_cctx,
+//                                                int *left_cctx) {
+//  const int ss_x = xd->plane[AOM_PLANE_U].subsampling_x;
+//  const int ss_y = xd->plane[AOM_PLANE_U].subsampling_y;
+//  const int txh = tx_size_high_unit[tx_size];
+//  const int txw = tx_size_wide_unit[tx_size];
+//
+//  // Offsets are needed for sub 8x8 blocks to reach the top left corner of the
+//  // current block where the current cctx_type is applied
+//  const int mi_row_offset = (xd->mi_row & 0x01) && (txh & 0x01) && ss_y;
+//  const int mi_col_offset = (xd->mi_col & 0x01) && (txw & 0x01) && ss_x;
+//  const int stride = xd->tx_type_map_stride;
+//  CctxType *cur_cctx_ptr =
+//      &xd->cctx_type_map[((blk_row << ss_y) - mi_row_offset) * stride +
+//                         (blk_col << ss_x) - mi_col_offset];
+//
+//  *above_cctx = xd->chroma_up_available ? (int)cur_cctx_ptr[-stride] : -1;
+//  *left_cctx = xd->chroma_left_available ? (int)cur_cctx_ptr[-1] : -1;
+//  assert(*above_cctx >= -1 && *above_cctx < CCTX_TYPES);
+//  assert(*left_cctx >= -1 && *left_cctx < CCTX_TYPES);
+//}
+
+static INLINE void get_above_and_left_cctx_type(
+    const AV1_COMMON *cm, const MACROBLOCKD *xd, int blk_row, int blk_col,
+    TX_SIZE tx_size, int *above_cctx, int *left_cctx) {
+  const int ss_x = xd->plane[AOM_PLANE_U].subsampling_x;
+  const int ss_y = xd->plane[AOM_PLANE_U].subsampling_y;
+  const int txh = tx_size_high_unit[tx_size];
+  const int txw = tx_size_wide_unit[tx_size];
+
+  const CommonModeInfoParams *const mi_params = &cm->mi_params;
+  const int stride = mi_params->mi_stride;
+
+  // Offsets are needed for sub 8x8 blocks to reach the top left corner of the
+  // current block where the current cctx_type is applied
+  const int mi_row_offset = (xd->mi_row & 0x01) && (txh & 0x01) && ss_y;
+  const int mi_col_offset = (xd->mi_col & 0x01) && (txw & 0x01) && ss_x;
+  const int mi_grid_idx = get_mi_grid_idx(mi_params, xd->mi_row - mi_row_offset,
+                                          xd->mi_col - mi_col_offset);
+  CctxType *const cur_cctx_ptr = mi_params->cctx_type_map + mi_grid_idx;
+
+  // TODO(kslu) change this workaround for shifts
+  const int cctx_stride = xd->tx_type_map_stride;
+  const int br = (txw == (cctx_stride >> ss_x)) ? blk_row : (blk_row << ss_y);
+  const int bc = (txw == (cctx_stride >> ss_x)) ? blk_col : (blk_col << ss_x);
+  if (blk_row)
+    *above_cctx = (int)xd->cctx_type_map[(br - 1) * cctx_stride + bc];
+  else
+    *above_cctx = xd->chroma_up_available ? (int)cur_cctx_ptr[-stride] : -1;
+
+  if (blk_col)
+    *left_cctx = (int)xd->cctx_type_map[br * stride + bc - 1];
+  else
+    *left_cctx = xd->chroma_left_available ? (int)cur_cctx_ptr[-1] : -1;
+
+  assert(*above_cctx >= -1 && *above_cctx < CCTX_TYPES);
+  assert(*left_cctx >= -1 && *left_cctx < CCTX_TYPES);
+}
+
+// 0: CCTX_NONE, unequal top and left context, or unavailable context
+// 1: positive angle cctx
+// 2: negative angle cctx
+static INLINE int get_cctx_context(const MACROBLOCKD *xd, const int above,
+                                   const int left) {
+  int above_ctx =
+      xd->chroma_up_available ? ((above > CCTX_60) + (above > CCTX_NONE)) : 0;
+  int left_ctx =
+      xd->chroma_left_available ? ((left > CCTX_60) + (left > CCTX_NONE)) : 0;
+  if (above_ctx == 0 || left_ctx == 0) return AOMMAX(above_ctx, left_ctx);
+  return (above_ctx == left_ctx) ? above_ctx : 0;
+}
+#endif  // CONFIG_CROSS_CHROMA_TX
+
 int av1_get_pred_context_switchable_interp(const MACROBLOCKD *xd, int dir);
 
 // Get a list of palette base colors that are used in the above and left blocks,
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index ba3490a..a1190be 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -251,14 +251,8 @@
 #if CONFIG_CROSS_CHROMA_TX && CCTX_INTRA
     eob_info *eob_data_u =
         dcb->eob_data[AOM_PLANE_U] + dcb->txb_offset[AOM_PLANE_U];
-#if CCTX_C1_NONZERO
-    if (eob_data->eob || (av1_get_cctx_type(xd, row, col) > CCTX_NONE &&
-                          plane == AOM_PLANE_V && eob_data_u->eob)) {
-#else
-    eob_info *eob_data_v =
-        dcb->eob_data[AOM_PLANE_V] + dcb->txb_offset[AOM_PLANE_V];
-    if (eob_data->eob || (plane && (eob_data_u->eob || eob_data_v->eob))) {
-#endif
+    if (eob_data->eob || (plane == AOM_PLANE_V && eob_data_u->eob &&
+                          av1_get_cctx_type(xd, row, col) > CCTX_NONE)) {
 #else
     if (eob_data->eob) {
 #endif  // CONFIG_CROSS_CHROMA_TX
@@ -1319,6 +1313,15 @@
                                       blk_row, blk_col, block, max_tx_size,
                                       &eobtotal);
                 block += stepr * stepc;
+#if CONFIG_CROSS_CHROMA_TX
+              } else if (plane == AOM_PLANE_U) {
+                // fill cctx_type_map with CCTX_NONE for skip blocks so their
+                // neighbors can derive cctx contexts
+                int row_offset, col_offset;
+                get_offsets_to_8x8(xd, max_tx_size, &row_offset, &col_offset);
+                update_cctx_array(xd, blk_row, blk_col, row_offset, col_offset,
+                                  max_tx_size, CCTX_NONE);
+#endif
               }
             }
           }
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 5181fcd..d6b9e07 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -874,9 +874,13 @@
                         int blk_row, int blk_col, TX_SIZE tx_size,
                         aom_reader *r) {
   MB_MODE_INFO *mbmi = xd->mi[0];
-  CctxType *cctx_type =
-      &xd->cctx_type_map[blk_row * xd->tx_type_map_stride + blk_col];
-  *cctx_type = CCTX_NONE;
+  // If it is a sub 8x8 chroma block, derive the mi_row and mi_col of the
+  // parent block area. Then apply cctx type update to this area w.r.t the
+  // offsets derived
+  int row_offset, col_offset;
+  get_offsets_to_8x8(xd, tx_size, &row_offset, &col_offset);
+  update_cctx_array(xd, blk_row, blk_col, row_offset, col_offset, tx_size,
+                    CCTX_NONE);
 
   // No need to read transform type if block is skipped.
   if (mbmi->skip_txfm[xd->tree_type == CHROMA_PART] ||
@@ -888,11 +892,26 @@
   if (qindex == 0) return;
 
   const int is_inter = is_inter_block(mbmi, xd->tree_type);
+  CctxType cctx_type = CCTX_NONE;
   if ((is_inter && CCTX_INTER) || (!is_inter && CCTX_INTRA)) {
     FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
     const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
-    *cctx_type = aom_read_symbol(r, ec_ctx->cctx_type_cdf[square_tx_size],
-                                 CCTX_TYPES, ACCT_STR);
+    int above_cctx, left_cctx;
+    get_above_and_left_cctx_type(cm, xd, blk_row, blk_col, tx_size, &above_cctx,
+                                 &left_cctx);
+    const int cctx_ctx = get_cctx_context(xd, above_cctx, left_cctx);
+#if CCTX_ADAPT_REDUCED_SET
+    const int cctx_idx =
+        aom_read_symbol(r, ec_ctx->cctx_type_cdf[square_tx_size][cctx_ctx],
+                        CCTX_TYPES_ALLOWED, ACCT_STR);
+    cctx_type = cctx_idx_to_type(cctx_idx, above_cctx, left_cctx);
+#else
+    cctx_type =
+        aom_read_symbol(r, ec_ctx->cctx_type_cdf[square_tx_size][cctx_ctx],
+                        CCTX_TYPES_ALLOWED, ACCT_STR);
+#endif
+    update_cctx_array(xd, blk_row, blk_col, row_offset, col_offset, tx_size,
+                      cctx_type);
   }
 }
 #endif  // CONFIG_CROSS_CHROMA_TX
diff --git a/av1/decoder/decoder.c b/av1/decoder/decoder.c
index 0558a17..a77ba3e 100644
--- a/av1/decoder/decoder.c
+++ b/av1/decoder/decoder.c
@@ -103,6 +103,10 @@
       mi_params->mi_stride * calc_mi_size(mi_params->mi_rows);
   memset(mi_params->mi_grid_base, 0,
          mi_grid_size * sizeof(*mi_params->mi_grid_base));
+#if CONFIG_CROSS_CHROMA_TX
+  memset(mi_params->cctx_type_map, 0,
+         mi_grid_size * sizeof(*mi_params->cctx_type_map));
+#endif  // CONFIG_CROSS_CHROMA_TX
 }
 
 static void dec_free_mi(CommonModeInfoParams *mi_params) {
diff --git a/av1/decoder/decodetxb.c b/av1/decoder/decodetxb.c
index 779408f..cc178c7 100644
--- a/av1/decoder/decodetxb.c
+++ b/av1/decoder/decodetxb.c
@@ -14,6 +14,7 @@
 
 #include "aom_ports/mem.h"
 #include "av1/common/idct.h"
+#include "av1/common/pred_common.h"
 #include "av1/common/scan.h"
 #include "av1/common/txb_common.h"
 #if CONFIG_FORWARDSKIP
@@ -192,23 +193,16 @@
 #endif  // CONFIG_CONTEXT_DERIVATION
 
 #if CONFIG_CROSS_CHROMA_TX
-#if CCTX_C1_NONZERO
   if (plane == AOM_PLANE_U) {
-    if (!all_zero)
+    if (!all_zero) {
       av1_read_cctx_type(cm, xd, blk_row, blk_col, tx_size, r);
-    else
-      xd->cctx_type_map[blk_row * xd->tx_type_map_stride + blk_col] = CCTX_NONE;
+    } else {
+      int row_offset, col_offset;
+      get_offsets_to_8x8(xd, tx_size, &row_offset, &col_offset);
+      update_cctx_array(xd, blk_row, blk_col, row_offset, col_offset, tx_size,
+                        CCTX_NONE);
+    }
   }
-#else
-  if (plane == AOM_PLANE_V) {
-    // cctx_type will be read either eob_v > 0 or eob_u > 0
-    eob_info *eob_data_u =
-        dcb->eob_data[AOM_PLANE_U] + dcb->txb_offset[AOM_PLANE_U];
-    const uint16_t eob_u = eob_data_u->eob;
-    if (!all_zero || eob_u > 0)
-      av1_read_cctx_type(cm, xd, blk_row, blk_col, tx_size, r);
-  }
-#endif  // CCTX_C1_NONZERO
 #endif  // CONFIG_CROSS_CHROMA_TX
 
   if (all_zero) {
@@ -363,19 +357,16 @@
 #endif  // CONFIG_CONTEXT_DERIVATION
 
 #if CONFIG_CROSS_CHROMA_TX
-#if CCTX_C1_NONZERO
-  if (plane == AOM_PLANE_U && !all_zero) {
-    av1_read_cctx_type(cm, xd, blk_row, blk_col, tx_size, r);
-  }
-#else
-  if (plane == AOM_PLANE_V) {
-    eob_info *eob_data_u =
-        dcb->eob_data[AOM_PLANE_U] + dcb->txb_offset[AOM_PLANE_U];
-    uint16_t eob_u = eob_data_u->eob;
-    if (!all_zero || eob_u > 0)
+  if (plane == AOM_PLANE_U) {
+    if (!all_zero) {
       av1_read_cctx_type(cm, xd, blk_row, blk_col, tx_size, r);
+    } else {
+      int row_offset, col_offset;
+      get_offsets_to_8x8(xd, tx_size, &row_offset, &col_offset);
+      update_cctx_array(xd, blk_row, blk_col, row_offset, col_offset, tx_size,
+                        CCTX_NONE);
+    }
   }
-#endif  // CCTX_C1_NONZERO
 #endif  // CONFIG_CROSS_CHROMA_TX
 #endif  // CONFIG_FORWARDSKIP
   eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
@@ -722,9 +713,6 @@
         for (int idy = 0; idy < txh; idy += tx_unit) {
           for (int idx = 0; idx < txw; idx += tx_unit) {
             xd->tx_type_map[(row + idy) * stride + col + idx] = tx_type;
-#if CONFIG_CROSS_CHROMA_TX
-            xd->cctx_type_map[(row + idy) * stride + col + idx] = CCTX_NONE;
-#endif  // CONFIG_CROSS_CHROMA_TX
           }
         }
       }
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index c062195..6653955 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -1160,7 +1160,8 @@
 
 #if CONFIG_CROSS_CHROMA_TX
 void av1_write_cctx_type(const AV1_COMMON *const cm, const MACROBLOCKD *xd,
-                         CctxType cctx_type, TX_SIZE tx_size, aom_writer *w) {
+                         int blk_row, int blk_col, CctxType cctx_type,
+                         TX_SIZE tx_size, aom_writer *w) {
   MB_MODE_INFO *mbmi = xd->mi[0];
   assert(xd->is_chroma_ref);
   const int is_inter = is_inter_block(mbmi, xd->tree_type);
@@ -1171,8 +1172,19 @@
       !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
     FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
     const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
-    aom_write_symbol(w, cctx_type, ec_ctx->cctx_type_cdf[square_tx_size],
-                     CCTX_TYPES);
+    int above_cctx, left_cctx;
+    get_above_and_left_cctx_type(cm, xd, blk_row, blk_col, tx_size, &above_cctx,
+                                 &left_cctx);
+    const int cctx_ctx = get_cctx_context(xd, above_cctx, left_cctx);
+#if CCTX_ADAPT_REDUCED_SET
+    aom_write_symbol(w, cctx_type_to_idx(cctx_type, above_cctx, left_cctx),
+                     ec_ctx->cctx_type_cdf[square_tx_size][cctx_ctx],
+                     CCTX_TYPES_ALLOWED);
+#else
+    aom_write_symbol(w, cctx_type,
+                     ec_ctx->cctx_type_cdf[square_tx_size][cctx_ctx],
+                     CCTX_TYPES_ALLOWED);
+#endif
   }
 }
 #endif  // CONFIG_CROSS_CHROMA_TX
@@ -2186,6 +2198,23 @@
   set_mi_row_col(xd, tile, mi_row, bh, mi_col, bw, mi_params->mi_rows,
                  mi_params->mi_cols);
 
+#if CONFIG_CROSS_CHROMA_TX
+  // For skip blocks, reset the corresponding area in cctx_type_map to
+  // CCTX_NONE, which will be used as contexts for later blocks. No need to use
+  // av1_get_adjusted_tx_size because uv_txsize is intended to cover the entire
+  // prediction block area
+  if (mbmi->skip_txfm[xd->tree_type == CHROMA_PART] &&
+      xd->tree_type != LUMA_PART && xd->is_chroma_ref) {
+    struct macroblockd_plane *const pd = &xd->plane[AOM_PLANE_U];
+    const BLOCK_SIZE uv_bsize =
+        get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
+    const TX_SIZE uv_txsize = max_txsize_rect_lookup[uv_bsize];
+    int row_offset, col_offset;
+    get_offsets_to_8x8(xd, uv_txsize, &row_offset, &col_offset);
+    update_cctx_array(xd, 0, 0, row_offset, col_offset, uv_txsize, CCTX_NONE);
+  }
+#endif  // CONFIG_CROSS_CHROMA_TX
+
   xd->above_txfm_context = cm->above_contexts.txfm[tile->tile_row] + mi_col;
   xd->left_txfm_context =
       xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK);
diff --git a/av1/encoder/bitstream.h b/av1/encoder/bitstream.h
index 8a7cd65..e788253 100644
--- a/av1/encoder/bitstream.h
+++ b/av1/encoder/bitstream.h
@@ -55,7 +55,8 @@
 
 #if CONFIG_CROSS_CHROMA_TX
 void av1_write_cctx_type(const AV1_COMMON *const cm, const MACROBLOCKD *xd,
-                         CctxType cctx_type, TX_SIZE tx_size, aom_writer *w);
+                         int blk_row, int blk_col, CctxType cctx_type,
+                         TX_SIZE tx_size, aom_writer *w);
 #endif  // CONFIG_CROSS_CHROMA_TX
 
 #ifdef __cplusplus
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 01f70d5..3abd50e 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -279,7 +279,7 @@
   TX_TYPE tx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
 #if CONFIG_CROSS_CHROMA_TX
   //! Map showing the cctx types for each block.
-  TX_TYPE cctx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
+  CctxType cctx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
 #endif  // CONFIG_CROSS_CHROMA_TX
   //! Rd_stats for the whole partition block.
   RD_STATS rd_stats;
@@ -855,7 +855,7 @@
 #endif  // CONFIG_DDT_INTER
 #if CONFIG_CROSS_CHROMA_TX
   //! cctx_type_cost
-  int cctx_type_cost[EXT_TX_SIZES][CCTX_TYPES];
+  int cctx_type_cost[EXT_TX_SIZES][CCTX_CONTEXTS][CCTX_TYPES_ALLOWED];
 #endif  // CONFIG_CROSS_CHROMA_TX
   /**@}*/
 
diff --git a/av1/encoder/encodeframe_utils.c b/av1/encoder/encodeframe_utils.c
index dcb753e..91a7073 100644
--- a/av1/encoder/encodeframe_utils.c
+++ b/av1/encoder/encodeframe_utils.c
@@ -247,18 +247,32 @@
   }
 
 #if CONFIG_CROSS_CHROMA_TX
-  if (xd->tree_type != LUMA_PART) {
+  if (xd->tree_type != LUMA_PART && xd->is_chroma_ref) {
     xd->cctx_type_map = ctx->cctx_type_map;
     xd->tx_type_map_stride = mi_size_wide[bsize];
+    // If this block is sub 8x8 in luma, derive the parent >= 8x8 block area,
+    // then update its corresponding chroma area in cctx_type_map to the
+    // current cctx type
+    const int ss_x = pd[AOM_PLANE_U].subsampling_x;
+    const int ss_y = pd[AOM_PLANE_U].subsampling_y;
+    const int mi_row_offset = (mi_row & 0x01) && (bh & 0x01) && ss_y;
+    const int mi_col_offset = (mi_col & 0x01) && (bw & 0x01) && ss_x;
+    const int grid_idx = get_mi_grid_idx(mi_params, mi_row - mi_row_offset,
+                                         mi_col - mi_col_offset);
+    CctxType *const cctx_type_map = mi_params->cctx_type_map + grid_idx;
+    const int mi_stride = mi_params->mi_stride;
+    const int is_inter = is_inter_block(mi_addr, xd->tree_type);
+    const int allow_cctx =
+        (is_inter && CCTX_INTER) || (!is_inter && CCTX_INTRA);
+    // Set cctx_type to CCTX_NONE when not allowed or for skip blocks
+    CctxType cur_cctx_type = (txfm_info->skip_txfm || !allow_cctx)
+                                 ? CCTX_NONE
+                                 : xd->cctx_type_map[0];
+    for (int blk_row = 0; blk_row < (mi_row_offset ? 2 : bh); ++blk_row) {
+      memset(&cctx_type_map[blk_row * mi_stride], cur_cctx_type,
+             (mi_col_offset ? 2 : bw) * sizeof(cctx_type_map[0]));
+    }
     if (!dry_run) {
-      const int grid_idx = get_mi_grid_idx(mi_params, mi_row, mi_col);
-      CctxType *const cctx_type_map = mi_params->cctx_type_map + grid_idx;
-      const int mi_stride = mi_params->mi_stride;
-      for (int blk_row = 0; blk_row < bh; ++blk_row) {
-        av1_copy_array(cctx_type_map + blk_row * mi_stride,
-                       xd->cctx_type_map + blk_row * xd->tx_type_map_stride,
-                       bw);
-      }
       xd->cctx_type_map = cctx_type_map;
       xd->tx_type_map_stride = mi_stride;
     }
@@ -1359,8 +1373,8 @@
                  CDF_SIZE(STX_TYPES));
 #endif
 #if CONFIG_CROSS_CHROMA_TX
-  AVG_CDF_STRIDE(ctx_left->cctx_type_cdf, ctx_tr->cctx_type_cdf, CCTX_TYPES,
-                 CDF_SIZE(CCTX_TYPES));
+  AVERAGE_CDF(ctx_left->cctx_type_cdf, ctx_tr->cctx_type_cdf,
+              CCTX_TYPES_ALLOWED);
 #endif  // CONFIG_CROSS_CHROMA_TX
 }
 
diff --git a/av1/encoder/encodemb.c b/av1/encoder/encodemb.c
index a2453b5..f3e4d49 100644
--- a/av1/encoder/encodemb.c
+++ b/av1/encoder/encodemb.c
@@ -78,7 +78,7 @@
 int av1_optimize_b(const struct AV1_COMP *cpi, MACROBLOCK *x, int plane,
                    int block, TX_SIZE tx_size, TX_TYPE tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-                   CctxType cctx_type,
+                   CctxType cctx_type, int blk_row, int blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
                    const TXB_CTX *const txb_ctx, int *rate_cost) {
   MACROBLOCKD *const xd = &x->e_mbd;
@@ -95,14 +95,15 @@
 #endif  // CONFIG_CONTEXT_DERIVATION
     );
 #if CONFIG_CROSS_CHROMA_TX
-    *rate_cost += get_cctx_type_cost(x, xd, plane, tx_size, block, cctx_type);
+    *rate_cost += get_cctx_type_cost(&cpi->common, x, xd, plane, tx_size,
+                                     blk_row, blk_col, block, cctx_type);
 #endif  // CONFIG_CROSS_CHROMA_TX
     return eob;
   }
 
   return av1_optimize_txb_new(cpi, x, plane, block, tx_size, tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-                              cctx_type,
+                              cctx_type, blk_row, blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
                               txb_ctx, rate_cost, cpi->oxcf.algo_cfg.sharpness);
 }
@@ -560,11 +561,26 @@
                                     tx_size, cm->features.reduced_tx_set_used);
 #if CONFIG_CROSS_CHROMA_TX
   CctxType cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
+#if CCTX_ADAPT_REDUCED_SET
+  if (plane) {
+    // TODO(kslu) change this workaround
+    // Since contexts can be changed during the dry run tx search, check if the
+    // cctx type is valid here. If not, just use CCTX_NONE.
+    int above_cctx, left_cctx;
+    get_above_and_left_cctx_type(cm, xd, blk_row, blk_col, tx_size, &above_cctx,
+                                 &left_cctx);
+    uint8_t allowed_cctx_mask = get_allowed_cctx_mask(above_cctx, left_cctx);
+    if (!(allowed_cctx_mask & (1 << cctx_type))) {
+      cctx_type = CCTX_NONE;
+      update_cctx_array(xd, blk_row, blk_col, 0, 0, tx_size, CCTX_NONE);
+    }
+  }
+#endif
 #endif  // CONFIG_CROSS_CHROMA_TX
 
   if (!is_blk_skip(x->txfm_search_info.blk_skip, plane,
                    blk_row * bw + blk_col) &&
-#if CONFIG_CROSS_CHROMA_TX && CCTX_INTER && CCTX_C1_NONZERO
+#if CONFIG_CROSS_CHROMA_TX && CCTX_INTER
 #if CCTX_C2_DROPPED
       (plane < AOM_PLANE_V ||
        ((cctx_type == CCTX_NONE || x->plane[AOM_PLANE_U].eobs[block]) &&
@@ -573,7 +589,7 @@
       (plane < AOM_PLANE_V || cctx_type == CCTX_NONE ||
        x->plane[AOM_PLANE_U].eobs[block]) &&
 #endif
-#endif  // CONFIG_CROSS_CHROMA_TX && CCTX_INTER && CCTX_C1_NONZERO
+#endif  // CONFIG_CROSS_CHROMA_TX && CCTX_INTER
 #if CONFIG_SKIP_MODE_ENHANCEMENT
       !(mbmi->skip_mode == 1)) {
 #else
@@ -635,7 +651,7 @@
       );
       av1_optimize_b(args->cpi, x, plane, block, tx_size, tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-                     cctx_type,
+                     cctx_type, blk_row, blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
                      &txb_ctx, &dummy_rate_cost);
     }
@@ -647,13 +663,12 @@
       av1_dropout_qcoeff(x, plane, block, tx_size, tx_type,
                          cm->quant_params.base_qindex);
     }
-#if CONFIG_CROSS_CHROMA_TX && CCTX_C1_NONZERO
+#if CONFIG_CROSS_CHROMA_TX
     // Since eob can be updated here, make sure cctx_type is always CCTX_NONE
     // when eob of U is 0.
-    // TODO(kslu) why cctx_type can be > CCTX_NONE when eob_u is 0?
     if (plane == AOM_PLANE_U && p->eobs[block] == 0)
-      update_cctx_array(xd, blk_row, blk_col, tx_size, CCTX_NONE);
-#endif  // CONFIG_CROSS_CHROMA_TX && CCTX_C1_NONZERO
+      update_cctx_array(xd, blk_row, blk_col, 0, 0, tx_size, CCTX_NONE);
+#endif  // CONFIG_CROSS_CHROMA_TX
   } else {
 #if CONFIG_CROSS_CHROMA_TX && CCTX_C2_DROPPED
     // Reset coeffs and dqcoeffs
@@ -1146,7 +1161,7 @@
       );
       av1_optimize_b(args->cpi, x, plane, block, tx_size, tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-                     CCTX_NONE,
+                     CCTX_NONE, blk_row, blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
                      &txb_ctx, &dummy_rate_cost);
     }
@@ -1246,6 +1261,19 @@
   TX_TYPE tx_type = av1_get_tx_type(xd, PLANE_TYPE_UV, blk_row, blk_col,
                                     tx_size, cm->features.reduced_tx_set_used);
   CctxType cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
+#if CCTX_ADAPT_REDUCED_SET
+  // TODO(kslu) change this workaround
+  // Since contexts can be changed during the dry run tx search, check if the
+  // cctx type is valid here. If not, just use CCTX_NONE.
+  int above_cctx, left_cctx;
+  get_above_and_left_cctx_type(cm, xd, blk_row, blk_col, tx_size, &above_cctx,
+                               &left_cctx);
+  uint8_t allowed_cctx_mask = get_allowed_cctx_mask(above_cctx, left_cctx);
+  if (!(allowed_cctx_mask & (1 << cctx_type))) {
+    cctx_type = CCTX_NONE;
+    update_cctx_array(xd, blk_row, blk_col, 0, 0, tx_size, CCTX_NONE);
+  }
+#endif
 
   av1_subtract_txb(x, AOM_PLANE_U, plane_bsize, blk_col, blk_row, tx_size);
   av1_subtract_txb(x, AOM_PLANE_V, plane_bsize, blk_col, blk_row, tx_size);
@@ -1283,22 +1311,20 @@
                             INTRA_BLOCK_OPT_TYPE == TRELLIS_DROPOUT_OPT));
 
   for (int plane = AOM_PLANE_U; plane <= AOM_PLANE_V; plane++) {
-#if CCTX_C1_NONZERO
+    // Since eob can be updated here, make sure cctx_type is always CCTX_NONE
+    // when eob of U is 0.
+    if (plane == AOM_PLANE_V && *eob_u == 0)
+      update_cctx_array(xd, blk_row, blk_col, 0, 0, tx_size, CCTX_NONE);
 #if CCTX_C2_DROPPED
     if (plane == AOM_PLANE_V && (!keep_chroma_c2(cctx_type) ||
                                  (*eob_u == 0 && cctx_type > CCTX_NONE))) {
 #else
     if (plane == AOM_PLANE_V && *eob_u == 0 && cctx_type > CCTX_NONE) {
 #endif
-      // Since eob can be updated here, make sure cctx_type is always CCTX_NONE
-      // when eob of U is 0.
-      if (*eob_u == 0 && cctx_type > CCTX_NONE)
-        update_cctx_array(xd, blk_row, blk_col, tx_size, CCTX_NONE);
       av1_quantize_skip(av1_get_max_eob(tx_size),
                         p_v->coeff + BLOCK_OFFSET(block), dqcoeff_v, eob_v);
       break;
     }
-#endif
     av1_setup_qmatrix(&cm->quant_params, xd, plane, tx_size, tx_type,
                       &quant_param);
     av1_xform_quant(
@@ -1320,7 +1346,7 @@
 #endif  // CONFIG_FORWARDSKIP
       );
       av1_optimize_b(args->cpi, x, plane, block, tx_size, tx_type, cctx_type,
-                     &txb_ctx, &dummy_rate_cost);
+                     blk_row, blk_col, &txb_ctx, &dummy_rate_cost);
     }
     if (do_dropout) {
       av1_dropout_qcoeff(x, plane, block, tx_size, tx_type,
diff --git a/av1/encoder/encodemb.h b/av1/encoder/encodemb.h
index ade30ee..68dd9cc 100644
--- a/av1/encoder/encodemb.h
+++ b/av1/encoder/encodemb.h
@@ -124,7 +124,7 @@
 int av1_optimize_b(const struct AV1_COMP *cpi, MACROBLOCK *mb, int plane,
                    int block, TX_SIZE tx_size, TX_TYPE tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-                   CctxType cctx_type,
+                   CctxType cctx_type, int blk_row, int blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
                    const TXB_CTX *const txb_ctx, int *rate_cost);
 
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 6d8cd79..0e1f301 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -1298,7 +1298,7 @@
                            [TX_TYPES];
 #endif  // CONFIG_DDT_INTER
 #if CONFIG_CROSS_CHROMA_TX
-  unsigned int cctx_type[EXT_TX_SIZES][CCTX_TYPES];
+  unsigned int cctx_type[EXT_TX_SIZES][CCTX_CONTEXTS][CCTX_TYPES_ALLOWED];
 #endif  // CONFIG_CROSS_CHROMA_TX
   unsigned int filter_intra_mode[FILTER_INTRA_MODES];
   unsigned int filter_intra[BLOCK_SIZES_ALL][2];
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index 4ca8a19..1157ad1 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c
@@ -457,23 +457,11 @@
 #endif  // CONFIG_CONTEXT_DERIVATION
 
 #if CONFIG_CROSS_CHROMA_TX
-#if CCTX_C1_NONZERO
-  if (plane == AOM_PLANE_U && eob > 0) {
+  if (plane == AOM_PLANE_U) {
     CctxType cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
-    av1_write_cctx_type(cm, xd, cctx_type, tx_size, w);
+    if (eob > 0)
+      av1_write_cctx_type(cm, xd, blk_row, blk_col, cctx_type, tx_size, w);
   }
-#else
-  // tx_type is signaled with Y plane if eob > 0. cctx_type is signaled with V
-  // plane if either of eob_u and eob_v is > 0.
-  if (plane == AOM_PLANE_V) {
-    const uint16_t *eob_txb_u = cb_coef_buff->eobs[AOM_PLANE_U] + txb_offset;
-    const uint16_t eob_u = eob_txb_u[block];
-    if (eob > 0 || eob_u > 0) {
-      const CctxType cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
-      av1_write_cctx_type(cm, xd, cctx_type, tx_size, w);
-    }
-  }
-#endif  // CCTX_C1_NONZERO
 #endif  // CONFIG_CROSS_CHROMA_TX
 
   if (eob == 0) return 0;
@@ -600,22 +588,10 @@
 #endif  // CONFIG_CONTEXT_DERIVATION
 
 #if CONFIG_CROSS_CHROMA_TX
-#if CCTX_C1_NONZERO
   if (plane == AOM_PLANE_U && eob > 0) {
     CctxType cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
-    av1_write_cctx_type(cm, xd, cctx_type, tx_size, w);
+    av1_write_cctx_type(cm, xd, blk_row, blk_col, cctx_type, tx_size, w);
   }
-#else
-  // CCTX type is transmitted with V plane
-  if (plane == AOM_PLANE_V) {
-    const uint16_t *eob_txb_u = cb_coef_buff->eobs[AOM_PLANE_U] + txb_offset;
-    const uint16_t eob_u = eob_txb_u[block];
-    if (eob > 0 || eob_u > 0) {
-      const CctxType cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
-      av1_write_cctx_type(cm, xd, cctx_type, tx_size, w);
-    }
-  }
-#endif  // CCTX_C1_NONZERO
 #endif  // CONFIG_CROSS_CHROMA_TX
 #endif  // CONFIG_FORWARDSKIP
 
@@ -879,22 +855,27 @@
 }
 
 #if CONFIG_CROSS_CHROMA_TX
-int get_cctx_type_cost(const MACROBLOCK *x, const MACROBLOCKD *xd, int plane,
-                       TX_SIZE tx_size, int block, CctxType cctx_type) {
+int get_cctx_type_cost(const AV1_COMMON *cm, const MACROBLOCK *x,
+                       const MACROBLOCKD *xd, int plane, TX_SIZE tx_size,
+                       int blk_row, int blk_col, int block,
+                       CctxType cctx_type) {
   const int is_inter = is_inter_block(xd->mi[0], xd->tree_type);
-  const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
-#if CCTX_C1_NONZERO
-  (void)block;
   if (plane == AOM_PLANE_U && x->plane[plane].eobs[block] &&
+      ((is_inter && CCTX_INTER) || (!is_inter && CCTX_INTRA))) {
+    const TX_SIZE square_tx_size = txsize_sqr_map[tx_size];
+    int above_cctx, left_cctx;
+    get_above_and_left_cctx_type(cm, xd, blk_row, blk_col, tx_size, &above_cctx,
+                                 &left_cctx);
+    const int cctx_ctx = get_cctx_context(xd, above_cctx, left_cctx);
+#if CCTX_ADAPT_REDUCED_SET
+    const int cctx_idx = cctx_type_to_idx(cctx_type, above_cctx, left_cctx);
+    return x->mode_costs.cctx_type_cost[square_tx_size][cctx_ctx][cctx_idx];
 #else
-  if (plane == AOM_PLANE_V &&
-      (x->plane[AOM_PLANE_U].eobs[block] ||
-       x->plane[AOM_PLANE_V].eobs[block]) &&
-#endif  // CCTX_C1_NONZERO
-      ((is_inter && CCTX_INTER) || (!is_inter && CCTX_INTRA)))
-    return x->mode_costs.cctx_type_cost[square_tx_size][cctx_type];
-  else
+    return x->mode_costs.cctx_type_cost[square_tx_size][cctx_ctx][cctx_type];
+#endif
+  } else {
     return 0;
+  }
 }
 #endif  // CONFIG_CROSS_CHROMA_TX
 
@@ -1024,13 +1005,16 @@
 
 #if CONFIG_FORWARDSKIP
 static AOM_FORCE_INLINE int warehouse_efficients_txb_skip(
+#if CONFIG_CROSS_CHROMA_TX
+    const AV1_COMMON *cm,
+#endif  // CONFIG_CROSS_CHROMA_TX
     const MACROBLOCK *x, const int plane, const int block,
     const TX_SIZE tx_size, const TXB_CTX *const txb_ctx,
     const struct macroblock_plane *p, const int eob,
     const LV_MAP_COEFF_COST *const coeff_costs, const MACROBLOCKD *const xd,
     const TX_TYPE tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-    const CctxType cctx_type,
+    const CctxType cctx_type, int blk_row, int blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
     int reduced_tx_set_used) {
   const tran_low_t *const qcoeff = p->qcoeff + BLOCK_OFFSET(block);
@@ -1053,7 +1037,8 @@
 #endif  // CONFIG_IST
   );
 #if CONFIG_CROSS_CHROMA_TX
-  cost += get_cctx_type_cost(x, xd, plane, tx_size, block, cctx_type);
+  cost += get_cctx_type_cost(cm, x, xd, plane, tx_size, blk_row, blk_col, block,
+                             cctx_type);
 #endif  // CONFIG_CROSS_CHROMA_TX
   DECLARE_ALIGNED(16, int8_t, coeff_contexts[MAX_TX_SQUARE]);
   av1_get_nz_map_contexts_skip(levels, scan, eob, tx_size, coeff_contexts);
@@ -1088,13 +1073,16 @@
 #endif  // CONFIG_FORWARDSKIP
 
 static AOM_FORCE_INLINE int warehouse_efficients_txb(
+#if CONFIG_CROSS_CHROMA_TX
+    const AV1_COMMON *cm,
+#endif  // CONFIG_CROSS_CHROMA_TX
     const MACROBLOCK *x, const int plane, const int block,
     const TX_SIZE tx_size, const TXB_CTX *const txb_ctx,
     const struct macroblock_plane *p, const int eob,
     const PLANE_TYPE plane_type, const LV_MAP_COEFF_COST *const coeff_costs,
     const MACROBLOCKD *const xd, const TX_TYPE tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-    const CctxType cctx_type,
+    const CctxType cctx_type, int blk_row, int blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
     const TX_CLASS tx_class, int reduced_tx_set_used) {
   const tran_low_t *const qcoeff = p->qcoeff + BLOCK_OFFSET(block);
@@ -1138,7 +1126,8 @@
 #endif
   );
 #if CONFIG_CROSS_CHROMA_TX
-  cost += get_cctx_type_cost(x, xd, plane, tx_size, block, cctx_type);
+  cost += get_cctx_type_cost(cm, x, xd, plane, tx_size, blk_row, blk_col, block,
+                             cctx_type);
 #endif  // CONFIG_CROSS_CHROMA_TX
 
   cost += get_eob_cost(eob, eob_costs, coeff_costs, tx_class);
@@ -1249,15 +1238,15 @@
 }
 
 static AOM_FORCE_INLINE int warehouse_efficients_txb_laplacian(
-#if CONFIG_FORWARDSKIP
+#if CONFIG_FORWARDSKIP || CONFIG_CROSS_CHROMA_TX
     const AV1_COMMON *cm,
-#endif  // CONFIG_FORWARDSKIP
+#endif  // CONFIG_FORWARDSKIP || CONFIG_CROSS_CHROMA_TX
     const MACROBLOCK *x, const int plane, const int block,
     const TX_SIZE tx_size, const TXB_CTX *const txb_ctx, const int eob,
     const PLANE_TYPE plane_type, const LV_MAP_COEFF_COST *const coeff_costs,
     const MACROBLOCKD *const xd, const TX_TYPE tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-    const CctxType cctx_type,
+    const CctxType cctx_type, int blk_row, int blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
     const TX_CLASS tx_class, int reduced_tx_set_used) {
 #if CONFIG_CONTEXT_DERIVATION
@@ -1291,7 +1280,8 @@
 #endif  // CONFIG_IST
   );
 #if CONFIG_CROSS_CHROMA_TX
-  cost += get_cctx_type_cost(x, xd, plane, tx_size, block, cctx_type);
+  cost += get_cctx_type_cost(cm, x, xd, plane, tx_size, blk_row, blk_col, block,
+                             cctx_type);
 #endif  // CONFIG_CROSS_CHROMA_TX
 
 #if !CONFIG_FORWARDSKIP
@@ -1387,7 +1377,7 @@
 }
 #endif  // CONFIG_FORWARDSKIP
 
-#if CONFIG_FORWARDSKIP
+#if CONFIG_FORWARDSKIP || CONFIG_CROSS_CHROMA_TX
 int av1_cost_coeffs_txb(const AV1_COMMON *cm, const MACROBLOCK *x,
                         const int plane, const int block,
 #else
@@ -1395,7 +1385,7 @@
 #endif  // CONFIG_FORWARDSKIP
                         const TX_SIZE tx_size, const TX_TYPE tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-                        const CctxType cctx_type,
+                        const CctxType cctx_type, int blk_row, int blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
                         const TXB_CTX *const txb_ctx, int reduced_tx_set_used) {
   const struct macroblock_plane *p = &x->plane[plane];
@@ -1423,7 +1413,8 @@
     skip_cost += coeff_costs->txb_skip_cost[txb_ctx->txb_skip_ctx][1];
 #endif  // CONFIG_CONTEXT_DERIVATION
 #if CONFIG_CROSS_CHROMA_TX
-    skip_cost += get_cctx_type_cost(x, xd, plane, tx_size, block, cctx_type);
+    skip_cost += get_cctx_type_cost(cm, x, xd, plane, tx_size, blk_row, blk_col,
+                                    block, cctx_type);
 #endif  // CONFIG_CROSS_CHROMA_TX
     return skip_cost;
   }
@@ -1443,38 +1434,49 @@
        tx_type == IDTX && plane == PLANE_TYPE_Y) ||
 #endif  // CONFIG_IST
       use_inter_fsc(cm, plane, tx_type, is_inter_block(mbmi, xd->tree_type))) {
-    return warehouse_efficients_txb_skip(x, plane, block, tx_size, txb_ctx, p,
-                                         eob, coeff_costs, xd, tx_type,
+    return warehouse_efficients_txb_skip(
 #if CONFIG_CROSS_CHROMA_TX
-                                         cctx_type,
+        cm,
 #endif  // CONFIG_CROSS_CHROMA_TX
-                                         reduced_tx_set_used);
+        x, plane, block, tx_size, txb_ctx, p, eob, coeff_costs, xd, tx_type,
+#if CONFIG_CROSS_CHROMA_TX
+        cctx_type, blk_row, blk_col,
+#endif  // CONFIG_CROSS_CHROMA_TX
+        reduced_tx_set_used);
   } else {
-    return warehouse_efficients_txb(x, plane, block, tx_size, txb_ctx, p, eob,
-                                    plane_type, coeff_costs, xd, tx_type,
+    return warehouse_efficients_txb(
 #if CONFIG_CROSS_CHROMA_TX
-                                    cctx_type,
+        cm,
 #endif  // CONFIG_CROSS_CHROMA_TX
-                                    tx_class, reduced_tx_set_used);
+        x, plane, block, tx_size, txb_ctx, p, eob, plane_type, coeff_costs, xd,
+        tx_type,
+#if CONFIG_CROSS_CHROMA_TX
+        cctx_type, blk_row, blk_col,
+#endif  // CONFIG_CROSS_CHROMA_TX
+        tx_class, reduced_tx_set_used);
   }
 #else
-  return warehouse_efficients_txb(x, plane, block, tx_size, txb_ctx, p, eob,
-                                  plane_type, coeff_costs, xd, tx_type,
+  return warehouse_efficients_txb(
 #if CONFIG_CROSS_CHROMA_TX
-                                  cctx_type,
+      cm,
 #endif  // CONFIG_CROSS_CHROMA_TX
-                                  tx_class, reduced_tx_set_used);
+      x, plane, block, tx_size, txb_ctx, p, eob, plane_type, coeff_costs, xd,
+      tx_type,
+#if CONFIG_CROSS_CHROMA_TX
+      cctx_type, blk_row, blk_col,
+#endif  // CONFIG_CROSS_CHROMA_TX
+      tx_class, reduced_tx_set_used);
 #endif  // CONFIG_FORWARDSKIP
 }
 
 int av1_cost_coeffs_txb_laplacian(
-#if CONFIG_FORWARDSKIP
+#if CONFIG_FORWARDSKIP || CONFIG_CROSS_CHROMA_TX
     const AV1_COMMON *cm,
 #endif  // CONFIG_FORWARDSKIP
     const MACROBLOCK *x, const int plane, const int block,
     const TX_SIZE tx_size, const TX_TYPE tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-    const CctxType cctx_type,
+    const CctxType cctx_type, int blk_row, int blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
     const TXB_CTX *const txb_ctx, const int reduced_tx_set_used,
     const int adjust_eob) {
@@ -1512,7 +1514,8 @@
     skip_cost += coeff_costs->txb_skip_cost[txb_ctx->txb_skip_ctx][1];
 #endif  // CONFIG_CONTEXT_DERIVATION
 #if CONFIG_CROSS_CHROMA_TX
-    skip_cost += get_cctx_type_cost(x, xd, plane, tx_size, block, cctx_type);
+    skip_cost += get_cctx_type_cost(cm, x, xd, plane, tx_size, blk_row, blk_col,
+                                    block, cctx_type);
 #endif  // CONFIG_CROSS_CHROMA_TX
     return skip_cost;
   }
@@ -1524,13 +1527,13 @@
 #endif
 
   return warehouse_efficients_txb_laplacian(
-#if CONFIG_FORWARDSKIP
+#if CONFIG_FORWARDSKIP || CONFIG_CROSS_CHROMA_TX
       cm,
-#endif  // CONFIG_FORWARDSKIP
+#endif  // CONFIG_FORWARDSKIP || CONFIG_CROSS_CHROMA_TX
       x, plane, block, tx_size, txb_ctx, eob, plane_type, coeff_costs, xd,
       tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-      cctx_type,
+      cctx_type, blk_row, blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
       tx_class, reduced_tx_set_used);
 }
@@ -1951,7 +1954,7 @@
 int av1_optimize_txb_new(const struct AV1_COMP *cpi, MACROBLOCK *x, int plane,
                          int block, TX_SIZE tx_size, TX_TYPE tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-                         CctxType cctx_type,
+                         CctxType cctx_type, int blk_row, int blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
                          const TXB_CTX *const txb_ctx, int *rate_cost,
                          int sharpness) {
@@ -2164,7 +2167,8 @@
       av1_get_txb_entropy_context(qcoeff, scan_order, p->eobs[block]);
 
 #if CONFIG_CROSS_CHROMA_TX
-  accu_rate += get_cctx_type_cost(x, xd, plane, tx_size, block, cctx_type);
+  accu_rate += get_cctx_type_cost(cm, x, xd, plane, tx_size, blk_row, blk_col,
+                                  block, cctx_type);
 #endif  // CONFIG_CROSS_CHROMA_TX
 
   *rate_cost = accu_rate;
@@ -2205,11 +2209,26 @@
       !mbmi->skip_txfm[xd->tree_type == CHROMA_PART] &&
       !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) {
     const CctxType cctx_type = av1_get_cctx_type(xd, blk_row, blk_col);
+    int above_cctx, left_cctx;
+    get_above_and_left_cctx_type(cm, xd, blk_row, blk_col, tx_size, &above_cctx,
+                                 &left_cctx);
+    const int cctx_ctx = get_cctx_context(xd, above_cctx, left_cctx);
     if (allow_update_cdf)
-      update_cdf(fc->cctx_type_cdf[txsize_sqr_map[tx_size]], cctx_type,
-                 CCTX_TYPES);
+#if CCTX_ADAPT_REDUCED_SET
+      update_cdf(fc->cctx_type_cdf[txsize_sqr_map[tx_size]][cctx_ctx],
+                 cctx_type_to_idx(cctx_type, above_cctx, left_cctx),
+                 CCTX_TYPES_ALLOWED);
+#else
+      update_cdf(fc->cctx_type_cdf[txsize_sqr_map[tx_size]][cctx_ctx],
+                 cctx_type, CCTX_TYPES_ALLOWED);
+#endif
 #if CONFIG_ENTROPY_STATS
-    ++counts->cctx_type[txsize_sqr_map[tx_size]][cctx_type];
+#if CCTX_ADAPT_REDUCED_SET
+    ++counts->cctx_type[txsize_sqr_map[tx_size]][cctx_ctx]
+                       [cctx_type_to_idx(cctx_type, above_cctx, left_cctx)];
+#else
+    ++counts->cctx_type[txsize_sqr_map[tx_size]][cctx_ctx][cctx_type];
+#endif
 #endif  // CONFIG_ENTROPY_STATS
   }
 }
@@ -2659,17 +2678,9 @@
     eob_txb[block] = eob;
 
 #if CONFIG_CROSS_CHROMA_TX
-#if CCTX_C1_NONZERO
     if (plane == AOM_PLANE_U && eob > 0)
       update_cctx_type_count(cm, xd, blk_row, blk_col, tx_size, td->counts,
                              allow_update_cdf);
-#else
-    if (plane == AOM_PLANE_V &&
-        (eob > 0 || x->plane[AOM_PLANE_U].eobs[block] > 0)) {
-      update_cctx_type_count(cm, xd, blk_row, blk_col, tx_size, td->counts,
-                             allow_update_cdf);
-    }
-#endif  // CCTX_C1_NONZERO
 #endif  // CONFIG_CROSS_CHROMA_TX
     if (eob == 0) {
       av1_set_entropy_contexts(xd, pd, plane, plane_bsize, tx_size, 0, blk_col,
diff --git a/av1/encoder/encodetxb.h b/av1/encoder/encodetxb.h
index 7e1be18..3f2bdcc 100644
--- a/av1/encoder/encodetxb.h
+++ b/av1/encoder/encodetxb.h
@@ -98,7 +98,11 @@
  * \param[in]    tx_type              The transform type.*/
 #if CONFIG_CROSS_CHROMA_TX
 /* \param[in]    cctx_type            The cross chroma component transform
- * type*/
+ * type
+ * \param[in]    blk_row      The row index of the current transform block
+ * in the macroblock. Each unit has 4 pixels in y plane.
+ * \param[in]    blk_col      The col index of the current transform block
+ * in the macroblock. Each unit has 4 pixels in y plane.*/
 #endif  // CONFIG_CROSS_CHROMA_TX
 /* \param[in]    txb_ctx              Context info for entropy coding transform
  block
@@ -113,7 +117,7 @@
     const MACROBLOCK *x, const int plane, const int block,
     const TX_SIZE tx_size, const TX_TYPE tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-    const CctxType cctx_type,
+    const CctxType cctx_type, int blk_row, int blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
     const TXB_CTX *const txb_ctx, int reduced_tx_set_used);
 
@@ -147,7 +151,11 @@
  * \param[in]    tx_size        The transform size
  * \param[in]    tx_type        The transform type*/
 #if CONFIG_CROSS_CHROMA_TX
-/* \param[in]    cctx_type      The cross chroma component transform type*/
+/* \param[in]    cctx_type      The cross chroma component transform type
+ * \param[in]    blk_row      The row index of the current transform block
+ * in the macroblock. Each unit has 4 pixels in y plane.
+ * \param[in]    blk_col      The col index of the current transform block
+ * in the macroblock. Each unit has 4 pixels in y plane.*/
 #endif  // CONFIG_CROSS_CHROMA_TX
 /* \param[in]    txb_ctx        Context info for entropy coding transform block
  * skip flag (tx_skip) and the sign of DC coefficient (dc_sign).
@@ -166,7 +174,7 @@
     const MACROBLOCK *x, const int plane, const int block,
     const TX_SIZE tx_size, const TX_TYPE tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-    const CctxType cctx_type,
+    const CctxType cctx_type, int blk_row, int blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
     const TXB_CTX *const txb_ctx, const int reduced_tx_set_used,
     const int adjust_eob);
@@ -506,6 +514,10 @@
  * \param[in]    tx_size        The transform size
  * \param[in]    tx_type        The transform type
  * \param[in]    cctx_type      The cross chroma component transform type
+ * \param[in]    blk_row      The row index of the current transform block
+ * in the macroblock. Each unit has 4 pixels in y plane.
+ * \param[in]    blk_col      The col index of the current transform block
+ * in the macroblock. Each unit has 4 pixels in y plane.
  * \param[in]    txb_ctx        Context info for entropy coding transform block
  * skip flag (tx_skip) and the sign of DC coefficient (dc_sign).
  * \param[out]   rate_cost      The entropy cost of coding the transform block
@@ -551,7 +563,7 @@
 int av1_optimize_txb_new(const struct AV1_COMP *cpi, MACROBLOCK *x, int plane,
                          int block, TX_SIZE tx_size, TX_TYPE tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-                         CctxType cctx_type,
+                         CctxType cctx_type, int blk_row, int blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
                          const TXB_CTX *const txb_ctx, int *rate_cost,
                          int sharpness);
@@ -575,9 +587,32 @@
  */
 CB_COEFF_BUFFER *av1_get_cb_coeff_buffer(const struct AV1_COMP *cpi, int mi_row,
                                          int mi_col);
+
 #if CONFIG_CROSS_CHROMA_TX
-int get_cctx_type_cost(const MACROBLOCK *x, const MACROBLOCKD *xd, int plane,
-                       TX_SIZE tx_size, int block, CctxType cctx_type);
+/*!\brief Return the entropy cost associated with the cross chroma transform
+ *
+ * \ingroup coefficient_coding
+ *
+ * \param[in]    cm             Top-level structure shared by encoder and
+ decoder
+ * \param[in]    x              Pointer to structure holding the data for the
+                                current encoding macroblock
+ * \param[in]    xd             Pointer to structure holding the data for the
+                                current macroblockd
+ * \param[in]    plane          The index of the current plane
+ * \param[in]    tx_size        The transform size
+ * \param[in]    blk_row      The row index of the current transform block
+ * in the macroblock. Each unit has 4 pixels in y plane.
+ * \param[in]    blk_col      The col index of the current transform block
+ * in the macroblock. Each unit has 4 pixels in y plane.
+ * \param[in]    block          The index of the current transform block
+ * \param[in]    cctx_type      The cross chroma transform type
+ *
+ * \return       int            Entropy cost for cctx type
+ */
+int get_cctx_type_cost(const AV1_COMMON *cm, const MACROBLOCK *x,
+                       const MACROBLOCKD *xd, int plane, TX_SIZE tx_size,
+                       int blk_row, int blk_col, int block, CctxType cctx_type);
 #endif  // CONFIG_CROSS_CHROMA_TX
 
 #if CONFIG_CONTEXT_DERIVATION
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 9eaec85..fd15af0 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -322,8 +322,10 @@
 
 #if CONFIG_CROSS_CHROMA_TX
   for (i = 0; i < EXT_TX_SIZES; ++i) {
-    av1_cost_tokens_from_cdf(mode_costs->cctx_type_cost[i],
-                             fc->cctx_type_cdf[i], NULL);
+    for (j = 0; j < CCTX_CONTEXTS; ++j) {
+      av1_cost_tokens_from_cdf(mode_costs->cctx_type_cost[i][j],
+                               fc->cctx_type_cdf[i][j], NULL);
+    }
   }
 #endif  // CONFIG_CROSS_CHROMA_TX
 
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 7baa75e..471743c 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -1626,7 +1626,7 @@
   uint8_t best_blk_skip[MAX_MIB_SIZE * MAX_MIB_SIZE];
   TX_TYPE best_tx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
 #if CONFIG_CROSS_CHROMA_TX
-  TX_TYPE best_cctx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
+  CctxType best_cctx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
 #endif  // CONFIG_CROSS_CHROMA_TX
   const int rate_mv0 = *rate_mv;
   const int interintra_allowed =
@@ -3569,7 +3569,7 @@
   TX_TYPE best_tx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
   av1_copy_array(best_tx_type_map, xd->tx_type_map, ctx->num_4x4_blk);
 #if CONFIG_CROSS_CHROMA_TX
-  TX_TYPE best_cctx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
+  CctxType best_cctx_type_map[MAX_MIB_SIZE * MAX_MIB_SIZE];
   av1_copy_array(best_cctx_type_map, xd->cctx_type_map, ctx->num_4x4_blk);
 #endif  // CONFIG_CROSS_CHROMA_TX
 
diff --git a/av1/encoder/tx_search.c b/av1/encoder/tx_search.c
index 4e33bbb..a09bd53 100644
--- a/av1/encoder/tx_search.c
+++ b/av1/encoder/tx_search.c
@@ -1152,7 +1152,7 @@
       if (quant_param_intra.use_optimize_b) {
         av1_optimize_b(cpi, x, plane, block, tx_size, best_tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-                       cctx_type,
+                       cctx_type, blk_row, blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
                        txb_ctx, rate_cost);
       }
@@ -1315,9 +1315,7 @@
   memcpy(tmp_dqcoeff_v, p_v->dqcoeff + BLOCK_OFFSET(block),
          sizeof(tran_low_t) * eob_max);
 
-#if CCTX_C1_NONZERO
   assert(p_u->eobs[block] > 0);
-#endif
   assert(cpi != NULL);
   assert(tx_size_wide_log2[0] == tx_size_high_log2[0]);
 
@@ -1551,7 +1549,7 @@
 #endif  // CONFIG_FORWARDSKIP
         x, plane, block, tx_size, tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-        CCTX_NONE,
+        CCTX_NONE, blk_row, blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
         txb_ctx, reduced_tx_set_used, 0);
 
@@ -1592,7 +1590,7 @@
 #endif  // CONFIG_FORWARDSKIP
         x, plane, block, tx_size, tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-        CCTX_NONE,
+        CCTX_NONE, blk_row, blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
         txb_ctx, reduced_tx_set_used, 0);
 
@@ -1712,7 +1710,7 @@
 #endif  // CONFIG_FORWARDSKIP
         x, plane, block, tx_size, tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-        CCTX_NONE,
+        CCTX_NONE, blk_row, blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
         txb_ctx, reduced_tx_set_used, 0);
     // tx domain dist
@@ -2339,7 +2337,7 @@
 #endif  // CONFIG_FORWARDSKIP
     MACROBLOCK *x, int plane, int block, TX_SIZE tx_size, const TX_TYPE tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-    const CctxType cctx_type,
+    const CctxType cctx_type, int blk_row, int blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
     const TXB_CTX *const txb_ctx, int reduced_tx_set_used) {
 #if TXCOEFF_COST_TIMER
@@ -2352,7 +2350,7 @@
 #endif  // CONFIG_FORWARDSKIP
       x, plane, block, tx_size, tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-      cctx_type,
+      cctx_type, blk_row, blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
       txb_ctx, reduced_tx_set_used);
 #if TXCOEFF_COST_TIMER
@@ -2800,7 +2798,7 @@
       if (quant_param.use_optimize_b) {
         av1_optimize_b(cpi, x, plane, block, tx_size, tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-                       CCTX_NONE,
+                       CCTX_NONE, blk_row, blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
                        txb_ctx, &rate_cost);
       } else {
@@ -2810,7 +2808,7 @@
 #endif  // CONFIG_FORWARDSKIP
             x, plane, block, tx_size, tx_type,
 #if CONFIG_CROSS_CHROMA_TX
-            CCTX_NONE,
+            CCTX_NONE, blk_row, blk_col,
 #endif  // CONFIG_CROSS_CHROMA_TX
             txb_ctx, cm->features.reduced_tx_set_used);
       }
@@ -3055,12 +3053,23 @@
   memcpy(orig_coeff_v, p_v->coeff + BLOCK_OFFSET(block),
          sizeof(tran_low_t) * max_eob);
 
+#if CCTX_ADAPT_REDUCED_SET
+  int above_cctx, left_cctx;
+  get_above_and_left_cctx_type(cm, xd, blk_row, blk_col, tx_size, &above_cctx,
+                               &left_cctx);
+  uint8_t cctx_mask = get_allowed_cctx_mask(above_cctx, left_cctx);
+#endif
+
   // Iterate through all transform type candidates.
   for (CctxType cctx_type = CCTX_START; cctx_type < CCTX_TYPES; ++cctx_type) {
+#if CCTX_ADAPT_REDUCED_SET
+    if (!(cctx_mask & (1 << cctx_type))) continue;
+#endif
+
     RD_STATS this_rd_stats;
     av1_invalid_rd_stats(&this_rd_stats);
 
-    update_cctx_array(xd, blk_row, blk_col, tx_size, cctx_type);
+    update_cctx_array(xd, blk_row, blk_col, 0, 0, tx_size, cctx_type);
     forward_cross_chroma_transform(x, block, tx_size, cctx_type);
 
     for (int plane = AOM_PLANE_U; plane <= AOM_PLANE_V; plane++) {
@@ -3092,18 +3101,17 @@
       // Calculate rate cost of quantized coefficients.
       if (quant_param.use_optimize_b) {
         av1_optimize_b(cpi, x, plane, block, tx_size, tx_type, cctx_type,
-                       &txb_ctx_uv[plane - AOM_PLANE_U],
+                       blk_row, blk_col, &txb_ctx_uv[plane - AOM_PLANE_U],
                        &rate_cost[plane - AOM_PLANE_U]);
       } else {
         rate_cost[plane - AOM_PLANE_U] = cost_coeffs(
 #if CONFIG_FORWARDSKIP
             cm,
 #endif  // CONFIG_FORWARDSKIP
-            x, plane, block, tx_size, tx_type, cctx_type,
+            x, plane, block, tx_size, tx_type, cctx_type, blk_row, blk_col,
             &txb_ctx_uv[plane - AOM_PLANE_U], cm->features.reduced_tx_set_used);
       }
     }
-#if CCTX_C1_NONZERO
     // TODO(kslu) for negative angles, skip av1_xform_quant and reuse previous
     // dqcoeffs
     uint64_t sse_dqcoeff_u =
@@ -3121,7 +3129,6 @@
       }
       continue;
     }
-#endif
 
     // If rd cost based on coeff rate alone is already more than best_rd,
     // terminate early.
@@ -3171,15 +3178,13 @@
   assert(best_rd != INT64_MAX);
 
   best_rd_stats->skip_txfm = (best_eob_u == 0 && best_eob_v == 0);
-  update_cctx_array(xd, blk_row, blk_col, tx_size, best_cctx_type);
+  update_cctx_array(xd, blk_row, blk_col, 0, 0, tx_size, best_cctx_type);
   p_u->txb_entropy_ctx[block] = best_txb_ctx_u;
   p_v->txb_entropy_ctx[block] = best_txb_ctx_v;
   p_u->eobs[block] = best_eob_u;
   p_v->eobs[block] = best_eob_v;
 
-#if CCTX_C1_NONZERO
   assert(IMPLIES(best_cctx_type > CCTX_NONE, best_eob_u > 0));
-#endif
 #if CCTX_C2_DROPPED
   assert(IMPLIES(!keep_chroma_c2(best_cctx_type), best_eob_v == 0));
 #endif
@@ -4284,7 +4289,7 @@
   const AV1_COMMON *cm = &cpi->common;
   RD_STATS rd_stats_joint_uv;
   av1_init_rd_stats(&rd_stats_joint_uv);
-  update_cctx_array(xd, blk_row, blk_col, tx_size, CCTX_NONE);
+  update_cctx_array(xd, blk_row, blk_col, 0, 0, tx_size, CCTX_NONE);
 
   // Obtain RD cost for CCTX_NONE
   RD_STATS rd_stats_uv[2];
diff --git a/tools/aom_entropy_optimizer.c b/tools/aom_entropy_optimizer.c
index a72a843..c98d648 100644
--- a/tools/aom_entropy_optimizer.c
+++ b/tools/aom_entropy_optimizer.c
@@ -375,10 +375,11 @@
 #if CONFIG_CROSS_CHROMA_TX
   /* cctx type */
   cts_each_dim[0] = EXT_TX_SIZES;
-  cts_each_dim[1] = CCTX_TYPES;
-  optimize_cdf_table(&fc.cctx_type[0][0], probsfile, 2, cts_each_dim,
+  cts_each_dim[1] = CCTX_CONTEXTS;
+  cts_each_dim[2] = CCTX_TYPES_ALLOWED;
+  optimize_cdf_table(&fc.cctx_type[0][0][0], probsfile, 3, cts_each_dim,
                      "static const aom_cdf_prob default_cctx_type[EXT_TX_SIZES]"
-                     "[CDF_SIZE(CCTX_TYPES)]");
+                     "[CCTX_CONTEXTS][CDF_SIZE(CCTX_TYPES_ALLOWED)]");
 #endif  // CONFIG_CROSS_CHROMA_TX
 
   /* tx type */