diff --git a/aom_dsp/arm/mem_neon.h b/aom_dsp/arm/mem_neon.h
index b5deb9c..fa571a6 100644
--- a/aom_dsp/arm/mem_neon.h
+++ b/aom_dsp/arm/mem_neon.h
@@ -642,6 +642,28 @@
   vst1_s16(s, s3);
 }
 
+static INLINE void store_s16_4x8(int16_t *s, ptrdiff_t dst_stride,
+                                 const int16x4_t s0, const int16x4_t s1,
+                                 const int16x4_t s2, const int16x4_t s3,
+                                 const int16x4_t s4, const int16x4_t s5,
+                                 const int16x4_t s6, const int16x4_t s7) {
+  vst1_s16(s, s0);
+  s += dst_stride;
+  vst1_s16(s, s1);
+  s += dst_stride;
+  vst1_s16(s, s2);
+  s += dst_stride;
+  vst1_s16(s, s3);
+  s += dst_stride;
+  vst1_s16(s, s4);
+  s += dst_stride;
+  vst1_s16(s, s5);
+  s += dst_stride;
+  vst1_s16(s, s6);
+  s += dst_stride;
+  vst1_s16(s, s7);
+}
+
 static INLINE void store_s16_8x4(int16_t *s, ptrdiff_t dst_stride,
                                  const int16x8_t s0, const int16x8_t s1,
                                  const int16x8_t s2, const int16x8_t s3) {
diff --git a/aom_dsp/arm/transpose_neon.h b/aom_dsp/arm/transpose_neon.h
index 8027018..9fc4fb0 100644
--- a/aom_dsp/arm/transpose_neon.h
+++ b/aom_dsp/arm/transpose_neon.h
@@ -325,6 +325,41 @@
   *a3 = vreinterpret_u8_u16(c1.val[1]);
 }
 
+static INLINE void transpose_elems_inplace_u8_16x4(uint8x16_t *a0,
+                                                   uint8x16_t *a1,
+                                                   uint8x16_t *a2,
+                                                   uint8x16_t *a3) {
+  // Swap 8 bit elements. Goes from:
+  // a0: 00 01 02 03 04 05 06 07 08 09 010 011 012 013 014 015
+  // a1: 10 11 12 13 14 15 16 17 18 19 110 111 112 113 114 115
+  // a2: 20 21 22 23 24 25 26 27 28 29 210 211 212 213 214 215
+  // a3: 30 31 32 33 34 35 36 37 38 39 310 311 312 313 314 315
+  // to:
+  // b0.val[0]: 00 10 02 12 04 14 06 16 08 18 010 110 012 112 014 114
+  // b0.val[1]: 01 11 03 13 05 15 07 17 09 19 011 111 013 113 015 115
+  // b1.val[0]: 20 30 22 32 24 34 26 36 28 38 210 310 212 312 214 314
+  // b1.val[1]: 21 31 23 33 25 35 27 37 29 39 211 311 213 313 215 315
+
+  const uint8x16x2_t b0 = vtrnq_u8(*a0, *a1);
+  const uint8x16x2_t b1 = vtrnq_u8(*a2, *a3);
+
+  // Swap 16 bit elements resulting in:
+  // c0.val[0]: 00 10 20 30 04 14 24 34 08  18  28  38  012 112 212 312
+  // c0.val[1]: 02 12 22 32 06 16 26 36 09  19  29  39  013 113 213 313
+  // c1.val[0]: 01 11 21 31 05 15 25 35 010 110 210 310 014 114 214 314
+  // c1.val[1]: 03 13 23 33 07 17 27 37 011 111 211 311 015 115 215 315
+
+  const uint16x8x2_t c0 = vtrnq_u16(vreinterpretq_u16_u8(b0.val[0]),
+                                    vreinterpretq_u16_u8(b1.val[0]));
+  const uint16x8x2_t c1 = vtrnq_u16(vreinterpretq_u16_u8(b0.val[1]),
+                                    vreinterpretq_u16_u8(b1.val[1]));
+
+  *a0 = vreinterpretq_u8_u16(c0.val[0]);
+  *a1 = vreinterpretq_u8_u16(c1.val[0]);
+  *a2 = vreinterpretq_u8_u16(c0.val[1]);
+  *a3 = vreinterpretq_u8_u16(c1.val[1]);
+}
+
 static INLINE void transpose_elems_inplace_u8_4x4(uint8x8_t *a0,
                                                   uint8x8_t *a1) {
   // Swap 16 bit elements. Goes from:
@@ -885,6 +920,40 @@
   out[7] = d3.val[1];
 }
 
+static INLINE void transpose_elems_inplace_s16_8x4(int16x8_t *a0, int16x8_t *a1,
+                                                   int16x8_t *a2,
+                                                   int16x8_t *a3) {
+  // Swap 16 bit elements. Goes from:
+  // a0: 00 01 02 03 04 05 06 07
+  // a1: 10 11 12 13 14 15 16 17
+  // a2: 20 21 22 23 24 25 26 27
+  // a3: 30 31 32 33 34 35 36 37
+  // to:
+  // b0.val[0]: 00 10 02 12 04 14 06 16
+  // b0.val[1]: 01 11 03 13 05 15 07 17
+  // b1.val[0]: 20 30 22 32 24 34 26 36
+  // b1.val[1]: 21 31 23 33 25 35 27 37
+
+  const int16x8x2_t b0 = vtrnq_s16(*a0, *a1);
+  const int16x8x2_t b1 = vtrnq_s16(*a2, *a3);
+
+  // Swap 32 bit elements resulting in:
+  // c0.val[0]: 00 10 20 30 04 14 24 34
+  // c0.val[1]: 01 11 21 31 05 15 25 35
+  // c1.val[0]: 02 12 22 32 06 16 26 36
+  // c1.val[1]: 03 13 23 33 07 17 27 37
+
+  const int32x4x2_t c0 = vtrnq_s32(vreinterpretq_s32_s16(b0.val[0]),
+                                   vreinterpretq_s32_s16(b1.val[0]));
+  const int32x4x2_t c1 = vtrnq_s32(vreinterpretq_s32_s16(b0.val[1]),
+                                   vreinterpretq_s32_s16(b1.val[1]));
+
+  *a0 = vreinterpretq_s16_s32(c0.val[0]);
+  *a1 = vreinterpretq_s16_s32(c1.val[0]);
+  *a2 = vreinterpretq_s16_s32(c0.val[1]);
+  *a3 = vreinterpretq_s16_s32(c1.val[1]);
+}
+
 static INLINE void transpose_elems_inplace_u16_4x4(uint16x4_t *a0,
                                                    uint16x4_t *a1,
                                                    uint16x4_t *a2,
diff --git a/av1/common/arm/av1_convolve_scale_neon.c b/av1/common/arm/av1_convolve_scale_neon.c
index 88d126e..114232d 100644
--- a/av1/common/arm/av1_convolve_scale_neon.c
+++ b/av1/common/arm/av1_convolve_scale_neon.c
@@ -351,6 +351,284 @@
   }
 }
 
+static INLINE void convolve_horiz_scale_2_8tap_neon(
+    const uint8_t *src, int src_stride, int16_t *dst, int dst_stride, int w,
+    int h, const int16_t *x_filter) {
+  const int bd = 8;
+
+  if (w == 4) {
+    // A shim of 1 << (ROUND0_BITS - 1) enables us to use non-rounding
+    // shifts - which are generally faster than rounding shifts on modern CPUs.
+    const int32x4_t horiz_offset =
+        vdupq_n_s32((1 << (bd + FILTER_BITS - 1)) + (1 << (ROUND0_BITS - 1)));
+    const int16x8_t filter = vld1q_s16(x_filter);
+
+    do {
+      uint8x16_t t0, t1, t2, t3;
+      load_u8_16x4(src, src_stride, &t0, &t1, &t2, &t3);
+      transpose_elems_inplace_u8_16x4(&t0, &t1, &t2, &t3);
+
+      int16x8_t tt0 = vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(t0)));
+      int16x8_t tt1 = vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(t1)));
+      int16x8_t tt2 = vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(t2)));
+      int16x8_t tt3 = vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(t3)));
+      int16x8_t tt4 = vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(t0)));
+      int16x8_t tt5 = vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(t1)));
+      int16x8_t tt6 = vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(t2)));
+      int16x8_t tt7 = vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(t3)));
+
+      int16x4_t s0 = vget_low_s16(tt0);
+      int16x4_t s1 = vget_low_s16(tt1);
+      int16x4_t s2 = vget_low_s16(tt2);
+      int16x4_t s3 = vget_low_s16(tt3);
+      int16x4_t s4 = vget_high_s16(tt0);
+      int16x4_t s5 = vget_high_s16(tt1);
+      int16x4_t s6 = vget_high_s16(tt2);
+      int16x4_t s7 = vget_high_s16(tt3);
+      int16x4_t s8 = vget_low_s16(tt4);
+      int16x4_t s9 = vget_low_s16(tt5);
+      int16x4_t s10 = vget_low_s16(tt6);
+      int16x4_t s11 = vget_low_s16(tt7);
+      int16x4_t s12 = vget_high_s16(tt4);
+      int16x4_t s13 = vget_high_s16(tt5);
+
+      int16x4_t d0 =
+          convolve8_4_h(s0, s1, s2, s3, s4, s5, s6, s7, filter, horiz_offset);
+      int16x4_t d1 =
+          convolve8_4_h(s2, s3, s4, s5, s6, s7, s8, s9, filter, horiz_offset);
+      int16x4_t d2 =
+          convolve8_4_h(s4, s5, s6, s7, s8, s9, s10, s11, filter, horiz_offset);
+      int16x4_t d3 = convolve8_4_h(s6, s7, s8, s9, s10, s11, s12, s13, filter,
+                                   horiz_offset);
+
+      transpose_elems_inplace_s16_4x4(&d0, &d1, &d2, &d3);
+
+      store_s16_4x4(dst, dst_stride, d0, d1, d2, d3);
+
+      dst += 4 * dst_stride;
+      src += 4 * src_stride;
+      h -= 4;
+    } while (h > 0);
+  } else {
+    // A shim of 1 << (ROUND0_BITS - 1) enables us to use non-rounding
+    // shifts - which are generally faster than rounding shifts on modern CPUs.
+    // The additional -1 is needed because we are halving the filter values.
+    const int16x8_t horiz_offset =
+        vdupq_n_s16((1 << (bd + FILTER_BITS - 2)) + (1 << (ROUND0_BITS - 2)));
+    // Filter values are all even so halve them to allow convolution
+    // kernel computations to stay in 16-bit element types.
+    const int16x8_t filter = vshrq_n_s16(vld1q_s16(x_filter), 1);
+
+    do {
+      const uint8_t *s = src;
+      int16_t *d = dst;
+      int width = w;
+
+      uint8x8_t t0, t1, t2, t3, t4, t5, t6, t7;
+      load_u8_8x8(s, src_stride, &t0, &t1, &t2, &t3, &t4, &t5, &t6, &t7);
+      transpose_elems_u8_8x8(t0, t1, t2, t3, t4, t5, t6, t7, &t0, &t1, &t2, &t3,
+                             &t4, &t5, &t6, &t7);
+
+      s += 8;
+
+      int16x8_t s0 = vreinterpretq_s16_u16(vmovl_u8(t0));
+      int16x8_t s1 = vreinterpretq_s16_u16(vmovl_u8(t1));
+      int16x8_t s2 = vreinterpretq_s16_u16(vmovl_u8(t2));
+      int16x8_t s3 = vreinterpretq_s16_u16(vmovl_u8(t3));
+      int16x8_t s4 = vreinterpretq_s16_u16(vmovl_u8(t4));
+      int16x8_t s5 = vreinterpretq_s16_u16(vmovl_u8(t5));
+      int16x8_t s6 = vreinterpretq_s16_u16(vmovl_u8(t6));
+      int16x8_t s7 = vreinterpretq_s16_u16(vmovl_u8(t7));
+
+      do {
+        uint8x8_t t8, t9, t10, t11, t12, t13, t14, t15;
+        load_u8_8x8(s, src_stride, &t8, &t9, &t10, &t11, &t12, &t13, &t14,
+                    &t15);
+        transpose_elems_u8_8x8(t8, t9, t10, t11, t12, t13, t14, t15, &t8, &t9,
+                               &t10, &t11, &t12, &t13, &t14, &t15);
+
+        int16x8_t s8 = vreinterpretq_s16_u16(vmovl_u8(t8));
+        int16x8_t s9 = vreinterpretq_s16_u16(vmovl_u8(t9));
+        int16x8_t s10 = vreinterpretq_s16_u16(vmovl_u8(t10));
+        int16x8_t s11 = vreinterpretq_s16_u16(vmovl_u8(t11));
+        int16x8_t s12 = vreinterpretq_s16_u16(vmovl_u8(t12));
+        int16x8_t s13 = vreinterpretq_s16_u16(vmovl_u8(t13));
+        int16x8_t s14 = vreinterpretq_s16_u16(vmovl_u8(t14));
+        int16x8_t s15 = vreinterpretq_s16_u16(vmovl_u8(t15));
+
+        int16x8_t d0 =
+            convolve8_8_h(s0, s1, s2, s3, s4, s5, s6, s7, filter, horiz_offset);
+        int16x8_t d1 =
+            convolve8_8_h(s2, s3, s4, s5, s6, s7, s8, s9, filter, horiz_offset);
+        int16x8_t d2 = convolve8_8_h(s4, s5, s6, s7, s8, s9, s10, s11, filter,
+                                     horiz_offset);
+        int16x8_t d3 = convolve8_8_h(s6, s7, s8, s9, s10, s11, s12, s13, filter,
+                                     horiz_offset);
+
+        transpose_elems_inplace_s16_8x4(&d0, &d1, &d2, &d3);
+
+        store_s16_4x8(d, dst_stride, vget_low_s16(d0), vget_low_s16(d1),
+                      vget_low_s16(d2), vget_low_s16(d3), vget_high_s16(d0),
+                      vget_high_s16(d1), vget_high_s16(d2), vget_high_s16(d3));
+
+        s0 = s8;
+        s1 = s9;
+        s2 = s10;
+        s3 = s11;
+        s4 = s12;
+        s5 = s13;
+        s6 = s14;
+        s7 = s15;
+
+        s += 8;
+        d += 4;
+        width -= 4;
+      } while (width != 0);
+
+      dst += 8 * dst_stride;
+      src += 8 * src_stride;
+      h -= 8;
+    } while (h > 0);
+  }
+}
+
+static INLINE void convolve_horiz_scale_2_6tap_neon(
+    const uint8_t *src, int src_stride, int16_t *dst, int dst_stride, int w,
+    int h, const int16_t *x_filter) {
+  const int bd = 8;
+
+  if (w == 4) {
+    // A shim of 1 << (ROUND0_BITS - 1) enables us to use non-rounding
+    // shifts - which are generally faster than rounding shifts on modern CPUs.
+    const int32x4_t horiz_offset =
+        vdupq_n_s32((1 << (bd + FILTER_BITS - 1)) + (1 << (ROUND0_BITS - 1)));
+    const int16x8_t filter = vld1q_s16(x_filter);
+
+    do {
+      uint8x16_t t0, t1, t2, t3;
+      load_u8_16x4(src, src_stride, &t0, &t1, &t2, &t3);
+      transpose_elems_inplace_u8_16x4(&t0, &t1, &t2, &t3);
+
+      int16x8_t tt0 = vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(t1)));
+      int16x8_t tt1 = vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(t2)));
+      int16x8_t tt2 = vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(t3)));
+      int16x8_t tt3 = vreinterpretq_s16_u16(vmovl_u8(vget_low_u8(t0)));
+      int16x8_t tt4 = vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(t0)));
+      int16x8_t tt5 = vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(t1)));
+      int16x8_t tt6 = vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(t2)));
+      int16x8_t tt7 = vreinterpretq_s16_u16(vmovl_u8(vget_high_u8(t3)));
+
+      int16x4_t s0 = vget_low_s16(tt0);
+      int16x4_t s1 = vget_low_s16(tt1);
+      int16x4_t s2 = vget_low_s16(tt2);
+      int16x4_t s3 = vget_high_s16(tt3);
+      int16x4_t s4 = vget_high_s16(tt0);
+      int16x4_t s5 = vget_high_s16(tt1);
+      int16x4_t s6 = vget_high_s16(tt2);
+      int16x4_t s7 = vget_low_s16(tt4);
+      int16x4_t s8 = vget_low_s16(tt5);
+      int16x4_t s9 = vget_low_s16(tt6);
+      int16x4_t s10 = vget_low_s16(tt7);
+      int16x4_t s11 = vget_high_s16(tt4);
+
+      int16x4_t d0 =
+          convolve6_4_h(s0, s1, s2, s3, s4, s5, filter, horiz_offset);
+      int16x4_t d1 =
+          convolve6_4_h(s2, s3, s4, s5, s6, s7, filter, horiz_offset);
+      int16x4_t d2 =
+          convolve6_4_h(s4, s5, s6, s7, s8, s9, filter, horiz_offset);
+      int16x4_t d3 =
+          convolve6_4_h(s6, s7, s8, s9, s10, s11, filter, horiz_offset);
+
+      transpose_elems_inplace_s16_4x4(&d0, &d1, &d2, &d3);
+
+      store_s16_4x4(dst, dst_stride, d0, d1, d2, d3);
+
+      dst += 4 * dst_stride;
+      src += 4 * src_stride;
+      h -= 4;
+    } while (h > 0);
+  } else {
+    // A shim of 1 << (ROUND0_BITS - 1) enables us to use non-rounding
+    // shifts - which are generally faster than rounding shifts on modern CPUs.
+    // The additional -1 is needed because we are halving the filter values.
+    const int16x8_t horiz_offset =
+        vdupq_n_s16((1 << (bd + FILTER_BITS - 2)) + (1 << (ROUND0_BITS - 2)));
+    // Filter values are all even so halve them to allow convolution
+    // kernel computations to stay in 16-bit element types.
+    const int16x8_t filter = vshrq_n_s16(vld1q_s16(x_filter), 1);
+
+    do {
+      const uint8_t *s = src;
+      int16_t *d = dst;
+      int width = w;
+
+      uint8x8_t t0, t1, t2, t3, t4, t5, t6, t7;
+      load_u8_8x8(s, src_stride, &t0, &t1, &t2, &t3, &t4, &t5, &t6, &t7);
+      transpose_elems_u8_8x8(t0, t1, t2, t3, t4, t5, t6, t7, &t0, &t1, &t2, &t3,
+                             &t4, &t5, &t6, &t7);
+
+      s += 8;
+
+      int16x8_t s0 = vreinterpretq_s16_u16(vmovl_u8(t1));
+      int16x8_t s1 = vreinterpretq_s16_u16(vmovl_u8(t2));
+      int16x8_t s2 = vreinterpretq_s16_u16(vmovl_u8(t3));
+      int16x8_t s3 = vreinterpretq_s16_u16(vmovl_u8(t4));
+      int16x8_t s4 = vreinterpretq_s16_u16(vmovl_u8(t5));
+      int16x8_t s5 = vreinterpretq_s16_u16(vmovl_u8(t6));
+      int16x8_t s6 = vreinterpretq_s16_u16(vmovl_u8(t7));
+
+      do {
+        uint8x8_t t8, t9, t10, t11, t12, t13, t14, t15;
+        load_u8_8x8(s, src_stride, &t8, &t9, &t10, &t11, &t12, &t13, &t14,
+                    &t15);
+        transpose_elems_u8_8x8(t8, t9, t10, t11, t12, t13, t14, t15, &t8, &t9,
+                               &t10, &t11, &t12, &t13, &t14, &t15);
+
+        int16x8_t s7 = vreinterpretq_s16_u16(vmovl_u8(t8));
+        int16x8_t s8 = vreinterpretq_s16_u16(vmovl_u8(t9));
+        int16x8_t s9 = vreinterpretq_s16_u16(vmovl_u8(t10));
+        int16x8_t s10 = vreinterpretq_s16_u16(vmovl_u8(t11));
+        int16x8_t s11 = vreinterpretq_s16_u16(vmovl_u8(t12));
+        int16x8_t s12 = vreinterpretq_s16_u16(vmovl_u8(t13));
+        int16x8_t s13 = vreinterpretq_s16_u16(vmovl_u8(t14));
+        int16x8_t s14 = vreinterpretq_s16_u16(vmovl_u8(t15));
+
+        int16x8_t d0 =
+            convolve6_8_h(s0, s1, s2, s3, s4, s5, filter, horiz_offset);
+        int16x8_t d1 =
+            convolve6_8_h(s2, s3, s4, s5, s6, s7, filter, horiz_offset);
+        int16x8_t d2 =
+            convolve6_8_h(s4, s5, s6, s7, s8, s9, filter, horiz_offset);
+        int16x8_t d3 =
+            convolve6_8_h(s6, s7, s8, s9, s10, s11, filter, horiz_offset);
+
+        transpose_elems_inplace_s16_8x4(&d0, &d1, &d2, &d3);
+
+        store_s16_4x8(d, dst_stride, vget_low_s16(d0), vget_low_s16(d1),
+                      vget_low_s16(d2), vget_low_s16(d3), vget_high_s16(d0),
+                      vget_high_s16(d1), vget_high_s16(d2), vget_high_s16(d3));
+
+        s0 = s8;
+        s1 = s9;
+        s2 = s10;
+        s3 = s11;
+        s4 = s12;
+        s5 = s13;
+        s6 = s14;
+
+        s += 8;
+        d += 4;
+        width -= 4;
+      } while (width != 0);
+
+      dst += 8 * dst_stride;
+      src += 8 * src_stride;
+      h -= 8;
+    } while (h > 0);
+  }
+}
+
 void av1_convolve_2d_scale_neon(const uint8_t *src, int src_stride,
                                 uint8_t *dst, int dst_stride, int w, int h,
                                 const InterpFilterParams *filter_params_x,
@@ -382,14 +660,41 @@
   const ptrdiff_t vert_offset = (filter_params_y->taps / 2 - 1) * src_stride;
 
   // Horizontal filter
-  if (filter_params_x->interp_filter == MULTITAP_SHARP) {
-    convolve_horiz_scale_8tap_neon(
-        src - horiz_offset - vert_offset, src_stride, im_block, im_stride, w,
-        im_h, filter_params_x->filter_ptr, subpel_x_qn, x_step_qn);
+
+  if (x_step_qn != 2 * (1 << SCALE_SUBPEL_BITS)) {
+    if (filter_params_x->interp_filter == MULTITAP_SHARP) {
+      convolve_horiz_scale_8tap_neon(
+          src - horiz_offset - vert_offset, src_stride, im_block, im_stride, w,
+          im_h, filter_params_x->filter_ptr, subpel_x_qn, x_step_qn);
+    } else {
+      convolve_horiz_scale_6tap_neon(
+          src - horiz_offset - vert_offset, src_stride, im_block, im_stride, w,
+          im_h, filter_params_x->filter_ptr, subpel_x_qn, x_step_qn);
+    }
   } else {
-    convolve_horiz_scale_6tap_neon(
-        src - horiz_offset - vert_offset, src_stride, im_block, im_stride, w,
-        im_h, filter_params_x->filter_ptr, subpel_x_qn, x_step_qn);
+    assert(subpel_x_qn < (1 << SCALE_SUBPEL_BITS));
+    // The filter index is calculated using the
+    // ((subpel_x_qn + x * x_step_qn) & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS
+    // equation, where the values of x are from 0 to w. If x_step_qn is a
+    // multiple of SCALE_SUBPEL_MASK we can leave it out of the equation.
+    const ptrdiff_t filter_offset =
+        SUBPEL_TAPS * ((subpel_x_qn & SCALE_SUBPEL_MASK) >> SCALE_EXTRA_BITS);
+    const int16_t *x_filter = filter_params_x->filter_ptr + filter_offset;
+
+    // The source index is calculated using the (subpel_x_qn + x * x_step_qn)
+    // >> SCALE_SUBPEL_BITS, where the values of x are from 0 to w. If
+    // subpel_x_qn < (1 << SCALE_SUBPEL_BITS) and x_step_qn % (1 <<
+    // SCALE_SUBPEL_BITS) == 0, the source index can be determined using the
+    // value x * (x_step_qn / (1 << SCALE_SUBPEL_BITS)).
+    if (filter_params_x->interp_filter == MULTITAP_SHARP) {
+      convolve_horiz_scale_2_8tap_neon(src - horiz_offset - vert_offset,
+                                       src_stride, im_block, im_stride, w, im_h,
+                                       x_filter);
+    } else {
+      convolve_horiz_scale_2_6tap_neon(src - horiz_offset - vert_offset,
+                                       src_stride, im_block, im_stride, w, im_h,
+                                       x_filter);
+    }
   }
 
   // Vertical filter