diff --git a/av1/common/av1_txfm.c b/av1/common/av1_txfm.c
index 0fe1e7f..a38b11d 100644
--- a/av1/common/av1_txfm.c
+++ b/av1/common/av1_txfm.c
@@ -196,6 +196,11 @@
     };
 #endif  // CONFIG_DST_32X32
 
+#if CONFIG_CROSS_CHROMA_TX
+// Haar transform [1, 1; 1, -1] * 1/sqrt(2) * (1<<CCTX_PREC_BITS)
+const int32_t cctx_mtx[4] = { 181, 181, 181, -181 };
+#endif  // CONFIG_CROSS_CHROMA_TX
+
 // av1_sinpi_arr_data[i][j] = (int)round((sqrt(2) * sin(j*Pi/9) * 2 / 3) * (1
 // << (cos_bit_min + i))) modified so that elements j=1,2 sum to element j=4.
 const int32_t av1_sinpi_arr_data[7][5] = {
diff --git a/av1/common/av1_txfm.h b/av1/common/av1_txfm.h
index 5958434..f68cf5e 100644
--- a/av1/common/av1_txfm.h
+++ b/av1/common/av1_txfm.h
@@ -49,6 +49,12 @@
 #define KLT_PREC_BITS 10
 #endif  // CONFIG_DDT_INTER
 
+#if CONFIG_CROSS_CHROMA_TX
+#define CCTX_DC_ONLY 0
+#define CCTX_PREC_BITS 8
+extern const int32_t cctx_mtx[4];
+#endif  // CONFIG_CROSS_CHROMA_TX
+
 #define MAX_TXFM_STAGE_NUM 12
 
 static const int cos_bit_min = 10;
diff --git a/av1/common/idct.c b/av1/common/idct.c
index 7f97bf6..7e56a68 100644
--- a/av1/common/idct.c
+++ b/av1/common/idct.c
@@ -320,6 +320,29 @@
   }
 }
 
+#if CONFIG_CROSS_CHROMA_TX
+void av1_inv_cross_chroma_tx_block(tran_low_t *dqcoeff_u, tran_low_t *dqcoeff_v,
+                                   TX_SIZE tx_size) {
+#if CCTX_DC_ONLY
+  const int ncoeffs = 1;
+#else
+  const int ncoeffs = av1_get_max_eob(tx_size);
+#endif
+  // TODO(kslu): check if there is any overflow issue
+  // TODO(kslu): keep track of the EOB before fwd and after inv cctx
+  int32_t *src_u = (int32_t *)dqcoeff_u;
+  int32_t *src_v = (int32_t *)dqcoeff_v;
+  int32_t tmp[2] = { 0, 0 };
+
+  for (int i = 0; i < ncoeffs; i++) {
+    tmp[0] = cctx_mtx[0] * src_u[i] + cctx_mtx[2] * src_v[i];
+    tmp[1] = cctx_mtx[1] * src_u[i] + cctx_mtx[3] * src_v[i];
+    src_u[i] = ROUND_POWER_OF_TWO_SIGNED(tmp[0], CCTX_PREC_BITS);
+    src_v[i] = ROUND_POWER_OF_TWO_SIGNED(tmp[1], CCTX_PREC_BITS);
+  }
+}
+#endif  // CONFIG_CROSS_CHROMA_TX
+
 void av1_inverse_transform_block(const MACROBLOCKD *xd,
 #if CONFIG_IST
                                  tran_low_t *dqcoeff,
diff --git a/av1/common/idct.h b/av1/common/idct.h
index 216f5ca..62b5c62 100644
--- a/av1/common/idct.h
+++ b/av1/common/idct.h
@@ -33,6 +33,11 @@
 #define MAX_TX_SCALE 1
 int av1_get_tx_scale(const TX_SIZE tx_size);
 
+#if CONFIG_CROSS_CHROMA_TX
+void av1_inv_cross_chroma_tx_block(tran_low_t *dqcoeff_u, tran_low_t *dqcoeff_v,
+                                   TX_SIZE tx_size);
+#endif  // CONFIG_CROSS_CHROMA_TX
+
 void av1_inverse_transform_block(const MACROBLOCKD *xd,
 #if CONFIG_IST
                                  tran_low_t *dqcoeff,
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 5ddf573..1c4664d 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -158,8 +158,24 @@
   tran_low_t *const dqcoeff = dcb->dqcoeff_block[plane] + dcb->cb_offset[plane];
 #endif
   eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
+#if CONFIG_CROSS_CHROMA_TX
+  // TODO(kslu): keep track of transform domain eobs of U and V
+  eob_info *eob_data_u =
+      dcb->eob_data[AOM_PLANE_U] + dcb->txb_offset[AOM_PLANE_U];
+  eob_info *eob_data_v =
+      dcb->eob_data[AOM_PLANE_V] + dcb->txb_offset[AOM_PLANE_V];
+  uint16_t scan_line = (plane == 0) ? eob_data->max_scan_line
+                                    : AOMMIN(av1_get_max_eob(tx_size),
+                                             AOMMAX(eob_data_u->max_scan_line,
+                                                    eob_data_v->max_scan_line));
+  uint16_t eob = (plane == 0)
+                     ? eob_data->eob
+                     : AOMMIN(av1_get_max_eob(tx_size),
+                              AOMMAX(eob_data_u->eob, eob_data_v->eob));
+#else
   uint16_t scan_line = eob_data->max_scan_line;
   uint16_t eob = eob_data->eob;
+#endif  // CONFIG_CROSS_CHROMA_TX
   av1_inverse_transform_block(&dcb->xd, dqcoeff, plane, tx_type, tx_size, dst,
                               stride, eob, reduced_tx_set);
 #if CONFIG_IST
@@ -249,6 +265,24 @@
   }
 }
 
+#if CONFIG_CROSS_CHROMA_TX
+static AOM_INLINE void inverse_cross_chroma_transform_block(
+    const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r,
+    const int plane, const int blk_row, const int blk_col,
+    const TX_SIZE tx_size) {
+  (void)cm;
+  (void)r;
+  (void)plane;
+  (void)blk_row;
+  (void)blk_col;
+  tran_low_t *dqcoeff_u =
+      dcb->dqcoeff_block[AOM_PLANE_U] + dcb->cb_offset[AOM_PLANE_U];
+  tran_low_t *dqcoeff_v =
+      dcb->dqcoeff_block[AOM_PLANE_V] + dcb->cb_offset[AOM_PLANE_V];
+  av1_inv_cross_chroma_tx_block(dqcoeff_u, dqcoeff_v, tx_size);
+}
+#endif  // CONFIG_CROSS_CHROMA_TX
+
 static AOM_INLINE void inverse_transform_inter_block(
     const AV1_COMMON *const cm, DecoderCodingBlock *dcb, aom_reader *const r,
     const int plane, const int blk_row, const int blk_col,
@@ -291,6 +325,9 @@
     AV1_COMMON *cm, ThreadData *const td, aom_reader *r,
     MB_MODE_INFO *const mbmi, int plane, BLOCK_SIZE plane_bsize, int blk_row,
     int blk_col, int block, TX_SIZE tx_size, int *eob_total) {
+#if CONFIG_CROSS_CHROMA_TX
+  if (plane == AOM_PLANE_U) return;
+#endif  // CONFIG_CROSS_CHROMA_TX
   DecoderCodingBlock *const dcb = &td->dcb;
   MACROBLOCKD *const xd = &dcb->xd;
   const struct macroblockd_plane *const pd = &xd->plane[plane];
@@ -308,6 +345,39 @@
   if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
 
   if (tx_size == plane_tx_size || plane) {
+#if CONFIG_CROSS_CHROMA_TX
+    switch (plane) {
+      case AOM_PLANE_Y:
+        td->read_coeffs_tx_inter_block_visit(cm, dcb, r, plane, blk_row,
+                                             blk_col, tx_size);
+
+        td->inverse_tx_inter_block_visit(cm, dcb, r, plane, blk_row, blk_col,
+                                         tx_size);
+        eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
+        *eob_total += eob_data->eob;
+        set_cb_buffer_offsets(dcb, tx_size, plane);
+        break;
+      case AOM_PLANE_V:
+        td->read_coeffs_tx_inter_block_visit(cm, dcb, r, AOM_PLANE_U, blk_row,
+                                             blk_col, tx_size);
+        td->read_coeffs_tx_inter_block_visit(cm, dcb, r, AOM_PLANE_V, blk_row,
+                                             blk_col, tx_size);
+        td->inverse_cctx_block_visit(cm, dcb, r, -1, blk_row, blk_col, tx_size);
+        td->inverse_tx_inter_block_visit(cm, dcb, r, AOM_PLANE_U, blk_row,
+                                         blk_col, tx_size);
+        td->inverse_tx_inter_block_visit(cm, dcb, r, AOM_PLANE_V, blk_row,
+                                         blk_col, tx_size);
+        eob_info *eob_data_u =
+            dcb->eob_data[AOM_PLANE_U] + dcb->txb_offset[AOM_PLANE_U];
+        eob_info *eob_data_v =
+            dcb->eob_data[AOM_PLANE_V] + dcb->txb_offset[AOM_PLANE_V];
+        *eob_total += eob_data_u->eob + eob_data_v->eob;
+        set_cb_buffer_offsets(dcb, tx_size, AOM_PLANE_U);
+        set_cb_buffer_offsets(dcb, tx_size, AOM_PLANE_V);
+        break;
+      case AOM_PLANE_U: assert(0); break;
+    }
+#else
     td->read_coeffs_tx_inter_block_visit(cm, dcb, r, plane, blk_row, blk_col,
                                          tx_size);
 
@@ -316,6 +386,7 @@
     eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane];
     *eob_total += eob_data->eob;
     set_cb_buffer_offsets(dcb, tx_size, plane);
+#endif  // CONFIG_CROSS_CHROMA_TX
   } else {
 #if CONFIG_NEW_TX_PARTITION
     TX_SIZE sub_txs[MAX_TX_PARTITIONS] = { 0 };
@@ -1161,104 +1232,94 @@
   const int plane_start = get_partition_plane_start(xd->tree_type);
   const int plane_end =
       get_partition_plane_end(xd->tree_type, av1_num_planes(cm));
-  if (!is_inter_block(mbmi, xd->tree_type)) {
-    int row, col;
+
+  int row, col;
+  const int max_blocks_wide = max_block_wide(xd, bsize, 0);
+  const int max_blocks_high = max_block_high(xd, bsize, 0);
+  const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
+  int mu_blocks_wide = mi_size_wide[max_unit_bsize];
+  int mu_blocks_high = mi_size_high[max_unit_bsize];
+  mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
+  mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
+
+  const int is_inter = is_inter_block(mbmi, xd->tree_type);
+  if (!is_inter) {
     assert(bsize == get_plane_block_size(bsize, xd->plane[0].subsampling_x,
                                          xd->plane[0].subsampling_y));
-    const int max_blocks_wide = max_block_wide(xd, bsize, 0);
-    const int max_blocks_high = max_block_high(xd, bsize, 0);
-    const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
-    int mu_blocks_wide = mi_size_wide[max_unit_bsize];
-    int mu_blocks_high = mi_size_high[max_unit_bsize];
-    mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
-    mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
-
-    for (row = 0; row < max_blocks_high; row += mu_blocks_high) {
-      for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
-        for (int plane = plane_start; plane < plane_end; ++plane) {
-          if (plane && !xd->is_chroma_ref) break;
-          const struct macroblockd_plane *const pd = &xd->plane[plane];
-          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];
-
-          const int unit_height = ROUND_POWER_OF_TWO(
-              AOMMIN(mu_blocks_high + row, max_blocks_high), pd->subsampling_y);
-          const int unit_width = ROUND_POWER_OF_TWO(
-              AOMMIN(mu_blocks_wide + col, max_blocks_wide), pd->subsampling_x);
-
-          for (int blk_row = row >> pd->subsampling_y; blk_row < unit_height;
-               blk_row += stepr) {
-            for (int blk_col = col >> pd->subsampling_x; blk_col < unit_width;
-                 blk_col += stepc) {
-              td->read_coeffs_tx_intra_block_visit(cm, dcb, r, plane, blk_row,
-                                                   blk_col, tx_size);
-              td->predict_and_recon_intra_block_visit(
-                  cm, dcb, r, plane, blk_row, blk_col, tx_size);
-              set_cb_buffer_offsets(dcb, tx_size, plane);
-            }
-          }
-        }
-      }
-    }
   } else {
     td->predict_inter_block_visit(cm, dcb, bsize);
-    // Reconstruction
-    if (!mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) {
-      int eobtotal = 0;
-
-      const int max_blocks_wide = max_block_wide(xd, bsize, 0);
-      const int max_blocks_high = max_block_high(xd, bsize, 0);
-      int row, col;
-
-      const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
+    if (!mbmi->skip_txfm[xd->tree_type == CHROMA_PART])
       assert(max_unit_bsize ==
              get_plane_block_size(BLOCK_64X64, xd->plane[0].subsampling_x,
                                   xd->plane[0].subsampling_y));
-      int mu_blocks_wide = mi_size_wide[max_unit_bsize];
-      int mu_blocks_high = mi_size_high[max_unit_bsize];
+  }
 
-      mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
-      mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
+  for (row = 0; row < max_blocks_high; row += mu_blocks_high) {
+    for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
+      for (int plane = plane_start; plane < plane_end; ++plane) {
+        if (plane && !xd->is_chroma_ref) break;
+        const struct macroblockd_plane *const pd = &xd->plane[plane];
+        const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
+        const int ss_x = pd->subsampling_x;
+        const int ss_y = pd->subsampling_y;
+        const int unit_height = ROUND_POWER_OF_TWO(
+            AOMMIN(mu_blocks_high + row, max_blocks_high), ss_y);
+        const int unit_width = ROUND_POWER_OF_TWO(
+            AOMMIN(mu_blocks_wide + col, max_blocks_wide), ss_x);
 
-      for (row = 0; row < max_blocks_high; row += mu_blocks_high) {
-        for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
-          for (int plane = plane_start; plane < plane_end; ++plane) {
-            if (plane && !xd->is_chroma_ref) break;
-            const struct macroblockd_plane *const pd = &xd->plane[plane];
-            const int ss_x = pd->subsampling_x;
-            const int ss_y = pd->subsampling_y;
-            const BLOCK_SIZE plane_bsize =
-                get_plane_block_size(bsize, ss_x, ss_y);
-            const TX_SIZE max_tx_size =
-                get_vartx_max_txsize(xd, plane_bsize, plane);
-            const int bh_var_tx = tx_size_high_unit[max_tx_size];
-            const int bw_var_tx = tx_size_wide_unit[max_tx_size];
-            int block = 0;
-            int step =
-                tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
-            int blk_row, blk_col;
-            const int unit_height = ROUND_POWER_OF_TWO(
-                AOMMIN(mu_blocks_high + row, max_blocks_high), ss_y);
-            const int unit_width = ROUND_POWER_OF_TWO(
-                AOMMIN(mu_blocks_wide + col, max_blocks_wide), ss_x);
-
-            for (blk_row = row >> ss_y; blk_row < unit_height;
-                 blk_row += bh_var_tx) {
-              for (blk_col = col >> ss_x; blk_col < unit_width;
-                   blk_col += bw_var_tx) {
+        const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, ss_x, ss_y);
+        const TX_SIZE max_tx_size =
+            get_vartx_max_txsize(xd, plane_bsize, plane);
+        const int stepr = is_inter ? tx_size_high_unit[max_tx_size]
+                                   : tx_size_high_unit[tx_size];
+        const int stepc = is_inter ? tx_size_wide_unit[max_tx_size]
+                                   : tx_size_wide_unit[tx_size];
+        int eobtotal = 0;
+        int block = 0;
+        for (int blk_row = row >> ss_y; blk_row < unit_height;
+             blk_row += stepr) {
+          for (int blk_col = col >> ss_x; blk_col < unit_width;
+               blk_col += stepc) {
+            if (!is_inter) {
+              td->read_coeffs_tx_intra_block_visit(cm, dcb, r, plane, blk_row,
+                                                   blk_col, tx_size);
+#if CONFIG_CROSS_CHROMA_TX
+              switch (plane) {
+                case AOM_PLANE_Y:
+                  td->predict_and_recon_intra_block_visit(
+                      cm, dcb, r, AOM_PLANE_Y, blk_row, blk_col, tx_size);
+                  set_cb_buffer_offsets(dcb, tx_size, AOM_PLANE_Y);
+                  break;
+                case AOM_PLANE_U: break;
+                case AOM_PLANE_V:
+                  td->predict_and_recon_intra_block_visit(
+                      cm, dcb, r, AOM_PLANE_U, blk_row, blk_col, tx_size);
+                  set_cb_buffer_offsets(dcb, tx_size, AOM_PLANE_U);
+                  td->predict_and_recon_intra_block_visit(
+                      cm, dcb, r, AOM_PLANE_V, blk_row, blk_col, tx_size);
+                  set_cb_buffer_offsets(dcb, tx_size, AOM_PLANE_V);
+                  break;
+              }
+#else
+              td->predict_and_recon_intra_block_visit(
+                  cm, dcb, r, plane, blk_row, blk_col, tx_size);
+              set_cb_buffer_offsets(dcb, tx_size, plane);
+#endif  // CONFIG_CROSS_CHROMA_TX
+            } else {
+              // Reconstruction
+              if (!mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) {
                 decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize,
                                       blk_row, blk_col, block, max_tx_size,
                                       &eobtotal);
-                block += step;
+                block += stepr * stepc;
               }
             }
           }
         }
       }
     }
-    td->cfl_store_inter_block_visit(cm, xd);
   }
+  if (is_inter) td->cfl_store_inter_block_visit(cm, xd);
 
   av1_visit_palette(pbi, xd, r, set_color_index_map_offset);
 }
@@ -3417,6 +3478,9 @@
   td->predict_and_recon_intra_block_visit = decode_block_void;
   td->read_coeffs_tx_inter_block_visit = decode_block_void;
   td->inverse_tx_inter_block_visit = decode_block_void;
+#if CONFIG_CROSS_CHROMA_TX
+  td->inverse_cctx_block_visit = decode_block_void;
+#endif  // CONFIG_CROSS_CHROMA_TX
   td->predict_inter_block_visit = predict_inter_block_void;
   td->cfl_store_inter_block_visit = cfl_store_inter_block_void;
 
@@ -3428,6 +3492,9 @@
     td->predict_and_recon_intra_block_visit =
         predict_and_reconstruct_intra_block;
     td->inverse_tx_inter_block_visit = inverse_transform_inter_block;
+#if CONFIG_CROSS_CHROMA_TX
+    td->inverse_cctx_block_visit = inverse_cross_chroma_transform_block;
+#endif  // CONFIG_CROSS_CHROMA_TX
     td->predict_inter_block_visit = predict_inter_block;
     td->cfl_store_inter_block_visit = cfl_store_inter_block;
   }
diff --git a/av1/decoder/decoder.h b/av1/decoder/decoder.h
index 78b6fc9..5f151cd 100644
--- a/av1/decoder/decoder.h
+++ b/av1/decoder/decoder.h
@@ -125,6 +125,9 @@
   decode_block_visitor_fn_t read_coeffs_tx_intra_block_visit;
   decode_block_visitor_fn_t predict_and_recon_intra_block_visit;
   decode_block_visitor_fn_t read_coeffs_tx_inter_block_visit;
+#if CONFIG_CROSS_CHROMA_TX
+  decode_block_visitor_fn_t inverse_cctx_block_visit;
+#endif  // CONFIG_CROSS_CHROMA_TX
   decode_block_visitor_fn_t inverse_tx_inter_block_visit;
   predict_inter_block_visitor_fn_t predict_inter_block_visit;
   cfl_store_inter_block_visitor_fn_t cfl_store_inter_block_visit;
diff --git a/av1/encoder/encodemb.c b/av1/encoder/encodemb.c
index 003be64..3cc29b1 100644
--- a/av1/encoder/encodemb.c
+++ b/av1/encoder/encodemb.c
@@ -273,11 +273,45 @@
   const struct macroblock_plane *const p = &x->plane[plane];
   const int is_inter = is_inter_block(mbmi, xd->tree_type);
 #endif  // CONFIG_FORWARDSKIP
+#if CONFIG_CROSS_CHROMA_TX
+  if (is_inter_block(x->e_mbd.mi[0], x->e_mbd.tree_type)) {
+    switch (plane) {
+      case AOM_PLANE_Y:
 #if CONFIG_IST
-  av1_xform(x, plane, block, blk_row, blk_col, plane_bsize, txfm_param, 0);
+        av1_xform(x, AOM_PLANE_Y, block, blk_row, blk_col, plane_bsize,
+                  txfm_param, 0);
+#else
+        av1_xform(x, AOM_PLANE_Y, block, blk_row, blk_col, plane_bsize,
+                  txfm_param);
+#endif
+        break;
+      case AOM_PLANE_U:
+#if CONFIG_IST
+        av1_xform(x, AOM_PLANE_U, block, blk_row, blk_col, plane_bsize,
+                  txfm_param, 0);
+        av1_xform(x, AOM_PLANE_V, block, blk_row, blk_col, plane_bsize,
+                  txfm_param, 0);
+#else
+        av1_xform(x, AOM_PLANE_U, block, blk_row, blk_col, plane_bsize,
+                  txfm_param);
+        av1_xform(x, AOM_PLANE_V, block, blk_row, blk_col, plane_bsize,
+                  txfm_param);
+#endif
+        forward_cross_chroma_transform(x, block, txfm_param->tx_size);
+        // TODO(kslu): maybe skip av1_setup_xform for V
+        break;
+      case AOM_PLANE_V: break;
+    }
+  } else {
+#endif  // CONFIG_CROSS_CHROMA_TX
+#if CONFIG_IST
+    av1_xform(x, plane, block, blk_row, blk_col, plane_bsize, txfm_param, 0);
 #else
   av1_xform(x, plane, block, blk_row, blk_col, plane_bsize, txfm_param);
 #endif
+#if CONFIG_CROSS_CHROMA_TX
+  }
+#endif  // CONFIG_CROSS_CHROMA_TX
 #if CONFIG_FORWARDSKIP
   const uint8_t fsc_mode =
       (mbmi->fsc_mode[xd->tree_type == CHROMA_PART] && plane == PLANE_TYPE_Y) ||
@@ -355,6 +389,17 @@
 #endif
 }
 
+#if CONFIG_CROSS_CHROMA_TX
+void forward_cross_chroma_transform(MACROBLOCK *x, int block, TX_SIZE tx_size) {
+  struct macroblock_plane *const p_u = &x->plane[AOM_PLANE_U];
+  struct macroblock_plane *const p_v = &x->plane[AOM_PLANE_V];
+  const int block_offset = BLOCK_OFFSET(block);
+  tran_low_t *coeff_u = p_u->coeff + block_offset;
+  tran_low_t *coeff_v = p_v->coeff + block_offset;
+  av1_fwd_cross_chroma_tx_block(coeff_u, coeff_v, tx_size);
+}
+#endif  // CONFIG_CROSS_CHROMA_TX
+
 void av1_quant(MACROBLOCK *x, int plane, int block, TxfmParam *txfm_param,
                QUANT_PARAM *qparam) {
   const struct macroblock_plane *const p = &x->plane[plane];
@@ -483,7 +528,7 @@
   MB_MODE_INFO *mbmi = xd->mi[0];
   struct macroblock_plane *const p = &x->plane[plane];
   struct macroblockd_plane *const pd = &xd->plane[plane];
-#if CONFIG_IST
+#if CONFIG_IST || CONFIG_CROSS_CHROMA_TX
   tran_low_t *dqcoeff = p->dqcoeff + BLOCK_OFFSET(block);
 #else
   tran_low_t *const dqcoeff = p->dqcoeff + BLOCK_OFFSET(block);
@@ -575,13 +620,45 @@
 
   av1_set_txb_context(x, plane, block, tx_size, a, l);
 
-  if (p->eobs[block]) {
-    *(args->skip) = 0;
-    av1_inverse_transform_block(xd, dqcoeff, plane, tx_type, tx_size, dst,
-                                pd->dst.stride, p->eobs[block],
+#if CONFIG_CROSS_CHROMA_TX
+  // In CONFIG_CROSS_CHROMA_TX, reconstruction for U plane relies on dqcoeffs of
+  // V plane, so the below operations for U are performed together with V once
+  // dqcoeffs of V are obtained.
+  if (is_inter_block(mbmi, xd->tree_type) && plane == AOM_PLANE_U) {
+    if (p->eobs[block]) *(args->skip) = 0;
+    return;
+  } else if (is_inter_block(mbmi, xd->tree_type) && plane == AOM_PLANE_V) {
+    struct macroblock_plane *const p_u = &x->plane[AOM_PLANE_U];
+    tran_low_t *dqcoeff_u = x->plane[AOM_PLANE_U].dqcoeff + BLOCK_OFFSET(block);
+    struct macroblockd_plane *const pd_u = &xd->plane[AOM_PLANE_U];
+    uint8_t *dst_u =
+        &pd_u->dst.buf[(blk_row * pd_u->dst.stride + blk_col) << MI_SIZE_LOG2];
+    av1_inv_cross_chroma_tx_block(dqcoeff_u, dqcoeff, tx_size);
+    av1_inverse_transform_block(xd, dqcoeff_u, AOM_PLANE_U, tx_type, tx_size,
+                                dst_u, pd_u->dst.stride,
+                                AOMMAX(p_u->eobs[block], p->eobs[block]),
                                 cm->features.reduced_tx_set_used);
   }
 
+  // TODO(kslu): keep track of transform domain eobs for U and V
+  if (p->eobs[block] || (plane && (x->plane[AOM_PLANE_U].eobs[block] ||
+                                   x->plane[AOM_PLANE_V].eobs[block]))) {
+#else
+  if (p->eobs[block]) {
+#endif  // CONFIG_CROSS_CHROMA_TX
+    *(args->skip) = 0;
+    av1_inverse_transform_block(
+        xd, dqcoeff, plane, tx_type, tx_size, dst, pd->dst.stride,
+#if CONFIG_CROSS_CHROMA_TX
+        (plane == 0) ? p->eobs[block]
+                     : AOMMAX(x->plane[AOM_PLANE_U].eobs[block],
+                              x->plane[AOM_PLANE_V].eobs[block]),
+#else
+        p->eobs[block],
+#endif
+        cm->features.reduced_tx_set_used);
+  }
+
   // TODO(debargha, jingning): Temporarily disable txk_type check for eob=0
   // case. It is possible that certain collision in hash index would cause
   // the assertion failure. To further optimize the rate-distortion
@@ -611,6 +688,18 @@
     int blk_h = block_size_high[bsize];
     mi_to_pixel_loc(&pixel_c, &pixel_r, xd->mi_col, xd->mi_row, blk_col,
                     blk_row, pd->subsampling_x, pd->subsampling_y);
+#if CONFIG_CROSS_CHROMA_TX
+    if (plane == AOM_PLANE_V) {
+      struct macroblockd_plane *const pd_u = &xd->plane[AOM_PLANE_U];
+      uint8_t *dst_u =
+          &pd_u->dst
+               .buf[(blk_row * pd_u->dst.stride + blk_col) << MI_SIZE_LOG2];
+      mismatch_record_block_tx(dst_u, pd_u->dst.stride,
+                               cm->current_frame.order_hint, AOM_PLANE_U,
+                               pixel_c, pixel_r, blk_w, blk_h,
+                               xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH);
+    }
+#endif  // CONFIG_CROSS_CHROMA_TX
     mismatch_record_block_tx(dst, pd->dst.stride, cm->current_frame.order_hint,
                              plane, pixel_c, pixel_r, blk_w, blk_h);
   }
@@ -808,6 +897,17 @@
     cpi,  x,    &ctx,    &mbmi->skip_txfm[xd->tree_type == CHROMA_PART],
     NULL, NULL, dry_run, cpi->optimize_seg_arr[mbmi->segment_id]
   };
+#if CONFIG_CROSS_CHROMA_TX
+  // Subtract first, so both U and V residues will be available when U component
+  // is being transformed and quantized.
+  for (int plane = plane_start; plane < plane_end; ++plane) {
+    const struct macroblockd_plane *const pd = &xd->plane[plane];
+    if (plane && !xd->is_chroma_ref) break;
+    const BLOCK_SIZE plane_bsize =
+        get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
+    av1_subtract_plane(x, plane_bsize, plane);
+  }
+#endif  // CONFIG_CROSS_CHROMA_TX
   for (int plane = plane_start; plane < plane_end; ++plane) {
     const struct macroblockd_plane *const pd = &xd->plane[plane];
     const int subsampling_x = pd->subsampling_x;
@@ -826,7 +926,10 @@
     const int step =
         tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
     av1_get_entropy_contexts(plane_bsize, pd, ctx.ta[plane], ctx.tl[plane]);
+#if !CONFIG_CROSS_CHROMA_TX
     av1_subtract_plane(x, plane_bsize, plane);
+#endif  // !CONFIG_CROSS_CHROMA_TX
+
     arg.ta = ctx.ta[plane];
     arg.tl = ctx.tl[plane];
     const BLOCK_SIZE max_unit_bsize =
@@ -1005,6 +1108,7 @@
   }
 
   if (*eob) {
+    // TODO(kslu) apply inv cctx for u plane once it is needed for intra
     av1_inverse_transform_block(xd, dqcoeff, plane, tx_type, tx_size, dst,
                                 dst_stride, *eob,
                                 cm->features.reduced_tx_set_used);
diff --git a/av1/encoder/encodemb.h b/av1/encoder/encodemb.h
index c289094..47f0b36 100644
--- a/av1/encoder/encodemb.h
+++ b/av1/encoder/encodemb.h
@@ -109,6 +109,10 @@
 #endif
 );
 
+#if CONFIG_CROSS_CHROMA_TX
+void forward_cross_chroma_transform(MACROBLOCK *x, int block, TX_SIZE tx_size);
+#endif  // CONFIG_CROSS_CHROMA_TX
+
 void av1_quant(MACROBLOCK *x, int plane, int block, TxfmParam *txfm_param,
                QUANT_PARAM *qparam);
 
diff --git a/av1/encoder/hybrid_fwd_txfm.c b/av1/encoder/hybrid_fwd_txfm.c
index 5ef2ff8..001f672 100644
--- a/av1/encoder/hybrid_fwd_txfm.c
+++ b/av1/encoder/hybrid_fwd_txfm.c
@@ -499,6 +499,27 @@
   }
 }
 
+#if CONFIG_CROSS_CHROMA_TX
+void av1_fwd_cross_chroma_tx_block(tran_low_t *coeff_u, tran_low_t *coeff_v,
+                                   TX_SIZE tx_size) {
+#if CCTX_DC_ONLY
+  const int ncoeffs = 1;
+#else
+  const int ncoeffs = av1_get_max_eob(tx_size);
+#endif
+  int32_t *src_u = (int32_t *)coeff_u;
+  int32_t *src_v = (int32_t *)coeff_v;
+  int32_t tmp[2] = { 0, 0 };
+
+  for (int i = 0; i < ncoeffs; i++) {
+    tmp[0] = cctx_mtx[0] * src_u[i] + cctx_mtx[1] * src_v[i];
+    tmp[1] = cctx_mtx[2] * src_u[i] + cctx_mtx[3] * src_v[i];
+    src_u[i] = ROUND_POWER_OF_TWO_SIGNED(tmp[0], CCTX_PREC_BITS);
+    src_v[i] = ROUND_POWER_OF_TWO_SIGNED(tmp[1], CCTX_PREC_BITS);
+  }
+}
+#endif  // CONFIG_CROSS_CHROMA_TX
+
 #if CONFIG_IST
 void av1_fwd_stxfm(tran_low_t *coeff, TxfmParam *txfm_param) {
   const TX_TYPE stx_type = txfm_param->sec_tx_type;
diff --git a/av1/encoder/hybrid_fwd_txfm.h b/av1/encoder/hybrid_fwd_txfm.h
index e171f67..6bc7ffb 100644
--- a/av1/encoder/hybrid_fwd_txfm.h
+++ b/av1/encoder/hybrid_fwd_txfm.h
@@ -25,6 +25,11 @@
 void av1_highbd_fwd_txfm(const int16_t *src_diff, tran_low_t *coeff,
                          int diff_stride, TxfmParam *txfm_param);
 
+#if CONFIG_CROSS_CHROMA_TX
+void av1_fwd_cross_chroma_tx_block(tran_low_t *dqcoeff_u, tran_low_t *dqcoeff_v,
+                                   TX_SIZE tx_size);
+#endif  // CONFIG_CROSS_CHROMA_TX
+
 #if CONFIG_IST
 void av1_fwd_stxfm(tran_low_t *coeff, TxfmParam *txfm_param);
 #endif
diff --git a/av1/encoder/tx_search.c b/av1/encoder/tx_search.c
index 3216e4a..4db1c8c 100644
--- a/av1/encoder/tx_search.c
+++ b/av1/encoder/tx_search.c
@@ -1142,6 +1142,7 @@
       }
     }
 
+    // TODO(kslu) apply inv cctx for u plane once it is needed for intra
     inverse_transform_block_facade(x, plane, block, blk_row, blk_col,
                                    x->plane[plane].eobs[block],
                                    cm->features.reduced_tx_set_used);
@@ -1217,7 +1218,7 @@
   const int dst_idx = (blk_row * dst_stride + blk_col) << MI_SIZE_LOG2;
   const uint8_t *src = &x->plane[plane].src.buf[src_idx];
   const uint8_t *dst = &xd->plane[plane].dst.buf[dst_idx];
-#if CONFIG_IST
+#if CONFIG_IST || CONFIG_CROSS_CHROMA_TX
   tran_low_t *dqcoeff = p->dqcoeff + BLOCK_OFFSET(block);
 #else
   const tran_low_t *dqcoeff = p->dqcoeff + BLOCK_OFFSET(block);
@@ -1236,6 +1237,12 @@
   const PLANE_TYPE plane_type = get_plane_type(plane);
   TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, blk_row, blk_col, tx_size,
                                     cpi->common.features.reduced_tx_set_used);
+#if CONFIG_CROSS_CHROMA_TX
+  if (is_inter_block(xd->mi[0], xd->tree_type) && plane == AOM_PLANE_U) {
+    tran_low_t *dqcoeff_v = x->plane[AOM_PLANE_V].dqcoeff + BLOCK_OFFSET(block);
+    av1_inv_cross_chroma_tx_block(dqcoeff, dqcoeff_v, tx_size);
+  }
+#endif  // CONFIG_CROSS_CHROMA_TX
   av1_inverse_transform_block(xd, dqcoeff, plane, tx_type, tx_size, recon,
                               MAX_TX_SIZE, eob,
                               cpi->common.features.reduced_tx_set_used);
@@ -2601,15 +2608,60 @@
       RD_STATS this_rd_stats;
       av1_invalid_rd_stats(&this_rd_stats);
 
-      if (!dc_only_blk)
+#if CONFIG_CROSS_CHROMA_TX
+      if (is_inter_block(mbmi, xd->tree_type)) {
+        switch (plane) {
+          case AOM_PLANE_Y:
+            if (!dc_only_blk) {
 #if CONFIG_IST
-        av1_xform(x, plane, block, blk_row, blk_col, plane_bsize, &txfm_param,
-                  1);
+              av1_xform(x, AOM_PLANE_Y, block, blk_row, blk_col, plane_bsize,
+                        &txfm_param, 1);
+#else
+              av1_xform(x, AOM_PLANE_Y, block, blk_row, blk_col, plane_bsize,
+                        &txfm_param);
+#endif
+            } else {
+              av1_xform_dc_only(x, AOM_PLANE_Y, block, &txfm_param,
+                                per_px_mean);
+            }
+            break;
+          case AOM_PLANE_U:
+            if (!dc_only_blk) {
+#if CONFIG_IST
+              av1_xform(x, AOM_PLANE_U, block, blk_row, blk_col, plane_bsize,
+                        &txfm_param, 1);
+              av1_xform(x, AOM_PLANE_V, block, blk_row, blk_col, plane_bsize,
+                        &txfm_param, 1);
+#else
+              av1_xform(x, AOM_PLANE_U, block, blk_row, blk_col, plane_bsize,
+                        &txfm_param);
+              av1_xform(x, AOM_PLANE_V, block, blk_row, blk_col, plane_bsize,
+                        &txfm_param);
+#endif
+            } else {
+              av1_xform_dc_only(x, AOM_PLANE_U, block, &txfm_param,
+                                per_px_mean);
+              av1_xform_dc_only(x, AOM_PLANE_V, block, &txfm_param,
+                                per_px_mean);
+            }
+            forward_cross_chroma_transform(x, block, txfm_param.tx_size);
+            break;
+          case AOM_PLANE_V: break;
+        }
+      } else {
+#endif
+        if (!dc_only_blk)
+#if CONFIG_IST
+          av1_xform(x, plane, block, blk_row, blk_col, plane_bsize, &txfm_param,
+                    1);
 #else
       av1_xform(x, plane, block, blk_row, blk_col, plane_bsize, &txfm_param);
 #endif
-      else
-        av1_xform_dc_only(x, plane, block, &txfm_param, per_px_mean);
+        else
+          av1_xform_dc_only(x, plane, block, &txfm_param, per_px_mean);
+#if CONFIG_CROSS_CHROMA_TX
+      }
+#endif  // CONFIG_CROSS_CHROMA_TX
 
 #if CONFIG_IST
       skip_trellis_based_on_satd[txfm_param.tx_type] =
diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake
index 46c4535..14e2a17 100644
--- a/build/cmake/aom_config_defaults.cmake
+++ b/build/cmake/aom_config_defaults.cmake
@@ -208,6 +208,8 @@
 set_aom_config_var(CONFIG_DST_32X32 0 NUMBER "AV2 DST7 32x32 experiment flag.")
 set_aom_config_var(CONFIG_DDT_INTER 0 NUMBER
                    "AV2 data-driven inter transform experiment flag.")
+set_aom_config_var(CONFIG_CROSS_CHROMA_TX 0
+                   "AV2 cross chroma component transform experiment flag.")
 #
 # Variables in this section control optional features of the build system.
 #