diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 4495f1c..a91c04b 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -619,11 +619,36 @@
   }
 }
 
-static INLINE void dec_build_inter_predictors(const AV1_COMMON *cm,
-                                              MACROBLOCKD *xd, int plane,
-                                              const MB_MODE_INFO *mi,
-                                              int build_for_obmc, int bw,
-                                              int bh, int mi_x, int mi_y) {
+static void dec_calc_subpel_params_and_extend(
+    MACROBLOCKD *xd, const struct scale_factors *const sf, const MV mv,
+    int plane, const MB_MODE_INFO *mi, int pre_x, int pre_y, int x, int y,
+    struct buf_2d *const pre_buf, int bw, int bh, int mi_x, int mi_y, int ref,
+    int is_intrabc, int build_for_obmc,
+    const WarpTypesAllowed *const warp_types, uint8_t **pre,
+    SubpelParams *subpel_params, int *src_stride) {
+  PadBlock block;
+  MV32 scaled_mv;
+  int subpel_x_mv, subpel_y_mv;
+  dec_calc_subpel_params(xd, sf, mv, plane, pre_x, pre_y, x, y, pre_buf,
+                         subpel_params, bw, bh, &block, mi_x, mi_y, &scaled_mv,
+                         &subpel_x_mv, &subpel_y_mv);
+  *pre = pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0;
+  *src_stride = pre_buf->stride;
+  const int highbd = is_cur_buf_hbd(xd);
+  const int do_warp =
+      bw >= 8 && bh >= 8 &&
+      av1_allow_warp(mi, warp_types, &xd->global_motion[mi->ref_frame[ref]],
+                     build_for_obmc, sf, NULL) &&
+      (xd->cur_frame_force_integer_mv == 0);
+  extend_mc_border(sf, pre_buf, scaled_mv, block, subpel_x_mv, subpel_y_mv,
+                   do_warp, is_intrabc, highbd, xd->mc_buf[ref], pre,
+                   src_stride);
+}
+
+static void dec_build_inter_predictors(const AV1_COMMON *cm, MACROBLOCKD *xd,
+                                       int plane, const MB_MODE_INFO *mi,
+                                       int build_for_obmc, int bw, int bh,
+                                       int mi_x, int mi_y) {
   struct macroblockd_plane *const pd = &xd->plane[plane];
   int is_compound = has_second_ref(mi);
   int ref;
@@ -677,7 +702,6 @@
     const struct buf_2d orig_pred_buf[2] = { pd->pre[0], pd->pre[1] };
 
     int row = row_start;
-    int src_stride;
     ref = 0;
     for (int y = 0; y < b8_h; y += b4_h) {
       int col = col_start;
@@ -713,24 +737,19 @@
 
         const MV mv = this_mbmi->mv[ref].as_mv;
 
-        uint8_t *pre;
+        const WarpTypesAllowed warp_types = {
+          is_global[ref], this_mbmi->motion_mode == WARPED_CAUSAL
+        };
+
         SubpelParams subpel_params;
-        PadBlock block;
-        MV32 scaled_mv;
-        int subpel_x_mv, subpel_y_mv;
-        int highbd;
+        uint8_t *pre;
+        int src_stride;
+        dec_calc_subpel_params_and_extend(
+            xd, sf, mv, plane, mi, pre_x, pre_y, x, y, pre_buf, bw, bh, mi_x,
+            mi_y, ref, is_intrabc, build_for_obmc, &warp_types, &pre,
+            &subpel_params, &src_stride);
 
-        dec_calc_subpel_params(xd, sf, mv, plane, pre_x, pre_y, x, y, pre_buf,
-                               &subpel_params, bw, bh, &block, mi_x, mi_y,
-                               &scaled_mv, &subpel_x_mv, &subpel_y_mv);
-        pre = pre_buf->buf0 + block.y0 * pre_buf->stride + block.x0;
-        src_stride = pre_buf->stride;
-        highbd = is_cur_buf_hbd(xd);
-        extend_mc_border(sf, pre_buf, scaled_mv, block, subpel_x_mv,
-                         subpel_y_mv, 0, is_intrabc, highbd, xd->mc_buf[ref],
-                         &pre, &src_stride);
         inter_pred_params.conv_params.do_average = ref;
-
         av1_init_inter_params(
             &inter_pred_params, b4_w, b4_h, (mi_y >> pd->subsampling_y) + y,
             (mi_x >> pd->subsampling_x) + x, pd->subsampling_x,
@@ -752,48 +771,23 @@
   {
     struct buf_2d *const dst_buf = &pd->dst;
     uint8_t *const dst = dst_buf->buf;
-    uint8_t *pre[2];
     InterPredParams inter_pred_params;
-    SubpelParams subpel_params[2];
-    int src_stride[2];
     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];
       const MV mv = mi->mv[ref].as_mv;
-      PadBlock block;
-      MV32 scaled_mv;
-      int subpel_x_mv, subpel_y_mv;
-      int highbd;
+      const WarpTypesAllowed warp_types = { is_global[ref],
+                                            mi->motion_mode == WARPED_CAUSAL };
 
-      dec_calc_subpel_params(xd, sf, mv, plane, pre_x, pre_y, 0, 0, pre_buf,
-                             &subpel_params[ref], bw, bh, &block, mi_x, mi_y,
-                             &scaled_mv, &subpel_x_mv, &subpel_y_mv);
-      pre[ref] = pre_buf->buf0 + (int64_t)block.y0 * pre_buf->stride + block.x0;
-      src_stride[ref] = pre_buf->stride;
-      highbd = is_cur_buf_hbd(xd);
+      SubpelParams subpel_params;
+      uint8_t *pre;
+      int src_stride;
+      dec_calc_subpel_params_and_extend(xd, sf, mv, plane, mi, pre_x, pre_y, 0,
+                                        0, pre_buf, bw, bh, mi_x, mi_y, ref,
+                                        is_intrabc, build_for_obmc, &warp_types,
+                                        &pre, &subpel_params, &src_stride);
 
-      WarpTypesAllowed warp_types;
-      warp_types.global_warp_allowed = is_global[ref];
-      warp_types.local_warp_allowed = mi->motion_mode == WARPED_CAUSAL;
-      int do_warp = (bw >= 8 && bh >= 8 &&
-                     av1_allow_warp(mi, &warp_types,
-                                    &xd->global_motion[mi->ref_frame[ref]],
-                                    build_for_obmc, sf, NULL));
-      do_warp = (do_warp && xd->cur_frame_force_integer_mv == 0);
-
-      extend_mc_border(sf, pre_buf, scaled_mv, block, subpel_x_mv, subpel_y_mv,
-                       do_warp, is_intrabc, highbd, xd->mc_buf[ref], &pre[ref],
-                       &src_stride[ref]);
-    }
-
-    for (ref = 0; ref < 1 + is_compound; ++ref) {
-      struct buf_2d *const pre_buf = is_intrabc ? dst_buf : &pd->pre[ref];
-      const struct scale_factors *const sf =
-          is_intrabc ? &cm->sf_identity : xd->block_ref_scale_factors[ref];
-      WarpTypesAllowed warp_types;
-      warp_types.global_warp_allowed = is_global[ref];
-      warp_types.local_warp_allowed = mi->motion_mode == WARPED_CAUSAL;
       inter_pred_params.conv_params.do_average = ref;
 
       av1_init_inter_params(&inter_pred_params, bw, bh,
@@ -802,7 +796,6 @@
                             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(
           ref, plane, xd->tmp_conv_dst, MAX_SB_SIZE, is_compound, xd->bd);
 
@@ -824,13 +817,11 @@
         // masked compound type has its own average mechanism
         inter_pred_params.conv_params.do_average = 0;
 
-        av1_make_masked_inter_predictor(pre[ref], src_stride[ref], dst,
-                                        dst_buf->stride, &inter_pred_params,
-                                        &subpel_params[ref]);
+        av1_make_masked_inter_predictor(pre, src_stride, dst, dst_buf->stride,
+                                        &inter_pred_params, &subpel_params);
       } else {
-        av1_make_inter_predictor(pre[ref], src_stride[ref], dst,
-                                 dst_buf->stride, &inter_pred_params,
-                                 &subpel_params[ref]);
+        av1_make_inter_predictor(pre, src_stride, dst, dst_buf->stride,
+                                 &inter_pred_params, &subpel_params);
       }
     }
   }