diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 84e4e93..bf1c333 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -1175,10 +1175,13 @@
 MAKE_BFP_SAD4D_WRAPPER(aom_highbd_sad4x4x4d)
 
 #if CONFIG_EXT_INTER
-#define HIGHBD_MBFP(BT, MSDF, MVF, MSVF) \
-  cpi->fn_ptr[BT].msdf = MSDF;           \
-  cpi->fn_ptr[BT].mvf = MVF;             \
-  cpi->fn_ptr[BT].msvf = MSVF;
+#define HIGHBD_MBFP(BT, MSDF, MVF, MSVF, MCSDF, MCVF, MCSVF) \
+  cpi->fn_ptr[BT].msdf = MSDF;                               \
+  cpi->fn_ptr[BT].mvf = MVF;                                 \
+  cpi->fn_ptr[BT].msvf = MSVF;                               \
+  cpi->fn_ptr[BT].mcsdf = MCSDF;                             \
+  cpi->fn_ptr[BT].mcvf = MCVF;                               \
+  cpi->fn_ptr[BT].mcsvf = MCSVF;
 
 #define MAKE_MBFP_SAD_WRAPPER(fnname)                                          \
   static unsigned int fnname##_bits8(                                          \
@@ -1199,10 +1202,38 @@
            4;                                                                  \
   }
 
+#define MAKE_MBFP_COMPOUND_SAD_WRAPPER(fnname)                           \
+  static unsigned int fnname##_bits8(                                    \
+      const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
+      int ref_stride, const uint8_t *second_pred_ptr, const uint8_t *m,  \
+      int m_stride, int invert_mask) {                                   \
+    return fnname(src_ptr, source_stride, ref_ptr, ref_stride,           \
+                  second_pred_ptr, m, m_stride, invert_mask);            \
+  }                                                                      \
+  static unsigned int fnname##_bits10(                                   \
+      const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
+      int ref_stride, const uint8_t *second_pred_ptr, const uint8_t *m,  \
+      int m_stride, int invert_mask) {                                   \
+    return fnname(src_ptr, source_stride, ref_ptr, ref_stride,           \
+                  second_pred_ptr, m, m_stride, invert_mask) >>          \
+           2;                                                            \
+  }                                                                      \
+  static unsigned int fnname##_bits12(                                   \
+      const uint8_t *src_ptr, int source_stride, const uint8_t *ref_ptr, \
+      int ref_stride, const uint8_t *second_pred_ptr, const uint8_t *m,  \
+      int m_stride, int invert_mask) {                                   \
+    return fnname(src_ptr, source_stride, ref_ptr, ref_stride,           \
+                  second_pred_ptr, m, m_stride, invert_mask) >>          \
+           4;                                                            \
+  }
+
 #if CONFIG_EXT_PARTITION
 MAKE_MBFP_SAD_WRAPPER(aom_highbd_masked_sad128x128)
 MAKE_MBFP_SAD_WRAPPER(aom_highbd_masked_sad128x64)
 MAKE_MBFP_SAD_WRAPPER(aom_highbd_masked_sad64x128)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad128x128)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad128x64)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad64x128)
 #endif  // CONFIG_EXT_PARTITION
 MAKE_MBFP_SAD_WRAPPER(aom_highbd_masked_sad64x64)
 MAKE_MBFP_SAD_WRAPPER(aom_highbd_masked_sad64x32)
@@ -1217,6 +1248,19 @@
 MAKE_MBFP_SAD_WRAPPER(aom_highbd_masked_sad8x4)
 MAKE_MBFP_SAD_WRAPPER(aom_highbd_masked_sad4x8)
 MAKE_MBFP_SAD_WRAPPER(aom_highbd_masked_sad4x4)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad64x64)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad64x32)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad32x64)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad32x32)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad32x16)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad16x32)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad16x16)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad16x8)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad8x16)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad8x8)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad8x4)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad4x8)
+MAKE_MBFP_COMPOUND_SAD_WRAPPER(aom_highbd_masked_compound_sad4x4)
 #endif  // CONFIG_EXT_INTER
 
 #if CONFIG_MOTION_VAR
@@ -1383,53 +1427,101 @@
 #if CONFIG_EXT_PARTITION
         HIGHBD_MBFP(BLOCK_128X128, aom_highbd_masked_sad128x128_bits8,
                     aom_highbd_masked_variance128x128,
-                    aom_highbd_masked_sub_pixel_variance128x128)
+                    aom_highbd_masked_sub_pixel_variance128x128,
+                    aom_highbd_masked_compound_sad128x128_bits8,
+                    aom_highbd_masked_compound_variance128x128,
+                    aom_highbd_masked_compound_sub_pixel_variance128x128)
         HIGHBD_MBFP(BLOCK_128X64, aom_highbd_masked_sad128x64_bits8,
                     aom_highbd_masked_variance128x64,
-                    aom_highbd_masked_sub_pixel_variance128x64)
+                    aom_highbd_masked_sub_pixel_variance128x64,
+                    aom_highbd_masked_compound_sad128x64_bits8,
+                    aom_highbd_masked_compound_variance128x64,
+                    aom_highbd_masked_compound_sub_pixel_variance128x64)
         HIGHBD_MBFP(BLOCK_64X128, aom_highbd_masked_sad64x128_bits8,
                     aom_highbd_masked_variance64x128,
-                    aom_highbd_masked_sub_pixel_variance64x128)
+                    aom_highbd_masked_sub_pixel_variance64x128,
+                    aom_highbd_masked_compound_sad64x128_bits8,
+                    aom_highbd_masked_compound_variance64x128,
+                    aom_highbd_masked_compound_sub_pixel_variance64x128)
 #endif  // CONFIG_EXT_PARTITION
         HIGHBD_MBFP(BLOCK_64X64, aom_highbd_masked_sad64x64_bits8,
                     aom_highbd_masked_variance64x64,
-                    aom_highbd_masked_sub_pixel_variance64x64)
+                    aom_highbd_masked_sub_pixel_variance64x64,
+                    aom_highbd_masked_compound_sad64x64_bits8,
+                    aom_highbd_masked_compound_variance64x64,
+                    aom_highbd_masked_compound_sub_pixel_variance64x64)
         HIGHBD_MBFP(BLOCK_64X32, aom_highbd_masked_sad64x32_bits8,
                     aom_highbd_masked_variance64x32,
-                    aom_highbd_masked_sub_pixel_variance64x32)
+                    aom_highbd_masked_sub_pixel_variance64x32,
+                    aom_highbd_masked_compound_sad64x32_bits8,
+                    aom_highbd_masked_compound_variance64x32,
+                    aom_highbd_masked_compound_sub_pixel_variance64x32)
         HIGHBD_MBFP(BLOCK_32X64, aom_highbd_masked_sad32x64_bits8,
                     aom_highbd_masked_variance32x64,
-                    aom_highbd_masked_sub_pixel_variance32x64)
+                    aom_highbd_masked_sub_pixel_variance32x64,
+                    aom_highbd_masked_compound_sad32x64_bits8,
+                    aom_highbd_masked_compound_variance32x64,
+                    aom_highbd_masked_compound_sub_pixel_variance32x64)
         HIGHBD_MBFP(BLOCK_32X32, aom_highbd_masked_sad32x32_bits8,
                     aom_highbd_masked_variance32x32,
-                    aom_highbd_masked_sub_pixel_variance32x32)
+                    aom_highbd_masked_sub_pixel_variance32x32,
+                    aom_highbd_masked_compound_sad32x32_bits8,
+                    aom_highbd_masked_compound_variance32x32,
+                    aom_highbd_masked_compound_sub_pixel_variance32x32)
         HIGHBD_MBFP(BLOCK_32X16, aom_highbd_masked_sad32x16_bits8,
                     aom_highbd_masked_variance32x16,
-                    aom_highbd_masked_sub_pixel_variance32x16)
+                    aom_highbd_masked_sub_pixel_variance32x16,
+                    aom_highbd_masked_compound_sad32x16_bits8,
+                    aom_highbd_masked_compound_variance32x16,
+                    aom_highbd_masked_compound_sub_pixel_variance32x16)
         HIGHBD_MBFP(BLOCK_16X32, aom_highbd_masked_sad16x32_bits8,
                     aom_highbd_masked_variance16x32,
-                    aom_highbd_masked_sub_pixel_variance16x32)
+                    aom_highbd_masked_sub_pixel_variance16x32,
+                    aom_highbd_masked_compound_sad16x32_bits8,
+                    aom_highbd_masked_compound_variance16x32,
+                    aom_highbd_masked_compound_sub_pixel_variance16x32)
         HIGHBD_MBFP(BLOCK_16X16, aom_highbd_masked_sad16x16_bits8,
                     aom_highbd_masked_variance16x16,
-                    aom_highbd_masked_sub_pixel_variance16x16)
+                    aom_highbd_masked_sub_pixel_variance16x16,
+                    aom_highbd_masked_compound_sad16x16_bits8,
+                    aom_highbd_masked_compound_variance16x16,
+                    aom_highbd_masked_compound_sub_pixel_variance16x16)
         HIGHBD_MBFP(BLOCK_8X16, aom_highbd_masked_sad8x16_bits8,
                     aom_highbd_masked_variance8x16,
-                    aom_highbd_masked_sub_pixel_variance8x16)
+                    aom_highbd_masked_sub_pixel_variance8x16,
+                    aom_highbd_masked_compound_sad8x16_bits8,
+                    aom_highbd_masked_compound_variance8x16,
+                    aom_highbd_masked_compound_sub_pixel_variance8x16)
         HIGHBD_MBFP(BLOCK_16X8, aom_highbd_masked_sad16x8_bits8,
                     aom_highbd_masked_variance16x8,
-                    aom_highbd_masked_sub_pixel_variance16x8)
+                    aom_highbd_masked_sub_pixel_variance16x8,
+                    aom_highbd_masked_compound_sad16x8_bits8,
+                    aom_highbd_masked_compound_variance16x8,
+                    aom_highbd_masked_compound_sub_pixel_variance16x8)
         HIGHBD_MBFP(BLOCK_8X8, aom_highbd_masked_sad8x8_bits8,
                     aom_highbd_masked_variance8x8,
-                    aom_highbd_masked_sub_pixel_variance8x8)
+                    aom_highbd_masked_sub_pixel_variance8x8,
+                    aom_highbd_masked_compound_sad8x8_bits8,
+                    aom_highbd_masked_compound_variance8x8,
+                    aom_highbd_masked_compound_sub_pixel_variance8x8)
         HIGHBD_MBFP(BLOCK_4X8, aom_highbd_masked_sad4x8_bits8,
                     aom_highbd_masked_variance4x8,
-                    aom_highbd_masked_sub_pixel_variance4x8)
+                    aom_highbd_masked_sub_pixel_variance4x8,
+                    aom_highbd_masked_compound_sad4x8_bits8,
+                    aom_highbd_masked_compound_variance4x8,
+                    aom_highbd_masked_compound_sub_pixel_variance4x8)
         HIGHBD_MBFP(BLOCK_8X4, aom_highbd_masked_sad8x4_bits8,
                     aom_highbd_masked_variance8x4,
-                    aom_highbd_masked_sub_pixel_variance8x4)
+                    aom_highbd_masked_sub_pixel_variance8x4,
+                    aom_highbd_masked_compound_sad8x4_bits8,
+                    aom_highbd_masked_compound_variance8x4,
+                    aom_highbd_masked_compound_sub_pixel_variance8x4)
         HIGHBD_MBFP(BLOCK_4X4, aom_highbd_masked_sad4x4_bits8,
                     aom_highbd_masked_variance4x4,
-                    aom_highbd_masked_sub_pixel_variance4x4)
+                    aom_highbd_masked_sub_pixel_variance4x4,
+                    aom_highbd_masked_compound_sad4x4_bits8,
+                    aom_highbd_masked_compound_variance4x4,
+                    aom_highbd_masked_compound_sub_pixel_variance4x4)
 #endif  // CONFIG_EXT_INTER
 #if CONFIG_MOTION_VAR
 #if CONFIG_EXT_PARTITION
@@ -1606,53 +1698,101 @@
 #if CONFIG_EXT_PARTITION
         HIGHBD_MBFP(BLOCK_128X128, aom_highbd_masked_sad128x128_bits10,
                     aom_highbd_10_masked_variance128x128,
-                    aom_highbd_10_masked_sub_pixel_variance128x128)
+                    aom_highbd_10_masked_sub_pixel_variance128x128,
+                    aom_highbd_masked_compound_sad128x128_bits10,
+                    aom_highbd_10_masked_compound_variance128x128,
+                    aom_highbd_10_masked_compound_sub_pixel_variance128x128)
         HIGHBD_MBFP(BLOCK_128X64, aom_highbd_masked_sad128x64_bits10,
                     aom_highbd_10_masked_variance128x64,
-                    aom_highbd_10_masked_sub_pixel_variance128x64)
+                    aom_highbd_10_masked_sub_pixel_variance128x64,
+                    aom_highbd_masked_compound_sad128x64_bits10,
+                    aom_highbd_10_masked_compound_variance128x64,
+                    aom_highbd_10_masked_compound_sub_pixel_variance128x64)
         HIGHBD_MBFP(BLOCK_64X128, aom_highbd_masked_sad64x128_bits10,
                     aom_highbd_10_masked_variance64x128,
-                    aom_highbd_10_masked_sub_pixel_variance64x128)
+                    aom_highbd_10_masked_sub_pixel_variance64x128,
+                    aom_highbd_masked_compound_sad64x128_bits10,
+                    aom_highbd_10_masked_compound_variance64x128,
+                    aom_highbd_10_masked_compound_sub_pixel_variance64x128)
 #endif  // CONFIG_EXT_PARTITION
         HIGHBD_MBFP(BLOCK_64X64, aom_highbd_masked_sad64x64_bits10,
                     aom_highbd_10_masked_variance64x64,
-                    aom_highbd_10_masked_sub_pixel_variance64x64)
+                    aom_highbd_10_masked_sub_pixel_variance64x64,
+                    aom_highbd_masked_compound_sad64x64_bits10,
+                    aom_highbd_10_masked_compound_variance64x64,
+                    aom_highbd_10_masked_compound_sub_pixel_variance64x64)
         HIGHBD_MBFP(BLOCK_64X32, aom_highbd_masked_sad64x32_bits10,
                     aom_highbd_10_masked_variance64x32,
-                    aom_highbd_10_masked_sub_pixel_variance64x32)
+                    aom_highbd_10_masked_sub_pixel_variance64x32,
+                    aom_highbd_masked_compound_sad64x32_bits10,
+                    aom_highbd_10_masked_compound_variance64x32,
+                    aom_highbd_10_masked_compound_sub_pixel_variance64x32)
         HIGHBD_MBFP(BLOCK_32X64, aom_highbd_masked_sad32x64_bits10,
                     aom_highbd_10_masked_variance32x64,
-                    aom_highbd_10_masked_sub_pixel_variance32x64)
+                    aom_highbd_10_masked_sub_pixel_variance32x64,
+                    aom_highbd_masked_compound_sad32x64_bits10,
+                    aom_highbd_10_masked_compound_variance32x64,
+                    aom_highbd_10_masked_compound_sub_pixel_variance32x64)
         HIGHBD_MBFP(BLOCK_32X32, aom_highbd_masked_sad32x32_bits10,
                     aom_highbd_10_masked_variance32x32,
-                    aom_highbd_10_masked_sub_pixel_variance32x32)
+                    aom_highbd_10_masked_sub_pixel_variance32x32,
+                    aom_highbd_masked_compound_sad32x32_bits10,
+                    aom_highbd_10_masked_compound_variance32x32,
+                    aom_highbd_10_masked_compound_sub_pixel_variance32x32)
         HIGHBD_MBFP(BLOCK_32X16, aom_highbd_masked_sad32x16_bits10,
                     aom_highbd_10_masked_variance32x16,
-                    aom_highbd_10_masked_sub_pixel_variance32x16)
+                    aom_highbd_10_masked_sub_pixel_variance32x16,
+                    aom_highbd_masked_compound_sad32x16_bits10,
+                    aom_highbd_10_masked_compound_variance32x16,
+                    aom_highbd_10_masked_compound_sub_pixel_variance32x16)
         HIGHBD_MBFP(BLOCK_16X32, aom_highbd_masked_sad16x32_bits10,
                     aom_highbd_10_masked_variance16x32,
-                    aom_highbd_10_masked_sub_pixel_variance16x32)
+                    aom_highbd_10_masked_sub_pixel_variance16x32,
+                    aom_highbd_masked_compound_sad16x32_bits10,
+                    aom_highbd_10_masked_compound_variance16x32,
+                    aom_highbd_10_masked_compound_sub_pixel_variance16x32)
         HIGHBD_MBFP(BLOCK_16X16, aom_highbd_masked_sad16x16_bits10,
                     aom_highbd_10_masked_variance16x16,
-                    aom_highbd_10_masked_sub_pixel_variance16x16)
+                    aom_highbd_10_masked_sub_pixel_variance16x16,
+                    aom_highbd_masked_compound_sad16x16_bits10,
+                    aom_highbd_10_masked_compound_variance16x16,
+                    aom_highbd_10_masked_compound_sub_pixel_variance16x16)
         HIGHBD_MBFP(BLOCK_8X16, aom_highbd_masked_sad8x16_bits10,
                     aom_highbd_10_masked_variance8x16,
-                    aom_highbd_10_masked_sub_pixel_variance8x16)
+                    aom_highbd_10_masked_sub_pixel_variance8x16,
+                    aom_highbd_masked_compound_sad8x16_bits10,
+                    aom_highbd_10_masked_compound_variance8x16,
+                    aom_highbd_10_masked_compound_sub_pixel_variance8x16)
         HIGHBD_MBFP(BLOCK_16X8, aom_highbd_masked_sad16x8_bits10,
                     aom_highbd_10_masked_variance16x8,
-                    aom_highbd_10_masked_sub_pixel_variance16x8)
+                    aom_highbd_10_masked_sub_pixel_variance16x8,
+                    aom_highbd_masked_compound_sad16x8_bits10,
+                    aom_highbd_10_masked_compound_variance16x8,
+                    aom_highbd_10_masked_compound_sub_pixel_variance16x8)
         HIGHBD_MBFP(BLOCK_8X8, aom_highbd_masked_sad8x8_bits10,
                     aom_highbd_10_masked_variance8x8,
-                    aom_highbd_10_masked_sub_pixel_variance8x8)
+                    aom_highbd_10_masked_sub_pixel_variance8x8,
+                    aom_highbd_masked_compound_sad8x8_bits10,
+                    aom_highbd_10_masked_compound_variance8x8,
+                    aom_highbd_10_masked_compound_sub_pixel_variance8x8)
         HIGHBD_MBFP(BLOCK_4X8, aom_highbd_masked_sad4x8_bits10,
                     aom_highbd_10_masked_variance4x8,
-                    aom_highbd_10_masked_sub_pixel_variance4x8)
+                    aom_highbd_10_masked_sub_pixel_variance4x8,
+                    aom_highbd_masked_compound_sad4x8_bits10,
+                    aom_highbd_10_masked_compound_variance4x8,
+                    aom_highbd_10_masked_compound_sub_pixel_variance4x8)
         HIGHBD_MBFP(BLOCK_8X4, aom_highbd_masked_sad8x4_bits10,
                     aom_highbd_10_masked_variance8x4,
-                    aom_highbd_10_masked_sub_pixel_variance8x4)
+                    aom_highbd_10_masked_sub_pixel_variance8x4,
+                    aom_highbd_masked_compound_sad8x4_bits10,
+                    aom_highbd_10_masked_compound_variance8x4,
+                    aom_highbd_10_masked_compound_sub_pixel_variance8x4)
         HIGHBD_MBFP(BLOCK_4X4, aom_highbd_masked_sad4x4_bits10,
                     aom_highbd_10_masked_variance4x4,
-                    aom_highbd_10_masked_sub_pixel_variance4x4)
+                    aom_highbd_10_masked_sub_pixel_variance4x4,
+                    aom_highbd_masked_compound_sad4x4_bits10,
+                    aom_highbd_10_masked_compound_variance4x4,
+                    aom_highbd_10_masked_compound_sub_pixel_variance4x4)
 #endif  // CONFIG_EXT_INTER
 #if CONFIG_MOTION_VAR
 #if CONFIG_EXT_PARTITION
@@ -1829,53 +1969,101 @@
 #if CONFIG_EXT_PARTITION
         HIGHBD_MBFP(BLOCK_128X128, aom_highbd_masked_sad128x128_bits12,
                     aom_highbd_12_masked_variance128x128,
-                    aom_highbd_12_masked_sub_pixel_variance128x128)
+                    aom_highbd_12_masked_sub_pixel_variance128x128,
+                    aom_highbd_masked_compound_sad128x128_bits12,
+                    aom_highbd_12_masked_compound_variance128x128,
+                    aom_highbd_12_masked_compound_sub_pixel_variance128x128)
         HIGHBD_MBFP(BLOCK_128X64, aom_highbd_masked_sad128x64_bits12,
                     aom_highbd_12_masked_variance128x64,
-                    aom_highbd_12_masked_sub_pixel_variance128x64)
+                    aom_highbd_12_masked_sub_pixel_variance128x64,
+                    aom_highbd_masked_compound_sad128x64_bits12,
+                    aom_highbd_12_masked_compound_variance128x64,
+                    aom_highbd_12_masked_compound_sub_pixel_variance128x64)
         HIGHBD_MBFP(BLOCK_64X128, aom_highbd_masked_sad64x128_bits12,
                     aom_highbd_12_masked_variance64x128,
-                    aom_highbd_12_masked_sub_pixel_variance64x128)
+                    aom_highbd_12_masked_sub_pixel_variance64x128,
+                    aom_highbd_masked_compound_sad64x128_bits12,
+                    aom_highbd_12_masked_compound_variance64x128,
+                    aom_highbd_12_masked_compound_sub_pixel_variance64x128)
 #endif  // CONFIG_EXT_PARTITION
         HIGHBD_MBFP(BLOCK_64X64, aom_highbd_masked_sad64x64_bits12,
                     aom_highbd_12_masked_variance64x64,
-                    aom_highbd_12_masked_sub_pixel_variance64x64)
+                    aom_highbd_12_masked_sub_pixel_variance64x64,
+                    aom_highbd_masked_compound_sad64x64_bits12,
+                    aom_highbd_12_masked_compound_variance64x64,
+                    aom_highbd_12_masked_compound_sub_pixel_variance64x64)
         HIGHBD_MBFP(BLOCK_64X32, aom_highbd_masked_sad64x32_bits12,
                     aom_highbd_12_masked_variance64x32,
-                    aom_highbd_12_masked_sub_pixel_variance64x32)
+                    aom_highbd_12_masked_sub_pixel_variance64x32,
+                    aom_highbd_masked_compound_sad64x32_bits12,
+                    aom_highbd_12_masked_compound_variance64x32,
+                    aom_highbd_12_masked_compound_sub_pixel_variance64x32)
         HIGHBD_MBFP(BLOCK_32X64, aom_highbd_masked_sad32x64_bits12,
                     aom_highbd_12_masked_variance32x64,
-                    aom_highbd_12_masked_sub_pixel_variance32x64)
+                    aom_highbd_12_masked_sub_pixel_variance32x64,
+                    aom_highbd_masked_compound_sad32x64_bits12,
+                    aom_highbd_12_masked_compound_variance32x64,
+                    aom_highbd_12_masked_compound_sub_pixel_variance32x64)
         HIGHBD_MBFP(BLOCK_32X32, aom_highbd_masked_sad32x32_bits12,
                     aom_highbd_12_masked_variance32x32,
-                    aom_highbd_12_masked_sub_pixel_variance32x32)
+                    aom_highbd_12_masked_sub_pixel_variance32x32,
+                    aom_highbd_masked_compound_sad32x32_bits12,
+                    aom_highbd_12_masked_compound_variance32x32,
+                    aom_highbd_12_masked_compound_sub_pixel_variance32x32)
         HIGHBD_MBFP(BLOCK_32X16, aom_highbd_masked_sad32x16_bits12,
                     aom_highbd_12_masked_variance32x16,
-                    aom_highbd_12_masked_sub_pixel_variance32x16)
+                    aom_highbd_12_masked_sub_pixel_variance32x16,
+                    aom_highbd_masked_compound_sad32x16_bits12,
+                    aom_highbd_12_masked_compound_variance32x16,
+                    aom_highbd_12_masked_compound_sub_pixel_variance32x16)
         HIGHBD_MBFP(BLOCK_16X32, aom_highbd_masked_sad16x32_bits12,
                     aom_highbd_12_masked_variance16x32,
-                    aom_highbd_12_masked_sub_pixel_variance16x32)
+                    aom_highbd_12_masked_sub_pixel_variance16x32,
+                    aom_highbd_masked_compound_sad16x32_bits12,
+                    aom_highbd_12_masked_compound_variance16x32,
+                    aom_highbd_12_masked_compound_sub_pixel_variance16x32)
         HIGHBD_MBFP(BLOCK_16X16, aom_highbd_masked_sad16x16_bits12,
                     aom_highbd_12_masked_variance16x16,
-                    aom_highbd_12_masked_sub_pixel_variance16x16)
+                    aom_highbd_12_masked_sub_pixel_variance16x16,
+                    aom_highbd_masked_compound_sad16x16_bits12,
+                    aom_highbd_12_masked_compound_variance16x16,
+                    aom_highbd_12_masked_compound_sub_pixel_variance16x16)
         HIGHBD_MBFP(BLOCK_8X16, aom_highbd_masked_sad8x16_bits12,
                     aom_highbd_12_masked_variance8x16,
-                    aom_highbd_12_masked_sub_pixel_variance8x16)
+                    aom_highbd_12_masked_sub_pixel_variance8x16,
+                    aom_highbd_masked_compound_sad8x16_bits12,
+                    aom_highbd_12_masked_compound_variance8x16,
+                    aom_highbd_12_masked_compound_sub_pixel_variance8x16)
         HIGHBD_MBFP(BLOCK_16X8, aom_highbd_masked_sad16x8_bits12,
                     aom_highbd_12_masked_variance16x8,
-                    aom_highbd_12_masked_sub_pixel_variance16x8)
+                    aom_highbd_12_masked_sub_pixel_variance16x8,
+                    aom_highbd_masked_compound_sad16x8_bits12,
+                    aom_highbd_12_masked_compound_variance16x8,
+                    aom_highbd_12_masked_compound_sub_pixel_variance16x8)
         HIGHBD_MBFP(BLOCK_8X8, aom_highbd_masked_sad8x8_bits12,
                     aom_highbd_12_masked_variance8x8,
-                    aom_highbd_12_masked_sub_pixel_variance8x8)
+                    aom_highbd_12_masked_sub_pixel_variance8x8,
+                    aom_highbd_masked_compound_sad8x8_bits12,
+                    aom_highbd_12_masked_compound_variance8x8,
+                    aom_highbd_12_masked_compound_sub_pixel_variance8x8)
         HIGHBD_MBFP(BLOCK_4X8, aom_highbd_masked_sad4x8_bits12,
                     aom_highbd_12_masked_variance4x8,
-                    aom_highbd_12_masked_sub_pixel_variance4x8)
+                    aom_highbd_12_masked_sub_pixel_variance4x8,
+                    aom_highbd_masked_compound_sad4x8_bits12,
+                    aom_highbd_12_masked_compound_variance4x8,
+                    aom_highbd_12_masked_compound_sub_pixel_variance4x8)
         HIGHBD_MBFP(BLOCK_8X4, aom_highbd_masked_sad8x4_bits12,
                     aom_highbd_12_masked_variance8x4,
-                    aom_highbd_12_masked_sub_pixel_variance8x4)
+                    aom_highbd_12_masked_sub_pixel_variance8x4,
+                    aom_highbd_masked_compound_sad8x4_bits12,
+                    aom_highbd_12_masked_compound_variance8x4,
+                    aom_highbd_12_masked_compound_sub_pixel_variance8x4)
         HIGHBD_MBFP(BLOCK_4X4, aom_highbd_masked_sad4x4_bits12,
                     aom_highbd_12_masked_variance4x4,
-                    aom_highbd_12_masked_sub_pixel_variance4x4)
+                    aom_highbd_12_masked_sub_pixel_variance4x4,
+                    aom_highbd_masked_compound_sad4x4_bits12,
+                    aom_highbd_12_masked_compound_variance4x4,
+                    aom_highbd_12_masked_compound_sub_pixel_variance4x4)
 #endif  // CONFIG_EXT_INTER
 
 #if CONFIG_MOTION_VAR
@@ -2464,45 +2652,80 @@
 #endif  // CONFIG_MOTION_VAR
 
 #if CONFIG_EXT_INTER
-#define MBFP(BT, MSDF, MVF, MSVF) \
-  cpi->fn_ptr[BT].msdf = MSDF;    \
-  cpi->fn_ptr[BT].mvf = MVF;      \
-  cpi->fn_ptr[BT].msvf = MSVF;
+#define MBFP(BT, MSDF, MVF, MSVF, MCSDF, MCVF, MCSVF) \
+  cpi->fn_ptr[BT].msdf = MSDF;                        \
+  cpi->fn_ptr[BT].mvf = MVF;                          \
+  cpi->fn_ptr[BT].msvf = MSVF;                        \
+  cpi->fn_ptr[BT].mcsdf = MCSDF;                      \
+  cpi->fn_ptr[BT].mcvf = MCVF;                        \
+  cpi->fn_ptr[BT].mcsvf = MCSVF;
 
 #if CONFIG_EXT_PARTITION
   MBFP(BLOCK_128X128, aom_masked_sad128x128, aom_masked_variance128x128,
-       aom_masked_sub_pixel_variance128x128)
+       aom_masked_sub_pixel_variance128x128, aom_masked_compound_sad128x128,
+       aom_masked_compound_variance128x128,
+       aom_masked_compound_sub_pixel_variance128x128)
   MBFP(BLOCK_128X64, aom_masked_sad128x64, aom_masked_variance128x64,
-       aom_masked_sub_pixel_variance128x64)
+       aom_masked_sub_pixel_variance128x64, aom_masked_compound_sad128x64,
+       aom_masked_compound_variance128x64,
+       aom_masked_compound_sub_pixel_variance128x64)
   MBFP(BLOCK_64X128, aom_masked_sad64x128, aom_masked_variance64x128,
-       aom_masked_sub_pixel_variance64x128)
+       aom_masked_sub_pixel_variance64x128, aom_masked_compound_sad64x128,
+       aom_masked_compound_variance64x128,
+       aom_masked_compound_sub_pixel_variance64x128)
 #endif  // CONFIG_EXT_PARTITION
   MBFP(BLOCK_64X64, aom_masked_sad64x64, aom_masked_variance64x64,
-       aom_masked_sub_pixel_variance64x64)
+       aom_masked_sub_pixel_variance64x64, aom_masked_compound_sad64x64,
+       aom_masked_compound_variance64x64,
+       aom_masked_compound_sub_pixel_variance64x64)
   MBFP(BLOCK_64X32, aom_masked_sad64x32, aom_masked_variance64x32,
-       aom_masked_sub_pixel_variance64x32)
+       aom_masked_sub_pixel_variance64x32, aom_masked_compound_sad64x32,
+       aom_masked_compound_variance64x32,
+       aom_masked_compound_sub_pixel_variance64x32)
   MBFP(BLOCK_32X64, aom_masked_sad32x64, aom_masked_variance32x64,
-       aom_masked_sub_pixel_variance32x64)
+       aom_masked_sub_pixel_variance32x64, aom_masked_compound_sad32x64,
+       aom_masked_compound_variance32x64,
+       aom_masked_compound_sub_pixel_variance32x64)
   MBFP(BLOCK_32X32, aom_masked_sad32x32, aom_masked_variance32x32,
-       aom_masked_sub_pixel_variance32x32)
+       aom_masked_sub_pixel_variance32x32, aom_masked_compound_sad32x32,
+       aom_masked_compound_variance32x32,
+       aom_masked_compound_sub_pixel_variance32x32)
   MBFP(BLOCK_32X16, aom_masked_sad32x16, aom_masked_variance32x16,
-       aom_masked_sub_pixel_variance32x16)
+       aom_masked_sub_pixel_variance32x16, aom_masked_compound_sad32x16,
+       aom_masked_compound_variance32x16,
+       aom_masked_compound_sub_pixel_variance32x16)
   MBFP(BLOCK_16X32, aom_masked_sad16x32, aom_masked_variance16x32,
-       aom_masked_sub_pixel_variance16x32)
+       aom_masked_sub_pixel_variance16x32, aom_masked_compound_sad16x32,
+       aom_masked_compound_variance16x32,
+       aom_masked_compound_sub_pixel_variance16x32)
   MBFP(BLOCK_16X16, aom_masked_sad16x16, aom_masked_variance16x16,
-       aom_masked_sub_pixel_variance16x16)
+       aom_masked_sub_pixel_variance16x16, aom_masked_compound_sad16x16,
+       aom_masked_compound_variance16x16,
+       aom_masked_compound_sub_pixel_variance16x16)
   MBFP(BLOCK_16X8, aom_masked_sad16x8, aom_masked_variance16x8,
-       aom_masked_sub_pixel_variance16x8)
+       aom_masked_sub_pixel_variance16x8, aom_masked_compound_sad16x8,
+       aom_masked_compound_variance16x8,
+       aom_masked_compound_sub_pixel_variance16x8)
   MBFP(BLOCK_8X16, aom_masked_sad8x16, aom_masked_variance8x16,
-       aom_masked_sub_pixel_variance8x16)
+       aom_masked_sub_pixel_variance8x16, aom_masked_compound_sad8x16,
+       aom_masked_compound_variance8x16,
+       aom_masked_compound_sub_pixel_variance8x16)
   MBFP(BLOCK_8X8, aom_masked_sad8x8, aom_masked_variance8x8,
-       aom_masked_sub_pixel_variance8x8)
+       aom_masked_sub_pixel_variance8x8, aom_masked_compound_sad8x8,
+       aom_masked_compound_variance8x8,
+       aom_masked_compound_sub_pixel_variance8x8)
   MBFP(BLOCK_4X8, aom_masked_sad4x8, aom_masked_variance4x8,
-       aom_masked_sub_pixel_variance4x8)
+       aom_masked_sub_pixel_variance4x8, aom_masked_compound_sad4x8,
+       aom_masked_compound_variance4x8,
+       aom_masked_compound_sub_pixel_variance4x8)
   MBFP(BLOCK_8X4, aom_masked_sad8x4, aom_masked_variance8x4,
-       aom_masked_sub_pixel_variance8x4)
+       aom_masked_sub_pixel_variance8x4, aom_masked_compound_sad8x4,
+       aom_masked_compound_variance8x4,
+       aom_masked_compound_sub_pixel_variance8x4)
   MBFP(BLOCK_4X4, aom_masked_sad4x4, aom_masked_variance4x4,
-       aom_masked_sub_pixel_variance4x4)
+       aom_masked_sub_pixel_variance4x4, aom_masked_compound_sad4x4,
+       aom_masked_compound_variance4x4,
+       aom_masked_compound_sub_pixel_variance4x4)
 #endif  // CONFIG_EXT_INTER
 
 #if CONFIG_HIGHBITDEPTH
diff --git a/av1/encoder/mbgraph.c b/av1/encoder/mbgraph.c
index 8578611..3f5daeb 100644
--- a/av1/encoder/mbgraph.c
+++ b/av1/encoder/mbgraph.c
@@ -52,11 +52,14 @@
   {
     int distortion;
     unsigned int sse;
-    cpi->find_fractional_mv_step(x, ref_mv, cpi->common.allow_high_precision_mv,
-                                 x->errorperbit, &v_fn_ptr, 0,
-                                 mv_sf->subpel_iters_per_step,
-                                 cond_cost_list(cpi, cost_list), NULL, NULL,
-                                 &distortion, &sse, NULL, 0, 0, 0);
+    cpi->find_fractional_mv_step(
+        x, ref_mv, cpi->common.allow_high_precision_mv, x->errorperbit,
+        &v_fn_ptr, 0, mv_sf->subpel_iters_per_step,
+        cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL,
+#if CONFIG_EXT_INTER
+        NULL, 0, 0,
+#endif
+        0, 0, 0);
   }
 
 #if CONFIG_EXT_INTER
diff --git a/av1/encoder/mcomp.c b/av1/encoder/mcomp.c
index 27a7509..cbdfc8f 100644
--- a/av1/encoder/mcomp.c
+++ b/av1/encoder/mcomp.c
@@ -176,6 +176,33 @@
 }
 
 /* checks if (r, c) has better score than previous best */
+#if CONFIG_EXT_INTER
+#define CHECK_BETTER(v, r, c)                                              \
+  if (c >= minc && c <= maxc && r >= minr && r <= maxr) {                  \
+    MV this_mv = { r, c };                                                 \
+    v = mv_err_cost(&this_mv, ref_mv, mvjcost, mvcost, error_per_bit);     \
+    if (second_pred == NULL)                                               \
+      thismse = vfp->svf(pre(y, y_stride, r, c), y_stride, sp(c), sp(r),   \
+                         src_address, src_stride, &sse);                   \
+    else if (mask)                                                         \
+      thismse = vfp->mcsvf(pre(y, y_stride, r, c), y_stride, sp(c), sp(r), \
+                           src_address, src_stride, second_pred, mask,     \
+                           mask_stride, invert_mask, &sse);                \
+    else                                                                   \
+      thismse = vfp->svaf(pre(y, y_stride, r, c), y_stride, sp(c), sp(r),  \
+                          src_address, src_stride, &sse, second_pred);     \
+    v += thismse;                                                          \
+    if (v < besterr) {                                                     \
+      besterr = v;                                                         \
+      br = r;                                                              \
+      bc = c;                                                              \
+      *distortion = thismse;                                               \
+      *sse1 = sse;                                                         \
+    }                                                                      \
+  } else {                                                                 \
+    v = INT_MAX;                                                           \
+  }
+#else
 #define CHECK_BETTER(v, r, c)                                             \
   if (c >= minc && c <= maxc && r >= minr && r <= maxr) {                 \
     MV this_mv = { r, c };                                                \
@@ -197,6 +224,7 @@
   } else {                                                                \
     v = INT_MAX;                                                          \
   }
+#endif
 
 #define CHECK_BETTER0(v, r, c) CHECK_BETTER(v, r, c)
 
@@ -206,6 +234,26 @@
 }
 
 /* checks if (r, c) has better score than previous best */
+#if CONFIG_EXT_INTER
+#define CHECK_BETTER1(v, r, c)                                               \
+  if (c >= minc && c <= maxc && r >= minr && r <= maxr) {                    \
+    MV this_mv = { r, c };                                                   \
+    thismse = upsampled_pref_error(                                          \
+        xd, vfp, src_address, src_stride, upre(y, y_stride, r, c), y_stride, \
+        second_pred, mask, mask_stride, invert_mask, w, h, &sse);            \
+    v = mv_err_cost(&this_mv, ref_mv, mvjcost, mvcost, error_per_bit);       \
+    v += thismse;                                                            \
+    if (v < besterr) {                                                       \
+      besterr = v;                                                           \
+      br = r;                                                                \
+      bc = c;                                                                \
+      *distortion = thismse;                                                 \
+      *sse1 = sse;                                                           \
+    }                                                                        \
+  } else {                                                                   \
+    v = INT_MAX;                                                             \
+  }
+#else
 #define CHECK_BETTER1(v, r, c)                                         \
   if (c >= minc && c <= maxc && r >= minr && r <= maxr) {              \
     MV this_mv = { r, c };                                             \
@@ -224,6 +272,7 @@
   } else {                                                             \
     v = INT_MAX;                                                       \
   }
+#endif
 
 #define FIRST_LEVEL_CHECKS                                       \
   {                                                              \
@@ -327,20 +376,36 @@
     const MACROBLOCKD *xd, const MV *bestmv, const MV *ref_mv,
     int error_per_bit, const aom_variance_fn_ptr_t *vfp,
     const uint8_t *const src, const int src_stride, const uint8_t *const y,
-    int y_stride, const uint8_t *second_pred, int w, int h, int offset,
-    int *mvjcost, int *mvcost[2], unsigned int *sse1, int *distortion) {
+    int y_stride, const uint8_t *second_pred,
+#if CONFIG_EXT_INTER
+    const uint8_t *mask, int mask_stride, int invert_mask,
+#endif
+    int w, int h, int offset, int *mvjcost, int *mvcost[2], unsigned int *sse1,
+    int *distortion) {
   unsigned int besterr;
 #if CONFIG_HIGHBITDEPTH
   if (second_pred != NULL) {
     if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
       DECLARE_ALIGNED(16, uint16_t, comp_pred16[MAX_SB_SQUARE]);
-      aom_highbd_comp_avg_pred(comp_pred16, second_pred, w, h, y + offset,
-                               y_stride);
+#if CONFIG_EXT_INTER
+      if (mask)
+        aom_highbd_comp_mask_pred(comp_pred16, second_pred, w, h, y + offset,
+                                  y_stride, mask, mask_stride, invert_mask);
+      else
+#endif
+        aom_highbd_comp_avg_pred(comp_pred16, second_pred, w, h, y + offset,
+                                 y_stride);
       besterr =
           vfp->vf(CONVERT_TO_BYTEPTR(comp_pred16), w, src, src_stride, sse1);
     } else {
       DECLARE_ALIGNED(16, uint8_t, comp_pred[MAX_SB_SQUARE]);
-      aom_comp_avg_pred(comp_pred, second_pred, w, h, y + offset, y_stride);
+#if CONFIG_EXT_INTER
+      if (mask)
+        aom_comp_mask_pred(comp_pred, second_pred, w, h, y + offset, y_stride,
+                           mask, mask_stride, invert_mask);
+      else
+#endif
+        aom_comp_avg_pred(comp_pred, second_pred, w, h, y + offset, y_stride);
       besterr = vfp->vf(comp_pred, w, src, src_stride, sse1);
     }
   } else {
@@ -352,7 +417,13 @@
   (void)xd;
   if (second_pred != NULL) {
     DECLARE_ALIGNED(16, uint8_t, comp_pred[MAX_SB_SQUARE]);
-    aom_comp_avg_pred(comp_pred, second_pred, w, h, y + offset, y_stride);
+#if CONFIG_EXT_INTER
+    if (mask)
+      aom_comp_mask_pred(comp_pred, second_pred, w, h, y + offset, y_stride,
+                         mask, mask_stride, invert_mask);
+    else
+#endif
+      aom_comp_avg_pred(comp_pred, second_pred, w, h, y + offset, y_stride);
     besterr = vfp->vf(comp_pred, w, src, src_stride, sse1);
   } else {
     besterr = vfp->vf(y + offset, y_stride, src, src_stride, sse1);
@@ -391,12 +462,19 @@
     MACROBLOCK *x, const MV *ref_mv, int allow_hp, int error_per_bit,
     const aom_variance_fn_ptr_t *vfp, int forced_stop, int iters_per_step,
     int *cost_list, int *mvjcost, int *mvcost[2], int *distortion,
-    unsigned int *sse1, const uint8_t *second_pred, int w, int h,
-    int use_upsampled_ref) {
+    unsigned int *sse1, const uint8_t *second_pred,
+#if CONFIG_EXT_INTER
+    const uint8_t *mask, int mask_stride, int invert_mask,
+#endif
+    int w, int h, int use_upsampled_ref) {
   SETUP_SUBPEL_SEARCH;
-  besterr = setup_center_error(
-      xd, bestmv, ref_mv, error_per_bit, vfp, src_address, src_stride, y,
-      y_stride, second_pred, w, h, offset, mvjcost, mvcost, sse1, distortion);
+  besterr =
+      setup_center_error(xd, bestmv, ref_mv, error_per_bit, vfp, src_address,
+                         src_stride, y, y_stride, second_pred,
+#if CONFIG_EXT_INTER
+                         mask, mask_stride, invert_mask,
+#endif
+                         w, h, offset, mvjcost, mvcost, sse1, distortion);
   (void)halfiters;
   (void)quarteriters;
   (void)eighthiters;
@@ -457,14 +535,21 @@
     MACROBLOCK *x, const MV *ref_mv, int allow_hp, int error_per_bit,
     const aom_variance_fn_ptr_t *vfp, int forced_stop, int iters_per_step,
     int *cost_list, int *mvjcost, int *mvcost[2], int *distortion,
-    unsigned int *sse1, const uint8_t *second_pred, int w, int h,
-    int use_upsampled_ref) {
+    unsigned int *sse1, const uint8_t *second_pred,
+#if CONFIG_EXT_INTER
+    const uint8_t *mask, int mask_stride, int invert_mask,
+#endif
+    int w, int h, int use_upsampled_ref) {
   SETUP_SUBPEL_SEARCH;
   (void)use_upsampled_ref;
 
-  besterr = setup_center_error(
-      xd, bestmv, ref_mv, error_per_bit, vfp, src_address, src_stride, y,
-      y_stride, second_pred, w, h, offset, mvjcost, mvcost, sse1, distortion);
+  besterr =
+      setup_center_error(xd, bestmv, ref_mv, error_per_bit, vfp, src_address,
+                         src_stride, y, y_stride, second_pred,
+#if CONFIG_EXT_INTER
+                         mask, mask_stride, invert_mask,
+#endif
+                         w, h, offset, mvjcost, mvcost, sse1, distortion);
   if (cost_list && cost_list[0] != INT_MAX && cost_list[1] != INT_MAX &&
       cost_list[2] != INT_MAX && cost_list[3] != INT_MAX &&
       cost_list[4] != INT_MAX && is_cost_list_wellbehaved(cost_list)) {
@@ -519,14 +604,21 @@
     MACROBLOCK *x, const MV *ref_mv, int allow_hp, int error_per_bit,
     const aom_variance_fn_ptr_t *vfp, int forced_stop, int iters_per_step,
     int *cost_list, int *mvjcost, int *mvcost[2], int *distortion,
-    unsigned int *sse1, const uint8_t *second_pred, int w, int h,
-    int use_upsampled_ref) {
+    unsigned int *sse1, const uint8_t *second_pred,
+#if CONFIG_EXT_INTER
+    const uint8_t *mask, int mask_stride, int invert_mask,
+#endif
+    int w, int h, int use_upsampled_ref) {
   SETUP_SUBPEL_SEARCH;
   (void)use_upsampled_ref;
 
-  besterr = setup_center_error(
-      xd, bestmv, ref_mv, error_per_bit, vfp, src_address, src_stride, y,
-      y_stride, second_pred, w, h, offset, mvjcost, mvcost, sse1, distortion);
+  besterr =
+      setup_center_error(xd, bestmv, ref_mv, error_per_bit, vfp, src_address,
+                         src_stride, y, y_stride, second_pred,
+#if CONFIG_EXT_INTER
+                         mask, mask_stride, invert_mask,
+#endif
+                         w, h, offset, mvjcost, mvcost, sse1, distortion);
   if (cost_list && cost_list[0] != INT_MAX && cost_list[1] != INT_MAX &&
       cost_list[2] != INT_MAX && cost_list[3] != INT_MAX &&
       cost_list[4] != INT_MAX) {
@@ -612,17 +704,29 @@
                                 const aom_variance_fn_ptr_t *vfp,
                                 const uint8_t *const src, const int src_stride,
                                 const uint8_t *const y, int y_stride,
-                                const uint8_t *second_pred, int w, int h,
-                                unsigned int *sse) {
+                                const uint8_t *second_pred,
+#if CONFIG_EXT_INTER
+                                const uint8_t *mask, int mask_stride,
+                                int invert_mask,
+#endif
+                                int w, int h, unsigned int *sse) {
   unsigned int besterr;
 #if CONFIG_HIGHBITDEPTH
   if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
     DECLARE_ALIGNED(16, uint16_t, pred16[MAX_SB_SQUARE]);
-    if (second_pred != NULL)
-      aom_highbd_comp_avg_upsampled_pred(pred16, second_pred, w, h, y,
-                                         y_stride);
-    else
+    if (second_pred != NULL) {
+#if CONFIG_EXT_INTER
+      if (mask)
+        aom_highbd_comp_mask_upsampled_pred(pred16, second_pred, w, h, y,
+                                            y_stride, mask, mask_stride,
+                                            invert_mask);
+      else
+#endif
+        aom_highbd_comp_avg_upsampled_pred(pred16, second_pred, w, h, y,
+                                           y_stride);
+    } else {
       aom_highbd_upsampled_pred(pred16, w, h, y, y_stride);
+    }
 
     besterr = vfp->vf(CONVERT_TO_BYTEPTR(pred16), w, src, src_stride, sse);
   } else {
@@ -631,10 +735,17 @@
   DECLARE_ALIGNED(16, uint8_t, pred[MAX_SB_SQUARE]);
   (void)xd;
 #endif  // CONFIG_HIGHBITDEPTH
-    if (second_pred != NULL)
-      aom_comp_avg_upsampled_pred(pred, second_pred, w, h, y, y_stride);
-    else
+    if (second_pred != NULL) {
+#if CONFIG_EXT_INTER
+      if (mask)
+        aom_comp_mask_upsampled_pred(pred, second_pred, w, h, y, y_stride, mask,
+                                     mask_stride, invert_mask);
+      else
+#endif
+        aom_comp_avg_upsampled_pred(pred, second_pred, w, h, y, y_stride);
+    } else {
       aom_upsampled_pred(pred, w, h, y, y_stride);
+    }
 
     besterr = vfp->vf(pred, w, src, src_stride, sse);
 #if CONFIG_HIGHBITDEPTH
@@ -647,23 +758,32 @@
     const MACROBLOCKD *xd, const MV *bestmv, const MV *ref_mv,
     int error_per_bit, const aom_variance_fn_ptr_t *vfp,
     const uint8_t *const src, const int src_stride, const uint8_t *const y,
-    int y_stride, const uint8_t *second_pred, int w, int h, int offset,
-    int *mvjcost, int *mvcost[2], unsigned int *sse1, int *distortion) {
-  unsigned int besterr = upsampled_pref_error(
-      xd, vfp, src, src_stride, y + offset, y_stride, second_pred, w, h, sse1);
+    int y_stride, const uint8_t *second_pred,
+#if CONFIG_EXT_INTER
+    const uint8_t *mask, int mask_stride, int invert_mask,
+#endif
+    int w, int h, int offset, int *mvjcost, int *mvcost[2], unsigned int *sse1,
+    int *distortion) {
+  unsigned int besterr = upsampled_pref_error(xd, vfp, src, src_stride,
+                                              y + offset, y_stride, second_pred,
+#if CONFIG_EXT_INTER
+                                              mask, mask_stride, invert_mask,
+#endif
+                                              w, h, sse1);
   *distortion = besterr;
   besterr += mv_err_cost(bestmv, ref_mv, mvjcost, mvcost, error_per_bit);
   return besterr;
 }
 
-int av1_find_best_sub_pixel_tree(MACROBLOCK *x, const MV *ref_mv, int allow_hp,
-                                 int error_per_bit,
-                                 const aom_variance_fn_ptr_t *vfp,
-                                 int forced_stop, int iters_per_step,
-                                 int *cost_list, int *mvjcost, int *mvcost[2],
-                                 int *distortion, unsigned int *sse1,
-                                 const uint8_t *second_pred, int w, int h,
-                                 int use_upsampled_ref) {
+int av1_find_best_sub_pixel_tree(
+    MACROBLOCK *x, const MV *ref_mv, int allow_hp, int error_per_bit,
+    const aom_variance_fn_ptr_t *vfp, int forced_stop, int iters_per_step,
+    int *cost_list, int *mvjcost, int *mvcost[2], int *distortion,
+    unsigned int *sse1, const uint8_t *second_pred,
+#if CONFIG_EXT_INTER
+    const uint8_t *mask, int mask_stride, int invert_mask,
+#endif
+    int w, int h, int use_upsampled_ref) {
   const uint8_t *const src_address = x->plane[0].src.buf;
   const int src_stride = x->plane[0].src.stride;
   const MACROBLOCKD *xd = &x->e_mbd;
@@ -700,12 +820,19 @@
   if (use_upsampled_ref)
     besterr = upsampled_setup_center_error(
         xd, bestmv, ref_mv, error_per_bit, vfp, src_address, src_stride, y,
-        y_stride, second_pred, w, h, (offset * 8), mvjcost, mvcost, sse1,
-        distortion);
+        y_stride, second_pred,
+#if CONFIG_EXT_INTER
+        mask, mask_stride, invert_mask,
+#endif
+        w, h, (offset * 8), mvjcost, mvcost, sse1, distortion);
   else
-    besterr = setup_center_error(
-        xd, bestmv, ref_mv, error_per_bit, vfp, src_address, src_stride, y,
-        y_stride, second_pred, w, h, offset, mvjcost, mvcost, sse1, distortion);
+    besterr =
+        setup_center_error(xd, bestmv, ref_mv, error_per_bit, vfp, src_address,
+                           src_stride, y, y_stride, second_pred,
+#if CONFIG_EXT_INTER
+                           mask, mask_stride, invert_mask,
+#endif
+                           w, h, offset, mvjcost, mvcost, sse1, distortion);
 
   (void)cost_list;  // to silence compiler warning
 
@@ -721,14 +848,23 @@
           const uint8_t *const pre_address = y + tr * y_stride + tc;
 
           thismse = upsampled_pref_error(xd, vfp, src_address, src_stride,
-                                         pre_address, y_stride, second_pred, w,
-                                         h, &sse);
+                                         pre_address, y_stride, second_pred,
+#if CONFIG_EXT_INTER
+                                         mask, mask_stride, invert_mask,
+#endif
+                                         w, h, &sse);
         } else {
           const uint8_t *const pre_address =
               y + (tr >> 3) * y_stride + (tc >> 3);
           if (second_pred == NULL)
             thismse = vfp->svf(pre_address, y_stride, sp(tc), sp(tr),
                                src_address, src_stride, &sse);
+#if CONFIG_EXT_INTER
+          else if (mask)
+            thismse = vfp->mcsvf(pre_address, y_stride, sp(tc), sp(tr),
+                                 src_address, src_stride, second_pred, mask,
+                                 mask_stride, invert_mask, &sse);
+#endif
           else
             thismse = vfp->svaf(pre_address, y_stride, sp(tc), sp(tr),
                                 src_address, src_stride, &sse, second_pred);
@@ -760,15 +896,24 @@
       if (use_upsampled_ref) {
         const uint8_t *const pre_address = y + tr * y_stride + tc;
 
-        thismse =
-            upsampled_pref_error(xd, vfp, src_address, src_stride, pre_address,
-                                 y_stride, second_pred, w, h, &sse);
+        thismse = upsampled_pref_error(xd, vfp, src_address, src_stride,
+                                       pre_address, y_stride, second_pred,
+#if CONFIG_EXT_INTER
+                                       mask, mask_stride, invert_mask,
+#endif
+                                       w, h, &sse);
       } else {
         const uint8_t *const pre_address = y + (tr >> 3) * y_stride + (tc >> 3);
 
         if (second_pred == NULL)
           thismse = vfp->svf(pre_address, y_stride, sp(tc), sp(tr), src_address,
                              src_stride, &sse);
+#if CONFIG_EXT_INTER
+        else if (mask)
+          thismse = vfp->mcsvf(pre_address, y_stride, sp(tc), sp(tr),
+                               src_address, src_stride, second_pred, mask,
+                               mask_stride, invert_mask, &sse);
+#endif
         else
           thismse = vfp->svaf(pre_address, y_stride, sp(tc), sp(tr),
                               src_address, src_stride, &sse, second_pred);
@@ -1232,6 +1377,27 @@
                      : 0);
 }
 
+#if CONFIG_EXT_INTER
+int av1_get_mvpred_mask_var(const MACROBLOCK *x, const MV *best_mv,
+                            const MV *center_mv, const uint8_t *second_pred,
+                            const uint8_t *mask, int mask_stride,
+                            int invert_mask, const aom_variance_fn_ptr_t *vfp,
+                            int use_mvcost) {
+  const MACROBLOCKD *const xd = &x->e_mbd;
+  const struct buf_2d *const what = &x->plane[0].src;
+  const struct buf_2d *const in_what = &xd->plane[0].pre[0];
+  const MV mv = { best_mv->row * 8, best_mv->col * 8 };
+  unsigned int unused;
+
+  return vfp->mcsvf(what->buf, what->stride, 0, 0,
+                    get_buf_from_mv(in_what, best_mv), in_what->stride,
+                    second_pred, mask, mask_stride, invert_mask, &unused) +
+         (use_mvcost ? mv_err_cost(&mv, center_mv, x->nmvjointcost, x->mvcost,
+                                   x->errorperbit)
+                     : 0);
+}
+#endif
+
 int av1_hex_search(MACROBLOCK *x, MV *start_mv, int search_param,
                    int sad_per_bit, int do_init_search, int *cost_list,
                    const aom_variance_fn_ptr_t *vfp, int use_mvcost,
@@ -2199,6 +2365,10 @@
 // mode.
 int av1_refining_search_8p_c(MACROBLOCK *x, int error_per_bit, int search_range,
                              const aom_variance_fn_ptr_t *fn_ptr,
+#if CONFIG_EXT_INTER
+                             const uint8_t *mask, int mask_stride,
+                             int invert_mask,
+#endif
                              const MV *center_mv, const uint8_t *second_pred) {
   const MV neighbors[8] = { { -1, 0 },  { 0, -1 }, { 0, 1 },  { 1, 0 },
                             { -1, -1 }, { 1, -1 }, { -1, 1 }, { 1, 1 } };
@@ -2212,10 +2382,18 @@
 
   clamp_mv(best_mv, x->mv_limits.col_min, x->mv_limits.col_max,
            x->mv_limits.row_min, x->mv_limits.row_max);
-  best_sad =
-      fn_ptr->sdaf(what->buf, what->stride, get_buf_from_mv(in_what, best_mv),
-                   in_what->stride, second_pred) +
-      mvsad_err_cost(x, best_mv, &fcenter_mv, error_per_bit);
+#if CONFIG_EXT_INTER
+  if (mask)
+    best_sad = fn_ptr->mcsdf(what->buf, what->stride,
+                             get_buf_from_mv(in_what, best_mv), in_what->stride,
+                             second_pred, mask, mask_stride, invert_mask) +
+               mvsad_err_cost(x, best_mv, &fcenter_mv, error_per_bit);
+  else
+#endif
+    best_sad =
+        fn_ptr->sdaf(what->buf, what->stride, get_buf_from_mv(in_what, best_mv),
+                     in_what->stride, second_pred) +
+        mvsad_err_cost(x, best_mv, &fcenter_mv, error_per_bit);
 
   for (i = 0; i < search_range; ++i) {
     int best_site = -1;
@@ -2225,9 +2403,17 @@
                       best_mv->col + neighbors[j].col };
 
       if (is_mv_in(&x->mv_limits, &mv)) {
-        unsigned int sad =
-            fn_ptr->sdaf(what->buf, what->stride, get_buf_from_mv(in_what, &mv),
-                         in_what->stride, second_pred);
+        unsigned int sad;
+#if CONFIG_EXT_INTER
+        if (mask)
+          sad = fn_ptr->mcsdf(what->buf, what->stride,
+                              get_buf_from_mv(in_what, &mv), in_what->stride,
+                              second_pred, mask, mask_stride, invert_mask);
+        else
+#endif
+          sad = fn_ptr->sdaf(what->buf, what->stride,
+                             get_buf_from_mv(in_what, &mv), in_what->stride,
+                             second_pred);
         if (sad < best_sad) {
           sad += mvsad_err_cost(x, &mv, &fcenter_mv, error_per_bit);
           if (sad < best_sad) {
@@ -3453,15 +3639,21 @@
   (void)thismse;           \
   (void)cost_list;
 // Return the maximum MV.
-int av1_return_max_sub_pixel_mv(MACROBLOCK *x, const MV *ref_mv, int allow_hp,
-                                int error_per_bit,
-                                const aom_variance_fn_ptr_t *vfp,
-                                int forced_stop, int iters_per_step,
-                                int *cost_list, int *mvjcost, int *mvcost[2],
-                                int *distortion, unsigned int *sse1,
-                                const uint8_t *second_pred, int w, int h,
-                                int use_upsampled_ref) {
+int av1_return_max_sub_pixel_mv(
+    MACROBLOCK *x, const MV *ref_mv, int allow_hp, int error_per_bit,
+    const aom_variance_fn_ptr_t *vfp, int forced_stop, int iters_per_step,
+    int *cost_list, int *mvjcost, int *mvcost[2], int *distortion,
+    unsigned int *sse1, const uint8_t *second_pred,
+#if CONFIG_EXT_INTER
+    const uint8_t *mask, int mask_stride, int invert_mask,
+#endif
+    int w, int h, int use_upsampled_ref) {
   COMMON_MV_TEST;
+#if CONFIG_EXT_INTER
+  (void)mask;
+  (void)mask_stride;
+  (void)invert_mask;
+#endif
   (void)minr;
   (void)minc;
   bestmv->row = maxr;
@@ -3473,17 +3665,23 @@
   return besterr;
 }
 // Return the minimum MV.
-int av1_return_min_sub_pixel_mv(MACROBLOCK *x, const MV *ref_mv, int allow_hp,
-                                int error_per_bit,
-                                const aom_variance_fn_ptr_t *vfp,
-                                int forced_stop, int iters_per_step,
-                                int *cost_list, int *mvjcost, int *mvcost[2],
-                                int *distortion, unsigned int *sse1,
-                                const uint8_t *second_pred, int w, int h,
-                                int use_upsampled_ref) {
+int av1_return_min_sub_pixel_mv(
+    MACROBLOCK *x, const MV *ref_mv, int allow_hp, int error_per_bit,
+    const aom_variance_fn_ptr_t *vfp, int forced_stop, int iters_per_step,
+    int *cost_list, int *mvjcost, int *mvcost[2], int *distortion,
+    unsigned int *sse1, const uint8_t *second_pred,
+#if CONFIG_EXT_INTER
+    const uint8_t *mask, int mask_stride, int invert_mask,
+#endif
+    int w, int h, int use_upsampled_ref) {
   COMMON_MV_TEST;
   (void)maxr;
   (void)maxc;
+#if CONFIG_EXT_INTER
+  (void)mask;
+  (void)mask_stride;
+  (void)invert_mask;
+#endif
   bestmv->row = minr;
   bestmv->col = minc;
   besterr = 0;
diff --git a/av1/encoder/mcomp.h b/av1/encoder/mcomp.h
index 8465860..eb989e8 100644
--- a/av1/encoder/mcomp.h
+++ b/av1/encoder/mcomp.h
@@ -58,6 +58,13 @@
 int av1_get_mvpred_av_var(const MACROBLOCK *x, const MV *best_mv,
                           const MV *center_mv, const uint8_t *second_pred,
                           const aom_variance_fn_ptr_t *vfp, int use_mvcost);
+#if CONFIG_EXT_INTER
+int av1_get_mvpred_mask_var(const MACROBLOCK *x, const MV *best_mv,
+                            const MV *center_mv, const uint8_t *second_pred,
+                            const uint8_t *mask, int mask_stride,
+                            int invert_mask, const aom_variance_fn_ptr_t *vfp,
+                            int use_mvcost);
+#endif
 
 struct AV1_COMP;
 struct SPEED_FEATURES;
@@ -91,8 +98,11 @@
     const aom_variance_fn_ptr_t *vfp,
     int forced_stop,  // 0 - full, 1 - qtr only, 2 - half only
     int iters_per_step, int *cost_list, int *mvjcost, int *mvcost[2],
-    int *distortion, unsigned int *sse1, const uint8_t *second_pred, int w,
-    int h, int use_upsampled_ref);
+    int *distortion, unsigned int *sse1, const uint8_t *second_pred,
+#if CONFIG_EXT_INTER
+    const uint8_t *mask, int mask_stride, int invert_mask,
+#endif
+    int w, int h, int use_upsampled_ref);
 
 extern fractional_mv_step_fp av1_find_best_sub_pixel_tree;
 extern fractional_mv_step_fp av1_find_best_sub_pixel_tree_pruned;
@@ -113,6 +123,10 @@
 
 int av1_refining_search_8p_c(MACROBLOCK *x, int error_per_bit, int search_range,
                              const aom_variance_fn_ptr_t *fn_ptr,
+#if CONFIG_EXT_INTER
+                             const uint8_t *mask, int mask_stride,
+                             int invert_mask,
+#endif
                              const MV *center_mv, const uint8_t *second_pred);
 
 struct AV1_COMP;
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index a4aff3c..63e594a 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -5452,7 +5452,8 @@
                                 BLOCK_SIZE bsize, int_mv *frame_mv, int mi_row,
                                 int mi_col,
 #if CONFIG_EXT_INTER
-                                int_mv *ref_mv_sub8x8[2],
+                                int_mv *ref_mv_sub8x8[2], const uint8_t *mask,
+                                int mask_stride,
 #endif  // CONFIG_EXT_INTER
                                 int *rate_mv, const int block) {
   const AV1_COMMON *const cm = &cpi->common;
@@ -5618,10 +5619,21 @@
     // Small-range full-pixel motion search.
     bestsme =
         av1_refining_search_8p_c(x, sadpb, search_range, &cpi->fn_ptr[bsize],
+#if CONFIG_EXT_INTER
+                                 mask, mask_stride, id,
+#endif
                                  &ref_mv[id].as_mv, second_pred);
-    if (bestsme < INT_MAX)
-      bestsme = av1_get_mvpred_av_var(x, best_mv, &ref_mv[id].as_mv,
-                                      second_pred, &cpi->fn_ptr[bsize], 1);
+    if (bestsme < INT_MAX) {
+#if CONFIG_EXT_INTER
+      if (mask)
+        bestsme = av1_get_mvpred_mask_var(x, best_mv, &ref_mv[id].as_mv,
+                                          second_pred, mask, mask_stride, id,
+                                          &cpi->fn_ptr[bsize], 1);
+      else
+#endif
+        bestsme = av1_get_mvpred_av_var(x, best_mv, &ref_mv[id].as_mv,
+                                        second_pred, &cpi->fn_ptr[bsize], 1);
+    }
 
     x->mv_limits = tmp_mv_limits;
 
@@ -5654,7 +5666,11 @@
             x, &ref_mv[id].as_mv, cpi->common.allow_high_precision_mv,
             x->errorperbit, &cpi->fn_ptr[bsize], 0,
             cpi->sf.mv.subpel_iters_per_step, NULL, x->nmvjointcost, x->mvcost,
-            &dis, &sse, second_pred, pw, ph, 1);
+            &dis, &sse, second_pred,
+#if CONFIG_EXT_INTER
+            mask, mask_stride, id,
+#endif
+            pw, ph, 1);
 
         // Restore the reference frames.
         pd->pre[0] = backup_pred;
@@ -5664,7 +5680,11 @@
             x, &ref_mv[id].as_mv, cpi->common.allow_high_precision_mv,
             x->errorperbit, &cpi->fn_ptr[bsize], 0,
             cpi->sf.mv.subpel_iters_per_step, NULL, x->nmvjointcost, x->mvcost,
-            &dis, &sse, second_pred, pw, ph, 0);
+            &dis, &sse, second_pred,
+#if CONFIG_EXT_INTER
+            mask, mask_stride, id,
+#endif
+            pw, ph, 0);
       }
     }
 
@@ -6060,8 +6080,11 @@
                   cpi->sf.mv.subpel_force_stop,
                   cpi->sf.mv.subpel_iters_per_step,
                   cond_cost_list(cpi, cost_list), x->nmvjointcost, x->mvcost,
-                  &distortion, &x->pred_sse[mbmi->ref_frame[0]], NULL, pw, ph,
-                  1);
+                  &distortion, &x->pred_sse[mbmi->ref_frame[0]], NULL,
+#if CONFIG_EXT_INTER
+                  NULL, 0, 0,
+#endif
+                  pw, ph, 1);
 
               if (try_second) {
                 int this_var;
@@ -6088,7 +6111,11 @@
                       cpi->sf.mv.subpel_iters_per_step,
                       cond_cost_list(cpi, cost_list), x->nmvjointcost,
                       x->mvcost, &distortion, &x->pred_sse[mbmi->ref_frame[0]],
-                      NULL, pw, ph, 1);
+                      NULL,
+#if CONFIG_EXT_INTER
+                      NULL, 0, 0,
+#endif
+                      pw, ph, 1);
                   if (this_var < best_mv_var) best_mv = x->best_mv.as_mv;
                   x->best_mv.as_mv = best_mv;
                 }
@@ -6103,7 +6130,11 @@
                   cpi->sf.mv.subpel_force_stop,
                   cpi->sf.mv.subpel_iters_per_step,
                   cond_cost_list(cpi, cost_list), x->nmvjointcost, x->mvcost,
-                  &distortion, &x->pred_sse[mbmi->ref_frame[0]], NULL, 0, 0, 0);
+                  &distortion, &x->pred_sse[mbmi->ref_frame[0]], NULL,
+#if CONFIG_EXT_INTER
+                  NULL, 0, 0,
+#endif
+                  0, 0, 0);
             }
 
 // save motion search result for use in compound prediction
@@ -6165,7 +6196,7 @@
             joint_motion_search(cpi, x, bsize, frame_mv[this_mode], mi_row,
                                 mi_col,
 #if CONFIG_EXT_INTER
-                                bsi->ref_mv,
+                                bsi->ref_mv, NULL, 0,
 #endif  // CONFIG_EXT_INTER
                                 &rate_mv, index);
 #if CONFIG_EXT_INTER
@@ -6958,8 +6989,11 @@
               x, &ref_mv, cm->allow_high_precision_mv, x->errorperbit,
               &cpi->fn_ptr[bsize], cpi->sf.mv.subpel_force_stop,
               cpi->sf.mv.subpel_iters_per_step, cond_cost_list(cpi, cost_list),
-              x->nmvjointcost, x->mvcost, &dis, &x->pred_sse[ref], NULL, pw, ph,
-              1);
+              x->nmvjointcost, x->mvcost, &dis, &x->pred_sse[ref], NULL,
+#if CONFIG_EXT_INTER
+              NULL, 0, 0,
+#endif
+              pw, ph, 1);
 
           if (try_second) {
             const int minc =
@@ -6983,7 +7017,11 @@
                   &cpi->fn_ptr[bsize], cpi->sf.mv.subpel_force_stop,
                   cpi->sf.mv.subpel_iters_per_step,
                   cond_cost_list(cpi, cost_list), x->nmvjointcost, x->mvcost,
-                  &dis, &x->pred_sse[ref], NULL, pw, ph, 1);
+                  &dis, &x->pred_sse[ref], NULL,
+#if CONFIG_EXT_INTER
+                  NULL, 0, 0,
+#endif
+                  pw, ph, 1);
               if (this_var < best_mv_var) best_mv = x->best_mv.as_mv;
               x->best_mv.as_mv = best_mv;
             }
@@ -6996,8 +7034,11 @@
               x, &ref_mv, cm->allow_high_precision_mv, x->errorperbit,
               &cpi->fn_ptr[bsize], cpi->sf.mv.subpel_force_stop,
               cpi->sf.mv.subpel_iters_per_step, cond_cost_list(cpi, cost_list),
-              x->nmvjointcost, x->mvcost, &dis, &x->pred_sse[ref], NULL, 0, 0,
-              0);
+              x->nmvjointcost, x->mvcost, &dis, &x->pred_sse[ref], NULL,
+#if CONFIG_EXT_INTER
+              NULL, 0, 0,
+#endif
+              0, 0, 0);
         }
 #if CONFIG_MOTION_VAR
         break;
@@ -7161,7 +7202,7 @@
 }
 
 static void do_masked_motion_search_indexed(
-    const AV1_COMP *const cpi, MACROBLOCK *x,
+    const AV1_COMP *const cpi, MACROBLOCK *x, const int_mv *const cur_mv,
     const INTERINTER_COMPOUND_DATA *const comp_data, BLOCK_SIZE bsize,
     int mi_row, int mi_col, int_mv *tmp_mv, int *rate_mv, int which) {
   // NOTE: which values: 0 - 0 only, 1 - 1 only, 2 - both
@@ -7173,11 +7214,21 @@
 
   mask = av1_get_compound_type_mask(comp_data, sb_type);
 
-  if (which == 0 || which == 2)
-    do_masked_motion_search(cpi, x, mask, mask_stride, bsize, mi_row, mi_col,
-                            &tmp_mv[0], &rate_mv[0], 0);
+  if (which == 2) {
+    int_mv frame_mv[TOTAL_REFS_PER_FRAME];
+    MV_REFERENCE_FRAME rf[2] = { mbmi->ref_frame[0], mbmi->ref_frame[1] };
+    assert(bsize >= BLOCK_8X8 || CONFIG_CB4X4);
 
-  if (which == 1 || which == 2) {
+    frame_mv[rf[0]].as_int = cur_mv[0].as_int;
+    frame_mv[rf[1]].as_int = cur_mv[1].as_int;
+    joint_motion_search(cpi, x, bsize, frame_mv, mi_row, mi_col, NULL, mask,
+                        mask_stride, rate_mv, 0);
+    tmp_mv[0].as_int = frame_mv[rf[0]].as_int;
+    tmp_mv[1].as_int = frame_mv[rf[1]].as_int;
+  } else if (which == 0) {
+    do_masked_motion_search(cpi, x, mask, mask_stride, bsize, mi_row, mi_col,
+                            &tmp_mv[0], rate_mv, 0);
+  } else if (which == 1) {
 // get the negative mask
 #if CONFIG_COMPOUND_SEGMENT
     uint8_t inv_mask_buf[2 * MAX_SB_SQUARE];
@@ -7188,7 +7239,7 @@
     mask = av1_get_compound_type_mask_inverse(comp_data, sb_type);
 #endif  // CONFIG_COMPOUND_SEGMENT
     do_masked_motion_search(cpi, x, mask, mask_stride, bsize, mi_row, mi_col,
-                            &tmp_mv[1], &rate_mv[1], 1);
+                            &tmp_mv[1], rate_mv, 1);
   }
 }
 #endif  // CONFIG_COMPOUND_SEGMENT || CONFIG_WEDGE
@@ -7665,15 +7716,13 @@
   }
 }
 
-static int interinter_compound_motion_search(const AV1_COMP *const cpi,
-                                             MACROBLOCK *x,
-                                             const BLOCK_SIZE bsize,
-                                             const int this_mode, int mi_row,
-                                             int mi_col) {
+static int interinter_compound_motion_search(
+    const AV1_COMP *const cpi, MACROBLOCK *x, const int_mv *const cur_mv,
+    const BLOCK_SIZE bsize, const int this_mode, int mi_row, int mi_col) {
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
   int_mv tmp_mv[2];
-  int rate_mvs[2], tmp_rate_mv = 0;
+  int tmp_rate_mv = 0;
   const INTERINTER_COMPOUND_DATA compound_data = {
 #if CONFIG_WEDGE
     mbmi->wedge_index,
@@ -7686,20 +7735,17 @@
     mbmi->interinter_compound_type
   };
   if (this_mode == NEW_NEWMV) {
-    do_masked_motion_search_indexed(cpi, x, &compound_data, bsize, mi_row,
-                                    mi_col, tmp_mv, rate_mvs, 2);
-    tmp_rate_mv = rate_mvs[0] + rate_mvs[1];
+    do_masked_motion_search_indexed(cpi, x, cur_mv, &compound_data, bsize,
+                                    mi_row, mi_col, tmp_mv, &tmp_rate_mv, 2);
     mbmi->mv[0].as_int = tmp_mv[0].as_int;
     mbmi->mv[1].as_int = tmp_mv[1].as_int;
   } else if (this_mode == NEW_NEARESTMV || this_mode == NEW_NEARMV) {
-    do_masked_motion_search_indexed(cpi, x, &compound_data, bsize, mi_row,
-                                    mi_col, tmp_mv, rate_mvs, 0);
-    tmp_rate_mv = rate_mvs[0];
+    do_masked_motion_search_indexed(cpi, x, cur_mv, &compound_data, bsize,
+                                    mi_row, mi_col, tmp_mv, &tmp_rate_mv, 0);
     mbmi->mv[0].as_int = tmp_mv[0].as_int;
   } else if (this_mode == NEAREST_NEWMV || this_mode == NEAR_NEWMV) {
-    do_masked_motion_search_indexed(cpi, x, &compound_data, bsize, mi_row,
-                                    mi_col, tmp_mv, rate_mvs, 1);
-    tmp_rate_mv = rate_mvs[1];
+    do_masked_motion_search_indexed(cpi, x, cur_mv, &compound_data, bsize,
+                                    mi_row, mi_col, tmp_mv, &tmp_rate_mv, 1);
     mbmi->mv[1].as_int = tmp_mv[1].as_int;
   }
   return tmp_rate_mv;
@@ -7726,8 +7772,8 @@
 
   if (have_newmv_in_inter_mode(this_mode) &&
       use_masked_motion_search(compound_type)) {
-    *out_rate_mv = interinter_compound_motion_search(cpi, x, bsize, this_mode,
-                                                     mi_row, mi_col);
+    *out_rate_mv = interinter_compound_motion_search(cpi, x, cur_mv, bsize,
+                                                     this_mode, mi_row, mi_col);
     av1_build_inter_predictors_sby(cm, xd, mi_row, mi_col, ctx, bsize);
     model_rd_for_sb(cpi, bsize, x, xd, 0, 0, &rate_sum, &dist_sum,
                     &tmp_skip_txfm_sb, &tmp_skip_sse_sb);
@@ -7823,8 +7869,8 @@
       frame_mv[refs[1]].as_int = single_newmv[refs[1]].as_int;
 
       if (cpi->sf.comp_inter_joint_search_thresh <= bsize) {
-        joint_motion_search(cpi, x, bsize, frame_mv, mi_row, mi_col, NULL,
-                            rate_mv, 0);
+        joint_motion_search(cpi, x, bsize, frame_mv, mi_row, mi_col, NULL, NULL,
+                            0, rate_mv, 0);
       } else {
         *rate_mv = 0;
         for (i = 0; i < 2; ++i) {
diff --git a/av1/encoder/temporal_filter.c b/av1/encoder/temporal_filter.c
index 98feb87..7508de8 100644
--- a/av1/encoder/temporal_filter.c
+++ b/av1/encoder/temporal_filter.c
@@ -297,8 +297,11 @@
   bestsme = cpi->find_fractional_mv_step(
       x, &best_ref_mv1, cpi->common.allow_high_precision_mv, x->errorperbit,
       &cpi->fn_ptr[BLOCK_16X16], 0, mv_sf->subpel_iters_per_step,
-      cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL, 0, 0,
-      0);
+      cond_cost_list(cpi, cost_list), NULL, NULL, &distortion, &sse, NULL,
+#if CONFIG_EXT_INTER
+      NULL, 0, 0,
+#endif
+      0, 0, 0);
 
   x->e_mbd.mi[0]->bmi[0].as_mv[0] = x->best_mv;