diff --git a/av1/common/entropy.c b/av1/common/entropy.c
index 2e1eb01..94dbcc2 100644
--- a/av1/common/entropy.c
+++ b/av1/common/entropy.c
@@ -202,11 +202,6 @@
 #endif
   RESET_CDF_COUNTER(fc->switchable_interp_cdf, SWITCHABLE_FILTERS);
   RESET_CDF_COUNTER(fc->kf_y_cdf, INTRA_MODES);
-#if CONFIG_ORIP
-  RESET_CDF_COUNTER(fc->angle_delta_cdf_hv,
-                    2 * MAX_ANGLE_DELTA + 1 + ADDITIONAL_ANGLE_DELTA);
-#endif
-
   RESET_CDF_COUNTER(fc->angle_delta_cdf, 2 * MAX_ANGLE_DELTA + 1);
 #if CONFIG_NEW_TX_PARTITION
   RESET_CDF_COUNTER(fc->intra_4way_txfm_partition_cdf[0], 4);
diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index 93392c8..e2c37ca 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -100,22 +100,6 @@
         { AOM_CDF7(2240, 11096, 15453, 20341, 22561, 28917) },
         { AOM_CDF7(3605, 10428, 12459, 17676, 21244, 30655) } }
     };
-
-#if CONFIG_ORIP
-static const aom_cdf_prob default_angle_delta_cdf_hv
-    [PARTITION_STRUCTURE_NUM][TOTAL_NUM_ORIP_ANGLE_DELTA]
-    [CDF_SIZE(2 * MAX_ANGLE_DELTA + 1 + ADDITIONAL_ANGLE_DELTA)] = {
-      {
-          { AOM_CDF8(1180, 3032, 4567, 19776, 22989, 25217, 26639) },
-          { AOM_CDF8(1301, 3608, 5801, 20487, 22974, 25330, 26371) },
-      },
-      {
-          { AOM_CDF8(1180, 3032, 4567, 19776, 22989, 25217, 26639) },
-          { AOM_CDF8(1301, 3608, 5801, 20487, 22974, 25330, 26371) },
-      }
-    };
-
-#endif
 #else
 static const aom_cdf_prob default_angle_delta_cdf[DIRECTIONAL_MODES][CDF_SIZE(
     2 * MAX_ANGLE_DELTA + 1)] = {
@@ -128,15 +112,6 @@
   { AOM_CDF7(2240, 11096, 15453, 20341, 22561, 28917) },
   { AOM_CDF7(3605, 10428, 12459, 17676, 21244, 30655) }
 };
-#if CONFIG_ORIP
-static const aom_cdf_prob
-    default_angle_delta_cdf_hv[TOTAL_NUM_ORIP_ANGLE_DELTA][CDF_SIZE(
-        2 * MAX_ANGLE_DELTA + 1 + ADDITIONAL_ANGLE_DELTA)] = {
-      { AOM_CDF8(1180, 3032, 4567, 19776, 22989, 25217, 26639) },
-      { AOM_CDF8(1301, 3608, 5801, 20487, 22974, 25330, 26371) },
-    };
-
-#endif
 #endif
 
 static const aom_cdf_prob default_if_y_mode_cdf[BLOCK_SIZE_GROUPS][CDF_SIZE(
@@ -1392,9 +1367,6 @@
   av1_copy(fc->palette_y_color_index_cdf, default_palette_y_color_index_cdf);
   av1_copy(fc->palette_uv_color_index_cdf, default_palette_uv_color_index_cdf);
   av1_copy(fc->kf_y_cdf, default_kf_y_mode_cdf);
-#if CONFIG_ORIP
-  av1_copy(fc->angle_delta_cdf_hv, default_angle_delta_cdf_hv);
-#endif
   av1_copy(fc->angle_delta_cdf, default_angle_delta_cdf);
   av1_copy(fc->comp_inter_cdf, default_comp_inter_cdf);
   av1_copy(fc->comp_ref_type_cdf, default_comp_ref_type_cdf);
diff --git a/av1/common/entropymode.h b/av1/common/entropymode.h
index fcbe79e..612123b 100644
--- a/av1/common/entropymode.h
+++ b/av1/common/entropymode.h
@@ -181,19 +181,9 @@
 #if CONFIG_SDP
   aom_cdf_prob angle_delta_cdf[PARTITION_STRUCTURE_NUM][DIRECTIONAL_MODES]
                               [CDF_SIZE(2 * MAX_ANGLE_DELTA + 1)];
-#if CONFIG_ORIP
-  aom_cdf_prob angle_delta_cdf_hv[PARTITION_STRUCTURE_NUM]
-                                 [TOTAL_NUM_ORIP_ANGLE_DELTA]
-                                 [CDF_SIZE(2 * MAX_ANGLE_DELTA + 1 +
-                                           ADDITIONAL_ANGLE_DELTA)];
-#endif
 #else
   aom_cdf_prob angle_delta_cdf[DIRECTIONAL_MODES]
                               [CDF_SIZE(2 * MAX_ANGLE_DELTA + 1)];
-#if CONFIG_ORIP
-  aom_cdf_prob angle_delta_cdf_hv[TOTAL_NUM_ORIP_ANGLE_DELTA][CDF_SIZE(
-      2 * MAX_ANGLE_DELTA + 1 + ADDITIONAL_ANGLE_DELTA)];
-#endif
 #endif
 
 #if CONFIG_NEW_TX_PARTITION
diff --git a/av1/common/enums.h b/av1/common/enums.h
index 555e378..5e1fa63 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -650,12 +650,6 @@
 #define MAX_ANGLE_DELTA 3
 #define ANGLE_STEP 3
 
-#if CONFIG_ORIP
-#define ADDITIONAL_ANGLE_DELTA 1
-#define TOTAL_NUM_ORIP_ANGLE_DELTA 2
-#define ANGLE_DELTA_VALUE_ORIP (MAX_ANGLE_DELTA + 1)
-#endif
-
 #define INTER_SINGLE_MODES SINGLE_INTER_MODE_NUM
 #define INTER_COMPOUND_MODES COMP_INTER_MODE_NUM
 
diff --git a/av1/common/reconinter.c b/av1/common/reconinter.c
index efd8b6d..77ab9d8 100644
--- a/av1/common/reconinter.c
+++ b/av1/common/reconinter.c
@@ -2518,12 +2518,7 @@
   av1_predict_intra_block(cm, xd, pd->width, pd->height,
                           max_txsize_rect_lookup[plane_bsize], mode, 0, 0,
                           FILTER_INTRA_MODES, ctx->plane[plane],
-                          ctx->stride[plane], dst, dst_stride, 0, 0,
-#if CONFIG_ORIP
-                          plane, 0);
-#else
-                          plane);
-#endif
+                          ctx->stride[plane], dst, dst_stride, 0, 0, plane);
 }
 
 void av1_combine_interintra(MACROBLOCKD *xd, BLOCK_SIZE bsize, int plane,
diff --git a/av1/common/reconintra.c b/av1/common/reconintra.c
index baf33cd..da53b8c 100644
--- a/av1/common/reconintra.c
+++ b/av1/common/reconintra.c
@@ -1430,7 +1430,6 @@
 #endif
 #if CONFIG_ORIP
     ,
-    const int disable_intra_pred_filter_for_hor_ver_mode,
     const int seq_intra_pred_filter_flag
 #endif
 #if CONFIG_IBP_DIR || CONFIG_IBP_DC
@@ -1525,8 +1524,7 @@
 
 #if CONFIG_ORIP && !CONFIG_ORIP_NONDC_DISABLED
     if (apply_sub_block_based_refinement_filter &&
-        (p_angle == 90 || p_angle == 180) &&
-        !disable_intra_pred_filter_for_hor_ver_mode) {
+        (p_angle == 90 || p_angle == 180)) {
       need_above = 1;
       need_left = 1;
       need_above_left = 1;
@@ -1780,9 +1778,8 @@
 #if CONFIG_ORIP
 #if !CONFIG_ORIP_NONDC_DISABLED
     // Apply sub-block based filter for horizontal/vertical intra mode
-    apply_sub_block_based_refinement_filter &=
-        av1_allow_orip_dir(p_angle, disable_intra_pred_filter_for_hor_ver_mode);
-    if (apply_sub_block_based_refinement_filter) {
+    if (apply_sub_block_based_refinement_filter &&
+        av1_allow_orip_dir(p_angle)) {
       av1_apply_orip_4x4subblock_hbd(dst, dst_stride, tx_size, above_row,
                                      left_col, mode, xd->bd);
     }
@@ -1829,7 +1826,6 @@
 #endif
 #if CONFIG_ORIP
     ,
-    const int disable_intra_pred_filter_for_hor_ver_mode,
     const int seq_intra_pred_filter_flag
 #endif
 #if CONFIG_IBP_DIR || CONFIG_IBP_DC
@@ -1922,8 +1918,7 @@
 
 #if CONFIG_ORIP && !CONFIG_ORIP_NONDC_DISABLED
     if (apply_sub_block_based_refinement_filter &&
-        (p_angle == 90 || p_angle == 180) &&
-        !disable_intra_pred_filter_for_hor_ver_mode) {
+        (p_angle == 90 || p_angle == 180)) {
       need_above = 1;
       need_left = 1;
       need_above_left = 1;
@@ -2173,9 +2168,8 @@
 #if CONFIG_ORIP
 #if !CONFIG_ORIP_NONDC_DISABLED
     // Apply sub-block based filter for horizontal/vertical intra mode
-    apply_sub_block_based_refinement_filter &=
-        av1_allow_orip_dir(p_angle, disable_intra_pred_filter_for_hor_ver_mode);
-    if (apply_sub_block_based_refinement_filter) {
+    if (apply_sub_block_based_refinement_filter &&
+        av1_allow_orip_dir(p_angle)) {
       av1_apply_orip_4x4subblock(dst, dst_stride, tx_size, above_row, left_col,
                                  mode);
     }
@@ -2264,12 +2258,7 @@
     const AV1_COMMON *cm, const MACROBLOCKD *xd, int wpx, int hpx,
     TX_SIZE tx_size, PREDICTION_MODE mode, int angle_delta, int use_palette,
     FILTER_INTRA_MODE filter_intra_mode, const uint8_t *ref, int ref_stride,
-    uint8_t *dst, int dst_stride, int col_off, int row_off, int plane
-#if CONFIG_ORIP
-    ,
-    const int disable_intra_pred_filter_for_hor_ver_mode
-#endif
-) {
+    uint8_t *dst, int dst_stride, int col_off, int row_off, int plane) {
   const MB_MODE_INFO *const mbmi = xd->mi[0];
   const int txwpx = tx_size_wide[tx_size];
   const int txhpx = tx_size_high[tx_size];
@@ -2349,55 +2338,55 @@
 #endif
 
   if (is_cur_buf_hbd(xd)) {
-    build_intra_predictors_high(
-        xd, ref, ref_stride, dst, dst_stride, mode, angle_delta,
-        filter_intra_mode, tx_size, disable_edge_filter,
-        have_top ? AOMMIN(txwpx, xr + txwpx) : 0,
-        have_top_right ? AOMMIN(txwpx, xr) : 0,
-        have_left ? AOMMIN(txhpx, yd + txhpx) : 0,
-        have_bottom_left ? AOMMIN(txhpx, yd) : 0, plane
+    build_intra_predictors_high(xd, ref, ref_stride, dst, dst_stride, mode,
+                                angle_delta, filter_intra_mode, tx_size,
+                                disable_edge_filter,
+                                have_top ? AOMMIN(txwpx, xr + txwpx) : 0,
+                                have_top_right ? AOMMIN(txwpx, xr) : 0,
+                                have_left ? AOMMIN(txhpx, yd + txhpx) : 0,
+                                have_bottom_left ? AOMMIN(txhpx, yd) : 0, plane
 #if CONFIG_MRLS
-        ,
-        is_sb_boundary
+                                ,
+                                is_sb_boundary
 #endif
 #if CONFIG_ORIP
-        ,
-        disable_intra_pred_filter_for_hor_ver_mode, cm->seq_params.enable_orip
+                                ,
+                                cm->seq_params.enable_orip
 #endif
 #if CONFIG_IBP_DIR || CONFIG_IBP_DC
-        ,
-        cm->seq_params.enable_ibp
+                                ,
+                                cm->seq_params.enable_ibp
 #endif
 #if CONFIG_IBP_DIR
-        ,
-        cm->ibp_directional_weights
+                                ,
+                                cm->ibp_directional_weights
 #endif
     );
     return;
   }
 
-  build_intra_predictors(
-      xd, ref, ref_stride, dst, dst_stride, mode, angle_delta,
-      filter_intra_mode, tx_size, disable_edge_filter,
-      have_top ? AOMMIN(txwpx, xr + txwpx) : 0,
-      have_top_right ? AOMMIN(txwpx, xr) : 0,
-      have_left ? AOMMIN(txhpx, yd + txhpx) : 0,
-      have_bottom_left ? AOMMIN(txhpx, yd) : 0, plane
+  build_intra_predictors(xd, ref, ref_stride, dst, dst_stride, mode,
+                         angle_delta, filter_intra_mode, tx_size,
+                         disable_edge_filter,
+                         have_top ? AOMMIN(txwpx, xr + txwpx) : 0,
+                         have_top_right ? AOMMIN(txwpx, xr) : 0,
+                         have_left ? AOMMIN(txhpx, yd + txhpx) : 0,
+                         have_bottom_left ? AOMMIN(txhpx, yd) : 0, plane
 #if CONFIG_MRLS
-      ,
-      is_sb_boundary
+                         ,
+                         is_sb_boundary
 #endif
 #if CONFIG_ORIP
-      ,
-      disable_intra_pred_filter_for_hor_ver_mode, cm->seq_params.enable_orip
+                         ,
+                         cm->seq_params.enable_orip
 #endif
 #if CONFIG_IBP_DIR || CONFIG_IBP_DC
-      ,
-      cm->seq_params.enable_ibp
+                         ,
+                         cm->seq_params.enable_ibp
 #endif
 #if CONFIG_IBP_DIR
-      ,
-      cm->ibp_directional_weights
+                         ,
+                         cm->ibp_directional_weights
 #endif
   );
 }
@@ -2417,34 +2406,7 @@
           ? mbmi->filter_intra_mode_info.filter_intra_mode
           : FILTER_INTRA_MODES;
 
-#if CONFIG_ORIP
-#if CONFIG_SDP
-  const BLOCK_SIZE bsize = mbmi->sb_type[AOM_PLANE_Y];
-#else
-  const BLOCK_SIZE bsize = mbmi->sb_type;
-#endif
-  const int angle_delta =
-      cm->seq_params.enable_orip
-          ? ((mbmi->angle_delta[plane != AOM_PLANE_Y] == ANGLE_DELTA_VALUE_ORIP)
-                 ? 0
-                 : mbmi->angle_delta[plane != AOM_PLANE_Y] * ANGLE_STEP)
-          : mbmi->angle_delta[plane != AOM_PLANE_Y] * ANGLE_STEP;
-  const int disable_intra_pred_filter_for_hor_ver_mode =
-      cm->seq_params.enable_orip
-          ? ((mbmi->angle_delta[plane != AOM_PLANE_Y] == ANGLE_DELTA_VALUE_ORIP)
-                 ? 1
-                 : 0)
-          : 1;
-  if (cm->seq_params.enable_orip) {
-    int violate_orip = disable_intra_pred_filter_for_hor_ver_mode;
-    violate_orip &= !av1_signal_orip_for_horver_modes(
-        cm, mbmi, plane != AOM_PLANE_Y, bsize);
-    assert(violate_orip == 0);
-  }
-
-#else
   const int angle_delta = mbmi->angle_delta[plane != AOM_PLANE_Y] * ANGLE_STEP;
-#endif
 
   if (plane != AOM_PLANE_Y && mbmi->uv_mode == UV_CFL_PRED) {
 #if CONFIG_DEBUG
@@ -2471,13 +2433,7 @@
       av1_predict_intra_block(cm, xd, pd->width, pd->height, tx_size, mode,
                               angle_delta, use_palette, filter_intra_mode, dst,
                               dst_stride, dst, dst_stride, blk_col, blk_row,
-#if CONFIG_ORIP
-                              plane,
-                              disable_intra_pred_filter_for_hor_ver_mode);
-#else
                               plane);
-#endif
-
       if (cfl->use_dc_pred_cache) {
         cfl_store_dc_pred(xd, dst, pred_plane, tx_size_wide[tx_size]);
         cfl->dc_pred_is_cached[pred_plane] = 1;
@@ -2499,12 +2455,7 @@
 
   av1_predict_intra_block(cm, xd, pd->width, pd->height, tx_size, mode,
                           angle_delta, use_palette, filter_intra_mode, dst,
-#if CONFIG_ORIP
-                          dst_stride, dst, dst_stride, blk_col, blk_row, plane,
-                          disable_intra_pred_filter_for_hor_ver_mode);
-#else
                           dst_stride, dst, dst_stride, blk_col, blk_row, plane);
-#endif
 }
 
 void av1_init_intra_predictors(void) {
diff --git a/av1/common/reconintra.h b/av1/common/reconintra.h
index a8b7abb..fd6e268 100644
--- a/av1/common/reconintra.h
+++ b/av1/common/reconintra.h
@@ -27,20 +27,11 @@
 void av1_predict_intra_block_facade(const AV1_COMMON *cm, MACROBLOCKD *xd,
                                     int plane, int blk_col, int blk_row,
                                     TX_SIZE tx_size);
-#if CONFIG_ORIP
-void av1_predict_intra_block(
-    const AV1_COMMON *cm, const MACROBLOCKD *xd, int wpx, int hpx,
-    TX_SIZE tx_size, PREDICTION_MODE mode, int angle_delta, int use_palette,
-    FILTER_INTRA_MODE filter_intra_mode, const uint8_t *ref, int ref_stride,
-    uint8_t *dst, int dst_stride, int col_off, int row_off, int plane,
-    const int disable_intra_pred_filter_for_hor_ver_mode);
-#else
 void av1_predict_intra_block(
     const AV1_COMMON *cm, const MACROBLOCKD *xd, int wpx, int hpx,
     TX_SIZE tx_size, PREDICTION_MODE mode, int angle_delta, int use_palette,
     FILTER_INTRA_MODE filter_intra_mode, const uint8_t *ref, int ref_stride,
     uint8_t *dst, int dst_stride, int col_off, int row_off, int plane);
-#endif
 
 #if CONFIG_ORIP
 void av1_apply_orip_4x4subblock_hbd(uint16_t *dst, ptrdiff_t stride,
@@ -123,8 +114,8 @@
 #endif
 #endif
 }
-static INLINE int av1_allow_orip_dir(int p_angle, int disable_filter) {
-  return (!disable_filter && (p_angle == 90 || p_angle == 180));
+static INLINE int av1_allow_orip_dir(int p_angle) {
+  return (p_angle == 90 || p_angle == 180);
 }
 #endif
 
@@ -202,47 +193,6 @@
   return type ? (blk_wh <= 8) : (blk_wh <= 16);
 }
 
-#if CONFIG_ORIP
-// This function returns if enable/disable ORIP is signalled in the bitstream
-// 1 means signal; 0 means does not signal
-static INLINE int av1_signal_orip_for_horver_modes(const AV1_COMMON *cm,
-                                                   const MB_MODE_INFO *mbmi,
-                                                   PLANE_TYPE plane,
-                                                   BLOCK_SIZE bsize) {
-#if CONFIG_ORIP_NONDC_DISABLED
-  return 0;
-#endif
-  if (!cm->seq_params.enable_orip) return 0;
-
-#if CONFIG_SDP
-  const int use_intrabc = mbmi->use_intrabc[PLANE_TYPE_Y];
-  const int is_inter = is_inter_block(mbmi, SHARED_PART);
-#else
-  const int use_intrabc = mbmi->use_intrabc;
-  const int is_inter = is_inter_block(mbmi);
-#endif
-
-  if (plane != PLANE_TYPE_Y || is_inter || use_intrabc) return 0;
-  if (!av1_use_angle_delta(bsize)) return 0;
-
-#if CONFIG_MRLS
-  if (mbmi->mrl_index) return 0;
-#endif
-
-  if (mbmi->mode == V_PRED || mbmi->mode == H_PRED) return 1;
-  return 0;
-}
-
-static INLINE int get_angle_delta_to_idx(int angle_delta) {
-  return (MAX_ANGLE_DELTA + angle_delta);
-}
-
-static INLINE int get_idx_to_angle_delta(int index) {
-  return (index - MAX_ANGLE_DELTA);
-}
-
-#endif
-
 #if CONFIG_IBP_DIR
 static const int32_t transpose_tx_size[TX_SIZES_ALL] = {
   TX_4X4,  TX_8X8,  TX_16X16, TX_32X32, TX_64X64, TX_8X4,   TX_4X8,
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 7cfc173..b3519dc 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -754,14 +754,6 @@
   }
 }
 
-#if CONFIG_ORIP
-static int read_angle_delta_hv(aom_reader *r, aom_cdf_prob *cdf) {
-  const int sym = aom_read_symbol(
-      r, cdf, 2 * MAX_ANGLE_DELTA + 1 + ADDITIONAL_ANGLE_DELTA, ACCT_STR);
-  return get_idx_to_angle_delta(sym);
-}
-#endif
-
 static int read_angle_delta(aom_reader *r, aom_cdf_prob *cdf) {
   const int sym = aom_read_symbol(r, cdf, 2 * MAX_ANGLE_DELTA + 1, ACCT_STR);
   return sym - MAX_ANGLE_DELTA;
@@ -1118,61 +1110,24 @@
   if (xd->tree_type != CHROMA_PART) {
 #endif  // CONFIG_SDP
     mbmi->mode = read_intra_mode(r, get_y_mode_cdf(ec_ctx, above_mi, left_mi));
-#if CONFIG_ORIP
-#if CONFIG_MRLS
-    // when both ORIP and MRLS are enabled, mrl index are signalled right after
-    // intra mode and before angle delta
-    // Parsing reference line index
-    mbmi->mrl_index =
-        (cm->seq_params.enable_mrls && av1_is_directional_mode(mbmi->mode))
-            ? read_mrl_index(ec_ctx, r)
-            : 0;
-#endif  // CONFIG_MRLS
-
-    if (use_angle_delta && av1_is_directional_mode(mbmi->mode)) {
-      int signal_intra_filter =
-          av1_signal_orip_for_horver_modes(cm, mbmi, PLANE_TYPE_Y, bsize);
-      aom_cdf_prob *anglecdf =
-          signal_intra_filter
 #if CONFIG_SDP
-              ? ec_ctx->angle_delta_cdf_hv[PLANE_TYPE_Y][mbmi->mode - V_PRED]
-              : ec_ctx->angle_delta_cdf[PLANE_TYPE_Y][mbmi->mode - V_PRED];
+    mbmi->angle_delta[PLANE_TYPE_Y] =
+        (use_angle_delta && av1_is_directional_mode(mbmi->mode))
+            ? read_angle_delta(
+                  r, ec_ctx->angle_delta_cdf[PLANE_TYPE_Y][mbmi->mode - V_PRED])
+            : 0;
 #else
-              ? ec_ctx->angle_delta_cdf_hv[mbmi->mode - V_PRED]
-              : ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED];
-#endif  // CONFIG_SDP
-
-      mbmi->angle_delta[PLANE_TYPE_Y] = signal_intra_filter
-                                            ? read_angle_delta_hv(r, anglecdf)
-                                            : read_angle_delta(r, anglecdf);
-    } else {
-      mbmi->angle_delta[PLANE_TYPE_Y] = 0;
-    }
-#elif CONFIG_SDP
   mbmi->angle_delta[PLANE_TYPE_Y] =
       (use_angle_delta && av1_is_directional_mode(mbmi->mode))
-          ? read_angle_delta(
-                r, ec_ctx->angle_delta_cdf[PLANE_TYPE_Y][mbmi->mode - V_PRED])
+          ? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED])
           : 0;
-#else
-mbmi->angle_delta[PLANE_TYPE_Y] =
-    (use_angle_delta && av1_is_directional_mode(mbmi->mode))
-        ? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED])
-        : 0;
-#endif  // CONFIG_ORIP
-
-#if CONFIG_MRLS && !CONFIG_ORIP
-    // When both ORIP and MRLS are enabled, mrl index are signalled right after
-    // intra mode and before angle delta
-    // However when MRLS is enabled but ORIP is disabled, mrl_index is signalled
-    // here ( after angle delta)
-    // Parsing reference line index
+#endif  // CONFIG_SDP
+#if CONFIG_MRLS
     mbmi->mrl_index =
         (cm->seq_params.enable_mrls && av1_is_directional_mode(mbmi->mode))
             ? read_mrl_index(ec_ctx, r)
             : 0;
 #endif
-
 #if CONFIG_SDP
   }
 #endif  // CONFIG_SDP
@@ -1492,37 +1447,7 @@
 
   mbmi->mode = read_intra_mode(r, ec_ctx->y_mode_cdf[size_group_lookup[bsize]]);
 
-#if CONFIG_MRLS && CONFIG_ORIP
 #if CONFIG_SDP
-  if (xd->tree_type != CHROMA_PART)
-#endif
-    // Parsing reference line index
-    mbmi->mrl_index =
-        (cm->seq_params.enable_mrls && av1_is_directional_mode(mbmi->mode))
-            ? read_mrl_index(ec_ctx, r)
-            : 0;
-#endif
-
-#if CONFIG_ORIP
-  if (use_angle_delta && av1_is_directional_mode(mbmi->mode)) {
-    int signal_intra_filter =
-        av1_signal_orip_for_horver_modes(cm, mbmi, PLANE_TYPE_Y, bsize);
-    aom_cdf_prob *anglecdf =
-        signal_intra_filter
-#if CONFIG_SDP
-            ? ec_ctx->angle_delta_cdf_hv[PLANE_TYPE_Y][mbmi->mode - V_PRED]
-            : ec_ctx->angle_delta_cdf[PLANE_TYPE_Y][mbmi->mode - V_PRED];
-#else
-            ? ec_ctx->angle_delta_cdf_hv[mbmi->mode - V_PRED]
-            : ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED];
-#endif
-    mbmi->angle_delta[PLANE_TYPE_Y] = signal_intra_filter
-                                          ? read_angle_delta_hv(r, anglecdf)
-                                          : read_angle_delta(r, anglecdf);
-  } else {
-    mbmi->angle_delta[PLANE_TYPE_Y] = 0;
-  }
-#elif CONFIG_SDP
   mbmi->angle_delta[PLANE_TYPE_Y] =
       use_angle_delta && av1_is_directional_mode(mbmi->mode)
           ? read_angle_delta(
@@ -1533,9 +1458,9 @@
       use_angle_delta && av1_is_directional_mode(mbmi->mode)
           ? read_angle_delta(r, ec_ctx->angle_delta_cdf[mbmi->mode - V_PRED])
           : 0;
-#endif  // CONFIG_ORIP
+#endif  // CONFIG_SDP
 
-#if CONFIG_MRLS && !CONFIG_ORIP
+#if CONFIG_MRLS
 #if CONFIG_SDP
   if (xd->tree_type != CHROMA_PART)
 #endif
@@ -1544,7 +1469,7 @@
         (cm->seq_params.enable_mrls && av1_is_directional_mode(mbmi->mode))
             ? read_mrl_index(ec_ctx, r)
             : 0;
-#endif
+#endif  // CONFIG_MRLS
 
   if (!cm->seq_params.monochrome && xd->is_chroma_ref) {
     mbmi->uv_mode =
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 509e679..1926bb9 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -841,14 +841,6 @@
   }
 }
 
-#if CONFIG_ORIP
-static AOM_INLINE void write_angle_delta_hv(aom_writer *w, int angle_delta,
-                                            aom_cdf_prob *cdf) {
-  aom_write_symbol(w, get_angle_delta_to_idx(angle_delta), cdf,
-                   2 * MAX_ANGLE_DELTA + 1 + ADDITIONAL_ANGLE_DELTA);
-}
-#endif
-
 static AOM_INLINE void write_angle_delta(aom_writer *w, int angle_delta,
                                          aom_cdf_prob *cdf) {
   aom_write_symbol(w, angle_delta + MAX_ANGLE_DELTA, cdf,
@@ -1408,46 +1400,17 @@
       write_intra_y_mode_nonkf(ec_ctx, bsize, mode, w);
     }
 
-#if CONFIG_MRLS && CONFIG_ORIP
-    // Encoding reference line index before angle delta if ORIP is enable
-    if (cm->seq_params.enable_mrls && av1_is_directional_mode(mode)) {
-      write_mrl_index(ec_ctx, mbmi->mrl_index, w);
-    }
-#endif
-
     // Y angle delta.
-#if !CONFIG_SDP
-    const int use_angle_delta = av1_use_angle_delta(bsize);
-#endif
     if (use_angle_delta && av1_is_directional_mode(mode)) {
-#if CONFIG_ORIP
-      int signal_intra_filter =
-          av1_signal_orip_for_horver_modes(cm, mbmi, PLANE_TYPE_Y, bsize);
-      aom_cdf_prob *cdf_angle =
-          signal_intra_filter
 #if CONFIG_SDP
-              ? ec_ctx->angle_delta_cdf_hv[PLANE_TYPE_Y][mode - V_PRED]
-              : ec_ctx->angle_delta_cdf[PLANE_TYPE_Y][mode - V_PRED];
-#else
-              ? ec_ctx->angle_delta_cdf_hv[mode - V_PRED]
-              : ec_ctx->angle_delta_cdf[mode - V_PRED];
-
-#endif  // CONFIG_SDP
-      assert(mbmi->angle_delta[PLANE_TYPE_Y] >= -3 &&
-             mbmi->angle_delta[PLANE_TYPE_Y] <= ANGLE_DELTA_VALUE_ORIP);
-      if (signal_intra_filter)
-        write_angle_delta_hv(w, mbmi->angle_delta[PLANE_TYPE_Y], cdf_angle);
-      else
-        write_angle_delta(w, mbmi->angle_delta[PLANE_TYPE_Y], cdf_angle);
-#elif CONFIG_SDP
-    write_angle_delta(w, mbmi->angle_delta[PLANE_TYPE_Y],
-                      ec_ctx->angle_delta_cdf[PLANE_TYPE_Y][mode - V_PRED]);
+      write_angle_delta(w, mbmi->angle_delta[PLANE_TYPE_Y],
+                        ec_ctx->angle_delta_cdf[PLANE_TYPE_Y][mode - V_PRED]);
 #else
     write_angle_delta(w, mbmi->angle_delta[PLANE_TYPE_Y],
                       ec_ctx->angle_delta_cdf[mode - V_PRED]);
-#endif  // CONFIG_ORIP
+#endif  // CONFIG_SDP
     }
-#if CONFIG_MRLS && !CONFIG_ORIP
+#if CONFIG_MRLS
     // Encoding reference line index
     if (cm->seq_params.enable_mrls && av1_is_directional_mode(mode)) {
       write_mrl_index(ec_ctx, mbmi->mrl_index, w);
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 2b93cb4..3915901 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -628,17 +628,7 @@
   //! angle_delta_cost
   int angle_delta_cost[PARTITION_STRUCTURE_NUM][DIRECTIONAL_MODES]
                       [2 * MAX_ANGLE_DELTA + 1];
-#if CONFIG_ORIP
-  //! angle_delta_cost_hv
-  int angle_delta_cost_hv[PARTITION_STRUCTURE_NUM][TOTAL_NUM_ORIP_ANGLE_DELTA]
-                         [2 * MAX_ANGLE_DELTA + 1 + ADDITIONAL_ANGLE_DELTA];
-#endif
 #else
-#if CONFIG_ORIP
-  //! angle_delta_cost_hv
-  int angle_delta_cost_hv[TOTAL_NUM_ORIP_ANGLE_DELTA]
-                         [2 * MAX_ANGLE_DELTA + 1 + ADDITIONAL_ANGLE_DELTA];
-#endif
   //! angle_delta_cost
   int angle_delta_cost[DIRECTIONAL_MODES][2 * MAX_ANGLE_DELTA + 1];
 #endif
diff --git a/av1/encoder/encodeframe_utils.c b/av1/encoder/encodeframe_utils.c
index 06adc08..fba9943 100644
--- a/av1/encoder/encodeframe_utils.c
+++ b/av1/encoder/encodeframe_utils.c
@@ -589,30 +589,13 @@
                            [mbmi->angle_delta[PLANE_TYPE_Y] + MAX_ANGLE_DELTA];
 #endif
 
-#if CONFIG_ORIP
-      int signal_intra_filter =
-          av1_signal_orip_for_horver_modes(cm, mbmi, PLANE_TYPE_Y, bsize);
-      if (signal_intra_filter) {
 #if CONFIG_SDP
-        update_cdf(fc->angle_delta_cdf_hv[PLANE_TYPE_Y][mbmi->mode - V_PRED],
-#else
-        update_cdf(fc->angle_delta_cdf_hv[mbmi->mode - V_PRED],
-#endif
-                   get_angle_delta_to_idx(mbmi->angle_delta[PLANE_TYPE_Y]),
-                   2 * MAX_ANGLE_DELTA + 1 + ADDITIONAL_ANGLE_DELTA);
-      } else {
-#endif
-#if CONFIG_SDP
-        update_cdf(fc->angle_delta_cdf[PLANE_TYPE_Y][mbmi->mode - V_PRED],
+      update_cdf(fc->angle_delta_cdf[PLANE_TYPE_Y][mbmi->mode - V_PRED],
 #else
     update_cdf(fc->angle_delta_cdf[mbmi->mode - V_PRED],
 #endif
-                   mbmi->angle_delta[PLANE_TYPE_Y] + MAX_ANGLE_DELTA,
-                   2 * MAX_ANGLE_DELTA + 1);
-
-#if CONFIG_ORIP
-      }
-#endif
+                 mbmi->angle_delta[PLANE_TYPE_Y] + MAX_ANGLE_DELTA,
+                 2 * MAX_ANGLE_DELTA + 1);
     }
 #if CONFIG_SDP
   }
@@ -1353,10 +1336,7 @@
   AVERAGE_CDF(ctx_left->kf_y_cdf, ctx_tr->kf_y_cdf, INTRA_MODES);
   AVERAGE_CDF(ctx_left->angle_delta_cdf, ctx_tr->angle_delta_cdf,
               2 * MAX_ANGLE_DELTA + 1);
-#if CONFIG_ORIP
-  AVERAGE_CDF(ctx_left->angle_delta_cdf_hv, ctx_tr->angle_delta_cdf_hv,
-              2 * MAX_ANGLE_DELTA + 1 + ADDITIONAL_ANGLE_DELTA);
-#endif
+
 #if CONFIG_NEW_TX_PARTITION
   // Square blocks
   AVERAGE_CDF(ctx_left->intra_4way_txfm_partition_cdf[0],
diff --git a/av1/encoder/intra_mode_search.c b/av1/encoder/intra_mode_search.c
index 0073ad6..782afbc 100644
--- a/av1/encoder/intra_mode_search.c
+++ b/av1/encoder/intra_mode_search.c
@@ -180,14 +180,6 @@
  *                                  the mode info for the current macroblock.
  */
 void set_y_mode_and_delta_angle(const int mode_idx, MB_MODE_INFO *const mbmi) {
-#if CONFIG_ORIP
-  if (mode_idx >= LUMA_MODE_COUNT) {
-    mbmi->mode = (mode_idx == LUMA_MODE_COUNT) ? H_PRED : V_PRED;
-    mbmi->angle_delta[PLANE_TYPE_Y] = ANGLE_DELTA_VALUE_ORIP;
-    return;
-  }
-#endif
-
   if (mode_idx < INTRA_MODE_END) {
     mbmi->mode = intra_rd_search_mode_order[mode_idx];
     mbmi->angle_delta[PLANE_TYPE_Y] = 0;
@@ -1112,16 +1104,8 @@
     mbmi->mrl_index = mrl_idx;
 #endif
 
-#if CONFIG_ORIP && !CONFIG_ORIP_NONDC_DISABLED
-    int total_num_mode = cpi->common.seq_params.enable_orip
-                             ? (LUMA_MODE_COUNT + TOTAL_NUM_ORIP_ANGLE_DELTA)
-                             : LUMA_MODE_COUNT;
-    for (int mode_idx = INTRA_MODE_START; mode_idx < total_num_mode;
+    for (int mode_idx = INTRA_MODE_START; mode_idx < LUMA_MODE_COUNT;
          ++mode_idx) {
-#else
-  for (int mode_idx = INTRA_MODE_START; mode_idx < LUMA_MODE_COUNT;
-       ++mode_idx) {
-#endif
       set_y_mode_and_delta_angle(mode_idx, mbmi);
       RD_STATS this_rd_stats;
       int this_rate, this_rate_tokenonly, s;
@@ -1141,23 +1125,6 @@
       if (is_directional_mode && directional_mode_skip_mask[mbmi->mode])
         continue;
 
-#if CONFIG_ORIP
-      int signal_intra_filter = av1_signal_orip_for_horver_modes(
-          &cpi->common, mbmi, PLANE_TYPE_Y, bsize);
-      if (!signal_intra_filter &&
-          mbmi->angle_delta[PLANE_TYPE_Y] == ANGLE_DELTA_VALUE_ORIP)
-        continue;
-      if (mbmi->angle_delta[PLANE_TYPE_Y] == ANGLE_DELTA_VALUE_ORIP) {
-        if (mbmi->mode == H_PRED && best_mbmi.mode != H_PRED) {
-          continue;
-        } else if (mbmi->mode == V_PRED && best_mbmi.mode != V_PRED) {
-          continue;
-        } else if (best_mbmi.angle_delta[PLANE_TYPE_Y]) {
-          continue;
-        }
-      }
-#endif
-
 #if CONFIG_MRLS
       if (!is_directional_mode && mrl_idx) continue;
       if (best_mbmi.mrl_index == 0 && mbmi->mrl_index > 1 &&
diff --git a/av1/encoder/intra_mode_search_utils.h b/av1/encoder/intra_mode_search_utils.h
index 9518cbd..e58505f 100644
--- a/av1/encoder/intra_mode_search_utils.h
+++ b/av1/encoder/intra_mode_search_utils.h
@@ -307,37 +307,16 @@
   }
   if (av1_is_directional_mode(mbmi->mode)) {
     if (av1_use_angle_delta(bsize)) {
-#if CONFIG_ORIP
-      int signal_intra_filter = av1_signal_orip_for_horver_modes(
-          &cpi->common, mbmi, PLANE_TYPE_Y, bsize);
-#endif  // CONFIG_ORIP
 #if CONFIG_SDP
-#if CONFIG_ORIP
-      if (signal_intra_filter)
-        total_rate +=
-            mode_costs
-                ->angle_delta_cost_hv[PLANE_TYPE_Y][mbmi->mode - V_PRED]
-                                     [get_angle_delta_to_idx(
-                                         mbmi->angle_delta[PLANE_TYPE_Y])];
-      else
-#endif
-        total_rate +=
-            mode_costs->angle_delta_cost[PLANE_TYPE_Y][mbmi->mode - V_PRED]
-                                        [MAX_ANGLE_DELTA +
-                                         mbmi->angle_delta[PLANE_TYPE_Y]];
+      total_rate +=
+          mode_costs->angle_delta_cost[PLANE_TYPE_Y][mbmi->mode - V_PRED]
+                                      [MAX_ANGLE_DELTA +
+                                       mbmi->angle_delta[PLANE_TYPE_Y]];
 #else
-#if CONFIG_ORIP
-      if (signal_intra_filter)
-        total_rate +=
-            mode_costs->angle_delta_cost_hv[mbmi->mode -
-                                            V_PRED][get_angle_delta_to_idx(
-                mbmi->angle_delta[PLANE_TYPE_Y])];
-      else
-#endif
-        total_rate +=
-            mode_costs->angle_delta_cost[mbmi->mode - V_PRED]
-                                        [MAX_ANGLE_DELTA +
-                                         mbmi->angle_delta[PLANE_TYPE_Y]];
+      total_rate +=
+          mode_costs->angle_delta_cost[mbmi->mode - V_PRED]
+                                      [MAX_ANGLE_DELTA +
+                                       mbmi->angle_delta[PLANE_TYPE_Y]];
 #endif
     }
   }
@@ -461,36 +440,14 @@
       cpi, bsize, x, xd, 0, 0, &this_rd_stats.rate, &this_rd_stats.dist,
       &this_rd_stats.skip_txfm, &temp_sse, NULL, NULL, NULL);
   if (av1_is_directional_mode(mbmi->mode) && av1_use_angle_delta(bsize)) {
-#if CONFIG_ORIP
-    int signal_intra_filter =
-        av1_signal_orip_for_horver_modes(cm, mbmi, PLANE_TYPE_Y, bsize);
-#endif  // CONFIG_ORIP
 #if CONFIG_SDP
-#if CONFIG_ORIP
-    if (signal_intra_filter)
-      mode_cost +=
-          mode_costs->angle_delta_cost_hv[PLANE_TYPE_Y][mbmi->mode - V_PRED]
-                                         [get_angle_delta_to_idx(
-                                             mbmi->angle_delta[PLANE_TYPE_Y])];
-    else
-#endif  // CONFIG_ORIP
-      mode_cost +=
-          mode_costs->angle_delta_cost[PLANE_TYPE_Y][mbmi->mode - V_PRED]
-                                      [MAX_ANGLE_DELTA +
-                                       mbmi->angle_delta[PLANE_TYPE_Y]];
+    mode_cost += mode_costs->angle_delta_cost[PLANE_TYPE_Y][mbmi->mode - V_PRED]
+                                             [MAX_ANGLE_DELTA +
+                                              mbmi->angle_delta[PLANE_TYPE_Y]];
 #else
-#if CONFIG_ORIP
-    if (signal_intra_filter)
-      mode_cost +=
-          mode_costs
-              ->angle_delta_cost_hv[mbmi->mode - V_PRED][get_angle_delta_to_idx(
-                  mbmi->angle_delta[PLANE_TYPE_Y])];
-    else
-#endif  // CONFIG_ORIP
-      mode_cost +=
-          mode_costs->angle_delta_cost[mbmi->mode - V_PRED]
-                                      [MAX_ANGLE_DELTA +
-                                       mbmi->angle_delta[PLANE_TYPE_Y]];
+    mode_cost += mode_costs->angle_delta_cost[mbmi->mode - V_PRED]
+                                             [MAX_ANGLE_DELTA +
+                                              mbmi->angle_delta[PLANE_TYPE_Y]];
 #endif  // CONFIG_SDP
   }
 
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index b3f29e4..f4d5ff7 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -269,28 +269,12 @@
     }
   }
 
-#if CONFIG_ORIP
-  for (i = 0; i < PARTITION_STRUCTURE_NUM; ++i) {
-    for (j = 0; j < TOTAL_NUM_ORIP_ANGLE_DELTA; ++j) {
-      av1_cost_tokens_from_cdf(mode_costs->angle_delta_cost_hv[i][j],
-                               fc->angle_delta_cdf_hv[i][j], NULL);
-    }
-  }
-#endif
-
 #else
   for (i = 0; i < DIRECTIONAL_MODES; ++i) {
     av1_cost_tokens_from_cdf(mode_costs->angle_delta_cost[i],
                              fc->angle_delta_cdf[i], NULL);
   }
-#if CONFIG_ORIP
-  for (i = 0; i < TOTAL_NUM_ORIP_ANGLE_DELTA; ++i) {
-    av1_cost_tokens_from_cdf(mode_costs->angle_delta_cost_hv[i],
-                             fc->angle_delta_cdf_hv[i], NULL);
-  }
-#endif
 #endif  // CONFIG_SDP
-
   av1_cost_tokens_from_cdf(mode_costs->intrabc_cost, fc->intrabc_cdf, NULL);
 
 #if CONFIG_IST
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index d018b19..525d0af 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -5971,18 +5971,8 @@
        mrl_index++) {
     mbmi->mrl_index = mrl_index;
 #endif
-
-#if CONFIG_ORIP && !CONFIG_ORIP_NONDC_DISABLED
-    int total_num_mode = cpi->common.seq_params.enable_orip
-                             ? (LUMA_MODE_COUNT + TOTAL_NUM_ORIP_ANGLE_DELTA)
-                             : LUMA_MODE_COUNT;
-    for (int mode_idx = INTRA_MODE_START; mode_idx < total_num_mode;
+    for (int mode_idx = INTRA_MODE_START; mode_idx < LUMA_MODE_COUNT;
          ++mode_idx) {
-#else
-
-  for (int mode_idx = INTRA_MODE_START; mode_idx < LUMA_MODE_COUNT;
-       ++mode_idx) {
-#endif
       if (sf->intra_sf.skip_intra_in_interframe &&
           search_state.intra_search_state.skip_intra_modes)
         break;
@@ -6011,14 +6001,6 @@
         continue;
       }
 #endif
-
-#if CONFIG_ORIP
-      int signal_intra_filter = av1_signal_orip_for_horver_modes(
-          &cpi->common, mbmi, PLANE_TYPE_Y, bsize);
-      if (!signal_intra_filter &&
-          mbmi->angle_delta[PLANE_TYPE_Y] == ANGLE_DELTA_VALUE_ORIP)
-        continue;
-#endif
       const PREDICTION_MODE this_mode = mbmi->mode;
 
       assert(av1_mode_defs[mode_enum].ref_frame[0] == INTRA_FRAME);
diff --git a/av1/encoder/tpl_model.c b/av1/encoder/tpl_model.c
index a8e0ac9..9c4b1ee 100644
--- a/av1/encoder/tpl_model.c
+++ b/av1/encoder/tpl_model.c
@@ -313,12 +313,7 @@
     av1_predict_intra_block(cm, xd, block_size_wide[bsize],
                             block_size_high[bsize], tx_size, mode, 0, 0,
                             FILTER_INTRA_MODES, dst_buffer, dst_buffer_stride,
-                            predictor, bw, 0, 0,
-#if CONFIG_ORIP
-                            0, 0);
-#else
-                            0);
-#endif
+                            predictor, bw, 0, 0, 0);
 
     intra_cost = tpl_get_satd_cost(x, src_diff, bw, src_mb_buffer, src_stride,
                                    predictor, bw, coeff, bw, bh, tx_size);
@@ -498,14 +493,7 @@
     av1_predict_intra_block(cm, xd, block_size_wide[bsize],
                             block_size_high[bsize], tx_size, best_mode, 0, 0,
                             FILTER_INTRA_MODES, dst_buffer, dst_buffer_stride,
-                            dst_buffer, dst_buffer_stride, 0, 0
-#if CONFIG_ORIP
-                            ,
-                            0, 0);
-#else
-                            ,
-                            0);
-#endif
+                            dst_buffer, dst_buffer_stride, 0, 0, 0);
   }
 
   int rate_cost;