diff --git a/apps/aomenc.c b/apps/aomenc.c
index feb7a46..5e5a200 100644
--- a/apps/aomenc.c
+++ b/apps/aomenc.c
@@ -39,6 +39,9 @@
 #include "common/stream_iter.h"
 #include "common/tools_common.h"
 #include "common/warnings.h"
+#if CONFIG_EXTENDED_SDP
+#include "av1/common/blockd.h"
+#endif  // CONFIG_EXTENDED_SDP
 
 #if CONFIG_WEBM_IO
 #include "common/webmenc.h"
diff --git a/av1/common/av1_common_int.h b/av1/common/av1_common_int.h
index 5183035..54cf83a 100644
--- a/av1/common/av1_common_int.h
+++ b/av1/common/av1_common_int.h
@@ -1967,6 +1967,16 @@
          cm->current_frame.frame_type == INTRA_ONLY_FRAME;
 }
 
+#if CONFIG_EXTENDED_SDP
+// Check whether this is chroma component of an intra region in inter frame
+static INLINE int is_inter_sdp_chroma(const AV1_COMMON *const cm,
+                                      REGION_TYPE cur_region_type,
+                                      TREE_TYPE cur_tree_type) {
+  return !frame_is_intra_only(cm) && cur_region_type == INTRA_REGION &&
+         cur_tree_type == CHROMA_PART;
+}
+#endif  // CONFIG_EXTENDED_SDP
+
 static INLINE int frame_is_sframe(const AV1_COMMON *cm) {
   return cm->current_frame.frame_type == S_FRAME;
 }
@@ -2575,6 +2585,24 @@
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
 }
 
+#if CONFIG_EXTENDED_SDP
+static INLINE int get_intra_region_context(BLOCK_SIZE bsize) {
+  const int width = block_size_wide[bsize];
+  const int height = block_size_high[bsize];
+  const int num_samples = width * height;
+  if (num_samples <= 64)
+    return 0;
+  else if (num_samples <= 128)
+    return 1;
+  else if (num_samples <= 256)
+    return 2;
+  else if (num_samples <= 512)
+    return 3;
+  else
+    return 4;
+}
+#endif  // CONFIG_EXTENDED_SDP
+
 #if CONFIG_BLOCK_256
 /*!\brief Returns the context used by \ref PARTITION_SPLIT. */
 static INLINE int square_split_context(const MACROBLOCKD *xd, int mi_row,
@@ -2672,6 +2700,7 @@
   }
   av1_zero_array(above_contexts->partition[0][tile_row] + mi_col_start,
                  aligned_width);
+
   if (num_planes > 1) {
     if (above_contexts->partition[1][tile_row] &&
         above_contexts->partition[2][tile_row]) {
diff --git a/av1/common/av1_loopfilter.c b/av1/common/av1_loopfilter.c
index 2c0fbc2..17dcc75 100644
--- a/av1/common/av1_loopfilter.c
+++ b/av1/common/av1_loopfilter.c
@@ -521,6 +521,8 @@
   params->filter_length = 0;
 
   TREE_TYPE tree_type = SHARED_PART;
+
+#if !CONFIG_EXTENDED_SDP
   const bool is_sdp_eligible = frame_is_intra_only(cm) &&
                                !cm->seq_params.monochrome &&
                                cm->seq_params.enable_sdp;
@@ -528,6 +530,7 @@
     tree_type = (plane == AOM_PLANE_Y) ? LUMA_PART : CHROMA_PART;
   }
   const int plane_type = is_sdp_eligible && plane > 0;
+#endif  // !CONFIG_EXTENDED_SDP
 
   // no deblocking is required
   const uint32_t width = plane_ptr->dst.width;
@@ -553,6 +556,16 @@
   // it not set up.
   if (mbmi == NULL) return TX_INVALID;
 
+#if CONFIG_EXTENDED_SDP
+  const bool is_sdp_eligible = cm->seq_params.enable_sdp &&
+                               !cm->seq_params.monochrome &&
+                               mbmi->region_type == INTRA_REGION;
+  if (is_sdp_eligible) {
+    tree_type = (plane == AOM_PLANE_Y) ? LUMA_PART : CHROMA_PART;
+  }
+  const int plane_type = is_sdp_eligible && plane > 0;
+#endif  // CONFIG_EXTENDED_SDP
+
 #if CONFIG_LF_SUB_PU
   TX_SIZE ts = get_transform_size(xd, mi[0], edge_dir, mi_row, mi_col, plane,
                                   tree_type, plane_ptr);
@@ -595,9 +608,28 @@
           const int pv_col =
               (VERT_EDGE == edge_dir) ? (mi_col - (1 << scale_horz)) : (mi_col);
 
+#if CONFIG_EXTENDED_SDP
+          TREE_TYPE prev_tree_type = SHARED_PART;
+          const bool is_prev_sdp_eligible =
+              cm->seq_params.enable_sdp && !cm->seq_params.monochrome &&
+              mi_prev->region_type == INTRA_REGION;
+          // With SDP in inter frames, the tree type of current block can be
+          // different with previous block, so we can't copy the tree type of
+          // current block to previous block, and we need to fetch the tree type
+          // of a previous block.
+          if (is_prev_sdp_eligible) {
+            prev_tree_type = (plane == AOM_PLANE_Y) ? LUMA_PART : CHROMA_PART;
+          }
+          const TX_SIZE pv_ts =
+              get_transform_size(xd, mi_prev, edge_dir, pv_row, pv_col, plane,
+                                 prev_tree_type, plane_ptr);
+#else
+
           const TX_SIZE pv_ts =
               get_transform_size(xd, mi_prev, edge_dir, pv_row, pv_col, plane,
                                  tree_type, plane_ptr);
+#endif  // CONFIG_EXTENDED_SDP
+
           const uint32_t pv_q =
               av1_get_filter_q(&cm->lf_info, edge_dir, plane, mi_prev);
           const uint32_t pv_side =
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 204d7c4..835d34a 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -430,6 +430,10 @@
   /*! \brief The partition type of the current coding block. */
   PARTITION_TYPE partition;
   /*! \brief The prediction mode used */
+#if CONFIG_EXTENDED_SDP
+  /*! \brief The region type used for the current block. */
+  REGION_TYPE region_type;
+#endif  // CONFIG_EXTENDED_SDP
   PREDICTION_MODE mode;
   /*! \brief The JMVD scaling mode for the current coding block. The supported
    *  scale modes for JOINT_NEWMV mode is 0, 1, 2, 3, and 4. The supported scale
@@ -746,6 +750,12 @@
   struct PARTITION_TREE *sub_tree[4];
   /*! \brief The partition type used to split the current block. */
   PARTITION_TYPE partition;
+#if CONFIG_EXTENDED_SDP
+  /*! \brief The region type used for the current block. */
+  REGION_TYPE region_type;
+  /*! \brief Whethe SDP is allowed for one block in inter frame. */
+  int inter_sdp_allowed_flag;
+#endif  // CONFIG_EXTENDED_SDP
   /*! \brief Block size of the current block. */
   BLOCK_SIZE bsize;
   /*! \brief Whether the chroma block info is ready. */
@@ -1363,6 +1373,61 @@
   info->bsize_base = bsize;
 }
 
+#if CONFIG_EXTENDED_SDP
+static INLINE int is_bsize_allowed_for_inter_sdp(BLOCK_SIZE bsize,
+                                                 PARTITION_TYPE partition) {
+  const int bw = block_size_wide[bsize];
+  const int bh = block_size_high[bsize];
+  return bw <= 32 && bh <= 32 && bw >= 8 && bh >= 8 &&
+         partition < PARTITION_HORZ_4A;
+}
+// Decide whether SDP is allowed for one block in inter frame.
+static INLINE int is_inter_sdp_allowed(BLOCK_SIZE parent_bsize,
+                                       PARTITION_TYPE parent_partition) {
+  const int bw = block_size_wide[parent_bsize];
+  const int bh = block_size_high[parent_bsize];
+  // Check if block width/height is less than 4.
+  const int bw_gt_4 = bw > 4;
+  const int bh_gt_4 = bh > 4;
+  // Check if half block width/height is less than 8.
+  const int hbw_gt_4 = bw > 8;
+  const int hbh_gt_4 = bh > 8;
+#if CONFIG_EXT_RECUR_PARTITIONS
+  // Check if quarter block width/height is less than 16.
+  const int qbw_gt_4 = bw > 16;
+  const int qbh_gt_4 = bh > 16;
+#endif  // !CONFIG_UNEVEN_4WAY || CONFIG_EXT_RECUR_PARTITIONS
+  // Check if one-eighth block width/height is less than 32.
+  const int ebw_gt_4 = bw > 32;
+  const int ebh_gt_4 = bh > 32;
+  switch (parent_partition) {
+    case PARTITION_NONE: return 1;
+    case PARTITION_HORZ: return bw_gt_4 && hbh_gt_4;
+    case PARTITION_VERT: return hbw_gt_4 && bh_gt_4;
+    case PARTITION_SPLIT: return hbw_gt_4 && hbh_gt_4;
+#if CONFIG_EXT_RECUR_PARTITIONS
+    case PARTITION_HORZ_4A:
+    case PARTITION_HORZ_4B: return bw_gt_4 && ebh_gt_4;
+    case PARTITION_VERT_4A:
+    case PARTITION_VERT_4B: return ebw_gt_4 && bh_gt_4;
+    case PARTITION_HORZ_3: return hbw_gt_4 && qbh_gt_4;
+    case PARTITION_VERT_3: return qbw_gt_4 && hbh_gt_4;
+#else   // CONFIG_EXT_RECUR_PARTITIONS
+    case PARTITION_HORZ_A:
+    case PARTITION_HORZ_B:
+    case PARTITION_VERT_A:
+    case PARTITION_VERT_B: return hbw_less_than_4 || hbh_less_than_4;
+    case PARTITION_HORZ_4: return bw_less_than_4 || qbh_less_than_4;
+    case PARTITION_VERT_4: return qbw_less_than_4 || bh_less_than_4;
+#endif  // CONFIG_EXT_RECUR_PARTITIONS
+    default:
+      assert(0 && "Invalid partition type!");
+      return 0;
+      break;
+  }
+}
+#endif  // CONFIG_EXTENDED_SDP
+
 // Decide whether a block needs coding multiple chroma coding blocks in it at
 // once to get around sub-4x4 coding.
 static INLINE int have_nz_chroma_ref_offset(BLOCK_SIZE bsize,
@@ -2334,6 +2399,7 @@
    * This is a pointer into 'left_txfm_context_buffer'.
    */
   TXFM_CONTEXT *left_txfm_context;
+
   /*!
    * left_txfm_context_buffer[i] is the left transform context for ith mi_row
    * in this *superblock*.
diff --git a/av1/common/entropy.c b/av1/common/entropy.c
index 85b7241..5c8d60a 100644
--- a/av1/common/entropy.c
+++ b/av1/common/entropy.c
@@ -387,6 +387,12 @@
   RESET_CDF_COUNTER(fc->uv_mode_cdf[1], UV_INTRA_MODES);
 #endif  // CONFIG_UV_CFL
 
+#if CONFIG_EXTENDED_SDP
+  for (int i = 0; i < INTER_SDP_BSIZE_GROUP; i++) {
+    RESET_CDF_COUNTER(fc->region_type_cdf[i], REGION_TYPES);
+  }
+#endif  // CONFIG_EXTENDED_SDP
+
 #if CONFIG_EXT_RECUR_PARTITIONS
   for (int plane_index = 0; plane_index < PARTITION_STRUCTURE_NUM;
        plane_index++) {
diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index 99629fb..279bfad 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -454,6 +454,22 @@
                     9875, 10521, 29048) } }
     };
 #endif  // CONFIG_AIMC
+
+#if CONFIG_EXTENDED_SDP
+static aom_cdf_prob default_region_type_cdf[INTER_SDP_BSIZE_GROUP]
+                                           [CDF_SIZE(REGION_TYPES)] = {
+                                             // w * h <= 64
+                                             { AOM_CDF2(16384), 0 },
+                                             // w * h <= 128
+                                             { AOM_CDF2(16384), 0 },
+                                             // w * h <= 256
+                                             { AOM_CDF2(16384), 0 },
+                                             // w * h <= 512
+                                             { AOM_CDF2(16384), 0 },
+                                             // w * h <= 1024
+                                             { AOM_CDF2(16384), 0 }
+                                           };
+#endif  // CONFIG_EXTENDED_SDP
 #if CONFIG_EXT_RECUR_PARTITIONS
 // clang-format off
 #if CONFIG_FLEX_PARTITION
@@ -7324,6 +7340,9 @@
   av1_copy(fc->filter_dir_cdf, default_filter_dir_cdf);
 #endif  // CONFIG_ENABLE_MHCCP
   av1_copy(fc->switchable_interp_cdf, default_switchable_interp_cdf);
+#if CONFIG_EXTENDED_SDP
+  av1_copy(fc->region_type_cdf, default_region_type_cdf);
+#endif  // CONFIG_EXTENDED_SDP
 #if CONFIG_EXT_RECUR_PARTITIONS
   av1_copy(fc->do_split_cdf, default_do_split_cdf);
 #if CONFIG_BLOCK_256
diff --git a/av1/common/entropymode.h b/av1/common/entropymode.h
index f8c15e4..1e8de90 100644
--- a/av1/common/entropymode.h
+++ b/av1/common/entropymode.h
@@ -537,6 +537,10 @@
 #endif  // CONFIG_BLOCK_256
   aom_cdf_prob rect_type_cdf[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS]
                             [CDF_SIZE(2)];
+#if CONFIG_EXTENDED_SDP
+  aom_cdf_prob region_type_cdf[INTER_SDP_BSIZE_GROUP][CDF_SIZE(REGION_TYPES)];
+#endif  // CONFIG_EXTENDED_SDP
+
   aom_cdf_prob do_ext_partition_cdf[PARTITION_STRUCTURE_NUM][NUM_RECT_PARTS]
                                    [PARTITION_CONTEXTS][CDF_SIZE(2)];
   aom_cdf_prob do_uneven_4way_partition_cdf[PARTITION_STRUCTURE_NUM]
diff --git a/av1/common/enums.h b/av1/common/enums.h
index 3fdca21..a959da6 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -355,6 +355,14 @@
   TREES_TYPES,
 } UENUM1BYTE(TREE_TYPE);
 
+#if CONFIG_EXTENDED_SDP
+enum {
+  INTRA_REGION = 0,
+  MIXED_INTER_INTRA_REGION = 1,
+  REGION_TYPES = 2,
+} UENUM1BYTE(REGION_TYPE);
+#endif  // CONFIG_EXTENDED_SDP
+
 #if CONFIG_BLOCK_256
 // 4X4, 8X8, 16X16, 32X32, 64X64, 128X128, 256X256
 #define SQR_BLOCK_SIZES 7
@@ -479,6 +487,13 @@
 #define PARTITION_BLOCK_SIZES 5
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
 
+#if CONFIG_EXTENDED_SDP
+// Extended SDP is only allowed for block samples >= 64 and <= 1024. The allowed
+// block size group is 64, 128, 256, 512, 1024, so the number of block size
+// group is 5 in total.
+#define INTER_SDP_BSIZE_GROUP 5
+#endif  // CONFIG_EXTENDED_SDP
+
 #define PARTITION_CONTEXTS (PARTITION_BLOCK_SIZES * PARTITION_PLOFFSET)
 
 // block transform size
@@ -1146,6 +1161,10 @@
 #endif  // CONFIG_NEW_TX_PARTITION
 typedef uint16_t TXFM_CONTEXT;
 
+#if CONFIG_EXTENDED_SDP
+typedef uint8_t INTRA_REGION_CONTEXT;
+#endif  // CONFIG_EXTENDED_SDP
+
 #define TIP_CONTEXTS 3
 
 #define INTER_REFS_PER_FRAME 7
diff --git a/av1/common/reconintra.h b/av1/common/reconintra.h
index 8f10cf3..16a5c27 100644
--- a/av1/common/reconintra.h
+++ b/av1/common/reconintra.h
@@ -99,12 +99,25 @@
   return bsize >= BLOCK_8X8;
 }
 
-static INLINE int av1_allow_intrabc(const AV1_COMMON *const cm) {
+static INLINE int av1_allow_intrabc(const AV1_COMMON *const cm,
+                                    const MACROBLOCKD *const xd) {
+#if CONFIG_EXTENDED_SDP
+  int cur_region_type = MIXED_INTER_INTRA_REGION;
+  if (xd->mi != NULL) cur_region_type = xd->mi[0]->region_type;
+#endif
 #if CONFIG_IBC_SR_EXT
   return (frame_is_intra_only(cm) || cm->features.allow_local_intrabc) &&
+#if CONFIG_EXTENDED_SDP
+         xd->tree_type != CHROMA_PART &&
+         (frame_is_intra_only(cm) || cur_region_type != INTRA_REGION) &&
+#endif  // CONFIG_EXTENDED_SDP
          cm->features.allow_screen_content_tools && cm->features.allow_intrabc;
 #else
   return frame_is_intra_only(cm) && cm->features.allow_screen_content_tools &&
+#if CONFIG_EXTENDED_SDP
+         xd->tree_type != CHROMA_PART &&
+         xd->mi[0]->region_type != INTRA_REGION &&
+#endif  // CONFIG_EXTENDED_SDP
          cm->features.allow_intrabc;
 #endif  // CONFIG_IBC_SR_EXT
 }
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 9662d7d..c54b4c6 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -1252,6 +1252,10 @@
   set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis, parent,
               index);
   xd->mi[0]->partition = partition;
+#if CONFIG_EXTENDED_SDP
+  // set region_type for each mbmi
+  xd->mi[0]->region_type = parent->region_type;
+#endif  // CONFIG_EXTENDED_SDP
   av1_read_mode_info(pbi, dcb, r, x_mis, y_mis);
 
 #if CONFIG_EXT_RECUR_PARTITIONS
@@ -1354,7 +1358,7 @@
 
 #if CONFIG_MORPH_PRED
   if (mbmi->morph_pred) {
-    assert(av1_allow_intrabc(cm));
+    assert(av1_allow_intrabc(cm, xd));
     assert(is_intrabc_block(mbmi, xd->tree_type));
     av1_build_morph_pred(cm, xd, bsize, mi_row, mi_col);
   }
@@ -2295,6 +2299,7 @@
   AV1_COMMON *cm = &pbi->common;
   const int num_planes = av1_num_planes(cm);
   MB_MODE_INFO *mbmi = xd->mi[0];
+
   int inter_block_tx = is_inter_block(mbmi, xd->tree_type) ||
                        is_intrabc_block(mbmi, xd->tree_type);
   if (xd->tree_type != CHROMA_PART) {
@@ -2711,6 +2716,18 @@
                                                      parse_decode_block };
   const int is_sb_root = bsize == cm->sb_size;
 
+#if CONFIG_EXTENDED_SDP
+  if (is_sb_root) {
+    if (!frame_is_intra_only(cm)) {
+      ptree->region_type = MIXED_INTER_INTRA_REGION;
+      ptree->inter_sdp_allowed_flag = 1;
+    } else {
+      ptree->region_type = INTRA_REGION;
+      ptree->inter_sdp_allowed_flag = 0;
+    }
+  }
+#endif  // CONFIG_EXTENDED_SDP
+
   if (parse_decode_flag & 1) {
     if (is_sb_root) {
       set_sb_mv_precision(sbi, pbi);
@@ -2767,6 +2784,30 @@
 
     ptree->partition = partition;
 
+#if CONFIG_EXTENDED_SDP
+    if (!is_sb_root && parent) {
+      if (parent->inter_sdp_allowed_flag == 1)
+        ptree->inter_sdp_allowed_flag =
+            is_inter_sdp_allowed(parent->bsize, parent->partition);
+      else
+        ptree->inter_sdp_allowed_flag = 0;
+      if (!frame_is_intra_only(cm) && ptree->partition &&
+          parent->region_type != INTRA_REGION &&
+          ptree->inter_sdp_allowed_flag &&
+          is_bsize_allowed_for_inter_sdp(bsize, ptree->partition)) {
+        const int ctx = get_intra_region_context(bsize);
+        ptree->region_type =
+            aom_read_symbol(reader, xd->tile_ctx->region_type_cdf[ctx],
+                            REGION_TYPES, ACCT_INFO("region_type"));
+        if (ptree->region_type == INTRA_REGION) xd->tree_type = LUMA_PART;
+      } else if (!frame_is_intra_only(cm)) {
+        ptree->region_type = parent->region_type;
+      } else {
+        ptree->region_type = INTRA_REGION;
+      }
+    }
+#endif  // CONFIG_EXTENDED_SDP
+
     switch (partition) {
 #if CONFIG_EXT_RECUR_PARTITIONS
       case PARTITION_HORZ_4A:
@@ -3031,6 +3072,21 @@
     default: assert(0 && "Invalid partition type");
   }
 
+#if CONFIG_EXTENDED_SDP
+  PARTITION_TREE *parent = ptree->parent;
+  if (!is_sb_root && parent) {
+    if (!frame_is_intra_only(cm) && !cm->seq_params.monochrome &&
+        ptree->partition && parent->region_type != INTRA_REGION &&
+        ptree->region_type == INTRA_REGION) {
+      // decode chroma part in one intra region
+      xd->tree_type = CHROMA_PART;
+      DEC_BLOCK(mi_row, mi_col, bsize, 0);
+      // reset back to shared part
+      xd->tree_type = SHARED_PART;
+    }
+  }
+#endif  // CONFIG_EXTENDED_SDP
+
 #undef DEC_PARTITION
 #undef DEC_BLOCK
 #undef DEC_BLOCK_EPT_ARG
@@ -8411,7 +8467,7 @@
       (uint32_t)aom_rb_bytes_read(rb);  // Size of the uncompressed header
   YV12_BUFFER_CONFIG *new_fb = &cm->cur_frame->buf;
   xd->cur_buf = new_fb;
-  if (av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+  if (av1_allow_intrabc(cm, xd) && xd->tree_type != CHROMA_PART) {
     av1_setup_scale_factors_for_frame(
         &cm->sf_identity, xd->cur_buf->y_crop_width, xd->cur_buf->y_crop_height,
         xd->cur_buf->y_crop_width, xd->cur_buf->y_crop_height);
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 62d2ae1..af72c4e 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -888,7 +888,10 @@
                                  aom_reader *r, int skip) {
   struct segmentation *const seg = &cm->seg;
   if (!seg->enabled) return 0;  // Default for disabled segmentation
-  assert(seg->update_map && !seg->temporal_update);
+#if CONFIG_EXTENDED_SDP
+  if (frame_is_intra_only(cm))
+#endif  // CONFIG_EXTENDED_SDP
+    assert(seg->update_map && !seg->temporal_update);
 
   const CommonModeInfoParams *const mi_params = &cm->mi_params;
   const int mi_row = xd->mi_row;
@@ -1888,7 +1891,11 @@
 
   FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
 
-  if (seg->segid_preskip)
+  if (seg->segid_preskip
+#if CONFIG_EXTENDED_SDP
+      && !(!frame_is_intra_only(cm) && xd->tree_type == CHROMA_PART)
+#endif  // CONFIG_EXTENDED_SDP
+  )
     mbmi->segment_id = read_intra_segment_id(cm, xd, bsize, r, 0);
 
 #if CONFIG_SKIP_MODE_ENHANCEMENT
@@ -1899,7 +1906,7 @@
 #endif  // CONFIG_MORPH_PRED
 
 #if CONFIG_SKIP_TXFM_OPT
-  if (av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+  if (av1_allow_intrabc(cm, xd) && xd->tree_type != CHROMA_PART) {
 #if CONFIG_NEW_CONTEXT_MODELING
     mbmi->use_intrabc[0] = 0;
     mbmi->use_intrabc[1] = 0;
@@ -1923,10 +1930,18 @@
       read_skip_txfm(cm, xd, mbmi->segment_id, r);
 #endif  // CONFIG_SKIP_TXFM_OPT
 
-  if (!seg->segid_preskip)
+  if (!seg->segid_preskip
+#if CONFIG_EXTENDED_SDP
+      && !(!frame_is_intra_only(cm) && xd->tree_type == CHROMA_PART)
+#endif  // CONFIG_EXTENDED_SDP
+  )
     mbmi->segment_id = read_intra_segment_id(
         cm, xd, bsize, r, mbmi->skip_txfm[xd->tree_type == CHROMA_PART]);
 
+#if CONFIG_EXTENDED_SDP
+  mbmi->seg_id_predicted = 0;
+#endif  // CONFIG_EXTENDED_SDP
+
   if (xd->tree_type != CHROMA_PART) read_cdef(cm, r, xd);
 
 #if CONFIG_CCSO
@@ -1958,7 +1973,7 @@
   xd->left_txfm_context =
       xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK);
 #endif  // !CONFIG_TX_PARTITION_CTX
-  if (av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+  if (av1_allow_intrabc(cm, xd) && xd->tree_type != CHROMA_PART) {
     read_intrabc_info(cm, dcb, r);
     if (is_intrabc_block(mbmi, xd->tree_type)) {
 #if CONFIG_LOSSLESS_DPCM
@@ -4309,7 +4324,6 @@
 #endif  // CONFIG_REFINEMV
 
   mbmi->segment_id = read_inter_segment_id(cm, xd, 1, r);
-
   mbmi->skip_mode = read_skip_mode(cm, xd, mbmi->segment_id, r);
 
   mbmi->fsc_mode[PLANE_TYPE_Y] = 0;
@@ -4336,7 +4350,8 @@
   }
 
 #if CONFIG_IBC_SR_EXT
-  if (!inter_block && av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+  if (!inter_block && av1_allow_intrabc(cm, xd) &&
+      xd->tree_type != CHROMA_PART) {
 #if CONFIG_NEW_CONTEXT_MODELING
     mbmi->use_intrabc[0] = 0;
     mbmi->use_intrabc[1] = 0;
@@ -4408,7 +4423,8 @@
 #endif  // !CONFIG_TX_PARTITION_CTX
 
 #if CONFIG_IBC_SR_EXT
-  if (!inter_block && av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+  if (!inter_block && av1_allow_intrabc(cm, xd) &&
+      xd->tree_type != CHROMA_PART) {
     mbmi->ref_frame[0] = INTRA_FRAME;
     mbmi->ref_frame[1] = NONE_FRAME;
     mbmi->palette_mode_info.palette_size[0] = 0;
@@ -4465,7 +4481,11 @@
   if (xd->tree_type == SHARED_PART)
     mi->sb_type[PLANE_TYPE_UV] = mi->sb_type[PLANE_TYPE_Y];
 
-  if (frame_is_intra_only(cm)) {
+  if (frame_is_intra_only(cm)
+#if CONFIG_EXTENDED_SDP
+      || mi->region_type == INTRA_REGION
+#endif  // CONFIG_EXTENDED_SDP
+  ) {
     read_intra_frame_mode_info(cm, dcb, r);
 #if CONFIG_IBC_BV_IMPROVEMENT
     if (cm->seq_params.enable_refmvbank) {
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 4e82142..68a55ec 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -2410,7 +2410,6 @@
   int ref;
 
   write_inter_segment_id(cpi, w, seg, segp, 0, 1);
-
   write_skip_mode(cm, xd, segment_id, mbmi, w);
 
 #if CONFIG_SKIP_TXFM_OPT
@@ -2418,7 +2417,8 @@
     write_is_inter(cm, xd, mbmi->segment_id, w, is_inter);
 
 #if CONFIG_IBC_SR_EXT
-    if (!is_inter && av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+    if (!is_inter && av1_allow_intrabc(cm, xd) &&
+        xd->tree_type != CHROMA_PART) {
       const int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
       if (xd->tree_type == CHROMA_PART) assert(use_intrabc == 0);
 #if CONFIG_NEW_CONTEXT_MODELING
@@ -2517,7 +2517,7 @@
 #endif  // !CONFIG_SKIP_TXFM_OPT
 
 #if CONFIG_IBC_SR_EXT
-  if (!is_inter && av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+  if (!is_inter && av1_allow_intrabc(cm, xd) && xd->tree_type != CHROMA_PART) {
     write_intrabc_info(
 #if CONFIG_IBC_BV_IMPROVEMENT && CONFIG_IBC_MAX_DRL
         cm->features.max_bvp_drl_bits,
@@ -3101,11 +3101,15 @@
   struct segmentation_probs *const segp = &ec_ctx->seg;
   const MB_MODE_INFO *const mbmi = xd->mi[0];
 
-  if (seg->segid_preskip && seg->update_map)
+  if (seg->segid_preskip && seg->update_map
+#if CONFIG_EXTENDED_SDP
+      && !(!frame_is_intra_only(cm) && xd->tree_type == CHROMA_PART)
+#endif  // CONFIG_EXTENDED_SDP
+  )
     write_segment_id(cpi, mbmi, w, seg, segp, 0);
 
 #if CONFIG_SKIP_TXFM_OPT
-  if (av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+  if (av1_allow_intrabc(cm, xd) && xd->tree_type != CHROMA_PART) {
     const int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
     if (xd->tree_type == CHROMA_PART) assert(use_intrabc == 0);
 #if CONFIG_NEW_CONTEXT_MODELING
@@ -3123,7 +3127,11 @@
 #else
   const int skip = write_skip(cm, xd, mbmi->segment_id, mbmi, w);
 #endif  // CONFIG_SKIP_TXFM_OPT
-  if (!seg->segid_preskip && seg->update_map)
+  if (!seg->segid_preskip && seg->update_map
+#if CONFIG_EXTENDED_SDP
+      && !(!frame_is_intra_only(cm) && xd->tree_type == CHROMA_PART)
+#endif  // CONFIG_EXTENDED_SDP
+  )
     write_segment_id(cpi, mbmi, w, seg, segp, skip);
 
   if (xd->tree_type != CHROMA_PART) write_cdef(cm, xd, w, skip);
@@ -3140,8 +3148,7 @@
 #endif
 
   write_delta_q_params(cpi, skip, w);
-
-  if (av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+  if (av1_allow_intrabc(cm, xd) && xd->tree_type != CHROMA_PART) {
     write_intrabc_info(
 #if CONFIG_IBC_BV_IMPROVEMENT && CONFIG_IBC_MAX_DRL
         cm->features.max_bvp_drl_bits,
@@ -3252,7 +3259,11 @@
   MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
   MB_MODE_INFO *m = xd->mi[0];
 
-  if (frame_is_intra_only(cm)) {
+  if (frame_is_intra_only(cm)
+#if CONFIG_EXTENDED_SDP
+      || m->region_type == INTRA_REGION
+#endif  // CONFIG_EXTENDED_SDP
+  ) {
     write_mb_modes_kf(cpi, xd, cpi->td.mb.mbmi_ext_frame, w);
   } else {
     // has_subpel_mv_component needs the ref frame buffers set up to look
@@ -3713,6 +3724,21 @@
 #else
   write_partition(cm, xd, mi_row, mi_col, partition, bsize, w);
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXTENDED_SDP
+  const int is_sb_root = bsize == cm->sb_size;
+  PARTITION_TREE *parent = ptree->parent;
+  if (!is_sb_root && !frame_is_intra_only(cm) && parent && partition &&
+      parent->region_type != INTRA_REGION && ptree->inter_sdp_allowed_flag &&
+      is_bsize_allowed_for_inter_sdp(bsize, ptree->partition)) {
+    const int ctx = get_intra_region_context(bsize);
+    assert(xd->tree_type != CHROMA_PART);
+    aom_write_symbol(w, ptree->region_type, xd->tile_ctx->region_type_cdf[ctx],
+                     REGION_TYPES);
+    if (ptree->region_type == INTRA_REGION) {
+      xd->tree_type = LUMA_PART;
+    }
+  }
+#endif  // CONFIG_EXTENDED_SDP
   switch (partition) {
     case PARTITION_NONE:
       write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
@@ -3921,6 +3947,17 @@
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
     default: assert(0); break;
   }
+#if CONFIG_EXTENDED_SDP
+  if (!is_sb_root && !frame_is_intra_only(cm) && !cm->seq_params.monochrome &&
+      parent && partition && parent->region_type != INTRA_REGION &&
+      ptree->region_type == INTRA_REGION) {
+    // run chroma part in luma region
+    xd->tree_type = CHROMA_PART;
+    write_modes_b(cpi, tile, w, tok, tok_end, mi_row, mi_col);
+    // reset back to shared part
+    xd->tree_type = SHARED_PART;
+  }
+#endif  // CONFIG_EXTENDED_SDP
 
   // update partition context
   update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition);
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 5ff0559..4165df3 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -835,6 +835,10 @@
    * \name Partition Costs
    ****************************************************************************/
   /**@{*/
+#if CONFIG_EXTENDED_SDP
+  //! Cost for coding the region type.
+  int region_type_cost[INTER_SDP_BSIZE_GROUP][REGION_TYPES];
+#endif  // CONFIG_EXTENDED_SDP
 #if CONFIG_EXT_RECUR_PARTITIONS
   /*! Cost for sending split token. */
   int do_split_cost[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS][2];
diff --git a/av1/encoder/context_tree.c b/av1/encoder/context_tree.c
index ddcb0d7..75f0307 100644
--- a/av1/encoder/context_tree.c
+++ b/av1/encoder/context_tree.c
@@ -224,6 +224,18 @@
   pc_tree->parent = parent;
   pc_tree->index = index;
   pc_tree->partitioning = PARTITION_NONE;
+#if CONFIG_EXTENDED_SDP
+  if (parent) {
+    pc_tree->region_type = parent->region_type;
+    if (parent->inter_sdp_allowed_flag == 1)
+      pc_tree->inter_sdp_allowed_flag =
+          is_inter_sdp_allowed(parent->block_size, parent_partition);
+    else
+      pc_tree->inter_sdp_allowed_flag = 0;
+  } else {
+    pc_tree->inter_sdp_allowed_flag = 1;
+  }
+#endif  // CONFIG_EXTENDED_SDP
   pc_tree->block_size = bsize;
   pc_tree->is_last_subblock = is_last;
   av1_invalid_rd_stats(&pc_tree->rd_cost);
@@ -236,8 +248,49 @@
                       parent ? &parent->chroma_ref_info : NULL,
                       parent ? parent->block_size : BLOCK_INVALID,
                       parent_partition, subsampling_x, subsampling_y);
-
+#if CONFIG_EXTENDED_SDP
+  pc_tree->none[INTRA_REGION] = NULL;
+  pc_tree->none[MIXED_INTER_INTRA_REGION] = NULL;
+  pc_tree->none_chroma = NULL;
+#else
   pc_tree->none = NULL;
+#endif  // CONFIG_EXTENDED_SDP
+#if CONFIG_EXTENDED_SDP
+  for (REGION_TYPE cur_region_type = INTRA_REGION;
+       cur_region_type < REGION_TYPES; ++cur_region_type) {
+    for (int i = 0; i < 2; ++i) {
+      pc_tree->horizontal[cur_region_type][i] = NULL;
+      pc_tree->vertical[cur_region_type][i] = NULL;
+    }
+#if CONFIG_EXT_RECUR_PARTITIONS
+    for (int i = 0; i < 4; ++i) {
+      pc_tree->horizontal4a[cur_region_type][i] = NULL;
+      pc_tree->horizontal4b[cur_region_type][i] = NULL;
+      pc_tree->vertical4a[cur_region_type][i] = NULL;
+      pc_tree->vertical4b[cur_region_type][i] = NULL;
+    }
+    for (int i = 0; i < 4; ++i) {
+      pc_tree->horizontal3[cur_region_type][i] = NULL;
+      pc_tree->vertical3[cur_region_type][i] = NULL;
+    }
+#else
+    for (int i = 0; i < 3; ++i) {
+      pc_tree->horizontala[cur_region_type][i] = NULL;
+      pc_tree->horizontalb[cur_region_type][i] = NULL;
+      pc_tree->verticala[cur_region_type][i] = NULL;
+      pc_tree->verticalb[cur_region_type][i] = NULL;
+    }
+#endif  // CONFIG_EXT_RECUR_PARTITIONS
+    for (int i = 0; i < 4; ++i) {
+#if !CONFIG_EXT_RECUR_PARTITIONS
+      pc_tree->horizontal4[cur_region_type][i] = NULL;
+      pc_tree->vertical4[cur_region_type][i] = NULL;
+#endif  // !CONFIG_EXT_RECUR_PARTITIONS
+      pc_tree->split[cur_region_type][i] = NULL;
+    }
+  }
+
+#else  // CONFIG_EXTENDED_SDP
   for (int i = 0; i < 2; ++i) {
     pc_tree->horizontal[i] = NULL;
     pc_tree->vertical[i] = NULL;
@@ -268,7 +321,7 @@
 #endif  // !CONFIG_EXT_RECUR_PARTITIONS
     pc_tree->split[i] = NULL;
   }
-
+#endif  // CONFIG_EXTENDED_SDP
   return pc_tree;
 }
 
@@ -284,9 +337,135 @@
 
   const PARTITION_TYPE partition = pc_tree->partitioning;
 
+#if CONFIG_EXTENDED_SDP
+  PC_TREE *parent = pc_tree->parent;
+  if (!keep_none &&
+      (!keep_best || (pc_tree->region_type != INTRA_REGION ||
+                      (parent && parent->region_type == INTRA_REGION))))
+    FREE_PMC_NODE(pc_tree->none_chroma);
+
+  for (int cur_region_type = INTRA_REGION; cur_region_type < REGION_TYPES;
+       ++cur_region_type) {
+    if (!keep_none && (!keep_best || (partition != PARTITION_NONE)))
+      FREE_PMC_NODE(pc_tree->none[cur_region_type]);
+
+    for (int i = 0; i < 2; ++i) {
+#if CONFIG_EXT_RECUR_PARTITIONS
+      if ((!keep_best || (partition != PARTITION_HORZ) ||
+           (cur_region_type != pc_tree->region_type)) &&
+          pc_tree->horizontal[cur_region_type][i] != NULL) {
+        av1_free_pc_tree_recursive(pc_tree->horizontal[cur_region_type][i],
+                                   num_planes, 0, 0);
+        pc_tree->horizontal[cur_region_type][i] = NULL;
+      }
+      if ((!keep_best || (partition != PARTITION_VERT) ||
+           (cur_region_type != pc_tree->region_type)) &&
+          pc_tree->vertical[cur_region_type][i] != NULL) {
+        av1_free_pc_tree_recursive(pc_tree->vertical[cur_region_type][i],
+                                   num_planes, 0, 0);
+        pc_tree->vertical[cur_region_type][i] = NULL;
+      }
+#else
+      if (!keep_best || (partition != PARTITION_HORZ))
+        FREE_PMC_NODE(pc_tree->horizontal[cur_region_type][i]);
+      if (!keep_best || (partition != PARTITION_VERT))
+        FREE_PMC_NODE(pc_tree->vertical[cur_region_type][i]);
+#endif  // CONFIG_EXT_RECUR_PARTITIONS
+    }
+#if CONFIG_EXT_RECUR_PARTITIONS
+
+    if (!keep_best || (partition != PARTITION_HORZ_4A) ||
+        (cur_region_type != pc_tree->region_type)) {
+      for (int i = 0; i < 4; ++i) {
+        if (pc_tree->horizontal4a[cur_region_type][i] != NULL) {
+          av1_free_pc_tree_recursive(pc_tree->horizontal4a[cur_region_type][i],
+                                     num_planes, 0, 0);
+          pc_tree->horizontal4a[cur_region_type][i] = NULL;
+        }
+      }
+    }
+
+    if (!keep_best || (partition != PARTITION_HORZ_4B) ||
+        (cur_region_type != pc_tree->region_type)) {
+      for (int i = 0; i < 4; ++i) {
+        if (pc_tree->horizontal4b[cur_region_type][i] != NULL) {
+          av1_free_pc_tree_recursive(pc_tree->horizontal4b[cur_region_type][i],
+                                     num_planes, 0, 0);
+          pc_tree->horizontal4b[cur_region_type][i] = NULL;
+        }
+      }
+    }
+
+    if (!keep_best || (partition != PARTITION_VERT_4A) ||
+        (cur_region_type != pc_tree->region_type)) {
+      for (int i = 0; i < 4; ++i) {
+        if (pc_tree->vertical4a[cur_region_type][i] != NULL) {
+          av1_free_pc_tree_recursive(pc_tree->vertical4a[cur_region_type][i],
+                                     num_planes, 0, 0);
+          pc_tree->vertical4a[cur_region_type][i] = NULL;
+        }
+      }
+    }
+
+    if (!keep_best || (partition != PARTITION_VERT_4B) ||
+        (cur_region_type != pc_tree->region_type)) {
+      for (int i = 0; i < 4; ++i) {
+        if (pc_tree->vertical4b[cur_region_type][i] != NULL) {
+          av1_free_pc_tree_recursive(pc_tree->vertical4b[cur_region_type][i],
+                                     num_planes, 0, 0);
+          pc_tree->vertical4b[cur_region_type][i] = NULL;
+        }
+      }
+    }
+    for (int i = 0; i < 4; ++i) {
+      if ((!keep_best || (partition != PARTITION_HORZ_3) ||
+           (cur_region_type != pc_tree->region_type)) &&
+          pc_tree->horizontal3[cur_region_type][i] != NULL) {
+        av1_free_pc_tree_recursive(pc_tree->horizontal3[cur_region_type][i],
+                                   num_planes, 0, 0);
+        pc_tree->horizontal3[cur_region_type][i] = NULL;
+      }
+      if ((!keep_best || (partition != PARTITION_VERT_3) ||
+           (cur_region_type != pc_tree->region_type)) &&
+          pc_tree->vertical3[cur_region_type][i] != NULL) {
+        av1_free_pc_tree_recursive(pc_tree->vertical3[cur_region_type][i],
+                                   num_planes, 0, 0);
+        pc_tree->vertical3[cur_region_type][i] = NULL;
+      }
+    }
+#else
+    for (int i = 0; i < 3; ++i) {
+      if (!keep_best || (partition != PARTITION_HORZ_A))
+        FREE_PMC_NODE(pc_tree->horizontala[cur_region_type][i]);
+      if (!keep_best || (partition != PARTITION_HORZ_B))
+        FREE_PMC_NODE(pc_tree->horizontalb[cur_region_type][i]);
+      if (!keep_best || (partition != PARTITION_VERT_A))
+        FREE_PMC_NODE(pc_tree->verticala[cur_region_type][i]);
+      if (!keep_best || (partition != PARTITION_VERT_B))
+        FREE_PMC_NODE(pc_tree->verticalb[cur_region_type][i]);
+    }
+    for (int i = 0; i < 4; ++i) {
+      if (!keep_best || (partition != PARTITION_HORZ_4))
+        FREE_PMC_NODE(pc_tree->horizontal4[cur_region_type][i]);
+      if (!keep_best || (partition != PARTITION_VERT_4))
+        FREE_PMC_NODE(pc_tree->vertical4[cur_region_type][i]);
+    }
+#endif  // CONFIG_EXT_RECUR_PARTITIONS
+
+    if (!keep_best || (partition != PARTITION_SPLIT) ||
+        (cur_region_type != pc_tree->region_type)) {
+      for (int i = 0; i < 4; ++i) {
+        if (pc_tree->split[cur_region_type][i] != NULL) {
+          av1_free_pc_tree_recursive(pc_tree->split[cur_region_type][i],
+                                     num_planes, 0, 0);
+          pc_tree->split[cur_region_type][i] = NULL;
+        }
+      }
+    }
+  }    // region type index
+#else  // CONFIG_EXTENDED_SDP
   if (!keep_none && (!keep_best || (partition != PARTITION_NONE)))
     FREE_PMC_NODE(pc_tree->none);
-
   for (int i = 0; i < 2; ++i) {
 #if CONFIG_EXT_RECUR_PARTITIONS
     if ((!keep_best || (partition != PARTITION_HORZ)) &&
@@ -381,7 +560,7 @@
       }
     }
   }
-
+#endif  // CONFIG_EXTENDED_SDP
   if (!keep_best && !keep_none) aom_free(pc_tree);
 }
 
@@ -393,6 +572,11 @@
   // Copy the best partition type. For basic information like bsize and index,
   // we assume they have been set properly when initializing the dst PC_TREE
   dst->partitioning = src->partitioning;
+#if CONFIG_EXTENDED_SDP
+  dst->region_type = src->region_type;
+  dst->inter_sdp_allowed_flag = src->inter_sdp_allowed_flag;
+  REGION_TYPE cur_region_type = src->region_type;
+#endif  // CONFIG_EXTENDED_SDP
   dst->rd_cost = src->rd_cost;
   dst->none_rd = src->none_rd;
   dst->skippable = src->skippable;
@@ -402,9 +586,46 @@
   const int mi_row = src->mi_row;
   const int mi_col = src->mi_col;
 
+#if CONFIG_EXTENDED_SDP
+  PC_TREE *src_parent = src->parent;
+  if ((src->region_type == INTRA_REGION &&
+       (src_parent && src_parent->region_type == MIXED_INTER_INTRA_REGION))) {
+    if (dst->none_chroma) av1_free_pmc(dst->none_chroma, num_planes);
+    dst->none_chroma = NULL;
+    if (src->none_chroma) {
+      dst->none_chroma =
+          av1_alloc_pmc(cm, tree_type, mi_row, mi_col, bsize, dst,
+                        PARTITION_NONE, 0, ss_x, ss_y, shared_bufs);
+      av1_copy_tree_context(dst->none_chroma, src->none_chroma);
+    }
+  }
+#endif  // CONFIG_EXTENDED_SDP
+
   switch (src->partitioning) {
     // PARTITION_NONE
     case PARTITION_NONE:
+#if CONFIG_EXTENDED_SDP
+      if (dst->none[cur_region_type])
+        av1_free_pmc(dst->none[cur_region_type], num_planes);
+      dst->none[cur_region_type] = NULL;
+      if (src->none[cur_region_type]) {
+        dst->none[cur_region_type] =
+            av1_alloc_pmc(cm, tree_type, mi_row, mi_col, bsize, dst,
+                          PARTITION_NONE, 0, ss_x, ss_y, shared_bufs);
+        av1_copy_tree_context(dst->none[cur_region_type],
+                              src->none[cur_region_type]);
+#if CONFIG_MVP_IMPROVEMENT
+        if (is_inter_block(&src->none[cur_region_type]->mic, xd->tree_type)) {
+#if WARP_CU_BANK
+          av1_update_warp_param_bank(cm, xd, &dst->none[cur_region_type]->mic);
+#endif  // WARP_CU_BANK
+          if (cm->seq_params.enable_refmvbank) {
+            av1_update_ref_mv_bank(cm, xd, &dst->none[cur_region_type]->mic);
+          }
+        }
+#endif  // CONFIG_MVP_IMPROVEMENT
+      }
+#else
       if (dst->none) av1_free_pmc(dst->none, num_planes);
       dst->none = NULL;
       if (src->none) {
@@ -422,11 +643,30 @@
         }
 #endif  // CONFIG_MVP_IMPROVEMENT
       }
+#endif  // CONFIG_EXTENDED_SDP
       break;
     // PARTITION_SPLIT
     case PARTITION_SPLIT:
       if (is_partition_valid(bsize, PARTITION_SPLIT)) {
         for (int i = 0; i < 4; ++i) {
+#if CONFIG_EXTENDED_SDP
+          if (dst->split[cur_region_type][i]) {
+            av1_free_pc_tree_recursive(dst->split[cur_region_type][i],
+                                       num_planes, 0, 0);
+            dst->split[cur_region_type][i] = NULL;
+          }
+          if (src->split[cur_region_type][i]) {
+            const int x_idx = (i & 1) * (mi_size_wide[bsize] >> 1);
+            const int y_idx = (i >> 1) * (mi_size_high[bsize] >> 1);
+            dst->split[cur_region_type][i] = av1_alloc_pc_tree_node(
+                tree_type, mi_row + y_idx, mi_col + x_idx, subsize, dst,
+                PARTITION_SPLIT, i, i == 3, ss_x, ss_y);
+            av1_copy_pc_tree_recursive(xd, cm, dst->split[cur_region_type][i],
+                                       src->split[cur_region_type][i], ss_x,
+                                       ss_y, shared_bufs, tree_type,
+                                       num_planes);
+          }
+#else   // CONFIG_EXTENDED_SDP
           if (dst->split[i]) {
             av1_free_pc_tree_recursive(dst->split[i], num_planes, 0, 0);
             dst->split[i] = NULL;
@@ -441,6 +681,7 @@
                                        ss_x, ss_y, shared_bufs, tree_type,
                                        num_planes);
           }
+#endif  // CONFIG_EXTENDED_SDP
         }
       }
       break;
@@ -448,6 +689,23 @@
     case PARTITION_HORZ:
       if (is_partition_valid(bsize, PARTITION_HORZ)) {
         for (int i = 0; i < 2; ++i) {
+#if CONFIG_EXTENDED_SDP
+          if (dst->horizontal[cur_region_type][i]) {
+            av1_free_pc_tree_recursive(dst->horizontal[cur_region_type][i],
+                                       num_planes, 0, 0);
+            dst->horizontal[cur_region_type][i] = NULL;
+          }
+          if (src->horizontal[cur_region_type][i]) {
+            const int this_mi_row = mi_row + i * (mi_size_high[bsize] >> 1);
+            dst->horizontal[cur_region_type][i] = av1_alloc_pc_tree_node(
+                tree_type, this_mi_row, mi_col, subsize, dst, PARTITION_HORZ, i,
+                i == 1, ss_x, ss_y);
+            av1_copy_pc_tree_recursive(
+                xd, cm, dst->horizontal[cur_region_type][i],
+                src->horizontal[cur_region_type][i], ss_x, ss_y, shared_bufs,
+                tree_type, num_planes);
+          }
+#else
           if (dst->horizontal[i]) {
             av1_free_pc_tree_recursive(dst->horizontal[i], num_planes, 0, 0);
             dst->horizontal[i] = NULL;
@@ -461,6 +719,7 @@
                                        src->horizontal[i], ss_x, ss_y,
                                        shared_bufs, tree_type, num_planes);
           }
+#endif  // CONFIG_EXTENDED_SDP
         }
       }
       break;
@@ -468,6 +727,23 @@
     case PARTITION_VERT:
       if (is_partition_valid(bsize, PARTITION_VERT)) {
         for (int i = 0; i < 2; ++i) {
+#if CONFIG_EXTENDED_SDP
+          if (dst->vertical[cur_region_type][i]) {
+            av1_free_pc_tree_recursive(dst->vertical[cur_region_type][i],
+                                       num_planes, 0, 0);
+            dst->vertical[cur_region_type][i] = NULL;
+          }
+          if (src->vertical[cur_region_type][i]) {
+            const int this_mi_col = mi_col + i * (mi_size_wide[bsize] >> 1);
+            dst->vertical[cur_region_type][i] = av1_alloc_pc_tree_node(
+                tree_type, mi_row, this_mi_col, subsize, dst, PARTITION_VERT, i,
+                i == 1, ss_x, ss_y);
+            av1_copy_pc_tree_recursive(
+                xd, cm, dst->vertical[cur_region_type][i],
+                src->vertical[cur_region_type][i], ss_x, ss_y, shared_bufs,
+                tree_type, num_planes);
+          }
+#else
           if (dst->vertical[i]) {
             av1_free_pc_tree_recursive(dst->vertical[i], num_planes, 0, 0);
             dst->vertical[i] = NULL;
@@ -481,6 +757,7 @@
                                        src->vertical[i], ss_x, ss_y,
                                        shared_bufs, tree_type, num_planes);
           }
+#endif  // CONFIG_EXTENDED_SDP
         }
       }
       break;
@@ -497,6 +774,22 @@
         const BLOCK_SIZE subsizes[4] = { subsize, bsize_med, bsize_big,
                                          subsize };
         for (int i = 0; i < 4; ++i) {
+#if CONFIG_EXTENDED_SDP
+          if (dst->horizontal4a[cur_region_type][i]) {
+            av1_free_pc_tree_recursive(dst->horizontal4a[cur_region_type][i],
+                                       num_planes, 0, 0);
+            dst->horizontal4a[cur_region_type][i] = NULL;
+          }
+          if (src->horizontal4a[cur_region_type][i]) {
+            dst->horizontal4a[cur_region_type][i] = av1_alloc_pc_tree_node(
+                tree_type, mi_rows[i], mi_col, subsizes[i], dst,
+                PARTITION_HORZ_4A, i, i == 3, ss_x, ss_y);
+            av1_copy_pc_tree_recursive(
+                xd, cm, dst->horizontal4a[cur_region_type][i],
+                src->horizontal4a[cur_region_type][i], ss_x, ss_y, shared_bufs,
+                tree_type, num_planes);
+          }
+#else
           if (dst->horizontal4a[i]) {
             av1_free_pc_tree_recursive(dst->horizontal4a[i], num_planes, 0, 0);
             dst->horizontal4a[i] = NULL;
@@ -509,6 +802,7 @@
                                        src->horizontal4a[i], ss_x, ss_y,
                                        shared_bufs, tree_type, num_planes);
           }
+#endif  // CONFIG_EXTENDED_SDP
         }
       }
       break;
@@ -525,6 +819,22 @@
         const BLOCK_SIZE subsizes[4] = { subsize, bsize_big, bsize_med,
                                          subsize };
         for (int i = 0; i < 4; ++i) {
+#if CONFIG_EXTENDED_SDP
+          if (dst->horizontal4b[cur_region_type][i]) {
+            av1_free_pc_tree_recursive(dst->horizontal4b[cur_region_type][i],
+                                       num_planes, 0, 0);
+            dst->horizontal4b[cur_region_type][i] = NULL;
+          }
+          if (src->horizontal4b[cur_region_type][i]) {
+            dst->horizontal4b[cur_region_type][i] = av1_alloc_pc_tree_node(
+                tree_type, mi_rows[i], mi_col, subsizes[i], dst,
+                PARTITION_HORZ_4B, i, i == 3, ss_x, ss_y);
+            av1_copy_pc_tree_recursive(
+                xd, cm, dst->horizontal4b[cur_region_type][i],
+                src->horizontal4b[cur_region_type][i], ss_x, ss_y, shared_bufs,
+                tree_type, num_planes);
+          }
+#else   // CONFIG_EXTENDED_SDP
           if (dst->horizontal4b[i]) {
             av1_free_pc_tree_recursive(dst->horizontal4b[i], num_planes, 0, 0);
             dst->horizontal4b[i] = NULL;
@@ -537,6 +847,7 @@
                                        src->horizontal4b[i], ss_x, ss_y,
                                        shared_bufs, tree_type, num_planes);
           }
+#endif  // CONFIG_EXTENDED_SDP
         }
       }
       break;
@@ -553,6 +864,22 @@
         const BLOCK_SIZE subsizes[4] = { subsize, bsize_med, bsize_big,
                                          subsize };
         for (int i = 0; i < 4; ++i) {
+#if CONFIG_EXTENDED_SDP
+          if (dst->vertical4a[cur_region_type][i]) {
+            av1_free_pc_tree_recursive(dst->vertical4a[cur_region_type][i],
+                                       num_planes, 0, 0);
+            dst->vertical4a[cur_region_type][i] = NULL;
+          }
+          if (src->vertical4a[cur_region_type][i]) {
+            dst->vertical4a[cur_region_type][i] = av1_alloc_pc_tree_node(
+                tree_type, mi_row, mi_cols[i], subsizes[i], dst,
+                PARTITION_VERT_4A, i, i == 3, ss_x, ss_y);
+            av1_copy_pc_tree_recursive(
+                xd, cm, dst->vertical4a[cur_region_type][i],
+                src->vertical4a[cur_region_type][i], ss_x, ss_y, shared_bufs,
+                tree_type, num_planes);
+          }
+#else   // CONFIG_EXTENDED_SDP
           if (dst->vertical4a[i]) {
             av1_free_pc_tree_recursive(dst->vertical4a[i], num_planes, 0, 0);
             dst->vertical4a[i] = NULL;
@@ -565,6 +892,7 @@
                                        src->vertical4a[i], ss_x, ss_y,
                                        shared_bufs, tree_type, num_planes);
           }
+#endif  // CONFIG_EXTENDED_SDP
         }
       }
       break;
@@ -581,6 +909,22 @@
         const BLOCK_SIZE subsizes[4] = { subsize, bsize_big, bsize_med,
                                          subsize };
         for (int i = 0; i < 4; ++i) {
+#if CONFIG_EXTENDED_SDP
+          if (dst->vertical4b[cur_region_type][i]) {
+            av1_free_pc_tree_recursive(dst->vertical4b[cur_region_type][i],
+                                       num_planes, 0, 0);
+            dst->vertical4b[cur_region_type][i] = NULL;
+          }
+          if (src->vertical4b[cur_region_type][i]) {
+            dst->vertical4b[cur_region_type][i] = av1_alloc_pc_tree_node(
+                tree_type, mi_row, mi_cols[i], subsizes[i], dst,
+                PARTITION_VERT_4B, i, i == 3, ss_x, ss_y);
+            av1_copy_pc_tree_recursive(
+                xd, cm, dst->vertical4b[cur_region_type][i],
+                src->vertical4b[cur_region_type][i], ss_x, ss_y, shared_bufs,
+                tree_type, num_planes);
+          }
+#else   // CONFIG_EXTENDED_SDP
           if (dst->vertical4b[i]) {
             av1_free_pc_tree_recursive(dst->vertical4b[i], num_planes, 0, 0);
             dst->vertical4b[i] = NULL;
@@ -593,6 +937,7 @@
                                        src->vertical4b[i], ss_x, ss_y,
                                        shared_bufs, tree_type, num_planes);
           }
+#endif  // CONFIG_EXTENDED_SDP
         }
       }
       break;
@@ -607,7 +952,22 @@
               get_h_partition_offset_mi_row(bsize, i, PARTITION_HORZ_3);
           const int offset_mc =
               get_h_partition_offset_mi_col(bsize, i, PARTITION_HORZ_3);
-
+#if CONFIG_EXTENDED_SDP
+          if (dst->horizontal3[cur_region_type][i]) {
+            av1_free_pc_tree_recursive(dst->horizontal3[cur_region_type][i],
+                                       num_planes, 0, 0);
+            dst->horizontal3[cur_region_type][i] = NULL;
+          }
+          if (src->horizontal3[cur_region_type][i]) {
+            dst->horizontal3[cur_region_type][i] = av1_alloc_pc_tree_node(
+                tree_type, mi_row + offset_mr, mi_col + offset_mc, this_subsize,
+                dst, PARTITION_HORZ_3, i, i == 3, ss_x, ss_y);
+            av1_copy_pc_tree_recursive(
+                xd, cm, dst->horizontal3[cur_region_type][i],
+                src->horizontal3[cur_region_type][i], ss_x, ss_y, shared_bufs,
+                tree_type, num_planes);
+          }
+#else   // CONFIG_EXTENDED_SDP
           if (dst->horizontal3[i]) {
             av1_free_pc_tree_recursive(dst->horizontal3[i], num_planes, 0, 0);
             dst->horizontal3[i] = NULL;
@@ -620,6 +980,7 @@
                                        src->horizontal3[i], ss_x, ss_y,
                                        shared_bufs, tree_type, num_planes);
           }
+#endif  // CONFIG_EXTENDED_SDP
         }
       }
       break;
@@ -633,7 +994,22 @@
               get_h_partition_offset_mi_row(bsize, i, PARTITION_VERT_3);
           const int offset_mc =
               get_h_partition_offset_mi_col(bsize, i, PARTITION_VERT_3);
-
+#if CONFIG_EXTENDED_SDP
+          if (dst->vertical3[cur_region_type][i]) {
+            av1_free_pc_tree_recursive(dst->vertical3[cur_region_type][i],
+                                       num_planes, 0, 0);
+            dst->vertical3[cur_region_type][i] = NULL;
+          }
+          if (src->vertical3[cur_region_type][i]) {
+            dst->vertical3[cur_region_type][i] = av1_alloc_pc_tree_node(
+                tree_type, mi_row + offset_mr, mi_col + offset_mc, this_subsize,
+                dst, PARTITION_VERT_3, i, i == 3, ss_x, ss_y);
+            av1_copy_pc_tree_recursive(
+                xd, cm, dst->vertical3[cur_region_type][i],
+                src->vertical3[cur_region_type][i], ss_x, ss_y, shared_bufs,
+                tree_type, num_planes);
+          }
+#else   // CONFIG_EXTENDED_SDP
           if (dst->vertical3[i]) {
             av1_free_pc_tree_recursive(dst->vertical3[i], num_planes, 0, 0);
             dst->vertical3[i] = NULL;
@@ -646,6 +1022,7 @@
                                        src->vertical3[i], ss_x, ss_y,
                                        shared_bufs, tree_type, num_planes);
           }
+#endif  // CONFIG_EXTENDED_SDP
         }
       }
       break;
@@ -782,6 +1159,36 @@
   if (pc_tree == NULL || pc_tree == target) return NULL;
 
   PC_TREE *result;
+#if CONFIG_EXTENDED_SDP
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+  result =
+      look_for_counterpart_helper(pc_tree->split[cur_region_type][0], target);
+  if (result) return result;
+  result = look_for_counterpart_helper(pc_tree->horizontal[cur_region_type][0],
+                                       target);
+  if (result) return result;
+  result = look_for_counterpart_helper(pc_tree->vertical[cur_region_type][0],
+                                       target);
+  if (result) return result;
+  result = look_for_counterpart_helper(
+      pc_tree->horizontal4a[cur_region_type][0], target);
+  if (result) return result;
+  result = look_for_counterpart_helper(
+      pc_tree->horizontal4b[cur_region_type][0], target);
+  if (result) return result;
+  result = look_for_counterpart_helper(pc_tree->vertical4a[cur_region_type][0],
+                                       target);
+  if (result) return result;
+  result = look_for_counterpart_helper(pc_tree->vertical4b[cur_region_type][0],
+                                       target);
+  if (result) return result;
+  result = look_for_counterpart_helper(pc_tree->horizontal3[cur_region_type][0],
+                                       target);
+  if (result) return result;
+  result = look_for_counterpart_helper(pc_tree->vertical3[cur_region_type][0],
+                                       target);
+  if (result) return result;
+#else
   result = look_for_counterpart_helper(pc_tree->split[0], target);
   if (result) return result;
   result = look_for_counterpart_helper(pc_tree->horizontal[0], target);
@@ -800,6 +1207,7 @@
   if (result) return result;
   result = look_for_counterpart_helper(pc_tree->vertical3[0], target);
   if (result) return result;
+#endif  // CONFIG_EXTENDED_SDP
   return NULL;
 }
 
diff --git a/av1/encoder/context_tree.h b/av1/encoder/context_tree.h
index 2016b4d..37c8744 100644
--- a/av1/encoder/context_tree.h
+++ b/av1/encoder/context_tree.h
@@ -71,7 +71,37 @@
 
 typedef struct PC_TREE {
   PARTITION_TYPE partitioning;
+#if CONFIG_EXTENDED_SDP
+  /*! \brief The region type used for the current block. */
+  REGION_TYPE region_type;
+#endif  // CONFIG_EXTENDED_SDP
   BLOCK_SIZE block_size;
+#if CONFIG_EXTENDED_SDP
+  int inter_sdp_allowed_flag;
+  PICK_MODE_CONTEXT *none[REGION_TYPES];
+  // record the chroma information in intra region.
+  PICK_MODE_CONTEXT *none_chroma;
+#if CONFIG_EXT_RECUR_PARTITIONS
+  struct PC_TREE *horizontal[REGION_TYPES][2];
+  struct PC_TREE *vertical[REGION_TYPES][2];
+  struct PC_TREE *horizontal4a[REGION_TYPES][4];
+  struct PC_TREE *horizontal4b[REGION_TYPES][4];
+  struct PC_TREE *vertical4a[REGION_TYPES][4];
+  struct PC_TREE *vertical4b[REGION_TYPES][4];
+  struct PC_TREE *horizontal3[REGION_TYPES][4];
+  struct PC_TREE *vertical3[REGION_TYPES][4];
+#else
+  PICK_MODE_CONTEXT *horizontal[REGION_TYPES][2];
+  PICK_MODE_CONTEXT *vertical[REGION_TYPES][2];
+  PICK_MODE_CONTEXT *horizontala[REGION_TYPES][3];
+  PICK_MODE_CONTEXT *horizontalb[REGION_TYPES][3];
+  PICK_MODE_CONTEXT *verticala[REGION_TYPES][3];
+  PICK_MODE_CONTEXT *verticalb[REGION_TYPES][3];
+  PICK_MODE_CONTEXT *horizontal4[REGION_TYPES][4];
+  PICK_MODE_CONTEXT *vertical4[REGION_TYPES][4];
+#endif  // CONFIG_EXT_RECUR_PARTITIONS
+  struct PC_TREE *split[REGION_TYPES][4];
+#else
   PICK_MODE_CONTEXT *none;
 #if CONFIG_EXT_RECUR_PARTITIONS
   struct PC_TREE *horizontal[2];
@@ -93,6 +123,7 @@
   PICK_MODE_CONTEXT *vertical4[4];
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   struct PC_TREE *split[4];
+#endif  // CONFIG_EXTENDED_SDP
   struct PC_TREE *parent;
   int mi_row;
   int mi_col;
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 0bb84cb..978dea1 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -566,6 +566,13 @@
     PC_TREE *const pc_root =
         av1_alloc_pc_tree_node(xd->tree_type, mi_row, mi_col, sb_size, NULL,
                                PARTITION_NONE, 0, 1, ss_x, ss_y);
+#if CONFIG_EXTENDED_SDP
+    if (!frame_is_intra_only(cm)) {
+      pc_root->region_type = MIXED_INTER_INTRA_REGION;
+    } else {
+      pc_root->region_type = INTRA_REGION;
+    }
+#endif  // CONFIG_EXTENDED_SDP
 #if CONFIG_EXT_RECUR_PARTITIONS
     const PARTITION_TREE *template_tree =
         multi_pass_params ? multi_pass_params->template_tree : NULL;
@@ -579,8 +586,11 @@
     int force_prune_flags[3] = { 0, 0, 0 };
 #endif  // CONFIG_ML_PART_SPLIT
     av1_rd_pick_partition(
-        cpi, td, tile_data, tp, mi_row, mi_col, sb_size, &dummy_rdc, dummy_rdc,
-        pc_root,
+        cpi, td, tile_data, tp, mi_row, mi_col, sb_size,
+#if CONFIG_EXTENDED_SDP
+        PARTITION_NONE,
+#endif  // CONFIG_EXTENDED_SDP
+        &dummy_rdc, dummy_rdc, pc_root,
 #if CONFIG_EXT_RECUR_PARTITIONS
         xd->tree_type == CHROMA_PART ? xd->sbi->ptree_root[0] : NULL,
         template_tree, INT_MAX,
diff --git a/av1/encoder/encodeframe_utils.c b/av1/encoder/encodeframe_utils.c
index cbb9c29..c352e68 100644
--- a/av1/encoder/encodeframe_utils.c
+++ b/av1/encoder/encodeframe_utils.c
@@ -1715,6 +1715,14 @@
                  UV_INTRA_MODES - 1, CDF_SIZE(UV_INTRA_MODES));
   AVERAGE_CDF(ctx_left->uv_mode_cdf[1], ctx_tr->uv_mode_cdf[1], UV_INTRA_MODES);
 #endif  // CONFIG_UV_CFL
+
+#if CONFIG_EXTENDED_SDP
+  for (int i = 0; i < INTER_SDP_BSIZE_GROUP; i++) {
+    AVERAGE_CDF(ctx_left->region_type_cdf[i], ctx_tr->region_type_cdf[i],
+                REGION_TYPES);
+  }
+#endif  // CONFIG_EXTENDED_SDP
+
 #if CONFIG_EXT_RECUR_PARTITIONS
   for (int plane_index = 0; plane_index < PARTITION_STRUCTURE_NUM;
        plane_index++) {
diff --git a/av1/encoder/encodeframe_utils.h b/av1/encoder/encodeframe_utils.h
index c714e9c..1eea6ef 100644
--- a/av1/encoder/encodeframe_utils.h
+++ b/av1/encoder/encodeframe_utils.h
@@ -173,6 +173,11 @@
   // Pointer to partition cost buffer
   const int *partition_cost;
 
+#if CONFIG_EXTENDED_SDP
+  // Pointer to region type cost buffer
+  int *region_type_cost;
+#endif  // CONFIG_EXTENDED_SDP
+
   // RD costs for different partition types.
   int64_t none_rd;
   int64_t split_rd[SUB_PARTITIONS_SPLIT];
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index aae2e02..b5f78aa 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -1374,6 +1374,9 @@
   unsigned int palette_uv_color_index[PALETTE_SIZES]
                                      [PALETTE_COLOR_INDEX_CONTEXTS]
                                      [PALETTE_COLORS];
+#if CONFIG_EXTENDED_SDP
+  unsigned int region_type[INTER_SDP_BSIZE_GROUP][REGION_TYPES];
+#endif  // CONFIG_EXTENDED_SDP
 #if CONFIG_EXT_RECUR_PARTITIONS
   unsigned int do_split[PARTITION_STRUCTURE_NUM][PARTITION_CONTEXTS][2];
   unsigned int do_square_split[PARTITION_STRUCTURE_NUM][SQUARE_SPLIT_CONTEXTS]
diff --git a/av1/encoder/intra_mode_search.c b/av1/encoder/intra_mode_search.c
index f392009..e8254f7 100644
--- a/av1/encoder/intra_mode_search.c
+++ b/av1/encoder/intra_mode_search.c
@@ -612,7 +612,10 @@
 
   // Only store reconstructed luma when there's chroma RDO. When there's no
   // chroma RDO, the reconstructed luma will be stored in encode_superblock().
-  xd->cfl.store_y = store_cfl_required_rdo(cm, x);
+#if CONFIG_EXTENDED_SDP
+  if (frame_is_intra_only(cm) || xd->tree_type != CHROMA_PART)
+#endif  // CONFIG_EXTENDED_SDP
+    xd->cfl.store_y = store_cfl_required_rdo(cm, x);
   if (xd->tree_type == SHARED_PART) {
     if (xd->cfl.store_y) {
       av1_encode_intra_block_plane(cpi, x, mbmi->sb_type[PLANE_TYPE_Y],
@@ -1251,7 +1254,7 @@
     mode_cost += ref_frame_cost;
     mode_cost += mrl_idx_cost;
   }
-#else   // CONFIG_LOSSLESS_DPCM
+#else  // CONFIG_LOSSLESS_DPCM
   const int context = get_y_mode_idx_ctx(xd);
   int mode_set_index = mbmi->y_mode_idx < FIRST_MODE_COUNT ? 0 : 1;
   mode_set_index += ((mbmi->y_mode_idx - FIRST_MODE_COUNT) / SECOND_MODE_COUNT);
@@ -1265,7 +1268,10 @@
                                 [mbmi->y_mode_idx - FIRST_MODE_COUNT -
                                  SECOND_MODE_COUNT * (mode_set_index - 1)];
   }
-  mode_cost += ref_frame_cost;
+#if CONFIG_EXTENDED_SDP
+  if (mbmi->region_type != INTRA_REGION)
+#endif  // CONFIG_EXTENDED_SDP
+    mode_cost += ref_frame_cost;
   mode_cost += mrl_idx_cost;
 #endif  // CONFIG_LOSSLESS_DPCM
 #else
diff --git a/av1/encoder/intra_mode_search_utils.h b/av1/encoder/intra_mode_search_utils.h
index 6304ccc..c853a3a 100644
--- a/av1/encoder/intra_mode_search_utils.h
+++ b/av1/encoder/intra_mode_search_utils.h
@@ -279,7 +279,7 @@
     }
   }
 #endif  // !CONFIG_AIMC
-  if (av1_allow_intrabc(&cpi->common) && xd->tree_type != CHROMA_PART) {
+  if (av1_allow_intrabc(&cpi->common, xd) && xd->tree_type != CHROMA_PART) {
 #if CONFIG_NEW_CONTEXT_MODELING
     const int intrabc_ctx = get_intrabc_ctx(xd);
     total_rate += mode_costs->intrabc_cost[intrabc_ctx][use_intrabc];
diff --git a/av1/encoder/partition_search.c b/av1/encoder/partition_search.c
index 67faefc..fc1851d 100644
--- a/av1/encoder/partition_search.c
+++ b/av1/encoder/partition_search.c
@@ -586,12 +586,11 @@
   }
 
   if (!dry_run) {
-    if (av1_allow_intrabc(cm) && is_intrabc_block(mbmi, xd->tree_type))
+    if (av1_allow_intrabc(cm, xd) && is_intrabc_block(mbmi, xd->tree_type))
       td->intrabc_used = 1;
 #if CONFIG_MORPH_PRED
     if (mbmi->morph_pred) {
-      assert(av1_allow_intrabc(cm));
-      assert(is_intrabc_block(mbmi, xd->tree_type));
+      assert(av1_allow_intrabc(cm, xd));
     }
 #endif  // CONFIG_MORPH_PRED
     if (txfm_params->tx_mode_search_type == TX_MODE_SELECT &&
@@ -653,12 +652,21 @@
       } else {
         intra_tx_size = mbmi->tx_size;
       }
-
-      for (j = 0; j < mi_height; j++)
-        for (i = 0; i < mi_width; i++)
-          if (mi_col + i < cm->mi_params.mi_cols &&
-              mi_row + j < cm->mi_params.mi_rows)
-            mi_4x4[mis * j + i]->tx_size = intra_tx_size;
+#if CONFIG_EXTENDED_SDP
+      // Since transform partitioning is only allowed for luma component,
+      // and tx_size variable represents the transform size of the luma
+      // component in one coded block, so chroma block should not change the
+      // tx_size.
+      if (xd->tree_type != CHROMA_PART || frame_is_intra_only(cm)) {
+#endif  // CONFIG_EXTENDED_SDP
+        for (j = 0; j < mi_height; j++)
+          for (i = 0; i < mi_width; i++)
+            if (mi_col + i < cm->mi_params.mi_cols &&
+                mi_row + j < cm->mi_params.mi_rows)
+              mi_4x4[mis * j + i]->tx_size = intra_tx_size;
+#if CONFIG_EXTENDED_SDP
+      }
+#endif  // CONFIG_EXTENDED_SDP
 
       if (intra_tx_size != max_txsize_rect_lookup[bsize])
         ++x->txfm_search_info.txb_split_count;
@@ -844,6 +852,11 @@
   av1_set_offsets_without_segment_id(cpi, tile, x, mi_row, mi_col, bsize,
                                      chroma_ref_info);
 
+#if CONFIG_EXTENDED_SDP
+  // Don't set up segment ID for chroma part in SDP of inter frame
+  if (!frame_is_intra_only(cm) && xd->tree_type == CHROMA_PART) return;
+#endif  // CONFIG_EXTENDED_SDP
+
   // Setup segment ID.
   mbmi = xd->mi[0];
   mbmi->segment_id = 0;
@@ -881,6 +894,7 @@
  * \param[in]    rd_cost        Pointer to structure holding rate and distortion
  *                              stats for the current block
  * \param[in]    partition      Partition mode of the parent block
+ * \param[in]    cur_region_type      Region type of the current block
  * \param[in]    bsize          Current block size
  * \param[in]    ctx            Pointer to structure holding coding contexts and
  *                              chosen modes for the current block
@@ -894,6 +908,9 @@
 static void pick_sb_modes(AV1_COMP *const cpi, TileDataEnc *tile_data,
                           MACROBLOCK *const x, int mi_row, int mi_col,
                           RD_STATS *rd_cost, PARTITION_TYPE partition,
+#if CONFIG_EXTENDED_SDP
+                          REGION_TYPE cur_region_type,
+#endif  // CONFIG_EXTENDED_SDP
                           BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx,
                           RD_STATS best_rd) {
   if (best_rd.rdcost < 0) {
@@ -912,6 +929,10 @@
   av1_set_offsets(cpi, &tile_data->tile_info, x, mi_row, mi_col, bsize,
                   &ctx->chroma_ref_info);
 
+#if CONFIG_EXTENDED_SDP
+  xd->mi[0]->region_type = cur_region_type;
+#endif  // CONFIG_EXTENDED_SDP
+
   if (ctx->rd_mode_is_ready) {
     assert(ctx->mic.sb_type[plane_type] == bsize);
     assert(ctx->mic.partition == partition);
@@ -998,7 +1019,11 @@
 
   // Find best coding mode & reconstruct the MB so it is available
   // as a predictor for MBs that follow in the SB
-  if (frame_is_intra_only(cm)) {
+  if (frame_is_intra_only(cm)
+#if CONFIG_EXTENDED_SDP
+      || mbmi->region_type == INTRA_REGION
+#endif  // CONFIG_EXTENDED_SDP
+  ) {
 #if CONFIG_COLLECT_COMPONENT_TIMING
     start_timing(cpi, av1_rd_pick_intra_mode_sb_time);
 #endif
@@ -1280,6 +1305,9 @@
   const int seg_ref_active = 0;
 
   if (current_frame->skip_mode_info.skip_mode_flag && !seg_ref_active &&
+#if CONFIG_EXTENDED_SDP
+      mbmi->region_type != INTRA_REGION &&
+#endif  // CONFIG_EXTENDED_SDP
       is_comp_ref_allowed(bsize)) {
     const int skip_mode_ctx = av1_get_skip_mode_context(xd);
 #if CONFIG_ENTROPY_STATS
@@ -1291,15 +1319,19 @@
 #if CONFIG_SKIP_TXFM_OPT
   const int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
   if (!seg_ref_active) {
-    if (!mbmi->skip_mode && !frame_is_intra_only(cm)) {
+    if (!mbmi->skip_mode && !frame_is_intra_only(cm)
+#if CONFIG_EXTENDED_SDP
+        && mbmi->region_type != INTRA_REGION
+#endif  // CONFIG_EXTENDED_SDP
+    ) {
       const int intra_inter_ctx = av1_get_intra_inter_context(xd);
 #if CONFIG_ENTROPY_STATS
       td->counts->intra_inter[intra_inter_ctx][inter_block]++;
 #endif  // CONFIG_ENTROPY_STATS
       update_cdf(fc->intra_inter_cdf[intra_inter_ctx], inter_block, 2);
     }
-
-    if (!inter_block && av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+    if (!inter_block && av1_allow_intrabc(cm, xd) &&
+        xd->tree_type != CHROMA_PART) {
 #if CONFIG_NEW_CONTEXT_MODELING
       const int intrabc_ctx = get_intrabc_ctx(xd);
       update_cdf(fc->intrabc_cdf[intrabc_ctx], use_intrabc, 2);
@@ -1393,7 +1425,7 @@
   if (!is_inter_block(mbmi, xd->tree_type)) {
     av1_sum_intra_stats(cm, td->counts, xd, mbmi);
   }
-  if (av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
+  if (av1_allow_intrabc(cm, xd) && xd->tree_type != CHROMA_PART) {
 #if !CONFIG_SKIP_TXFM_OPT
     const int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
 #if CONFIG_NEW_CONTEXT_MODELING
@@ -2806,6 +2838,21 @@
     ptree->bsize = bsize;
     ptree->mi_row = mi_row;
     ptree->mi_col = mi_col;
+#if CONFIG_EXTENDED_SDP
+    ptree->region_type = pc_tree->region_type;
+    const int is_sb_root = bsize == cm->sb_size;
+    ptree->inter_sdp_allowed_flag = pc_tree->inter_sdp_allowed_flag;
+    if (!frame_is_intra_only(cm) && !is_sb_root &&
+        partition != PARTITION_NONE && parent &&
+        parent->region_type != INTRA_REGION && xd->tree_type != CHROMA_PART &&
+        ptree->inter_sdp_allowed_flag &&
+        is_bsize_allowed_for_inter_sdp(bsize, partition)) {
+      assert(xd->tree_type != CHROMA_PART);
+      const int intra_region_ctx = get_intra_region_context(bsize);
+      update_cdf(xd->tile_ctx->region_type_cdf[intra_region_ctx],
+                 ptree->region_type, REGION_TYPES);
+    }
+#endif  // CONFIG_EXTENDED_SDP
     const int ss_x = xd->plane[1].subsampling_x;
     const int ss_y = xd->plane[1].subsampling_y;
     set_chroma_ref_info(
@@ -2860,19 +2907,45 @@
     }
   }
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXTENDED_SDP
+  // encode both the luma and chroma blocks in one intra region
+  int encode_sdp_intra_region_yuv = 0;
+  if (!frame_is_intra_only(cm) && xd->tree_type == SHARED_PART &&
+      pc_tree->region_type == INTRA_REGION) {
+    encode_sdp_intra_region_yuv = 1;
+    xd->tree_type = LUMA_PART;
+  }
+#endif  // CONFIG_EXTENDED_SDP
   switch (partition) {
     case PARTITION_NONE:
       encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize,
-               partition, pc_tree->none, rate);
+               partition,
+#if CONFIG_EXTENDED_SDP
+               pc_tree->none[pc_tree->region_type],
+#else
+               pc_tree->none,
+#endif  // CONFIG_EXTENDED_SDP
+               rate);
       break;
     case PARTITION_VERT:
 #if CONFIG_EXT_RECUR_PARTITIONS
       encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
-                pc_tree->vertical[0], sub_tree[0],
-                track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
+#if CONFIG_EXTENDED_SDP
+                pc_tree->vertical[pc_tree->region_type][0],
+#else
+                pc_tree->vertical[0],
+#endif  // CONFIG_EXTENDED_SDP
+                sub_tree[0], track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+                rate);
       if (mi_col + hbs_w < cm->mi_params.mi_cols) {
         encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + hbs_w, dry_run,
-                  subsize, pc_tree->vertical[1], sub_tree[1],
+                  subsize,
+#if CONFIG_EXTENDED_SDP
+                  pc_tree->vertical[pc_tree->region_type][1],
+#else
+                  pc_tree->vertical[1],
+#endif  // CONFIG_EXTENDED_SDP
+                  sub_tree[1],
                   track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
       }
 #else   // CONFIG_EXT_RECUR_PARTITIONS
@@ -2887,11 +2960,22 @@
     case PARTITION_HORZ:
 #if CONFIG_EXT_RECUR_PARTITIONS
       encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
-                pc_tree->horizontal[0], sub_tree[0],
-                track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
+#if CONFIG_EXTENDED_SDP
+                pc_tree->horizontal[pc_tree->region_type][0],
+#else
+                pc_tree->horizontal[0],
+#endif  // CONFIG_EXTENDED_SDP
+                sub_tree[0], track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+                rate);
       if (mi_row + hbs_h < cm->mi_params.mi_rows) {
         encode_sb(cpi, td, tile_data, tp, mi_row + hbs_h, mi_col, dry_run,
-                  subsize, pc_tree->horizontal[1], sub_tree[1],
+                  subsize,
+#if CONFIG_EXTENDED_SDP
+                  pc_tree->horizontal[pc_tree->region_type][1],
+#else
+                  pc_tree->horizontal[1],
+#endif  // CONFIG_EXTENDED_SDP
+                  sub_tree[1],
                   track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
       }
 #else   // CONFIG_EXT_RECUR_PARTITIONS
@@ -2909,20 +2993,41 @@
       const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_HORZ][bsize_big];
       assert(subsize == subsize_lookup[PARTITION_HORZ][bsize_med]);
       encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
-                pc_tree->horizontal4a[0], sub_tree[0],
-                track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
+#if CONFIG_EXTENDED_SDP
+                pc_tree->horizontal4a[pc_tree->region_type][0],
+#else
+                pc_tree->horizontal4a[0],
+#endif  // CONFIG_EXTENDED_SDP
+                sub_tree[0], track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+                rate);
       if (mi_row + ebs_h >= cm->mi_params.mi_rows) break;
-      encode_sb(cpi, td, tile_data, tp, mi_row + ebs_h, mi_col, dry_run,
-                bsize_med, pc_tree->horizontal4a[1], sub_tree[1],
-                track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
+      encode_sb(
+          cpi, td, tile_data, tp, mi_row + ebs_h, mi_col, dry_run, bsize_med,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->horizontal4a[pc_tree->region_type][1],
+#else
+          pc_tree->horizontal4a[1],
+#endif  // CONFIG_EXTENDED_SDP
+          sub_tree[1], track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
       if (mi_row + 3 * ebs_h >= cm->mi_params.mi_rows) break;
       encode_sb(cpi, td, tile_data, tp, mi_row + 3 * ebs_h, mi_col, dry_run,
-                bsize_big, pc_tree->horizontal4a[2], sub_tree[2],
-                track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
+                bsize_big,
+#if CONFIG_EXTENDED_SDP
+                pc_tree->horizontal4a[pc_tree->region_type][2],
+#else
+                pc_tree->horizontal4a[2],
+#endif  // CONFIG_EXTENDED_SDP
+                sub_tree[2], track_ptree_luma ? ptree_luma->sub_tree[2] : NULL,
+                rate);
       if (mi_row + 7 * ebs_h >= cm->mi_params.mi_rows) break;
-      encode_sb(cpi, td, tile_data, tp, mi_row + 7 * ebs_h, mi_col, dry_run,
-                subsize, pc_tree->horizontal4a[3], sub_tree[3],
-                track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
+      encode_sb(
+          cpi, td, tile_data, tp, mi_row + 7 * ebs_h, mi_col, dry_run, subsize,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->horizontal4a[pc_tree->region_type][3],
+#else
+          pc_tree->horizontal4a[3],
+#endif  // CONFIG_EXTENDED_SDP
+          sub_tree[3], track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
       break;
     }
     case PARTITION_HORZ_4B: {
@@ -2930,20 +3035,41 @@
       const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_HORZ][bsize_big];
       assert(subsize == subsize_lookup[PARTITION_HORZ][bsize_med]);
       encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
-                pc_tree->horizontal4b[0], sub_tree[0],
-                track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
+#if CONFIG_EXTENDED_SDP
+                pc_tree->horizontal4b[pc_tree->region_type][0],
+#else
+                pc_tree->horizontal4b[0],
+#endif  // CONFIG_EXTENDED_SDP
+                sub_tree[0], track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+                rate);
       if (mi_row + ebs_h >= cm->mi_params.mi_rows) break;
-      encode_sb(cpi, td, tile_data, tp, mi_row + ebs_h, mi_col, dry_run,
-                bsize_big, pc_tree->horizontal4b[1], sub_tree[1],
-                track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
+      encode_sb(
+          cpi, td, tile_data, tp, mi_row + ebs_h, mi_col, dry_run, bsize_big,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->horizontal4b[pc_tree->region_type][1],
+#else
+          pc_tree->horizontal4b[1],
+#endif  // CONFIG_EXTENDED_SDP
+          sub_tree[1], track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
       if (mi_row + 5 * ebs_h >= cm->mi_params.mi_rows) break;
       encode_sb(cpi, td, tile_data, tp, mi_row + 5 * ebs_h, mi_col, dry_run,
-                bsize_med, pc_tree->horizontal4b[2], sub_tree[2],
-                track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
+                bsize_med,
+#if CONFIG_EXTENDED_SDP
+                pc_tree->horizontal4b[pc_tree->region_type][2],
+#else
+                pc_tree->horizontal4b[2],
+#endif  // CONFIG_EXTENDED_SDP
+                sub_tree[2], track_ptree_luma ? ptree_luma->sub_tree[2] : NULL,
+                rate);
       if (mi_row + 7 * ebs_h >= cm->mi_params.mi_rows) break;
-      encode_sb(cpi, td, tile_data, tp, mi_row + 7 * ebs_h, mi_col, dry_run,
-                subsize, pc_tree->horizontal4b[3], sub_tree[3],
-                track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
+      encode_sb(
+          cpi, td, tile_data, tp, mi_row + 7 * ebs_h, mi_col, dry_run, subsize,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->horizontal4b[pc_tree->region_type][3],
+#else
+          pc_tree->horizontal4b[3],
+#endif  // CONFIG_EXTENDED_SDP
+          sub_tree[3], track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
       break;
     }
     case PARTITION_VERT_4A: {
@@ -2951,20 +3077,41 @@
       const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_VERT][bsize_big];
       assert(subsize == subsize_lookup[PARTITION_VERT][bsize_med]);
       encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
-                pc_tree->vertical4a[0], sub_tree[0],
-                track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
+#if CONFIG_EXTENDED_SDP
+                pc_tree->vertical4a[pc_tree->region_type][0],
+#else
+                pc_tree->vertical4a[0],
+#endif  // CONFIG_EXTENDED_SDP
+                sub_tree[0], track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+                rate);
       if (mi_col + ebs_w >= cm->mi_params.mi_cols) break;
-      encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + ebs_w, dry_run,
-                bsize_med, pc_tree->vertical4a[1], sub_tree[1],
-                track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
+      encode_sb(
+          cpi, td, tile_data, tp, mi_row, mi_col + ebs_w, dry_run, bsize_med,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->vertical4a[pc_tree->region_type][1],
+#else
+          pc_tree->vertical4a[1],
+#endif  // CONFIG_EXTENDED_SDP
+          sub_tree[1], track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
       if (mi_col + 3 * ebs_w >= cm->mi_params.mi_cols) break;
       encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 3 * ebs_w, dry_run,
-                bsize_big, pc_tree->vertical4a[2], sub_tree[2],
-                track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
+                bsize_big,
+#if CONFIG_EXTENDED_SDP
+                pc_tree->vertical4a[pc_tree->region_type][2],
+#else
+                pc_tree->vertical4a[2],
+#endif  // CONFIG_EXTENDED_SDP
+                sub_tree[2], track_ptree_luma ? ptree_luma->sub_tree[2] : NULL,
+                rate);
       if (mi_col + 7 * ebs_w >= cm->mi_params.mi_cols) break;
-      encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 7 * ebs_w, dry_run,
-                subsize, pc_tree->vertical4a[3], sub_tree[3],
-                track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
+      encode_sb(
+          cpi, td, tile_data, tp, mi_row, mi_col + 7 * ebs_w, dry_run, subsize,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->vertical4a[pc_tree->region_type][3],
+#else
+          pc_tree->vertical4a[3],
+#endif  // CONFIG_EXTENDED_SDP
+          sub_tree[3], track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
       break;
     }
     case PARTITION_VERT_4B: {
@@ -2972,20 +3119,41 @@
       const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_VERT][bsize_big];
       assert(subsize == subsize_lookup[PARTITION_VERT][bsize_med]);
       encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
-                pc_tree->vertical4b[0], sub_tree[0],
-                track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
+#if CONFIG_EXTENDED_SDP
+                pc_tree->vertical4b[pc_tree->region_type][0],
+#else
+                pc_tree->vertical4b[0],
+#endif  // CONFIG_EXTENDED_SDP
+                sub_tree[0], track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+                rate);
       if (mi_col + ebs_w >= cm->mi_params.mi_cols) break;
-      encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + ebs_w, dry_run,
-                bsize_big, pc_tree->vertical4b[1], sub_tree[1],
-                track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
+      encode_sb(
+          cpi, td, tile_data, tp, mi_row, mi_col + ebs_w, dry_run, bsize_big,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->vertical4b[pc_tree->region_type][1],
+#else
+          pc_tree->vertical4b[1],
+#endif  // CONFIG_EXTENDED_SDP
+          sub_tree[1], track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
       if (mi_col + 5 * ebs_w >= cm->mi_params.mi_cols) break;
       encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 5 * ebs_w, dry_run,
-                bsize_med, pc_tree->vertical4b[2], sub_tree[2],
-                track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
+                bsize_med,
+#if CONFIG_EXTENDED_SDP
+                pc_tree->vertical4b[pc_tree->region_type][2],
+#else
+                pc_tree->vertical4b[2],
+#endif  // CONFIG_EXTENDED_SDP
+                sub_tree[2], track_ptree_luma ? ptree_luma->sub_tree[2] : NULL,
+                rate);
       if (mi_col + 7 * ebs_w >= cm->mi_params.mi_cols) break;
-      encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 7 * ebs_w, dry_run,
-                subsize, pc_tree->vertical4b[3], sub_tree[3],
-                track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
+      encode_sb(
+          cpi, td, tile_data, tp, mi_row, mi_col + 7 * ebs_w, dry_run, subsize,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->vertical4b[pc_tree->region_type][3],
+#else
+          pc_tree->vertical4b[3],
+#endif  // CONFIG_EXTENDED_SDP
+          sub_tree[3], track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
       break;
     }
     case PARTITION_HORZ_3:
@@ -2997,9 +3165,15 @@
         const int offset_c = get_h_partition_offset_mi_col(bsize, i, partition);
         const int this_mi_row = mi_row + offset_r;
         const int this_mi_col = mi_col + offset_c;
-        PC_TREE *this_pc_tree = partition == PARTITION_HORZ_3
-                                    ? pc_tree->horizontal3[i]
-                                    : pc_tree->vertical3[i];
+        PC_TREE *this_pc_tree =
+            partition == PARTITION_HORZ_3
+#if CONFIG_EXTENDED_SDP
+                ? pc_tree->horizontal3[pc_tree->region_type][i]
+                : pc_tree->vertical3[pc_tree->region_type][i];
+#else
+                ? pc_tree->horizontal3[i]
+                : pc_tree->vertical3[i];
+#endif  // CONFIG_EXTENDED_SDP
 
         if (partition == PARTITION_HORZ_3) {
           if (this_mi_row >= cm->mi_params.mi_rows) break;
@@ -3014,17 +3188,38 @@
     }
     case PARTITION_SPLIT:
       encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
-                pc_tree->split[0], sub_tree[0],
-                track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
-      encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + hbs_w, dry_run,
-                subsize, pc_tree->split[1], sub_tree[1],
-                track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
-      encode_sb(cpi, td, tile_data, tp, mi_row + hbs_h, mi_col, dry_run,
-                subsize, pc_tree->split[2], sub_tree[2],
-                track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
+#if CONFIG_EXTENDED_SDP
+                pc_tree->split[pc_tree->region_type][0],
+#else
+                pc_tree->split[0],
+#endif  // CONFIG_EXTENDED_SDP
+                sub_tree[0], track_ptree_luma ? ptree_luma->sub_tree[0] : NULL,
+                rate);
+      encode_sb(
+          cpi, td, tile_data, tp, mi_row, mi_col + hbs_w, dry_run, subsize,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->split[pc_tree->region_type][1],
+#else
+          pc_tree->split[1],
+#endif  // CONFIG_EXTENDED_SDP
+          sub_tree[1], track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
+      encode_sb(
+          cpi, td, tile_data, tp, mi_row + hbs_h, mi_col, dry_run, subsize,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->split[pc_tree->region_type][2],
+#else
+          pc_tree->split[2],
+#endif  // CONFIG_EXTENDED_SDP
+          sub_tree[2], track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
       encode_sb(cpi, td, tile_data, tp, mi_row + hbs_h, mi_col + hbs_w, dry_run,
-                subsize, pc_tree->split[3], sub_tree[3],
-                track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
+                subsize,
+#if CONFIG_EXTENDED_SDP
+                pc_tree->split[pc_tree->region_type][3],
+#else
+                pc_tree->split[3],
+#endif  // CONFIG_EXTENDED_SDP
+                sub_tree[3], track_ptree_luma ? ptree_luma->sub_tree[3] : NULL,
+                rate);
       break;
 #else   // CONFIG_EXT_RECUR_PARTITIONS
     case PARTITION_SPLIT:
@@ -3091,6 +3286,16 @@
     default: assert(0 && "Invalid partition type."); break;
   }
 
+#if CONFIG_EXTENDED_SDP
+  // encode the chroma blocks under one intra region in inter frame
+  if (encode_sdp_intra_region_yuv && !cm->seq_params.monochrome) {
+    xd->tree_type = CHROMA_PART;
+    encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, bsize,
+             PARTITION_NONE, pc_tree->none_chroma, rate);
+    xd->tree_type = SHARED_PART;
+  }
+#endif  // CONFIG_EXTENDED_SDP
+
   if (ptree) ptree->is_settled = 1;
   update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition);
 }
@@ -3348,12 +3553,40 @@
   RD_SEARCH_MACROBLOCK_CONTEXT x_ctx;
   RD_STATS last_part_rdc, invalid_rdc;
 
+#if CONFIG_EXTENDED_SDP
+  if (!frame_is_intra_only(cm))
+    pc_tree->region_type = MIXED_INTER_INTRA_REGION;
+  else
+    pc_tree->region_type = INTRA_REGION;
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+  if (is_inter_sdp_chroma(cm, cur_region_type, x->e_mbd.tree_type)) {
+    if (pc_tree->none_chroma == NULL) {
+      pc_tree->none_chroma =
+          av1_alloc_pmc(cm, xd->tree_type, mi_row, mi_col, bsize, pc_tree,
+                        PARTITION_NONE, 0, ss_x, ss_y, &td->shared_coeff_buf);
+    }
+  } else {
+    if (pc_tree->none[cur_region_type] == NULL) {
+      pc_tree->none[cur_region_type] =
+          av1_alloc_pmc(cm, xd->tree_type, mi_row, mi_col, bsize, pc_tree,
+                        PARTITION_NONE, 0, ss_x, ss_y, &td->shared_coeff_buf);
+    }
+  }
+#else
   if (pc_tree->none == NULL) {
     pc_tree->none =
         av1_alloc_pmc(cm, xd->tree_type, mi_row, mi_col, bsize, pc_tree,
                       PARTITION_NONE, 0, ss_x, ss_y, &td->shared_coeff_buf);
   }
+#endif  // CONFIG_EXTENDED_SDP
+#if CONFIG_EXTENDED_SDP
+  PICK_MODE_CONTEXT *ctx_none =
+      is_inter_sdp_chroma(cm, cur_region_type, x->e_mbd.tree_type)
+          ? pc_tree->none_chroma
+          : pc_tree->none[pc_tree->region_type];
+#else
   PICK_MODE_CONTEXT *ctx_none = pc_tree->none;
+#endif  // CONFIG_EXTENDED_SDP
 
   if (mi_row >= mi_params->mi_rows || mi_col >= mi_params->mi_cols) return;
 
@@ -3398,20 +3631,36 @@
   switch (partition) {
     case PARTITION_NONE:
       pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &last_part_rdc,
-                    PARTITION_NONE, bsize, ctx_none, invalid_rdc);
+                    PARTITION_NONE,
+#if CONFIG_EXTENDED_SDP
+                    pc_tree->region_type,
+#endif  // CONFIG_EXTENDED_SDP
+                    bsize, ctx_none, invalid_rdc);
       break;
     case PARTITION_HORZ:
 #if CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXTENDED_SDP
+      pc_tree->horizontal[cur_region_type][0] =
+#else
       pc_tree->horizontal[0] =
+#endif  // CONFIG_EXTENDED_SDP
           av1_alloc_pc_tree_node(xd->tree_type, mi_row, mi_col, subsize,
                                  pc_tree, PARTITION_HORZ, 0, 0, ss_x, ss_y);
+#if CONFIG_EXTENDED_SDP
+      pc_tree->horizontal[cur_region_type][1] =
+#else
       pc_tree->horizontal[1] =
+#endif  // CONFIG_EXTENDED_SDP
           av1_alloc_pc_tree_node(xd->tree_type, mi_row + hbh, mi_col, subsize,
                                  pc_tree, PARTITION_HORZ, 1, 1, ss_x, ss_y);
       av1_rd_use_partition(cpi, td, tile_data, mib, tp, mi_row, mi_col, subsize,
                            &last_part_rdc.rate, &last_part_rdc.dist, 1,
                            ptree ? ptree->sub_tree[0] : NULL,
+#if CONFIG_EXTENDED_SDP
+                           pc_tree->horizontal[cur_region_type][0]);
+#else
                            pc_tree->horizontal[0]);
+#endif  // CONFIG_EXTENDED_SDP
 #else   // CONFIG_EXT_RECUR_PARTITIONS
       for (int i = 0; i < SUB_PARTITIONS_RECT; ++i) {
         if (pc_tree->horizontal[i] == NULL) {
@@ -3429,10 +3678,15 @@
         RD_STATS tmp_rdc;
         av1_init_rd_stats(&tmp_rdc);
 #if CONFIG_EXT_RECUR_PARTITIONS
-        av1_rd_use_partition(
-            cpi, td, tile_data, mib + hbh * mi_params->mi_stride, tp,
-            mi_row + hbh, mi_col, subsize, &tmp_rdc.rate, &tmp_rdc.dist, 0,
-            ptree ? ptree->sub_tree[1] : NULL, pc_tree->horizontal[1]);
+        av1_rd_use_partition(cpi, td, tile_data,
+                             mib + hbh * mi_params->mi_stride, tp, mi_row + hbh,
+                             mi_col, subsize, &tmp_rdc.rate, &tmp_rdc.dist, 0,
+                             ptree ? ptree->sub_tree[1] : NULL,
+#if CONFIG_EXTENDED_SDP
+                             pc_tree->horizontal[cur_region_type][1]);
+#else
+                             pc_tree->horizontal[1]);
+#endif  // CONFIG_EXTENDED_SDP
 #else   // CONFIG_EXT_RECUR_PARTITIONS
         const PICK_MODE_CONTEXT *const ctx_h = pc_tree->horizontal[0];
         av1_update_state(cpi, td, ctx_h, mi_row, mi_col, subsize, 1);
@@ -3453,16 +3707,28 @@
       break;
     case PARTITION_VERT:
 #if CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXTENDED_SDP
+      pc_tree->vertical[cur_region_type][0] =
+#else
       pc_tree->vertical[0] =
+#endif  // CONFIG_EXTENDED_SDP
           av1_alloc_pc_tree_node(xd->tree_type, mi_row, mi_col, subsize,
                                  pc_tree, PARTITION_VERT, 0, 0, ss_x, ss_y);
+#if CONFIG_EXTENDED_SDP
+      pc_tree->vertical[cur_region_type][1] =
+#else
       pc_tree->vertical[1] =
+#endif  // CONFIG_EXTENDED_SDP
           av1_alloc_pc_tree_node(xd->tree_type, mi_row, mi_col + hbw, subsize,
                                  pc_tree, PARTITION_VERT, 1, 1, ss_x, ss_y);
       av1_rd_use_partition(cpi, td, tile_data, mib, tp, mi_row, mi_col, subsize,
                            &last_part_rdc.rate, &last_part_rdc.dist, 1,
                            ptree ? ptree->sub_tree[0] : NULL,
+#if CONFIG_EXTENDED_SDP
+                           pc_tree->vertical[cur_region_type][0]);
+#else
                            pc_tree->vertical[0]);
+#endif  // CONFIG_EXTENDED_SDP
 #else   // CONFIG_EXT_RECUR_PARTITIONS
       for (int i = 0; i < SUB_PARTITIONS_RECT; ++i) {
         if (pc_tree->vertical[i] == NULL) {
@@ -3482,7 +3748,11 @@
         av1_rd_use_partition(
             cpi, td, tile_data, mib + hbw, tp, mi_row, mi_col + hbw, subsize,
             &tmp_rdc.rate, &tmp_rdc.dist, 0, ptree ? ptree->sub_tree[1] : NULL,
+#if CONFIG_EXTENDED_SDP
+            pc_tree->vertical[cur_region_type][1]);
+#else
             pc_tree->vertical[1]);
+#endif  // CONFIG_EXTENDED_SDP
 #else   // CONFIG_EXT_RECUR_PARTITIONS
         const PICK_MODE_CONTEXT *const ctx_v = pc_tree->vertical[0];
         av1_update_state(cpi, td, ctx_v, mi_row, mi_col, subsize, 1);
@@ -3514,17 +3784,27 @@
         if ((mi_row + y_idx >= mi_params->mi_rows) ||
             (mi_col + x_idx >= mi_params->mi_cols))
           continue;
-        pc_tree->split[i] = av1_alloc_pc_tree_node(
-            xd->tree_type, mi_row + y_idx, mi_col + x_idx, subsize, pc_tree,
-            PARTITION_SPLIT, i, i == 3, ss_x, ss_y);
+#if CONFIG_EXTENDED_SDP
+        pc_tree->split[cur_region_type][i]
+#else
+        pc_tree->split[i]
+#endif  // CONFIG_EXTENDED_SDP
+            = av1_alloc_pc_tree_node(xd->tree_type, mi_row + y_idx,
+                                     mi_col + x_idx, subsize, pc_tree,
+                                     PARTITION_SPLIT, i, i == 3, ss_x, ss_y);
 
         av1_init_rd_stats(&tmp_rdc);
-        av1_rd_use_partition(
-            cpi, td, tile_data,
-            mib + jj * hbs * mi_params->mi_stride + ii * hbs, tp,
-            mi_row + y_idx, mi_col + x_idx, subsize, &tmp_rdc.rate,
-            &tmp_rdc.dist, i != (SUB_PARTITIONS_SPLIT - 1),
-            ptree ? ptree->sub_tree[i] : NULL, pc_tree->split[i]);
+        av1_rd_use_partition(cpi, td, tile_data,
+                             mib + jj * hbs * mi_params->mi_stride + ii * hbs,
+                             tp, mi_row + y_idx, mi_col + x_idx, subsize,
+                             &tmp_rdc.rate, &tmp_rdc.dist,
+                             i != (SUB_PARTITIONS_SPLIT - 1),
+                             ptree ? ptree->sub_tree[i] : NULL,
+#if CONFIG_EXTENDED_SDP
+                             pc_tree->split[cur_region_type][i]);
+#else
+                             pc_tree->split[i]);
+#endif  // CONFIG_EXTENDED_SDP
         if (tmp_rdc.rate == INT_MAX || tmp_rdc.dist == INT64_MAX) {
           av1_invalid_rd_stats(&last_part_rdc);
           break;
@@ -3686,6 +3966,9 @@
   av1_rd_stats_subtraction(x->rdmult, &best_rdcost, sum_rdc, &rdcost_remaining);
   RD_STATS this_rdc;
   pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &this_rdc, partition,
+#if CONFIG_EXTENDED_SDP
+                pc_tree->region_type,
+#endif  // CONFIG_EXTENDED_SDP
                 subsize, this_ctx, rdcost_remaining);
 
   if (this_rdc.rate == INT_MAX) {
@@ -3759,6 +4042,12 @@
   update_best_level_banks(level_banks, &x->e_mbd);
 #endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
   pc_tree->partitioning = partition;
+#if CONFIG_EXTENDED_SDP
+  if (!frame_is_intra_only(cm))
+    pc_tree->region_type = MIXED_INTER_INTRA_REGION;
+  else
+    pc_tree->region_type = INTRA_REGION;
+#endif  // CONFIG_EXTENDED_SDP
   return true;
 }
 #endif  // !CONFIG_EXT_RECUR_PARTITIONS
@@ -3771,6 +4060,9 @@
     BLOCK_SIZE parent_bsize,
 #endif  // CONFIG_CB1TO4_SPLIT
     const PARTITION_TREE *ptree_luma, const PARTITION_TREE *template_tree,
+#if CONFIG_EXTENDED_SDP
+    REGION_TYPE cur_region_type,
+#endif  // CONFIG_EXTENDED_SDP
     const CHROMA_REF_INFO *chroma_ref_info) {
   // Partition types forced by bitstream syntax.
   const MACROBLOCKD *xd = &x->e_mbd;
@@ -3796,6 +4088,9 @@
 #if CONFIG_CB1TO4_SPLIT
       && (parent_bsize == BLOCK_INVALID || parent_bsize <= BLOCK_LARGEST)
 #endif  // CONFIG_CB1TO4_SPLIT
+#if CONFIG_EXTENDED_SDP
+      && !is_inter_sdp_chroma(cm, cur_region_type, xd->tree_type)
+#endif  // CONFIG_EXTENDED_SDP
   ) {
     return av1_get_prev_partition(x, mi_row, mi_col, bsize, cm->sb_size);
   }
@@ -3984,6 +4279,7 @@
   blk_params->bsize = bsize;
 
 #if CONFIG_CB1TO4_SPLIT
+  assert(pc_tree != NULL);
   blk_params->parent_bsize =
       pc_tree->parent ? pc_tree->parent->block_size : BLOCK_INVALID;
 #endif  // CONFIG_CB1TO4_SPLIT
@@ -4046,6 +4342,13 @@
   }
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
 
+#if CONFIG_EXTENDED_SDP
+  if (xd->tree_type != CHROMA_PART) {
+    const int ctx = get_intra_region_context(bsize);
+    part_search_state->region_type_cost = mode_costs->region_type_cost[ctx];
+  }
+#endif  // CONFIG_EXTENDED_SDP
+
   // Initialize HORZ and VERT win flags as true for all split partitions.
   for (int i = 0; i < SUB_PARTITIONS_SPLIT; i++) {
     part_search_state->split_part_rect_win[i].rect_part_win[HORZ] = true;
@@ -4085,7 +4388,11 @@
 #if CONFIG_CB1TO4_SPLIT
       blk_params->parent_bsize,
 #endif  // CONFIG_CB1TO4_SPLIT
-      ptree_luma, template_tree, &pc_tree->chroma_ref_info);
+      ptree_luma, template_tree,
+#if CONFIG_EXTENDED_SDP
+      (pc_tree ? pc_tree->region_type : MIXED_INTER_INTRA_REGION),
+#endif  // CONFIG_EXTENDED_SDP
+      &pc_tree->chroma_ref_info);
 
   init_allowed_partitions(part_search_state, &cpi->oxcf.part_cfg,
                           &pc_tree->chroma_ref_info, tree_type);
@@ -4228,7 +4535,11 @@
 
   // Obtain the best mode for the partition sub-block.
   pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &part_search_state->this_rdc,
-                partition_type, bsize, cur_partition_ctx, best_remain_rdcost);
+                partition_type,
+#if CONFIG_EXTENDED_SDP
+                pc_tree->region_type,
+#endif  // CONFIG_EXTENDED_SDP
+                bsize, cur_partition_ctx, best_remain_rdcost);
   av1_rd_cost_update(x->rdmult, &part_search_state->this_rdc);
 
   // Update the partition rd cost with the current sub-block rd.
@@ -4254,6 +4565,9 @@
     BLOCK_SIZE bsize, const int is_not_edge_block[NUM_RECT_PARTS],
     SB_MULTI_PASS_MODE multi_pass_mode, const PARTITION_TREE *ptree_luma,
     const PARTITION_TREE *template_tree, bool *both_blocks_skippable,
+#if CONFIG_EXTENDED_SDP
+    PARTITION_TYPE parent_partition,
+#endif  // CONFIG_INTER_SDP
     int max_recursion_depth
 #if CONFIG_ML_PART_SPLIT
     ,
@@ -4264,18 +4578,35 @@
   RD_STATS *sum_rdc = &part_search_state->sum_rdc;
 
   sum_rdc->rate = part_search_state->partition_cost[partition_type];
+#if CONFIG_EXTENDED_SDP
+  if (pc_tree->region_type == MIXED_INTER_INTRA_REGION && pc_tree->parent &&
+      is_inter_sdp_allowed(pc_tree->parent->block_size, parent_partition) &&
+      is_bsize_allowed_for_inter_sdp(bsize, PARTITION_HORZ))
+    sum_rdc->rate +=
+        part_search_state->region_type_cost[MIXED_INTER_INTRA_REGION];
+#endif  // CONFIG_EXTENDED_SDP
   sum_rdc->rdcost = RDCOST(x->rdmult, sum_rdc->rate, 0);
 
   RD_STATS this_rdc;
   RD_STATS best_remain_rdcost;
+#if CONFIG_EXTENDED_SDP
+  PC_TREE **sub_tree = (rect_type == HORZ)
+                           ? pc_tree->horizontal[pc_tree->region_type]
+                           : pc_tree->vertical[pc_tree->region_type];
+#else
   PC_TREE **sub_tree =
       (rect_type == HORZ) ? pc_tree->horizontal : pc_tree->vertical;
+#endif  // CONFIG_EXTENDED_SDP
   *both_blocks_skippable = true;
   av1_rd_stats_subtraction(x->rdmult, best_rdc, sum_rdc, &best_remain_rdcost);
   bool partition_found = av1_rd_pick_partition(
       cpi, td, tile_data, tp, mi_pos_rect[rect_type][0][0],
-      mi_pos_rect[rect_type][0][1], bsize, &this_rdc, best_remain_rdcost,
-      sub_tree[0], get_partition_subtree_const(ptree_luma, 0),
+      mi_pos_rect[rect_type][0][1], bsize,
+#if CONFIG_EXTENDED_SDP
+      (rect_type == HORZ ? PARTITION_HORZ : PARTITION_VERT),
+#endif  // CONFIG_EXTENDED_SDP
+      &this_rdc, best_remain_rdcost, sub_tree[0],
+      get_partition_subtree_const(ptree_luma, 0),
       get_partition_subtree_const(template_tree, 0), max_recursion_depth, NULL,
       NULL, multi_pass_mode, NULL
 #if CONFIG_ML_PART_SPLIT
@@ -4299,8 +4630,12 @@
     av1_rd_stats_subtraction(x->rdmult, best_rdc, sum_rdc, &best_remain_rdcost);
     partition_found = av1_rd_pick_partition(
         cpi, td, tile_data, tp, mi_pos_rect[rect_type][1][0],
-        mi_pos_rect[rect_type][1][1], bsize, &this_rdc, best_remain_rdcost,
-        sub_tree[1], get_partition_subtree_const(ptree_luma, 1),
+        mi_pos_rect[rect_type][1][1], bsize,
+#if CONFIG_EXTENDED_SDP
+        (rect_type == HORZ ? PARTITION_HORZ : PARTITION_VERT),
+#endif  // CONFIG_EXTENDED_SDP
+        &this_rdc, best_remain_rdcost, sub_tree[1],
+        get_partition_subtree_const(ptree_luma, 1),
         get_partition_subtree_const(template_tree, 1), max_recursion_depth,
         NULL, NULL, multi_pass_mode, NULL
 #if CONFIG_ML_PART_SPLIT
@@ -4397,6 +4732,9 @@
 #if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
     LevelBanksRDO *level_banks,
 #endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+#if CONFIG_EXTENDED_SDP
+    PARTITION_TYPE parent_partition,
+#endif  // CONFIG_INTER_SDP
     int64_t part_none_rd
 #if CONFIG_ML_PART_SPLIT
     ,
@@ -4515,7 +4853,13 @@
       continue;
     }
 
+#if CONFIG_EXTENDED_SDP
+    const REGION_TYPE cur_region_type = pc_tree->region_type;
+    PC_TREE **sub_tree = (i == HORZ) ? pc_tree->horizontal[cur_region_type]
+                                     : pc_tree->vertical[cur_region_type];
+#else
     PC_TREE **sub_tree = (i == HORZ) ? pc_tree->horizontal : pc_tree->vertical;
+#endif  // CONFIG_EXTENDED_SDP
     assert(sub_tree);
 
     const int num_planes = av1_num_planes(cm);
@@ -4543,7 +4887,11 @@
         cpi, td, tile_data, tp, x, pc_tree, part_search_state, best_rdc, i,
         mi_pos_rect, blk_params.subsize, is_not_edge_block, multi_pass_mode,
         track_ptree_luma ? ptree_luma : NULL, template_tree,
-        &both_blocks_skippable, max_recursion_depth
+        &both_blocks_skippable,
+#if CONFIG_EXTENDED_SDP
+        parent_partition,
+#endif  // CONFIG_INTER_SDP
+        max_recursion_depth
 #if CONFIG_ML_PART_SPLIT
         ,
         next_force_prune_flags[i]
@@ -4965,6 +5313,12 @@
 #endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
     part_search_state->found_best_partition = true;
     pc_tree->partitioning = partition_type;
+#if CONFIG_EXTENDED_SDP
+    if (!frame_is_intra_only(cm))
+      pc_tree->region_type = MIXED_INTER_INTRA_REGION;
+    else
+      pc_tree->region_type = INTRA_REGION;
+#endif  // CONFIG_EXTENDED_SDP
   }
 #if CONFIG_COLLECT_PARTITION_STATS
   if (partition_timer_on) {
@@ -5078,6 +5432,9 @@
 #if CONFIG_EXT_RECUR_PARTITIONS
     TREE_TYPE tree_type,
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXTENDED_SDP
+    int sdp_inter_chroma_flag,
+#endif  // CONFIG_EXTENDED_SDP
     PartitionSearchState *part_search_state) {
   PartitionBlkParams blk_params = part_search_state->part_blk_params;
 #if CONFIG_EXT_RECUR_PARTITIONS
@@ -5086,6 +5443,12 @@
     return;
   }
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXTENDED_SDP
+  if (sdp_inter_chroma_flag) {
+    part_search_state->partition_none_allowed = 1;
+    return;
+  }
+#endif  // CONFIG_EXTENDED_SDP
 #if CONFIG_EXT_RECUR_PARTITIONS
   if (is_bsize_geq(blk_params.min_partition_size, blk_params.bsize) &&
       blk_params.has_rows && blk_params.has_cols)
@@ -5118,15 +5481,37 @@
   PartitionBlkParams blk_params = part_search_state->part_blk_params;
   RD_STATS partition_rdcost;
   // Set PARTITION_NONE context.
+#if CONFIG_EXTENDED_SDP
+  if (is_inter_sdp_chroma(cm, pc_tree->region_type, x->e_mbd.tree_type)) {
+    if (pc_tree->none_chroma == NULL) {
+      pc_tree->none_chroma = av1_alloc_pmc(
+          cm, x->e_mbd.tree_type, blk_params.mi_row, blk_params.mi_col,
+          blk_params.bsize, pc_tree, PARTITION_NONE, 0, part_search_state->ss_x,
+          part_search_state->ss_y, &td->shared_coeff_buf);
+    }
+  } else {
+    if (pc_tree->none[pc_tree->region_type] == NULL) {
+      pc_tree->none[pc_tree->region_type] = av1_alloc_pmc(
+          cm, x->e_mbd.tree_type, blk_params.mi_row, blk_params.mi_col,
+          blk_params.bsize, pc_tree, PARTITION_NONE, 0, part_search_state->ss_x,
+          part_search_state->ss_y, &td->shared_coeff_buf);
+    }
+  }
+#else
   if (pc_tree->none == NULL)
     pc_tree->none = av1_alloc_pmc(
         cm, x->e_mbd.tree_type, blk_params.mi_row, blk_params.mi_col,
         blk_params.bsize, pc_tree, PARTITION_NONE, 0, part_search_state->ss_x,
         part_search_state->ss_y, &td->shared_coeff_buf);
+#endif  // CONFIG_EXTENDED_SDP
 
   // Set PARTITION_NONE type cost.
   if (part_search_state->partition_none_allowed) {
-    if (part_search_state->is_block_splittable) {
+    if (part_search_state->is_block_splittable
+#if CONFIG_EXTENDED_SDP
+        && !is_inter_sdp_chroma(cm, pc_tree->region_type, x->e_mbd.tree_type)
+#endif  // CONFIG_EXTENDED_SDP
+    ) {
       *pt_cost = part_search_state->partition_cost[PARTITION_NONE] < INT_MAX
                      ? part_search_state->partition_cost[PARTITION_NONE]
                      : 0;
@@ -5290,6 +5675,50 @@
 }
 #endif
 
+#if CONFIG_EXTENDED_SDP
+static void inter_sdp_copy_luma_mode_info(PC_TREE *pc_tree,
+                                          PICK_MODE_CONTEXT *ctx_chroma_none,
+                                          MB_MODE_INFO *mbmi) {
+  PC_TREE *cur_pc_tree = pc_tree;
+  PARTITION_TYPE partition = cur_pc_tree->partitioning;
+  while (partition) {
+    switch (partition) {
+      case PARTITION_HORZ:
+        cur_pc_tree = cur_pc_tree->horizontal[INTRA_REGION][0];
+        break;
+      case PARTITION_VERT:
+        cur_pc_tree = cur_pc_tree->vertical[INTRA_REGION][0];
+        break;
+      case PARTITION_SPLIT:
+        cur_pc_tree = cur_pc_tree->split[INTRA_REGION][0];
+        break;
+      case PARTITION_HORZ_4A:
+        cur_pc_tree = cur_pc_tree->horizontal4a[INTRA_REGION][0];
+        break;
+      case PARTITION_HORZ_4B:
+        cur_pc_tree = cur_pc_tree->horizontal4b[INTRA_REGION][0];
+        break;
+      case PARTITION_VERT_4A:
+        cur_pc_tree = cur_pc_tree->vertical4a[INTRA_REGION][0];
+        break;
+      case PARTITION_VERT_4B:
+        cur_pc_tree = cur_pc_tree->vertical4b[INTRA_REGION][0];
+        break;
+      case PARTITION_VERT_3:
+        cur_pc_tree = cur_pc_tree->vertical3[INTRA_REGION][0];
+        break;
+      case PARTITION_HORZ_3:
+        cur_pc_tree = cur_pc_tree->horizontal3[INTRA_REGION][0];
+        break;
+      default: assert(0 && "Invalid partition type!"); break;
+    }
+    partition = cur_pc_tree->partitioning;
+  }
+  ctx_chroma_none->mic = cur_pc_tree->none[INTRA_REGION]->mic;
+  *mbmi = cur_pc_tree->none[INTRA_REGION]->mic;
+}
+#endif  // CONFIG_EXTENDED_SDP
+
 // PARTITION_NONE search.
 static void none_partition_search(
     AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data, MACROBLOCK *x,
@@ -5315,17 +5744,29 @@
     return;
   }
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
+
+#if CONFIG_EXTENDED_SDP
+  int sdp_inter_chroma_flag =
+      is_inter_sdp_chroma(cm, pc_tree->region_type, x->e_mbd.tree_type);
+#endif  // CONFIG_EXTENDED_SDP
   // Set PARTITION_NONE allowed flag.
   set_part_none_allowed_flag(cpi,
 #if CONFIG_EXT_RECUR_PARTITIONS
                              x->e_mbd.tree_type,
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXTENDED_SDP
+                             sdp_inter_chroma_flag,
+#endif  // CONFIG_EXTENDED_SDP
                              part_search_state);
   if (!part_search_state->partition_none_allowed) {
     return;
   }
 #if CONFIG_EXT_RECUR_PARTITIONS
-  if (part_search_state->prune_partition_none) {
+  if (part_search_state->prune_partition_none
+#if CONFIG_EXTENDED_SDP
+      && !sdp_inter_chroma_flag
+#endif  // CONFIG_EXTENDED_SDP
+  ) {
     return;
   }
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
@@ -5337,6 +5778,16 @@
   set_none_partition_params(cm, td, x, pc_tree, part_search_state,
                             &best_remain_rdcost, best_rdc, &pt_cost);
 
+#if CONFIG_EXTENDED_SDP
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+  PICK_MODE_CONTEXT *ctx_none = sdp_inter_chroma_flag
+                                    ? pc_tree->none_chroma
+                                    : pc_tree->none[pc_tree->region_type];
+  if (sdp_inter_chroma_flag) {
+    inter_sdp_copy_luma_mode_info(pc_tree, ctx_none, x->e_mbd.mi[0]);
+  }
+#endif  // CONFIG_EXTENDED_SDP
+
 #if CONFIG_COLLECT_PARTITION_STATS
   // Timer start for partition None.
   if (best_remain_rdcost >= 0) {
@@ -5353,11 +5804,30 @@
 
   // PARTITION_NONE evaluation and cost update.
   pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, this_rdc, PARTITION_NONE,
-                bsize, pc_tree->none, best_remain_rdcost);
+#if CONFIG_EXTENDED_SDP
+                pc_tree->region_type,
+#endif  // CONFIG_EXTENDED_SDP
+                bsize,
+#if CONFIG_EXTENDED_SDP
+                ctx_none,
+#else
+                pc_tree->none,
+#endif  // CONFIG_EXTENDED_SDP
+                best_remain_rdcost);
 #if CONFIG_EXT_RECUR_PARTITIONS
   x->inter_mode_cache = NULL;
-  if (this_rdc->rate != INT_MAX) {
-    av1_add_mode_search_context_to_cache(sms_data, pc_tree->none);
+  if (this_rdc->rate != INT_MAX
+#if CONFIG_EXTENDED_SDP
+      && !is_inter_sdp_chroma(cm, cur_region_type, x->e_mbd.tree_type)
+#endif  // CONFIG_EXTENDED_SDP
+  ) {
+    av1_add_mode_search_context_to_cache(sms_data,
+#if CONFIG_EXTENDED_SDP
+                                         pc_tree->none[pc_tree->region_type]
+#else
+                                         pc_tree->none
+#endif  // CONFIG_EXTENDED_SDP
+    );
   }
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   av1_rd_cost_update(x->rdmult, this_rdc);
@@ -5375,21 +5845,44 @@
   if (none_rd) *none_rd = this_rdc->rdcost;
   part_search_state->none_rd = this_rdc->rdcost;
 #if CONFIG_EXT_RECUR_PARTITIONS
-  pc_tree->none_rd = *this_rdc;
+#if CONFIG_EXTENDED_SDP
+  if (pc_tree->region_type == MIXED_INTER_INTRA_REGION ||
+      frame_is_intra_only(cm))
+#endif  // CONFIG_EXTENDED_SDP
+    pc_tree->none_rd = *this_rdc;
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
   if (this_rdc->rate != INT_MAX) {
 #if CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXTENDED_SDP
+    pc_tree->skippable = sdp_inter_chroma_flag
+                             ? pc_tree->none_chroma->skippable
+                             : pc_tree->none[pc_tree->region_type]->skippable;
+#else
     pc_tree->skippable = pc_tree->none->skippable;
+#endif  // CONFIG_EXTENDED_SDP
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
     // Record picked ref frame to prune ref frames for other partition types.
-    if (cpi->sf.inter_sf.prune_ref_frames) {
+    if (cpi->sf.inter_sf.prune_ref_frames
+#if CONFIG_EXTENDED_SDP
+        && x->e_mbd.tree_type != CHROMA_PART
+#endif  // CONFIG_EXTENDED_SDP
+    ) {
+#if CONFIG_EXTENDED_SDP
+      const int ref_type = av1_ref_frame_type(
+          pc_tree->none[pc_tree->region_type]->mic.ref_frame);
+#else
       const int ref_type = av1_ref_frame_type(pc_tree->none->mic.ref_frame);
+#endif  // CONFIG_EXTENDED_SDP
       av1_update_picked_ref_frames_mask(x, ref_type, bsize, cm->mib_size,
                                         mi_row, mi_col);
     }
 
     // Calculate the total cost and update the best partition.
-    if (part_search_state->is_block_splittable) {
+    if (part_search_state->is_block_splittable
+#if CONFIG_EXTENDED_SDP
+        && !sdp_inter_chroma_flag
+#endif  // CONFIG_EXTENDED_SDP
+    ) {
       this_rdc->rate += pt_cost;
       this_rdc->rdcost = RDCOST(x->rdmult, this_rdc->rate, this_rdc->dist);
     }
@@ -5405,14 +5898,26 @@
         pc_tree->partitioning = PARTITION_NONE;
       }
 #else
-      pc_tree->partitioning = PARTITION_NONE;
+#if CONFIG_EXTENDED_SDP
+      if (!sdp_inter_chroma_flag)
+#endif  // CONFIG_EXTENDED_SDP
+        pc_tree->partitioning = PARTITION_NONE;
 #endif  // !CONFIG_EXT_RECUR_PARTITIONS
 
       // Disable split and rectangular partition search
       // based on PARTITION_NONE cost.
-      prune_partitions_after_none(cpi, x, sms_tree, pc_tree->none,
-                                  part_search_state, best_rdc,
-                                  pb_source_variance);
+#if CONFIG_EXTENDED_SDP
+      if (frame_is_intra_only(cm) || cur_region_type != INTRA_REGION ||
+          x->e_mbd.tree_type != CHROMA_PART)
+#endif  // CONFIG_EXTENDED_SDP
+        prune_partitions_after_none(cpi, x, sms_tree,
+#if CONFIG_EXTENDED_SDP
+                                    pc_tree->none[pc_tree->region_type],
+#else
+                                  pc_tree->none,
+#endif  // CONFIG_EXTENDED_SDP
+                                    part_search_state, best_rdc,
+                                    pb_source_variance);
     }
   }
   av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm));
@@ -5469,7 +5974,11 @@
   }
 
   const int num_planes = av1_num_planes(cm);
+#if CONFIG_EXTENDED_SDP
+  PC_TREE **sub_tree = pc_tree->split[pc_tree->region_type];
+#else
   PC_TREE **sub_tree = pc_tree->split;
+#endif  // CONFIG_EXTENDED_SDP
   assert(sub_tree);
   for (int idx = 0; idx < SUB_PARTITIONS_SPLIT; idx++) {
     if (sub_tree[idx]) {
@@ -5509,9 +6018,16 @@
     if (mi_row + y_idx >= mi_params->mi_rows ||
         mi_col + x_idx >= mi_params->mi_cols)
       continue;
-
+#if CONFIG_EXTENDED_SDP
+    if (pc_tree->split[pc_tree->region_type][idx] == NULL) {
+#else
     if (pc_tree->split[idx] == NULL) {
+#endif  // CONFIG_EXTENDED_SDP
+#if CONFIG_EXTENDED_SDP
+      pc_tree->split[pc_tree->region_type][idx] = av1_alloc_pc_tree_node(
+#else
       pc_tree->split[idx] = av1_alloc_pc_tree_node(
+#endif
           x->e_mbd.tree_type, mi_row + y_idx, mi_col + x_idx, subsize, pc_tree,
           PARTITION_SPLIT, idx, idx == 3, part_search_state->ss_x,
           part_search_state->ss_y);
@@ -5538,6 +6054,9 @@
 #endif  // CONFIG_ML_PART_SPLIT
     if (!av1_rd_pick_partition(
             cpi, td, tile_data, tp, mi_row + y_idx, mi_col + x_idx, subsize,
+#if CONFIG_EXTENDED_SDP
+            PARTITION_SPLIT,
+#endif  // CONFIG_EXTENDED_SDP
             &part_search_state->this_rdc, best_remain_rdcost, sub_tree[idx],
             track_ptree_luma ? ptree_luma->sub_tree[idx] : NULL,
             get_partition_subtree_const(template_tree, idx),
@@ -5569,8 +6088,21 @@
 
     // Set split ctx as ready for use.
     if (idx <= 1 && (bsize <= BLOCK_8X8 ||
-                     pc_tree->split[idx]->partitioning == PARTITION_NONE)) {
+#if CONFIG_EXTENDED_SDP
+                     pc_tree->split[pc_tree->region_type][idx]->partitioning ==
+                         PARTITION_NONE
+#else
+                     pc_tree->split[idx]->partitioning == PARTITION_NONE
+#endif  // CONFIG_EXTENDED_SDP
+                     )) {
+#if CONFIG_EXTENDED_SDP
+      const MB_MODE_INFO *const mbmi =
+          &pc_tree->split[pc_tree->region_type][idx]
+               ->none[pc_tree->region_type]
+               ->mic;
+#else
       const MB_MODE_INFO *const mbmi = &pc_tree->split[idx]->none->mic;
+#endif  // CONFIG_EXTENDED_SDP
       const PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
       // Neither palette mode nor cfl predicted.
       if (pmi->palette_size[0] == 0 && pmi->palette_size[1] == 0) {
@@ -5687,6 +6219,9 @@
   int force_prune_flags[3] = { 0, 0, 0 };
 #endif  // CONFIG_ML_PART_SPLIT
   if (!av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, bsize,
+#if CONFIG_EXTENDED_SDP
+                             rdo_data->partition,
+#endif  // CONFIG_EXTENDED_SDP
                              &this_rdc, rdcost_remaining, rdo_data->pc_tree,
                              rdo_data->ptree_luma, rdo_data->template_tree,
                              max_recursion_depth, NULL, NULL, multi_pass_mode,
@@ -5739,6 +6274,9 @@
   const int ebs_w = mi_size_wide[bsize] / 8;
   const int ebs_h = mi_size_high[bsize] / 8;
   const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
+#if CONFIG_EXTENDED_SDP
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+#endif  // CONFIG_EXTENDED_SDP
   switch (partition) {
     case PARTITION_NONE:
       for (int col = 0; col < mi_width; col++) {
@@ -5751,52 +6289,113 @@
       }
       break;
     case PARTITION_HORZ:
-      trace_partition_boundary(partition_boundaries, pc_tree->horizontal[0],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->horizontal[cur_region_type][0],
+#else
+                               pc_tree->horizontal[0],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col,
                                get_partition_subsize(bsize, PARTITION_HORZ));
-      trace_partition_boundary(partition_boundaries, pc_tree->horizontal[1],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->horizontal[cur_region_type][1],
+#else
+                               pc_tree->horizontal[1],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row + mi_height / 2, mi_col,
                                get_partition_subsize(bsize, PARTITION_HORZ));
       break;
     case PARTITION_VERT:
-      trace_partition_boundary(partition_boundaries, pc_tree->vertical[0],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->vertical[cur_region_type][0],
+#else
+                               pc_tree->vertical[0],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col,
                                get_partition_subsize(bsize, PARTITION_VERT));
-      trace_partition_boundary(partition_boundaries, pc_tree->vertical[1],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->vertical[cur_region_type][1],
+#else
+                               pc_tree->vertical[1],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col + mi_width / 2,
                                get_partition_subsize(bsize, PARTITION_VERT));
       break;
     case PARTITION_HORZ_3:
       trace_partition_boundary(
-          partition_boundaries, pc_tree->horizontal3[0], mi_row, mi_col,
-          get_h_partition_subsize(bsize, 0, PARTITION_HORZ_3));
+          partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->horizontal3[cur_region_type][0],
+#else
+          pc_tree->horizontal3[0],
+#endif  // CONFIG_EXTENDED_SDP
+          mi_row, mi_col, get_h_partition_subsize(bsize, 0, PARTITION_HORZ_3));
       trace_partition_boundary(
-          partition_boundaries, pc_tree->horizontal3[1], mi_row + mi_height / 4,
-          mi_col, get_h_partition_subsize(bsize, 1, PARTITION_HORZ_3));
-      trace_partition_boundary(
-          partition_boundaries, pc_tree->horizontal3[2], mi_row + mi_height / 4,
-          mi_col + mi_width / 2,
+          partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->horizontal3[cur_region_type][1],
+#else
+          pc_tree->horizontal3[1],
+#endif  // CONFIG_EXTENDED_SDP
+          mi_row + mi_height / 4, mi_col,
           get_h_partition_subsize(bsize, 1, PARTITION_HORZ_3));
       trace_partition_boundary(
-          partition_boundaries, pc_tree->horizontal3[3],
+          partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->horizontal3[cur_region_type][2],
+#else
+          pc_tree->horizontal3[2],
+#endif  // CONFIG_EXTENDED_SDP
+          mi_row + mi_height / 4, mi_col + mi_width / 2,
+          get_h_partition_subsize(bsize, 1, PARTITION_HORZ_3));
+      trace_partition_boundary(
+          partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->horizontal3[cur_region_type][3],
+#else
+          pc_tree->horizontal3[3],
+#endif  // CONFIG_EXTENDED_SDP
           mi_row + 3 * mi_height / 4, mi_col,
           get_h_partition_subsize(bsize, 0, PARTITION_HORZ_3));
       break;
     case PARTITION_VERT_3:
       trace_partition_boundary(
-          partition_boundaries, pc_tree->vertical3[0], mi_row, mi_col,
-          get_h_partition_subsize(bsize, 0, PARTITION_VERT_3));
+          partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->vertical3[cur_region_type][0],
+#else
+          pc_tree->vertical3[0],
+#endif  // CONFIG_EXTENDED_SDP
+          mi_row, mi_col, get_h_partition_subsize(bsize, 0, PARTITION_VERT_3));
       trace_partition_boundary(
-          partition_boundaries, pc_tree->vertical3[1], mi_row,
-          mi_col + mi_width / 4,
+          partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->vertical3[cur_region_type][1],
+#else
+          pc_tree->vertical3[1],
+#endif  // CONFIG_EXTENDED_SDP
+          mi_row, mi_col + mi_width / 4,
           get_h_partition_subsize(bsize, 1, PARTITION_VERT_3));
       trace_partition_boundary(
-          partition_boundaries, pc_tree->vertical3[2], mi_row + mi_height / 2,
-          mi_col + mi_width / 4,
+          partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->vertical3[cur_region_type][2],
+#else
+          pc_tree->vertical3[2],
+#endif  // CONFIG_EXTENDED_SDP
+          mi_row + mi_height / 2, mi_col + mi_width / 4,
           get_h_partition_subsize(bsize, 1, PARTITION_VERT_3));
       trace_partition_boundary(
-          partition_boundaries, pc_tree->vertical3[3], mi_row,
-          mi_col + 3 * mi_width / 4,
+          partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+          pc_tree->vertical3[cur_region_type][3],
+#else
+          pc_tree->vertical3[3],
+#endif  // CONFIG_EXTENDED_SDP
+          mi_row, mi_col + 3 * mi_width / 4,
           get_h_partition_subsize(bsize, 0, PARTITION_VERT_3));
       break;
     case PARTITION_HORZ_4A: {
@@ -5804,13 +6403,33 @@
       assert(bsize_big < BLOCK_SIZES_ALL);
       const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_HORZ][bsize_big];
       assert(subsize == subsize_lookup[PARTITION_HORZ][bsize_med]);
-      trace_partition_boundary(partition_boundaries, pc_tree->horizontal4a[0],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->horizontal4a[cur_region_type][0],
+#else
+                               pc_tree->horizontal4a[0],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col, subsize);
-      trace_partition_boundary(partition_boundaries, pc_tree->horizontal4a[1],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->horizontal4a[cur_region_type][1],
+#else
+                               pc_tree->horizontal4a[1],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row + ebs_h, mi_col, bsize_med);
-      trace_partition_boundary(partition_boundaries, pc_tree->horizontal4a[2],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->horizontal4a[cur_region_type][2],
+#else
+                               pc_tree->horizontal4a[2],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row + 3 * ebs_h, mi_col, bsize_big);
-      trace_partition_boundary(partition_boundaries, pc_tree->horizontal4a[3],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->horizontal4a[cur_region_type][3],
+#else
+                               pc_tree->horizontal4a[3],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row + 7 * ebs_h, mi_col, subsize);
       break;
     }
@@ -5819,13 +6438,33 @@
       assert(bsize_big < BLOCK_SIZES_ALL);
       const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_HORZ][bsize_big];
       assert(subsize == subsize_lookup[PARTITION_HORZ][bsize_med]);
-      trace_partition_boundary(partition_boundaries, pc_tree->horizontal4b[0],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->horizontal4b[cur_region_type][0],
+#else
+                               pc_tree->horizontal4b[0],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col, subsize);
-      trace_partition_boundary(partition_boundaries, pc_tree->horizontal4b[1],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->horizontal4b[cur_region_type][1],
+#else
+                               pc_tree->horizontal4b[1],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row + ebs_h, mi_col, bsize_big);
-      trace_partition_boundary(partition_boundaries, pc_tree->horizontal4b[2],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->horizontal4b[cur_region_type][2],
+#else
+                               pc_tree->horizontal4b[2],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row + 5 * ebs_h, mi_col, bsize_med);
-      trace_partition_boundary(partition_boundaries, pc_tree->horizontal4b[3],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->horizontal4b[cur_region_type][3],
+#else
+                               pc_tree->horizontal4b[3],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row + 7 * ebs_h, mi_col, subsize);
       break;
     }
@@ -5834,13 +6473,33 @@
       assert(bsize_big < BLOCK_SIZES_ALL);
       const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_VERT][bsize_big];
       assert(subsize == subsize_lookup[PARTITION_VERT][bsize_med]);
-      trace_partition_boundary(partition_boundaries, pc_tree->vertical4a[0],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->vertical4a[cur_region_type][0],
+#else
+                               pc_tree->vertical4a[0],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col, subsize);
-      trace_partition_boundary(partition_boundaries, pc_tree->vertical4a[1],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->vertical4a[cur_region_type][1],
+#else
+                               pc_tree->vertical4a[1],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col + ebs_w, bsize_med);
-      trace_partition_boundary(partition_boundaries, pc_tree->vertical4a[2],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->vertical4a[cur_region_type][2],
+#else
+                               pc_tree->vertical4a[2],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col + 3 * ebs_w, bsize_big);
-      trace_partition_boundary(partition_boundaries, pc_tree->vertical4a[3],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->vertical4a[cur_region_type][3],
+#else
+                               pc_tree->vertical4a[3],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col + 7 * ebs_w, subsize);
       break;
     }
@@ -5849,13 +6508,33 @@
       assert(bsize_big < BLOCK_SIZES_ALL);
       const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_VERT][bsize_big];
       assert(subsize == subsize_lookup[PARTITION_VERT][bsize_med]);
-      trace_partition_boundary(partition_boundaries, pc_tree->vertical4b[0],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->vertical4b[cur_region_type][0],
+#else
+                               pc_tree->vertical4b[0],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col, subsize);
-      trace_partition_boundary(partition_boundaries, pc_tree->vertical4b[1],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->vertical4b[cur_region_type][1],
+#else
+                               pc_tree->vertical4b[1],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col + ebs_w, bsize_big);
-      trace_partition_boundary(partition_boundaries, pc_tree->vertical4b[2],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->vertical4b[cur_region_type][2],
+#else
+                               pc_tree->vertical4b[2],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col + 5 * ebs_w, bsize_med);
-      trace_partition_boundary(partition_boundaries, pc_tree->vertical4b[3],
+      trace_partition_boundary(partition_boundaries,
+#if CONFIG_EXTENDED_SDP
+                               pc_tree->vertical4b[cur_region_type][3],
+#else
+                               pc_tree->vertical4b[3],
+#endif  // CONFIG_EXTENDED_SDP
                                mi_row, mi_col + 7 * ebs_w, subsize);
       break;
     }
@@ -6058,6 +6737,10 @@
     return;
   }
 
+#if CONFIG_EXTENDED_SDP
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+#endif  // CONFIG_EXTENDED_SDP
+
   // Prune horz 3 with speed features
   if (part_search_state->partition_3_allowed[HORZ] &&
       !frame_is_intra_only(cm) && forced_partition != PARTITION_HORZ_3) {
@@ -6070,13 +6753,29 @@
       // Prune if the best partition is rect but the subtrees did not further
       // split in horz
       if (pc_tree->partitioning == PARTITION_HORZ &&
+#if CONFIG_EXTENDED_SDP
+          pc_tree->horizontal[cur_region_type][0] &&
+          pc_tree->horizontal[cur_region_type][1] &&
+          !node_uses_horz(pc_tree->horizontal[cur_region_type][0]) &&
+          !node_uses_horz(pc_tree->horizontal[cur_region_type][1])
+#else
           !node_uses_horz(pc_tree->horizontal[0]) &&
-          !node_uses_horz(pc_tree->horizontal[1])) {
+          !node_uses_horz(pc_tree->horizontal[1])
+#endif  // CONFIG_EXTENDED_SDP
+      ) {
         part_search_state->prune_partition_3[HORZ] = 1;
       }
       if (pc_tree->partitioning == PARTITION_VERT &&
+#if CONFIG_EXTENDED_SDP
+          pc_tree->vertical[cur_region_type][0] &&
+          pc_tree->vertical[cur_region_type][1] &&
+          !node_uses_horz(pc_tree->vertical[cur_region_type][0]) &&
+          !node_uses_horz(pc_tree->vertical[cur_region_type][1])
+#else
           !node_uses_horz(pc_tree->vertical[0]) &&
-          !node_uses_horz(pc_tree->vertical[1])) {
+          !node_uses_horz(pc_tree->vertical[1])
+#endif  // CONFIG_EXTENDED_SDP
+      ) {
         part_search_state->prune_partition_3[HORZ] = 1;
       }
     }
@@ -6093,13 +6792,29 @@
       // Prune if the best partition is rect but the subtrees did not further
       // split in vert
       if (pc_tree->partitioning == PARTITION_VERT &&
+#if CONFIG_EXTENDED_SDP
+          pc_tree->vertical[cur_region_type][0] &&
+          pc_tree->vertical[cur_region_type][1] &&
+          !node_uses_vert(pc_tree->vertical[cur_region_type][0]) &&
+          !node_uses_vert(pc_tree->vertical[cur_region_type][1])
+#else
           !node_uses_vert(pc_tree->vertical[0]) &&
-          !node_uses_vert(pc_tree->vertical[1])) {
+          !node_uses_vert(pc_tree->vertical[1])
+#endif  // CONFIG_EXTENDED_SDP
+      ) {
         part_search_state->prune_partition_3[VERT] = 1;
       }
       if (pc_tree->partitioning == PARTITION_HORZ &&
+#if CONFIG_EXTENDED_SDP
+          pc_tree->horizontal[cur_region_type][0] &&
+          pc_tree->horizontal[cur_region_type][1] &&
+          !node_uses_vert(pc_tree->horizontal[cur_region_type][0]) &&
+          !node_uses_vert(pc_tree->horizontal[cur_region_type][1])
+#else
           !node_uses_vert(pc_tree->horizontal[0]) &&
-          !node_uses_vert(pc_tree->horizontal[1])) {
+          !node_uses_vert(pc_tree->horizontal[1])
+#endif  // CONFIG_EXTENDED_SDP
+      ) {
         part_search_state->prune_partition_3[VERT] = 1;
       }
     }
@@ -6126,6 +6841,205 @@
   }
 }
 
+#if CONFIG_EXTENDED_SDP
+// Early termination of SDP for intra blocks in inter frames
+static INLINE void early_termination_inter_sdp(PC_TREE *pc_tree,
+                                               float *total_count,
+                                               float *inter_mode_count) {
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+  if (pc_tree->partitioning == PARTITION_NONE) {
+    if (pc_tree->none[cur_region_type] == NULL) return;
+    const MB_MODE_INFO *const mi = &(pc_tree->none[cur_region_type])->mic;
+    if (mi == NULL) return;
+    *total_count += 1;
+    if (mi->mode >= NEARMV && mi->mode < MB_MODE_COUNT) *inter_mode_count += 1;
+    return;
+  }
+  switch (pc_tree->partitioning) {
+    case PARTITION_HORZ:
+      early_termination_inter_sdp(pc_tree->horizontal[cur_region_type][0],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->horizontal[cur_region_type][1],
+                                  total_count, inter_mode_count);
+      break;
+    case PARTITION_VERT:
+      early_termination_inter_sdp(pc_tree->vertical[cur_region_type][0],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->vertical[cur_region_type][1],
+                                  total_count, inter_mode_count);
+      break;
+    case PARTITION_HORZ_4A:
+      early_termination_inter_sdp(pc_tree->horizontal4a[cur_region_type][0],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->horizontal4a[cur_region_type][1],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->horizontal4a[cur_region_type][2],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->horizontal4a[cur_region_type][3],
+                                  total_count, inter_mode_count);
+      break;
+    case PARTITION_HORZ_4B:
+      early_termination_inter_sdp(pc_tree->horizontal4b[cur_region_type][0],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->horizontal4b[cur_region_type][1],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->horizontal4b[cur_region_type][2],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->horizontal4b[cur_region_type][3],
+                                  total_count, inter_mode_count);
+      break;
+    case PARTITION_VERT_4A:
+      early_termination_inter_sdp(pc_tree->vertical4a[cur_region_type][0],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->vertical4a[cur_region_type][1],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->vertical4a[cur_region_type][2],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->vertical4a[cur_region_type][3],
+                                  total_count, inter_mode_count);
+      break;
+    case PARTITION_VERT_4B:
+      early_termination_inter_sdp(pc_tree->vertical4b[cur_region_type][0],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->vertical4b[cur_region_type][1],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->vertical4b[cur_region_type][2],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->vertical4b[cur_region_type][3],
+                                  total_count, inter_mode_count);
+      break;
+    case PARTITION_HORZ_3:
+      early_termination_inter_sdp(pc_tree->horizontal3[cur_region_type][0],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->horizontal3[cur_region_type][1],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->horizontal3[cur_region_type][2],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->horizontal3[cur_region_type][3],
+                                  total_count, inter_mode_count);
+      break;
+    case PARTITION_VERT_3:
+      early_termination_inter_sdp(pc_tree->vertical3[cur_region_type][0],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->vertical3[cur_region_type][1],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->vertical3[cur_region_type][2],
+                                  total_count, inter_mode_count);
+      early_termination_inter_sdp(pc_tree->vertical3[cur_region_type][3],
+                                  total_count, inter_mode_count);
+      break;
+    default: break;
+  }
+}
+
+// Search SDP for intra blocks in inter frames
+static INLINE void search_intra_region_partitioning(
+    PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
+    TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
+    PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
+    const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
+    PartitionSearchState *part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+    LevelBanksRDO *level_banks,
+#endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+    SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth,
+    PARTITION_TYPE parent_partition) {
+  const AV1_COMMON *const cm = &cpi->common;
+  MACROBLOCK *const x = &td->mb;
+  const int num_planes = av1_num_planes(cm);
+  MACROBLOCKD *const xd = &x->e_mbd;
+
+  // Add one encoder fast method for early terminating inter-sdp
+  float total_count = 0;
+  float inter_mode_count = 0;
+  early_termination_inter_sdp(pc_tree, &total_count, &inter_mode_count);
+  // if over 60% of the coded blocks under this region are inter coded blocks,
+  // skip the rdo for inter-sdp
+  if (total_count * 0.7 < inter_mode_count) return;
+
+  pc_tree->region_type = INTRA_REGION;
+  // store the current best partitioning
+  PARTITION_TYPE cur_best_partitioning = pc_tree->partitioning;
+  pc_tree->partitioning = PARTITION_NONE;
+
+  RD_STATS *sum_rdc = &part_search_state->sum_rdc;
+  av1_init_rd_stats(sum_rdc);
+
+  sum_rdc->rate = part_search_state->region_type_cost[pc_tree->region_type];
+  sum_rdc->rdcost = RDCOST(x->rdmult, sum_rdc->rate, 0);
+
+  RD_STATS best_remain_rdcost;
+
+  av1_rd_stats_subtraction(x->rdmult, best_rdc, sum_rdc, &best_remain_rdcost);
+
+  const PartitionBlkParams *blk_params = &search_state->part_blk_params;
+  const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
+  const BLOCK_SIZE bsize = blk_params->bsize;
+
+  RD_STATS this_rdc;
+  av1_init_rd_stats(&this_rdc);
+
+  // Encoder RDO for luma component in intra region
+  xd->tree_type = LUMA_PART;
+  if (!av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, bsize,
+#if CONFIG_EXTENDED_SDP
+                             parent_partition,
+#endif  // CONFIG_EXTENDED_SDP
+                             &this_rdc, best_remain_rdcost, pc_tree, ptree_luma,
+                             template_tree, max_recursion_depth, NULL, NULL,
+                             multi_pass_mode, NULL)) {
+    av1_invalid_rd_stats(&this_rdc);
+    av1_invalid_rd_stats(sum_rdc);
+  }
+  // Encoder RDO for chroma component in intra region
+  if (this_rdc.rdcost != INT64_MAX && !cm->seq_params.monochrome) {
+    sum_rdc->rate += this_rdc.rate;
+    sum_rdc->dist += this_rdc.dist;
+    av1_rd_cost_update(x->rdmult, sum_rdc);
+    xd->tree_type = CHROMA_PART;
+    av1_rd_stats_subtraction(x->rdmult, best_rdc, sum_rdc, &best_remain_rdcost);
+    av1_init_rd_stats(&this_rdc);
+    if (!av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, bsize,
+#if CONFIG_EXTENDED_SDP
+                               parent_partition,
+#endif  // CONFIG_EXTENDED_SDP
+                               &this_rdc, best_remain_rdcost, pc_tree,
+                               ptree_luma, template_tree, max_recursion_depth,
+                               NULL, NULL, multi_pass_mode, NULL)) {
+      av1_invalid_rd_stats(&this_rdc);
+      av1_invalid_rd_stats(sum_rdc);
+    }
+    if (this_rdc.rdcost != INT64_MAX) {
+      sum_rdc->rate += this_rdc.rate;
+      sum_rdc->dist += this_rdc.dist;
+      av1_rd_cost_update(x->rdmult, sum_rdc);
+    }
+  }
+  // reset tree_type to shared_part
+  xd->tree_type = SHARED_PART;
+  // compare current rd cost with best rd cost
+  if (sum_rdc->rdcost < best_rdc->rdcost) {
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+    update_best_level_banks(level_banks, &x->e_mbd);
+#endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+    *best_rdc = *sum_rdc;
+    search_state->found_best_partition = true;
+#if CONFIG_EXTENDED_SDP
+    pc_tree->region_type = INTRA_REGION;
+#endif  // CONFIG_EXTENDED_SDP
+  } else {
+    // set back to the previous stored region_type and partitioning type
+    pc_tree->region_type = MIXED_INTER_INTRA_REGION;
+    pc_tree->partitioning = cur_best_partitioning;
+  }
+
+  av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+  restore_level_banks(&x->e_mbd, level_banks);
+#endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+}
+#endif  // CONFIG_EXTENDED_SDP
+
 // Pruning logic for PARTITION_HORZ_4A/B and PARTITION_VERT_4A/B.
 static AOM_INLINE void prune_ext_partitions_4way(
     AV1_COMP *const cpi, PC_TREE *pc_tree,
@@ -6134,6 +7048,10 @@
   const PARTITION_SPEED_FEATURES *part_sf = &cpi->sf.part_sf;
   const PARTITION_TYPE forced_partition = part_search_state->forced_partition;
 
+#if CONFIG_EXTENDED_SDP
+  const int cur_region_type = pc_tree->region_type;
+#endif  // CONFIG_EXTENDED_SDP
+
   // Prune HORZ 4A with speed features
   if (part_search_state->partition_4a_allowed[HORZ] &&
       forced_partition != PARTITION_HORZ_4A) {
@@ -6147,27 +7065,47 @@
       // Prune if the best partition is rect but subtrees did not further split
       // in horz
       if (pc_tree->partitioning == PARTITION_HORZ &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_horz(pc_tree->horizontal[cur_region_type][0]) &&
+          !node_uses_horz(pc_tree->horizontal[cur_region_type][1])) {
+#else
           !node_uses_horz(pc_tree->horizontal[0]) &&
           !node_uses_horz(pc_tree->horizontal[1])) {
+#endif  // CONFIG_EXTENDED_SDP
         part_search_state->prune_partition_4a[HORZ] = 1;
       }
       if (pc_tree->partitioning == PARTITION_VERT &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_horz(pc_tree->vertical[cur_region_type][0]) &&
+          !node_uses_horz(pc_tree->vertical[cur_region_type][1])) {
+#else
           !node_uses_horz(pc_tree->vertical[0]) &&
           !node_uses_horz(pc_tree->vertical[1])) {
+#endif  // CONFIG_EXTENDED_SDP
         part_search_state->prune_partition_4a[HORZ] = 1;
       }
     }
     if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm)) {
       if (pc_tree->partitioning == PARTITION_HORZ_3 &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_horz(pc_tree->horizontal3[cur_region_type][0]) &&
+          !node_uses_horz(pc_tree->horizontal3[cur_region_type][3])) {
+#else
           !node_uses_horz(pc_tree->horizontal3[0]) &&
           !node_uses_horz(pc_tree->horizontal3[3])) {
+#endif  // CONFIG_EXTENDED_SDP
         // Prune if best partition is horizontal H, but first and last
         // subpartitions did not further split in horizontal direction.
         part_search_state->prune_partition_4a[HORZ] = 1;
       }
       if (pc_tree->partitioning == PARTITION_VERT_3 &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_horz(pc_tree->vertical3[cur_region_type][1]) &&
+          !node_uses_horz(pc_tree->vertical3[cur_region_type][2])) {
+#else
           !node_uses_horz(pc_tree->vertical3[1]) &&
           !node_uses_horz(pc_tree->vertical3[2])) {
+#endif  // CONFIG_EXTENDED_SDP
         // Prune if best partition is vertical H, but middle two
         // subpartitions did not further split in horizontal direction.
         part_search_state->prune_partition_4a[HORZ] = 1;
@@ -6211,27 +7149,47 @@
       // Prune if the best partition is rect but subtrees did not further split
       // in horz
       if (pc_tree->partitioning == PARTITION_HORZ &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_horz(pc_tree->horizontal[cur_region_type][0]) &&
+          !node_uses_horz(pc_tree->horizontal[cur_region_type][1])) {
+#else
           !node_uses_horz(pc_tree->horizontal[0]) &&
           !node_uses_horz(pc_tree->horizontal[1])) {
+#endif  // CONFIG_EXTENDED_SDP
         part_search_state->prune_partition_4b[HORZ] = 1;
       }
       if (pc_tree->partitioning == PARTITION_VERT &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_horz(pc_tree->vertical[cur_region_type][0]) &&
+          !node_uses_horz(pc_tree->vertical[cur_region_type][1])) {
+#else
           !node_uses_horz(pc_tree->vertical[0]) &&
           !node_uses_horz(pc_tree->vertical[1])) {
+#endif  // CONFIG_EXTENDED_SDP
         part_search_state->prune_partition_4b[HORZ] = 1;
       }
     }
     if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm)) {
       if (pc_tree->partitioning == PARTITION_HORZ_3 &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_horz(pc_tree->horizontal3[cur_region_type][0]) &&
+          !node_uses_horz(pc_tree->horizontal3[cur_region_type][3])) {
+#else
           !node_uses_horz(pc_tree->horizontal3[0]) &&
           !node_uses_horz(pc_tree->horizontal3[3])) {
+#endif  // CONFIG_EXTENDED_SDP
         // Prune if best partition is horizontal H, but first and last
         // subpartitions did not further split in horizontal direction.
         part_search_state->prune_partition_4b[HORZ] = 1;
       }
       if (pc_tree->partitioning == PARTITION_VERT_3 &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_horz(pc_tree->vertical3[cur_region_type][1]) &&
+          !node_uses_horz(pc_tree->vertical3[cur_region_type][2])) {
+#else
           !node_uses_horz(pc_tree->vertical3[1]) &&
           !node_uses_horz(pc_tree->vertical3[2])) {
+#endif  // CONFIG_EXTENDED_SDP
         // Prune if best partition is vertical H, but middle two
         // subpartitions did not further split in horizontal direction.
         part_search_state->prune_partition_4b[HORZ] = 1;
@@ -6275,27 +7233,47 @@
       // Prune if the best partition is rect but subtrees did not further split
       // in vert
       if (pc_tree->partitioning == PARTITION_VERT &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_vert(pc_tree->vertical[cur_region_type][0]) &&
+          !node_uses_vert(pc_tree->vertical[cur_region_type][1])) {
+#else
           !node_uses_vert(pc_tree->vertical[0]) &&
           !node_uses_vert(pc_tree->vertical[1])) {
+#endif  // CONFIG_EXTENDED_SDP
         part_search_state->prune_partition_4a[VERT] = 1;
       }
       if (pc_tree->partitioning == PARTITION_HORZ &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_vert(pc_tree->horizontal[cur_region_type][0]) &&
+          !node_uses_vert(pc_tree->horizontal[cur_region_type][1])) {
+#else
           !node_uses_vert(pc_tree->horizontal[0]) &&
           !node_uses_vert(pc_tree->horizontal[1])) {
+#endif  // CONFIG_EXTENDED_SDP
         part_search_state->prune_partition_4a[VERT] = 1;
       }
     }
     if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm)) {
       if (pc_tree->partitioning == PARTITION_VERT_3 &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_vert(pc_tree->vertical3[cur_region_type][0]) &&
+          !node_uses_vert(pc_tree->vertical3[cur_region_type][3])) {
+#else
           !node_uses_vert(pc_tree->vertical3[0]) &&
           !node_uses_vert(pc_tree->vertical3[3])) {
+#endif  // CONFIG_EXTENDED_SDP
         // Prune if best partition is vertical H, but first and last
         // subpartitions did not further split in vertical direction.
         part_search_state->prune_partition_4a[VERT] = 1;
       }
       if (pc_tree->partitioning == PARTITION_HORZ_3 &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_vert(pc_tree->horizontal3[cur_region_type][1]) &&
+          !node_uses_vert(pc_tree->horizontal3[cur_region_type][2])) {
+#else
           !node_uses_vert(pc_tree->horizontal3[1]) &&
           !node_uses_vert(pc_tree->horizontal3[2])) {
+#endif  // CONFIG_EXTENDED_SDP
         // Prune if best partition is horizontal H, but middle two
         // subpartitions did not further split in vertical direction.
         part_search_state->prune_partition_4a[VERT] = 1;
@@ -6339,27 +7317,47 @@
       // Prune if the best partition is rect but subtrees did not further split
       // in vert
       if (pc_tree->partitioning == PARTITION_VERT &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_vert(pc_tree->vertical[cur_region_type][0]) &&
+          !node_uses_vert(pc_tree->vertical[cur_region_type][1])) {
+#else
           !node_uses_vert(pc_tree->vertical[0]) &&
           !node_uses_vert(pc_tree->vertical[1])) {
+#endif  // CONFIG_EXTENDED_SDP
         part_search_state->prune_partition_4b[VERT] = 1;
       }
       if (pc_tree->partitioning == PARTITION_HORZ &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_vert(pc_tree->horizontal[cur_region_type][0]) &&
+          !node_uses_vert(pc_tree->horizontal[cur_region_type][1])) {
+#else
           !node_uses_vert(pc_tree->horizontal[0]) &&
           !node_uses_vert(pc_tree->horizontal[1])) {
+#endif  // CONFIG_EXTENDED_SDP
         part_search_state->prune_partition_4b[VERT] = 1;
       }
     }
     if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm)) {
       if (pc_tree->partitioning == PARTITION_VERT_3 &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_vert(pc_tree->vertical3[cur_region_type][0]) &&
+          !node_uses_vert(pc_tree->vertical3[cur_region_type][3])) {
+#else
           !node_uses_vert(pc_tree->vertical3[0]) &&
           !node_uses_vert(pc_tree->vertical3[3])) {
+#endif  // CONFIG_EXTENDED_SDP
         // Prune if best partition is vertical H, but first and last
         // subpartitions did not further split in vertical direction.
         part_search_state->prune_partition_4b[VERT] = 1;
       }
       if (pc_tree->partitioning == PARTITION_HORZ_3 &&
+#if CONFIG_EXTENDED_SDP
+          !node_uses_vert(pc_tree->horizontal3[cur_region_type][1]) &&
+          !node_uses_vert(pc_tree->horizontal3[cur_region_type][2])) {
+#else
           !node_uses_vert(pc_tree->horizontal3[1]) &&
           !node_uses_vert(pc_tree->horizontal3[2])) {
+#endif  // CONFIG_EXTENDED_SDP
         // Prune if best partition is horizontal H, but middle two
         // subpartitions did not further split in vertical direction.
         part_search_state->prune_partition_4b[VERT] = 1;
@@ -6468,6 +7466,14 @@
   const int eighth_step = mi_size_high[bsize] / 8;
 
   sum_rdc.rate = search_state->partition_cost[PARTITION_HORZ_4A];
+#if CONFIG_EXTENDED_SDP
+  if (pc_tree->region_type == MIXED_INTER_INTRA_REGION && pc_tree->parent &&
+      is_inter_sdp_allowed(pc_tree->parent->block_size,
+                           pc_tree->parent->partitioning) &&
+      is_bsize_allowed_for_inter_sdp(bsize, PARTITION_HORZ_4A))
+    sum_rdc.rate +=
+        part_search_state->region_type_cost[MIXED_INTER_INTRA_REGION];
+#endif  // CONFIG_EXTENDED_SDP
   sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
 
   const BLOCK_SIZE sml_subsize =
@@ -6480,7 +7486,22 @@
   const BLOCK_SIZE subblock_sizes[4] = { sml_subsize, med_subsize, big_subsize,
                                          sml_subsize };
 
+#if CONFIG_EXTENDED_SDP
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+#endif  // CONFIG_EXTENDED_SDP
+
   for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+    if (pc_tree->horizontal4a[cur_region_type][idx]) {
+      av1_free_pc_tree_recursive(pc_tree->horizontal4a[cur_region_type][idx],
+                                 num_planes, 0, 0);
+      pc_tree->horizontal4a[cur_region_type][idx] = NULL;
+    }
+    const int this_mi_row = mi_row + eighth_step * cum_step_multipliers[idx];
+    pc_tree->horizontal4a[cur_region_type][idx] = av1_alloc_pc_tree_node(
+        xd->tree_type, this_mi_row, mi_col, subblock_sizes[idx], pc_tree,
+        PARTITION_HORZ_4A, idx, idx == 3, ss_x, ss_y);
+#else
     if (pc_tree->horizontal4a[idx]) {
       av1_free_pc_tree_recursive(pc_tree->horizontal4a[idx], num_planes, 0, 0);
       pc_tree->horizontal4a[idx] = NULL;
@@ -6489,6 +7510,7 @@
     pc_tree->horizontal4a[idx] = av1_alloc_pc_tree_node(
         xd->tree_type, this_mi_row, mi_col, subblock_sizes[idx], pc_tree,
         PARTITION_HORZ_4A, idx, idx == 3, ss_x, ss_y);
+#endif  // CONFIG_EXTENDED_SDP
   }
 
   bool skippable = true;
@@ -6497,14 +7519,19 @@
 
     if (i > 0 && this_mi_row >= cm->mi_params.mi_rows) break;
 
-    SUBBLOCK_RDO_DATA rdo_data = { pc_tree->horizontal4a[i],
-                                   get_partition_subtree_const(ptree_luma, i),
-                                   get_partition_subtree_const(template_tree,
-                                                               i),
-                                   this_mi_row,
-                                   mi_col,
-                                   subblock_sizes[i],
-                                   PARTITION_HORZ_4A };
+    SUBBLOCK_RDO_DATA rdo_data = {
+#if CONFIG_EXTENDED_SDP
+      pc_tree->horizontal4a[cur_region_type][i],
+#else
+      pc_tree->horizontal4a[i],
+#endif
+      get_partition_subtree_const(ptree_luma, i),
+      get_partition_subtree_const(template_tree, i),
+      this_mi_row,
+      mi_col,
+      subblock_sizes[i],
+      PARTITION_HORZ_4A
+    };
     if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
                              &sum_rdc, multi_pass_mode, &skippable,
                              max_recursion_depth)) {
@@ -6551,6 +7578,10 @@
   const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
   const BLOCK_SIZE bsize = blk_params->bsize;
 
+#if CONFIG_EXTENDED_SDP
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+#endif
+
   if (is_part_pruned_by_forced_partition(part_search_state,
                                          PARTITION_HORZ_4B) ||
       !part_search_state->partition_4b_allowed[HORZ] ||
@@ -6575,6 +7606,14 @@
   const int eighth_step = mi_size_high[bsize] / 8;
 
   sum_rdc.rate = search_state->partition_cost[PARTITION_HORZ_4B];
+#if CONFIG_EXTENDED_SDP
+  if (pc_tree->region_type == MIXED_INTER_INTRA_REGION && pc_tree->parent &&
+      is_inter_sdp_allowed(pc_tree->parent->block_size,
+                           pc_tree->parent->partitioning) &&
+      is_bsize_allowed_for_inter_sdp(bsize, PARTITION_HORZ_4A))
+    sum_rdc.rate +=
+        part_search_state->region_type_cost[MIXED_INTER_INTRA_REGION];
+#endif  // CONFIG_EXTENDED_SDP
   sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
 
   const BLOCK_SIZE sml_subsize =
@@ -6588,6 +7627,17 @@
                                          sml_subsize };
 
   for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+    if (pc_tree->horizontal4b[cur_region_type][idx]) {
+      av1_free_pc_tree_recursive(pc_tree->horizontal4b[cur_region_type][idx],
+                                 num_planes, 0, 0);
+      pc_tree->horizontal4b[cur_region_type][idx] = NULL;
+    }
+    const int this_mi_row = mi_row + eighth_step * cum_step_multipliers[idx];
+    pc_tree->horizontal4b[cur_region_type][idx] = av1_alloc_pc_tree_node(
+        xd->tree_type, this_mi_row, mi_col, subblock_sizes[idx], pc_tree,
+        PARTITION_HORZ_4B, idx, idx == 3, ss_x, ss_y);
+#else
     if (pc_tree->horizontal4b[idx]) {
       av1_free_pc_tree_recursive(pc_tree->horizontal4b[idx], num_planes, 0, 0);
       pc_tree->horizontal4b[idx] = NULL;
@@ -6596,6 +7646,7 @@
     pc_tree->horizontal4b[idx] = av1_alloc_pc_tree_node(
         xd->tree_type, this_mi_row, mi_col, subblock_sizes[idx], pc_tree,
         PARTITION_HORZ_4B, idx, idx == 3, ss_x, ss_y);
+#endif  // CONFIG_EXTENDED_SDP
   }
 
   bool skippable = true;
@@ -6604,14 +7655,19 @@
 
     if (i > 0 && this_mi_row >= cm->mi_params.mi_rows) break;
 
-    SUBBLOCK_RDO_DATA rdo_data = { pc_tree->horizontal4b[i],
-                                   get_partition_subtree_const(ptree_luma, i),
-                                   get_partition_subtree_const(template_tree,
-                                                               i),
-                                   this_mi_row,
-                                   mi_col,
-                                   subblock_sizes[i],
-                                   PARTITION_HORZ_4B };
+    SUBBLOCK_RDO_DATA rdo_data = {
+#if CONFIG_EXTENDED_SDP
+      pc_tree->horizontal4b[cur_region_type][i],
+#else
+      pc_tree->horizontal4b[i],
+#endif  // CONFIG_EXTENDED_SDP
+      get_partition_subtree_const(ptree_luma, i),
+      get_partition_subtree_const(template_tree, i),
+      this_mi_row,
+      mi_col,
+      subblock_sizes[i],
+      PARTITION_HORZ_4B
+    };
     if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
                              &sum_rdc, multi_pass_mode, &skippable,
                              max_recursion_depth)) {
@@ -6658,6 +7714,10 @@
   const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
   const BLOCK_SIZE bsize = blk_params->bsize;
 
+#if CONFIG_EXTENDED_SDP
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+#endif  // CONFIG_EXTENDED_SDP
+
   if (is_part_pruned_by_forced_partition(part_search_state,
                                          PARTITION_VERT_4A) ||
       !part_search_state->partition_4a_allowed[VERT] ||
@@ -6682,6 +7742,14 @@
   const int eighth_step = mi_size_wide[bsize] / 8;
 
   sum_rdc.rate = search_state->partition_cost[PARTITION_VERT_4A];
+#if CONFIG_EXTENDED_SDP
+  if (pc_tree->region_type == MIXED_INTER_INTRA_REGION && pc_tree->parent &&
+      is_inter_sdp_allowed(pc_tree->parent->block_size,
+                           pc_tree->parent->partitioning) &&
+      is_bsize_allowed_for_inter_sdp(bsize, PARTITION_VERT_4A))
+    sum_rdc.rate +=
+        part_search_state->region_type_cost[MIXED_INTER_INTRA_REGION];
+#endif  // CONFIG_EXTENDED_SDP
   sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
 
   const BLOCK_SIZE sml_subsize =
@@ -6695,6 +7763,17 @@
                                          sml_subsize };
 
   for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+    if (pc_tree->vertical4a[cur_region_type][idx]) {
+      av1_free_pc_tree_recursive(pc_tree->vertical4a[cur_region_type][idx],
+                                 num_planes, 0, 0);
+      pc_tree->vertical4a[cur_region_type][idx] = NULL;
+    }
+    const int this_mi_col = mi_col + eighth_step * cum_step_multipliers[idx];
+    pc_tree->vertical4a[cur_region_type][idx] = av1_alloc_pc_tree_node(
+        xd->tree_type, mi_row, this_mi_col, subblock_sizes[idx], pc_tree,
+        PARTITION_VERT_4A, idx, idx == 3, ss_x, ss_y);
+#else
     if (pc_tree->vertical4a[idx]) {
       av1_free_pc_tree_recursive(pc_tree->vertical4a[idx], num_planes, 0, 0);
       pc_tree->vertical4a[idx] = NULL;
@@ -6703,6 +7782,7 @@
     pc_tree->vertical4a[idx] = av1_alloc_pc_tree_node(
         xd->tree_type, mi_row, this_mi_col, subblock_sizes[idx], pc_tree,
         PARTITION_VERT_4A, idx, idx == 3, ss_x, ss_y);
+#endif  // CONFIG_EXTENDED_SDP
   }
 
   bool skippable = true;
@@ -6711,14 +7791,19 @@
 
     if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break;
 
-    SUBBLOCK_RDO_DATA rdo_data = { pc_tree->vertical4a[i],
-                                   get_partition_subtree_const(ptree_luma, i),
-                                   get_partition_subtree_const(template_tree,
-                                                               i),
-                                   mi_row,
-                                   this_mi_col,
-                                   subblock_sizes[i],
-                                   PARTITION_VERT_4A };
+    SUBBLOCK_RDO_DATA rdo_data = {
+#if CONFIG_EXTENDED_SDP
+      pc_tree->vertical4a[cur_region_type][i],
+#else
+      pc_tree->vertical4a[i],
+#endif  // CONFIG_EXTENDED_SDP
+      get_partition_subtree_const(ptree_luma, i),
+      get_partition_subtree_const(template_tree, i),
+      mi_row,
+      this_mi_col,
+      subblock_sizes[i],
+      PARTITION_VERT_4A
+    };
     if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
                              &sum_rdc, multi_pass_mode, &skippable,
                              max_recursion_depth)) {
@@ -6765,6 +7850,10 @@
   const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
   const BLOCK_SIZE bsize = blk_params->bsize;
 
+#if CONFIG_EXTENDED_SDP
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+#endif  // CONFIG_EXTENDED_SDP
+
   if (is_part_pruned_by_forced_partition(part_search_state,
                                          PARTITION_VERT_4B) ||
       !part_search_state->partition_4b_allowed[VERT] ||
@@ -6789,6 +7878,14 @@
   const int eighth_step = mi_size_wide[bsize] / 8;
 
   sum_rdc.rate = search_state->partition_cost[PARTITION_VERT_4B];
+#if CONFIG_EXTENDED_SDP
+  if (pc_tree->region_type == MIXED_INTER_INTRA_REGION && pc_tree->parent &&
+      is_inter_sdp_allowed(pc_tree->parent->block_size,
+                           pc_tree->parent->partitioning) &&
+      is_bsize_allowed_for_inter_sdp(bsize, PARTITION_VERT_4A))
+    sum_rdc.rate +=
+        part_search_state->region_type_cost[MIXED_INTER_INTRA_REGION];
+#endif  // CONFIG_EXTENDED_SDP
   sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
 
   const BLOCK_SIZE sml_subsize =
@@ -6802,6 +7899,17 @@
                                          sml_subsize };
 
   for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+    if (pc_tree->vertical4b[cur_region_type][idx]) {
+      av1_free_pc_tree_recursive(pc_tree->vertical4b[cur_region_type][idx],
+                                 num_planes, 0, 0);
+      pc_tree->vertical4b[cur_region_type][idx] = NULL;
+    }
+    const int this_mi_col = mi_col + eighth_step * cum_step_multipliers[idx];
+    pc_tree->vertical4b[cur_region_type][idx] = av1_alloc_pc_tree_node(
+        xd->tree_type, mi_row, this_mi_col, subblock_sizes[idx], pc_tree,
+        PARTITION_VERT_4B, idx, idx == 3, ss_x, ss_y);
+#else
     if (pc_tree->vertical4b[idx]) {
       av1_free_pc_tree_recursive(pc_tree->vertical4b[idx], num_planes, 0, 0);
       pc_tree->vertical4b[idx] = NULL;
@@ -6810,6 +7918,7 @@
     pc_tree->vertical4b[idx] = av1_alloc_pc_tree_node(
         xd->tree_type, mi_row, this_mi_col, subblock_sizes[idx], pc_tree,
         PARTITION_VERT_4B, idx, idx == 3, ss_x, ss_y);
+#endif  // CONFIG_EXTENDED_SDP
   }
 
   bool skippable = true;
@@ -6818,14 +7927,19 @@
 
     if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break;
 
-    SUBBLOCK_RDO_DATA rdo_data = { pc_tree->vertical4b[i],
-                                   get_partition_subtree_const(ptree_luma, i),
-                                   get_partition_subtree_const(template_tree,
-                                                               i),
-                                   mi_row,
-                                   this_mi_col,
-                                   subblock_sizes[i],
-                                   PARTITION_VERT_4B };
+    SUBBLOCK_RDO_DATA rdo_data = {
+#if CONFIG_EXTENDED_SDP
+      pc_tree->vertical4b[cur_region_type][i],
+#else
+      pc_tree->vertical4b[i],
+#endif  // CONFIG_EXTENDED_SDP
+      get_partition_subtree_const(ptree_luma, i),
+      get_partition_subtree_const(template_tree, i),
+      mi_row,
+      this_mi_col,
+      subblock_sizes[i],
+      PARTITION_VERT_4B
+    };
     if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
                              &sum_rdc, multi_pass_mode, &skippable,
                              max_recursion_depth)) {
@@ -6873,6 +7987,10 @@
   const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
   const BLOCK_SIZE bsize = blk_params->bsize;
 
+#if CONFIG_EXTENDED_SDP
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+#endif  // CONFIG_EXTENDED_SDP
+
   if (is_part_pruned_by_forced_partition(part_search_state, PARTITION_HORZ_3) ||
       !part_search_state->partition_3_allowed[HORZ] ||
       part_search_state->prune_partition_3[HORZ]) {
@@ -6899,6 +8017,14 @@
   const int quarter_step = mi_size_high[bsize] / 4;
 
   sum_rdc.rate = search_state->partition_cost[PARTITION_HORZ_3];
+#if CONFIG_EXTENDED_SDP
+  if (pc_tree->region_type == MIXED_INTER_INTRA_REGION && pc_tree->parent &&
+      is_inter_sdp_allowed(pc_tree->parent->block_size,
+                           pc_tree->parent->partitioning) &&
+      is_bsize_allowed_for_inter_sdp(bsize, PARTITION_HORZ_3))
+    sum_rdc.rate +=
+        part_search_state->region_type_cost[MIXED_INTER_INTRA_REGION];
+#endif  // CONFIG_EXTENDED_SDP
   sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
 
   const BLOCK_SIZE sml_subsize =
@@ -6911,6 +8037,18 @@
   const int offset_mc[4] = { 0, 0, mi_size_wide[bsize] / 2, 0 };
 
   for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+    if (pc_tree->horizontal3[cur_region_type][idx]) {
+      av1_free_pc_tree_recursive(pc_tree->horizontal3[cur_region_type][idx],
+                                 num_planes, 0, 0);
+      pc_tree->horizontal3[cur_region_type][idx] = NULL;
+    }
+
+    pc_tree->horizontal3[cur_region_type][idx] = av1_alloc_pc_tree_node(
+        xd->tree_type, mi_row + offset_mr[idx], mi_col + offset_mc[idx],
+        subblock_sizes[idx], pc_tree, PARTITION_HORZ_3, idx, idx == 3, ss_x,
+        ss_y);
+#else
     if (pc_tree->horizontal3[idx]) {
       av1_free_pc_tree_recursive(pc_tree->horizontal3[idx], num_planes, 0, 0);
       pc_tree->horizontal3[idx] = NULL;
@@ -6920,6 +8058,7 @@
         xd->tree_type, mi_row + offset_mr[idx], mi_col + offset_mc[idx],
         subblock_sizes[idx], pc_tree, PARTITION_HORZ_3, idx, idx == 3, ss_x,
         ss_y);
+#endif
   }
 
   bool skippable = true;
@@ -6929,14 +8068,19 @@
 
     if (i > 0 && this_mi_row >= cm->mi_params.mi_rows) break;
 
-    SUBBLOCK_RDO_DATA rdo_data = { pc_tree->horizontal3[i],
-                                   get_partition_subtree_const(ptree_luma, i),
-                                   get_partition_subtree_const(template_tree,
-                                                               i),
-                                   this_mi_row,
-                                   this_mi_col,
-                                   subblock_sizes[i],
-                                   PARTITION_HORZ_3 };
+    SUBBLOCK_RDO_DATA rdo_data = {
+#if CONFIG_EXTENDED_SDP
+      pc_tree->horizontal3[cur_region_type][i],
+#else
+      pc_tree->horizontal3[i],
+#endif  // CONFIG_EXTENDED_SDP
+      get_partition_subtree_const(ptree_luma, i),
+      get_partition_subtree_const(template_tree, i),
+      this_mi_row,
+      this_mi_col,
+      subblock_sizes[i],
+      PARTITION_HORZ_3
+    };
     if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
                              &sum_rdc, multi_pass_mode, &skippable,
                              max_recursion_depth)) {
@@ -6984,6 +8128,10 @@
   const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
   const BLOCK_SIZE bsize = blk_params->bsize;
 
+#if CONFIG_EXTENDED_SDP
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+#endif  // CONFIG_EXTENDED_SDP
+
   if (is_part_pruned_by_forced_partition(part_search_state, PARTITION_VERT_3) ||
       !part_search_state->partition_3_allowed[VERT] ||
       part_search_state->prune_partition_3[VERT]) {
@@ -7011,6 +8159,14 @@
   const int quarter_step = mi_size_wide[bsize] / 4;
 
   sum_rdc.rate = search_state->partition_cost[PARTITION_VERT_3];
+#if CONFIG_EXTENDED_SDP
+  if (pc_tree->region_type == MIXED_INTER_INTRA_REGION && pc_tree->parent &&
+      is_inter_sdp_allowed(pc_tree->parent->block_size,
+                           pc_tree->parent->partitioning) &&
+      is_bsize_allowed_for_inter_sdp(bsize, PARTITION_VERT_3))
+    sum_rdc.rate +=
+        part_search_state->region_type_cost[MIXED_INTER_INTRA_REGION];
+#endif  // CONFIG_EXTENDED_SDP
   sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
 
   const BLOCK_SIZE sml_subsize =
@@ -7023,6 +8179,18 @@
   const int offset_mc[4] = { 0, quarter_step, quarter_step, 3 * quarter_step };
 
   for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+    if (pc_tree->vertical3[cur_region_type][idx]) {
+      av1_free_pc_tree_recursive(pc_tree->vertical3[cur_region_type][idx],
+                                 num_planes, 0, 0);
+      pc_tree->vertical3[cur_region_type][idx] = NULL;
+    }
+
+    pc_tree->vertical3[cur_region_type][idx] = av1_alloc_pc_tree_node(
+        xd->tree_type, mi_row + offset_mr[idx], mi_col + offset_mc[idx],
+        subblock_sizes[idx], pc_tree, PARTITION_VERT_3, idx, idx == 3, ss_x,
+        ss_y);
+#else
     if (pc_tree->vertical3[idx]) {
       av1_free_pc_tree_recursive(pc_tree->vertical3[idx], num_planes, 0, 0);
       pc_tree->vertical3[idx] = NULL;
@@ -7032,6 +8200,7 @@
         xd->tree_type, mi_row + offset_mr[idx], mi_col + offset_mc[idx],
         subblock_sizes[idx], pc_tree, PARTITION_VERT_3, idx, idx == 3, ss_x,
         ss_y);
+#endif
   }
 
   bool skippable = true;
@@ -7041,14 +8210,19 @@
 
     if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break;
 
-    SUBBLOCK_RDO_DATA rdo_data = { pc_tree->vertical3[i],
-                                   get_partition_subtree_const(ptree_luma, i),
-                                   get_partition_subtree_const(template_tree,
-                                                               i),
-                                   this_mi_row,
-                                   this_mi_col,
-                                   subblock_sizes[i],
-                                   PARTITION_VERT_3 };
+    SUBBLOCK_RDO_DATA rdo_data = {
+#if CONFIG_EXTENDED_SDP
+      pc_tree->vertical3[cur_region_type][i],
+#else
+      pc_tree->vertical3[i],
+#endif  // CONFIG_EXTENDED_SDP
+      get_partition_subtree_const(ptree_luma, i),
+      get_partition_subtree_const(template_tree, i),
+      this_mi_row,
+      this_mi_col,
+      subblock_sizes[i],
+      PARTITION_VERT_3
+    };
     if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
                              &sum_rdc, multi_pass_mode, &skippable,
                              max_recursion_depth)) {
@@ -7079,69 +8253,134 @@
                                           int curr_depth) {
   const PARTITION_TYPE partition = pc_tree->partitioning;
   int max_depth = curr_depth;
+#if CONFIG_EXTENDED_SDP
+  int cur_region_type = pc_tree->region_type;
+#endif  // CONFIG_EXTENDED_SDP
   switch (partition) {
     case PARTITION_NONE: break;
     case PARTITION_SPLIT:
       for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+        max_depth = AOMMAX(
+            max_depth, get_partition_depth(pc_tree->split[cur_region_type][idx],
+                                           curr_depth + 2));
+#else
         max_depth = AOMMAX(max_depth, get_partition_depth(pc_tree->split[idx],
                                                           curr_depth + 2));
+#endif  // CONFIG_EXTENDED_SDP
       }
       break;
 #if CONFIG_EXT_RECUR_PARTITIONS
     case PARTITION_HORZ:
       for (int idx = 0; idx < 2; idx++) {
+#if CONFIG_EXTENDED_SDP
+        max_depth = AOMMAX(
+            max_depth,
+            get_partition_depth(pc_tree->horizontal[cur_region_type][idx],
+                                curr_depth + 1));
+#else
         max_depth = AOMMAX(
             max_depth,
             get_partition_depth(pc_tree->horizontal[idx], curr_depth + 1));
+#endif  // CONFIG_EXTENDED_SDP
       }
       break;
     case PARTITION_VERT:
       for (int idx = 0; idx < 2; idx++) {
+#if CONFIG_EXTENDED_SDP
+        max_depth =
+            AOMMAX(max_depth,
+                   get_partition_depth(pc_tree->vertical[cur_region_type][idx],
+                                       curr_depth + 1));
+#else
         max_depth =
             AOMMAX(max_depth,
                    get_partition_depth(pc_tree->vertical[idx], curr_depth + 1));
+#endif  // CONFIG_EXTENDED_SDP
       }
       break;
     case PARTITION_HORZ_3:
       for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+        max_depth = AOMMAX(
+            max_depth,
+            get_partition_depth(pc_tree->horizontal3[cur_region_type][idx],
+                                curr_depth + 1));
+#else
         max_depth = AOMMAX(
             max_depth,
             get_partition_depth(pc_tree->horizontal3[idx], curr_depth + 1));
+#endif  // CONFIG_EXTENDED_SDP
       }
       break;
     case PARTITION_VERT_3:
       for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+        max_depth =
+            AOMMAX(max_depth,
+                   get_partition_depth(pc_tree->vertical3[cur_region_type][idx],
+                                       curr_depth + 1));
+#else
         max_depth = AOMMAX(
             max_depth,
             get_partition_depth(pc_tree->vertical3[idx], curr_depth + 1));
+#endif
       }
       break;
     case PARTITION_HORZ_4A:
       for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+        max_depth = AOMMAX(
+            max_depth,
+            get_partition_depth(pc_tree->horizontal4a[cur_region_type][idx],
+                                curr_depth + 1));
+#else
         max_depth = AOMMAX(
             max_depth,
             get_partition_depth(pc_tree->horizontal4a[idx], curr_depth + 1));
+#endif  // CONFIG_EXTENDED_SDP
       }
       break;
     case PARTITION_HORZ_4B:
       for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+        max_depth = AOMMAX(
+            max_depth,
+            get_partition_depth(pc_tree->horizontal4b[cur_region_type][idx],
+                                curr_depth + 1));
+#else
         max_depth = AOMMAX(
             max_depth,
             get_partition_depth(pc_tree->horizontal4b[idx], curr_depth + 1));
+#endif  // CONFIG_EXTENDED_SDP
       }
       break;
     case PARTITION_VERT_4A:
       for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+        max_depth = AOMMAX(
+            max_depth,
+            get_partition_depth(pc_tree->vertical4a[cur_region_type][idx],
+                                curr_depth + 1));
+#else
         max_depth = AOMMAX(
             max_depth,
             get_partition_depth(pc_tree->vertical4a[idx], curr_depth + 1));
+#endif  // CONFIG_EXTENDED_SDP
       }
       break;
     case PARTITION_VERT_4B:
       for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+        max_depth = AOMMAX(
+            max_depth,
+            get_partition_depth(pc_tree->vertical4b[cur_region_type][idx],
+                                curr_depth + 1));
+#else
         max_depth = AOMMAX(
             max_depth,
             get_partition_depth(pc_tree->vertical4b[idx], curr_depth + 1));
+#endif  // CONFIG_EXTENDED_SDP
       }
       break;
     default: assert(0); break;
@@ -7241,13 +8480,25 @@
   PC_TREE *const *tree = NULL;
   int num_sub_parts = 0;
   if (cur_best_partition == PARTITION_SPLIT) {
+#if CONFIG_EXTENDED_SDP
+    tree = pc_tree->split[pc_tree->region_type];
+#else
     tree = pc_tree->split;
+#endif  // CONFIG_EXTENDED_SDP
     num_sub_parts = SUB_PARTITIONS_SPLIT;
   } else if (cur_best_partition == PARTITION_HORZ) {
+#if CONFIG_EXTENDED_SDP
+    tree = pc_tree->horizontal[pc_tree->region_type];
+#else
     tree = pc_tree->horizontal;
+#endif  // CONFIG_EXTENDED_SDP
     num_sub_parts = NUM_RECT_PARTS;
   } else if (cur_best_partition == PARTITION_VERT) {
+#if CONFIG_EXTENDED_SDP
+    tree = pc_tree->vertical[pc_tree->region_type];
+#else
     tree = pc_tree->vertical;
+#endif  // CONFIG_EXTENDED_SDP
     num_sub_parts = NUM_RECT_PARTS;
   } else {
     assert(0 &&
@@ -7284,6 +8535,7 @@
 * \param[in]    mi_col             Column coordinate of the block in a step
 size of MI_SIZE
 * \param[in]    bsize              Current block size
+* \param[in]    parent_partition   Partition of the parent block
 * \param[in]    rd_cost            Pointer to the final rd cost of the block
 * \param[in]    best_rdc           Upper bound of rd cost of a valid partition
 * \param[in]    pc_tree            Pointer to the PC_TREE node storing the
@@ -7357,8 +8609,12 @@
 
 bool av1_rd_pick_partition(AV1_COMP *const cpi, ThreadData *td,
                            TileDataEnc *tile_data, TokenExtra **tp, int mi_row,
-                           int mi_col, BLOCK_SIZE bsize, RD_STATS *rd_cost,
-                           RD_STATS best_rdc, PC_TREE *pc_tree,
+                           int mi_col, BLOCK_SIZE bsize,
+#if CONFIG_EXTENDED_SDP
+                           PARTITION_TYPE parent_partition,
+#endif  // CONFIG_EXTENDED_SDP
+                           RD_STATS *rd_cost, RD_STATS best_rdc,
+                           PC_TREE *pc_tree,
 #if CONFIG_EXT_RECUR_PARTITIONS
                            const PARTITION_TREE *ptree_luma,
                            const PARTITION_TREE *template_tree,
@@ -7380,6 +8636,13 @@
   RD_SEARCH_MACROBLOCK_CONTEXT x_ctx;
   const TokenExtra *const tp_orig = *tp;
   PartitionSearchState part_search_state;
+
+#if CONFIG_EXTENDED_SDP
+  if (frame_is_intra_only(cm) && pc_tree) {
+    pc_tree->region_type = INTRA_REGION;
+  }
+#endif  // CONFIG_EXTENDED_SDP
+
   // Initialization of state variables used in partition search.
   init_partition_search_state_params(x, cpi, &part_search_state,
 #if CONFIG_EXT_RECUR_PARTITIONS
@@ -7402,6 +8665,7 @@
   // different partition path. If yes directly copy the RDO decision made for
   // the counterpart.
   PC_TREE *counterpart_block = av1_look_for_counterpart_block(pc_tree);
+  assert(pc_tree != NULL);
   if (counterpart_block
 #if CONFIG_CB1TO4_SPLIT
       &&
@@ -7412,6 +8676,10 @@
                               ? counterpart_block->parent->block_size
                               : BLOCK_INVALID))
 #endif  // CONFIG_CB1TO4_SPLIT
+#if CONFIG_EXTENDED_SDP
+      && (pc_tree->region_type == counterpart_block->region_type &&
+          (pc_tree->region_type != INTRA_REGION || frame_is_intra_only(cm)))
+#endif  // CONFIG_EXTENDED_SDP
   ) {
     if (counterpart_block->rd_cost.rate != INT_MAX) {
       av1_copy_pc_tree_recursive(xd, cm, pc_tree, counterpart_block,
@@ -7568,7 +8836,11 @@
 #if CONFIG_CB1TO4_SPLIT
         blk_params.parent_bsize,
 #endif  // CONFIG_CB1TO4_SPLIT
-        ptree_luma, template_tree, &pc_tree->chroma_ref_info);
+        ptree_luma, template_tree,
+#if CONFIG_EXTENDED_SDP
+        pc_tree->region_type,
+#endif  // CONFIG_EXTENDED_SDP
+        &pc_tree->chroma_ref_info);
   }
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
 
@@ -7683,7 +8955,19 @@
 #endif  // CONFIG_ML_PART_SPLIT
   // PARTITION_NONE search stage.
   int64_t part_none_rd = INT64_MAX;
+#if CONFIG_EXTENDED_SDP
+  int partition_none_allowed = 1;
+  if (pc_tree->parent && pc_tree->region_type == INTRA_REGION &&
+      pc_tree->parent->region_type == MIXED_INTER_INTRA_REGION &&
+      xd->tree_type != CHROMA_PART)
+    partition_none_allowed = 0;
+  if (!frame_is_intra_only(cm) && pc_tree->region_type == INTRA_REGION)
+    search_none_after_rect &= (xd->tree_type != CHROMA_PART);
+  if (!search_none_after_rect && !search_none_after_split &&
+      partition_none_allowed) {
+#else
   if (!search_none_after_rect && !search_none_after_split) {
+#endif  // CONFIG_EXTENDED_SDP
     none_partition_search(cpi, td, tile_data, x, pc_tree, sms_tree, &x_ctx,
                           &part_search_state, &best_rdc, &pb_source_variance,
                           none_rd, &part_none_rd
@@ -7693,6 +8977,14 @@
 #endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
     );
   }
+#if CONFIG_EXTENDED_SDP
+  if (pc_tree->parent && pc_tree->region_type == INTRA_REGION &&
+      pc_tree->parent->region_type == MIXED_INTER_INTRA_REGION &&
+      xd->tree_type == CHROMA_PART) {
+    *rd_cost = best_rdc;
+    return part_search_state.found_best_partition;
+  }
+#endif  // CONFIG_EXTENDED_SDP
 
 #if CONFIG_EXT_RECUR_PARTITIONS
   if (cpi->sf.part_sf.end_part_search_after_consec_failures && x->is_whole_sb &&
@@ -7743,17 +9035,35 @@
     // after rect
     assert(pc_tree->partitioning == PARTITION_SPLIT);
     for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+      const int depth =
+          get_partition_depth(pc_tree->split[pc_tree->region_type][idx], 0);
+#else
       const int depth = get_partition_depth(pc_tree->split[idx], 0);
+#endif  // CONFIG_EXTENDED_SDP
       search_none_after_split &= depth == 0;
     }
   }
   if (cpi->sf.part_sf.prune_rect_with_split_depth && !frame_is_intra_only(cm) &&
       part_search_state.forced_partition == PARTITION_INVALID &&
+#if CONFIG_EXTENDED_SDP
+      pc_tree->split[pc_tree->region_type][0] &&
+      pc_tree->split[pc_tree->region_type][1] &&
+      pc_tree->split[pc_tree->region_type][2] &&
+      pc_tree->split[pc_tree->region_type][3]
+#else
       pc_tree->split[0] && pc_tree->split[1] && pc_tree->split[2] &&
-      pc_tree->split[3]) {
+      pc_tree->split[3]
+#endif  // CONFIG_EXTENDED_SDP
+  ) {
     int min_depth = INT_MAX, max_depth = 0;
     for (int idx = 0; idx < 4; idx++) {
+#if CONFIG_EXTENDED_SDP
+      const int depth =
+          get_partition_depth(pc_tree->split[pc_tree->region_type][idx], 0);
+#else
       const int depth = get_partition_depth(pc_tree->split[idx], 0);
+#endif  // CONFIG_EXTENDED_SDP
       min_depth = AOMMIN(min_depth, depth);
       max_depth = AOMMAX(max_depth, depth);
     }
@@ -7765,6 +9075,9 @@
   }
 
   if (part_search_state.forced_partition == PARTITION_INVALID &&
+#if CONFIG_EXTENDED_SDP
+      partition_none_allowed &&
+#endif  // CONFIG_EXTENDED_SDP
       search_none_after_split) {
     none_partition_search(cpi, td, tile_data, x, pc_tree, sms_tree, &x_ctx,
                           &part_search_state, &best_rdc, &pb_source_variance,
@@ -7787,6 +9100,9 @@
 #if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
       &level_banks,
 #endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+#if CONFIG_EXTENDED_SDP
+      parent_partition,
+#endif  // CONFIG_INTER_SDP
       part_none_rd
 #if CONFIG_ML_PART_SPLIT
       ,
@@ -7803,7 +9119,12 @@
   assert(IMPLIES(!cpi->oxcf.part_cfg.enable_rect_partitions,
                  !part_search_state.do_rectangular_split));
 #if CONFIG_EXT_RECUR_PARTITIONS
+#if CONFIG_EXTENDED_SDP
+  if (search_none_after_rect && !search_none_after_split &&
+      partition_none_allowed) {
+#else
   if (search_none_after_rect && !search_none_after_split) {
+#endif  // CONFIG_EXTENDED_SDP
     prune_none_with_rect_results(&part_search_state, pc_tree);
     none_partition_search(cpi, td, tile_data, x, pc_tree, sms_tree, &x_ctx,
                           &part_search_state, &best_rdc, &pb_source_variance,
@@ -7918,51 +9239,63 @@
 #endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
                           multi_pass_mode, ext_recur_depth);
 
-  prune_ext_partitions_4way(cpi, pc_tree, &part_search_state,
-                            partition_boundaries);
+#if CONFIG_EXTENDED_SDP
+  if ((pc_tree->region_type != INTRA_REGION || frame_is_intra_only(cm))) {
+#endif  // CONFIG_EXTENDED_SDP
+    prune_ext_partitions_4way(cpi, pc_tree, &part_search_state,
+                              partition_boundaries);
 
-  // PARTITION_HORZ_4A
-  search_partition_horz_4a(&part_search_state, cpi, td, tile_data, tp,
-                           &best_rdc, pc_tree,
-                           track_ptree_luma ? ptree_luma : NULL, template_tree,
-                           &x_ctx, &part_search_state,
+    // PARTITION_HORZ_4A
+    search_partition_horz_4a(&part_search_state, cpi, td, tile_data, tp,
+                             &best_rdc, pc_tree,
+                             track_ptree_luma ? ptree_luma : NULL,
+                             template_tree, &x_ctx, &part_search_state,
 #if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
-                           &level_banks,
+                             &level_banks,
 #endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
-                           multi_pass_mode, ext_recur_depth);
+                             multi_pass_mode, ext_recur_depth);
 
-  // PARTITION_HORZ_4B
-  search_partition_horz_4b(&part_search_state, cpi, td, tile_data, tp,
-                           &best_rdc, pc_tree,
-                           track_ptree_luma ? ptree_luma : NULL, template_tree,
-                           &x_ctx, &part_search_state,
+    // PARTITION_HORZ_4B
+    search_partition_horz_4b(&part_search_state, cpi, td, tile_data, tp,
+                             &best_rdc, pc_tree,
+                             track_ptree_luma ? ptree_luma : NULL,
+                             template_tree, &x_ctx, &part_search_state,
 #if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
-                           &level_banks,
+                             &level_banks,
 #endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
-                           multi_pass_mode, ext_recur_depth);
+                             multi_pass_mode, ext_recur_depth);
 
-  // PARTITION_VERT_4A
-  search_partition_vert_4a(&part_search_state, cpi, td, tile_data, tp,
-                           &best_rdc, pc_tree,
-                           track_ptree_luma ? ptree_luma : NULL, template_tree,
-                           &x_ctx, &part_search_state,
+    // PARTITION_VERT_4A
+    search_partition_vert_4a(&part_search_state, cpi, td, tile_data, tp,
+                             &best_rdc, pc_tree,
+                             track_ptree_luma ? ptree_luma : NULL,
+                             template_tree, &x_ctx, &part_search_state,
 #if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
-                           &level_banks,
+                             &level_banks,
 #endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
-                           multi_pass_mode, ext_recur_depth);
+                             multi_pass_mode, ext_recur_depth);
 
-  // PARTITION_VERT_4B
-  search_partition_vert_4b(&part_search_state, cpi, td, tile_data, tp,
-                           &best_rdc, pc_tree,
-                           track_ptree_luma ? ptree_luma : NULL, template_tree,
-                           &x_ctx, &part_search_state,
+    // PARTITION_VERT_4B
+    search_partition_vert_4b(&part_search_state, cpi, td, tile_data, tp,
+                             &best_rdc, pc_tree,
+                             track_ptree_luma ? ptree_luma : NULL,
+                             template_tree, &x_ctx, &part_search_state,
 #if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
-                           &level_banks,
+                             &level_banks,
 #endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
-                           multi_pass_mode, ext_recur_depth);
+                             multi_pass_mode, ext_recur_depth);
+#if CONFIG_EXTENDED_SDP
+  }
+#endif  // CONFIG_EXTENDED_SDP
 #endif  // CONFIG_EXT_RECUR_PARTITIONS
 
-  if (bsize == cm->sb_size && !part_search_state.found_best_partition) {
+  if (bsize == cm->sb_size && !part_search_state.found_best_partition
+#if CONFIG_EXTENDED_SDP
+      && ((!frame_is_intra_only(cm) &&
+           pc_tree->region_type == MIXED_INTER_INTRA_REGION) ||
+          ((frame_is_intra_only(cm) && pc_tree->region_type == INTRA_REGION)))
+#endif  // CONFIG_EXTENDED_SDP
+  ) {
     if (x->must_find_valid_partition) {
       aom_internal_error(
           &cpi->common.error, AOM_CODEC_ERROR,
@@ -7991,6 +9324,23 @@
   }
 #endif  // CONFIG_EXT_RECUR_PARTITIONS && !defined(NDEBUG)
 
+#if CONFIG_EXTENDED_SDP
+  if (frame_is_intra_only(cm)) pc_tree->inter_sdp_allowed_flag = 0;
+  if (!frame_is_intra_only(cm) &&
+      pc_tree->region_type == MIXED_INTER_INTRA_REGION && pc_tree->parent &&
+      pc_tree->inter_sdp_allowed_flag == 1 &&
+      is_bsize_allowed_for_inter_sdp(bsize, PARTITION_HORZ)) {
+    search_intra_region_partitioning(
+        &part_search_state, cpi, td, tile_data, tp, &best_rdc, pc_tree,
+        track_ptree_luma ? ptree_luma : NULL, template_tree, &x_ctx,
+        &part_search_state,
+#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+        &level_banks,
+#endif  // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
+        multi_pass_mode, ext_recur_depth, parent_partition);
+  }
+#endif  // CONFIG_EXTENDED_SDP
+
   // Store the final rd cost
   *rd_cost = best_rdc;
 #if CONFIG_MVP_IMPROVEMENT
diff --git a/av1/encoder/partition_search.h b/av1/encoder/partition_search.h
index fec481c..f11aa1c 100644
--- a/av1/encoder/partition_search.h
+++ b/av1/encoder/partition_search.h
@@ -34,8 +34,12 @@
                           PC_TREE *pc_tree);
 bool av1_rd_pick_partition(AV1_COMP *const cpi, ThreadData *td,
                            TileDataEnc *tile_data, TokenExtra **tp, int mi_row,
-                           int mi_col, BLOCK_SIZE bsize, RD_STATS *rd_cost,
-                           RD_STATS best_rdc, PC_TREE *pc_tree,
+                           int mi_col, BLOCK_SIZE bsize,
+#if CONFIG_EXTENDED_SDP
+                           PARTITION_TYPE parent_partition,
+#endif  // CONFIG_EXTENDED_SDP
+                           RD_STATS *rd_cost, RD_STATS best_rdc,
+                           PC_TREE *pc_tree,
 #if CONFIG_EXT_RECUR_PARTITIONS
                            const PARTITION_TREE *ptree_luma,
                            const PARTITION_TREE *template_tree,
diff --git a/av1/encoder/partition_strategy.c b/av1/encoder/partition_strategy.c
index 853f06e..3c19b0e 100644
--- a/av1/encoder/partition_strategy.c
+++ b/av1/encoder/partition_strategy.c
@@ -1467,6 +1467,18 @@
       : (rect_part == PARTITION_HORZ) ? rect_part_win_info->rect_part_win[HORZ]
                                       : rect_part_win_info->rect_part_win[VERT];
   num_win += (sub_part_win) ? 1 : 0;
+#if CONFIG_EXTENDED_SDP
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+  if (pc_tree->split[cur_region_type][split_idx1]) {
+    num_win += (pc_tree->split[cur_region_type][split_idx1]->partitioning ==
+                PARTITION_NONE);
+  } else {
+    num_win += 1;
+  }
+  if (pc_tree->split[cur_region_type][split_idx2]) {
+    num_win += (pc_tree->split[cur_region_type][split_idx2]->partitioning ==
+                PARTITION_NONE);
+#else
   if (pc_tree->split[split_idx1]) {
     num_win +=
         (pc_tree->split[split_idx1]->partitioning == PARTITION_NONE) ? 1 : 0;
@@ -1476,6 +1488,7 @@
   if (pc_tree->split[split_idx2]) {
     num_win +=
         (pc_tree->split[split_idx2]->partitioning == PARTITION_NONE) ? 1 : 0;
+#endif  // CONFIG_EXTENDED_SDP
   } else {
     num_win += 1;
   }
@@ -2030,10 +2043,20 @@
 
   // Whether we are in the middle of a PARTITION_3 subblock
   const PC_TREE *parent = pc_tree->parent;
+#if CONFIG_EXTENDED_SDP
+  REGION_TYPE cur_region_type = pc_tree->region_type;
+  ml_features[num_features++] =
+      parent && (parent->horizontal3[cur_region_type][1] == pc_tree ||
+                 parent->horizontal3[cur_region_type][2] == pc_tree);
+  ml_features[num_features++] =
+      parent && (parent->vertical3[cur_region_type][1] == pc_tree ||
+                 parent->vertical3[cur_region_type][2] == pc_tree);
+#else
   ml_features[num_features++] = parent && (parent->horizontal3[1] == pc_tree ||
                                            parent->horizontal3[2] == pc_tree);
   ml_features[num_features++] = parent && (parent->vertical3[1] == pc_tree ||
                                            parent->vertical3[2] == pc_tree);
+#endif  // CONFIG_EXTENDED_SDP
   assert(num_features == 19);
 }
 
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index d32653b..0e71e22 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -99,6 +99,12 @@
 void av1_fill_mode_rates(AV1_COMMON *const cm, const MACROBLOCKD *xd,
                          ModeCosts *mode_costs, FRAME_CONTEXT *fc) {
   int i, j;
+#if CONFIG_EXTENDED_SDP
+  for (i = 0; i < INTER_SDP_BSIZE_GROUP; ++i) {
+    av1_cost_tokens_from_cdf(mode_costs->region_type_cost[i],
+                             fc->region_type_cdf[i], NULL);
+  }
+#endif  // CONFIG_EXTENDED_SDP
 #if CONFIG_EXT_RECUR_PARTITIONS
   for (int plane_index = (xd->tree_type == CHROMA_PART);
        plane_index < PARTITION_STRUCTURE_NUM; plane_index++) {
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index f2a7745..d96450b 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -6595,7 +6595,7 @@
                                        int64_t best_rd) {
   const AV1_COMMON *const cm = &cpi->common;
   MACROBLOCKD *const xd = &x->e_mbd;
-  if (!av1_allow_intrabc(cm) || (xd->tree_type == CHROMA_PART) ||
+  if (!av1_allow_intrabc(cm, xd) || (xd->tree_type == CHROMA_PART) ||
       !cpi->oxcf.kf_cfg.enable_intrabc)
     return INT64_MAX;
   const int num_planes = av1_num_planes(cm);
@@ -10584,7 +10584,7 @@
   if (search_state.best_skip2 == 0) {
     const int try_intrabc = cpi->oxcf.kf_cfg.enable_intrabc &&
                             cpi->oxcf.kf_cfg.enable_intrabc_ext &&
-                            av1_allow_intrabc(cm) &&
+                            av1_allow_intrabc(cm, xd) &&
                             (xd->tree_type != CHROMA_PART);
     if (try_intrabc) {
       this_rd_cost.rdcost = INT64_MAX;
diff --git a/av1/encoder/reconinter_enc.c b/av1/encoder/reconinter_enc.c
index eb0b368..17c6029 100644
--- a/av1/encoder/reconinter_enc.c
+++ b/av1/encoder/reconinter_enc.c
@@ -358,7 +358,7 @@
 
 #if CONFIG_MORPH_PRED
   if (mbmi->morph_pred) {
-    assert(av1_allow_intrabc(cm));
+    assert(av1_allow_intrabc(cm, xd));
     assert(is_intrabc_block(mbmi, xd->tree_type));
     av1_build_morph_pred(cm, xd, bsize, mi_row, mi_col);
   }
diff --git a/av1/encoder/segmentation.c b/av1/encoder/segmentation.c
index b8adb49..31d1ffc 100644
--- a/av1/encoder/segmentation.c
+++ b/av1/encoder/segmentation.c
@@ -63,7 +63,11 @@
   no_pred_segcounts[segment_id]++;
 
   // Temporal prediction not allowed on key frames
-  if (cm->current_frame.frame_type != KEY_FRAME) {
+  if (cm->current_frame.frame_type != KEY_FRAME
+#if CONFIG_EXTENDED_SDP
+      && xd->mi[0]->region_type != INTRA_REGION
+#endif  // CONFIG_EXTENDED_SDP
+  ) {
     const BLOCK_SIZE bsize = xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART];
     // Test to see if the segment id matches the predicted value.
     const int pred_segment_id =
diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake
index 6625c9b..8ced654 100644
--- a/build/cmake/aom_config_defaults.cmake
+++ b/build/cmake/aom_config_defaults.cmake
@@ -197,6 +197,8 @@
   "AV2 experiment flag to enable modified context derivation : CWG-B065.")
 set_aom_config_var(CONFIG_EXTENDED_WARP_PREDICTION 1
                    "AV2 experiment flag to add new local warp modes")
+set_aom_config_var(CONFIG_EXTENDED_SDP 1
+                   "Enable SDP for intra blocks in inter frame")
 # Begin: CWG-C016
 set_aom_config_var(
   CONFIG_LR_IMPROVEMENTS
diff --git a/tools/aom_entropy_optimizer.c b/tools/aom_entropy_optimizer.c
index f88324a..d53937e 100644
--- a/tools/aom_entropy_optimizer.c
+++ b/tools/aom_entropy_optimizer.c
@@ -620,6 +620,15 @@
       "[CCTX_CONTEXTS][CDF_SIZE(CCTX_TYPES)]",
       0, &total_count, 0, mem_wanted, "Transforms");
 
+#if CONFIG_INTER_SDP
+  cts_each_dim[0] = INTER_SDP_BSIZE_GROUP;
+  cts_each_dim[1] = REGION_TYPES;
+  optimize_cdf_table(&fc.region_type[0][0], probsfile, 2, cts_each_dim,
+                     "static aom_cdf_prob default_region_type_cdf"
+                     "[INTER_SDP_BSIZE_GROUP][CDF_SIZE(2)]",
+                     0, &total_count, 0, mem_wanted, "Partitions");
+#endif  // CONFIG_INTER_SDP
+
 #if CONFIG_EXT_RECUR_PARTITIONS
   cts_each_dim[0] = PARTITION_STRUCTURE_NUM;
   cts_each_dim[1] = PARTITION_CONTEXTS;