diff --git a/av1/common/reconinter.c b/av1/common/reconinter.c
index 22a0429..52b4173 100644
--- a/av1/common/reconinter.c
+++ b/av1/common/reconinter.c
@@ -74,7 +74,8 @@
   inter_pred_params->is_intrabc = is_intrabc;
   inter_pred_params->scale_factors = sf;
   inter_pred_params->ref_frame_buf = *ref_buf;
-  inter_pred_params->mode = UNIFORM_PRED;
+  inter_pred_params->mode = TRANSLATION_PRED;
+  inter_pred_params->comp_mode = UNIFORM_SINGLE;
 
   if (is_intrabc) {
     inter_pred_params->interp_filter_params[0] = &av1_intrabc_filter_params;
@@ -89,6 +90,10 @@
   }
 }
 
+void av1_init_comp_mode(InterPredParams *inter_pred_params) {
+  inter_pred_params->comp_mode = UNIFORM_COMP;
+}
+
 void av1_init_warp_params(InterPredParams *inter_pred_params,
                           const struct buf_2d *ref_buf,
                           const WarpTypesAllowed *warp_types, int ref,
@@ -109,10 +114,8 @@
 void av1_init_mask_comp(InterPredParams *inter_pred_params, BLOCK_SIZE bsize,
                         const INTERINTER_COMPOUND_DATA *mask_comp) {
   inter_pred_params->sb_type = bsize;
-  if (inter_pred_params->conv_params.do_average &&
-      is_masked_compound_type(mask_comp->type)) {
-    inter_pred_params->mask_comp = *mask_comp;
-  }
+  inter_pred_params->mask_comp = *mask_comp;
+  inter_pred_params->comp_mode = MASK_COMP;
 }
 
 void av1_make_inter_predictor(const uint8_t *src, int src_stride, uint8_t *dst,
@@ -134,7 +137,7 @@
         inter_pred_params->block_width, inter_pred_params->block_height,
         dst_stride, inter_pred_params->subsampling_x,
         inter_pred_params->subsampling_y, &inter_pred_params->conv_params);
-  } else if (inter_pred_params->mode == UNIFORM_PRED) {
+  } else if (inter_pred_params->mode == TRANSLATION_PRED) {
 #if CONFIG_AV1_HIGHBITDEPTH
     if (inter_pred_params->use_hbd_buf) {
       highbd_inter_predictor(
diff --git a/av1/common/reconinter.h b/av1/common/reconinter.h
index 5e6488a..7b3b51f 100644
--- a/av1/common/reconinter.h
+++ b/av1/common/reconinter.h
@@ -92,13 +92,19 @@
 };
 
 typedef enum InterPredMode {
-  UNIFORM_PRED,
+  TRANSLATION_PRED,
   WARP_PRED,
-  MASK_PRED,
 } InterPredMode;
 
+typedef enum InterCompMode {
+  UNIFORM_SINGLE,
+  UNIFORM_COMP,
+  MASK_COMP,
+} InterCompMode;
+
 typedef struct InterPredParams {
   InterPredMode mode;
+  InterCompMode comp_mode;
   WarpedMotionParams warp_params;
   ConvolveParams conv_params;
   const InterpFilterParams *interp_filter_params[2];
@@ -125,6 +131,8 @@
                            const struct buf_2d *ref_buf,
                            int_interpfilters interp_filters);
 
+void av1_init_comp_mode(InterPredParams *inter_pred_params);
+
 void av1_init_warp_params(InterPredParams *inter_pred_params,
                           const struct buf_2d *ref_buf,
                           const WarpTypesAllowed *warp_types, int ref,
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index cbea8f3..284cbd0 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -826,13 +826,16 @@
                             mi_x >> pd->subsampling_x, pd->subsampling_x,
                             pd->subsampling_y, xd->bd, is_cur_buf_hbd(xd),
                             mi->use_intrabc, sf, pre_buf, mi->interp_filters);
-
+      if (is_compound) av1_init_comp_mode(&inter_pred_params);
       if (!build_for_obmc)
         av1_init_warp_params(&inter_pred_params, &pd->pre[ref], &warp_types,
                              ref, xd, mi);
 
-      av1_init_mask_comp(&inter_pred_params, mi->sb_type, &mi->interinter_comp);
-      inter_pred_params.mask_comp.seg_mask = xd->seg_mask;
+      if (is_masked_compound_type(mi->interinter_comp.type)) {
+        av1_init_mask_comp(&inter_pred_params, mi->sb_type,
+                           &mi->interinter_comp);
+        inter_pred_params.mask_comp.seg_mask = xd->seg_mask;
+      }
 
       if (ref && is_masked_compound_type(mi->interinter_comp.type)) {
         // masked compound type has its own average mechanism
diff --git a/av1/encoder/reconinter_enc.c b/av1/encoder/reconinter_enc.c
index b424829..6c9ec55 100644
--- a/av1/encoder/reconinter_enc.c
+++ b/av1/encoder/reconinter_enc.c
@@ -175,55 +175,61 @@
 
   {
     InterPredParams inter_pred_params;
-    inter_pred_params.conv_params = get_conv_params_no_round(
-        0, plane, xd->tmp_conv_dst, MAX_SB_SIZE, is_compound, xd->bd);
-
-    av1_dist_wtd_comp_weight_assign(
-        cm, mi, 0, &inter_pred_params.conv_params.fwd_offset,
-        &inter_pred_params.conv_params.bck_offset,
-        &inter_pred_params.conv_params.use_dist_wtd_comp_avg, is_compound);
 
     struct buf_2d *const dst_buf = &pd->dst;
     uint8_t *const dst = dst_buf->buf;
     for (ref = 0; ref < 1 + is_compound; ++ref) {
       const struct scale_factors *const sf =
           is_intrabc ? &cm->sf_identity : xd->block_ref_scale_factors[ref];
-      struct buf_2d *const pre_buf = is_intrabc ? dst_buf : &pd->pre[ref];
+      struct buf_2d pre_buf = is_intrabc ? *dst_buf : pd->pre[ref];
       const MV mv = mi->mv[ref].as_mv;
 
       uint8_t *pre;
       SubpelParams subpel_params;
-      calc_subpel_params(xd, sf, mv, plane, pre_x, pre_y, 0, 0, pre_buf, &pre,
+      calc_subpel_params(xd, sf, mv, plane, pre_x, pre_y, 0, 0, &pre_buf, &pre,
                          &subpel_params, bw, bh);
 
       WarpTypesAllowed warp_types;
       warp_types.global_warp_allowed = is_global[ref];
       warp_types.local_warp_allowed = mi->motion_mode == WARPED_CAUSAL;
 
-      av1_init_inter_params(&inter_pred_params, bw, bh,
-                            mi_y >> pd->subsampling_y,
-                            mi_x >> pd->subsampling_x, pd->subsampling_x,
-                            pd->subsampling_y, xd->bd, is_cur_buf_hbd(xd),
-                            mi->use_intrabc, sf, pre_buf, mi->interp_filters);
+      av1_init_inter_params(&inter_pred_params, bw, bh, pre_y, pre_x,
+                            pd->subsampling_x, pd->subsampling_y, xd->bd,
+                            is_cur_buf_hbd(xd), mi->use_intrabc, sf, &pre_buf,
+                            mi->interp_filters);
+
+      if (is_compound) av1_init_comp_mode(&inter_pred_params);
+
+      inter_pred_params.conv_params = get_conv_params_no_round(
+          0, plane, xd->tmp_conv_dst, MAX_SB_SIZE, is_compound, xd->bd);
+
+      av1_dist_wtd_comp_weight_assign(
+          cm, mi, 0, &inter_pred_params.conv_params.fwd_offset,
+          &inter_pred_params.conv_params.bck_offset,
+          &inter_pred_params.conv_params.use_dist_wtd_comp_avg, is_compound);
 
       inter_pred_params.conv_params.do_average = ref;
 
-      av1_init_warp_params(&inter_pred_params, &pd->pre[ref], &warp_types, ref,
-                           xd, mi);
+      av1_init_warp_params(&inter_pred_params, &pre_buf, &warp_types, ref, xd,
+                           mi);
 
-      av1_init_mask_comp(&inter_pred_params, mi->sb_type, &mi->interinter_comp);
-      // Assigne physical buffer
-      inter_pred_params.mask_comp.seg_mask = xd->seg_mask;
+      if (is_masked_compound_type(mi->interinter_comp.type)) {
+        av1_init_mask_comp(&inter_pred_params, mi->sb_type,
+                           &mi->interinter_comp);
+        // Assigne physical buffer
+        inter_pred_params.mask_comp.seg_mask = xd->seg_mask;
+      }
 
       if (ref && is_masked_compound_type(mi->interinter_comp.type)) {
         // masked compound type has its own average mechanism
         inter_pred_params.conv_params.do_average = 0;
-        av1_make_masked_inter_predictor(pre, pre_buf->stride, dst,
+        av1_make_masked_inter_predictor(pre, pre_buf.stride, dst,
                                         dst_buf->stride, &inter_pred_params,
                                         &subpel_params);
       } else {
-        av1_make_inter_predictor(pre, pre_buf->stride, dst, dst_buf->stride,
-                                 &inter_pred_params, &subpel_params);
+        av1_build_inter_predictor(pre_buf.buf, pre_buf.stride, dst,
+                                  dst_buf->stride, &mv, mi_x, mi_y,
+                                  &inter_pred_params);
       }
     }
   }
@@ -272,7 +278,6 @@
                                InterPredParams *inter_pred_params) {
   SubpelParams subpel_params;
   const struct scale_factors *sf = inter_pred_params->scale_factors;
-
   (void)pix_row;
   (void)pix_col;