aarch64: vp9: Add NEON optimizations of VP9 MC functions

Message ID 1476737079-16360-1-git-send-email-martin@martin.st
State Superseded
Headers show

Commit Message

Martin Storsjö Oct. 17, 2016, 8:44 p.m.
This work is sponsored by, and copyright, Google.

These are ported from the ARM version; it is essentially a 1:1
port with no extra added features, but with some hand tuning
(especially for the plain copy/avg functions). The ARM version
isn't very register starved to begin with, so there's not much
to be gained  from having more spare registers here - we only
avoid having to clobber callee-saved registers.

Examples of runtimes vs the 32 bit version, on a Cortex A53:
                                     ARM   AArch64
vp9_avg4_neon:                      31.2      23.7
vp9_avg8_neon:                      57.0      53.7
vp9_avg16_neon:                    169.4     167.4
vp9_avg32_neon:                    717.3     716.1
vp9_avg64_neon:                   2475.5    2514.2
vp9_avg_8tap_smooth_4h_neon:       131.2     123.0
vp9_avg_8tap_smooth_4hv_neon:      505.3     458.3
vp9_avg_8tap_smooth_4v_neon:       135.0     112.2
vp9_avg_8tap_smooth_8h_neon:       238.2     231.0
vp9_avg_8tap_smooth_8hv_neon:      731.6     679.2
vp9_avg_8tap_smooth_8v_neon:       270.0     246.5
vp9_avg_8tap_smooth_64h_neon:    11503.6   11487.3
vp9_avg_8tap_smooth_64hv_neon:   25299.4   25277.8
vp9_avg_8tap_smooth_64v_neon:    13614.7   13605.8
vp9_put4_neon:                      17.2      16.5
vp9_put8_neon:                      39.2      37.8
vp9_put16_neon:                     98.6      99.2
vp9_put32_neon:                    405.1     307.4
vp9_put64_neon:                   1627.1    1107.6
vp9_put_8tap_smooth_4h_neon:       124.2     116.2
vp9_put_8tap_smooth_4hv_neon:      493.2     445.3
vp9_put_8tap_smooth_4v_neon:       122.0      99.5
vp9_put_8tap_smooth_8h_neon:       227.2     219.3
vp9_put_8tap_smooth_8hv_neon:      698.3     650.2
vp9_put_8tap_smooth_8v_neon:       240.0     218.2
vp9_put_8tap_smooth_64h_neon:    10885.1   10846.1
vp9_put_8tap_smooth_64hv_neon:   23377.7   23338.6
vp9_put_8tap_smooth_64v_neon:    11679.4   11682.5

These are generally about as fast as the corresponding ARM
routines on the same CPU (at least on the A53), in most cases
marginally faster.

The speedup vs C code is pretty much the same as for the 32 bit
case; on the A53 it's around 2-13x - slightly varying since the
C versions generally don't end up exactly as fast as on 32 bit.
---
I'm still open for comments on the ARM version as well; most comments
to that one will be applied to this one in sync, or vice versa.
---
 libavcodec/aarch64/Makefile              |   2 +
 libavcodec/aarch64/vp9dsp_init_aarch64.c | 139 ++++++
 libavcodec/aarch64/vp9mc_neon.S          | 748 +++++++++++++++++++++++++++++++
 libavcodec/vp9.h                         |   1 +
 libavcodec/vp9dsp.c                      |   2 +
 5 files changed, 892 insertions(+)
 create mode 100644 libavcodec/aarch64/vp9dsp_init_aarch64.c
 create mode 100644 libavcodec/aarch64/vp9mc_neon.S

Patch

diff --git a/libavcodec/aarch64/Makefile b/libavcodec/aarch64/Makefile
index 764bedc..6f1227a 100644
--- a/libavcodec/aarch64/Makefile
+++ b/libavcodec/aarch64/Makefile
@@ -17,6 +17,7 @@  OBJS-$(CONFIG_DCA_DECODER)              += aarch64/dcadsp_init.o
 OBJS-$(CONFIG_RV40_DECODER)             += aarch64/rv40dsp_init_aarch64.o
 OBJS-$(CONFIG_VC1_DECODER)              += aarch64/vc1dsp_init_aarch64.o
 OBJS-$(CONFIG_VORBIS_DECODER)           += aarch64/vorbisdsp_init.o
+OBJS-$(CONFIG_VP9_DECODER)              += aarch64/vp9dsp_init_aarch64.o
 
 # ARMv8 optimizations
 
@@ -43,3 +44,4 @@  NEON-OBJS-$(CONFIG_MPEGAUDIODSP)        += aarch64/mpegaudiodsp_neon.o
 NEON-OBJS-$(CONFIG_DCA_DECODER)         += aarch64/dcadsp_neon.o               \
                                            aarch64/synth_filter_neon.o
 NEON-OBJS-$(CONFIG_VORBIS_DECODER)      += aarch64/vorbisdsp_neon.o
+NEON-OBJS-$(CONFIG_VP9_DECODER)         += aarch64/vp9mc_neon.o
diff --git a/libavcodec/aarch64/vp9dsp_init_aarch64.c b/libavcodec/aarch64/vp9dsp_init_aarch64.c
new file mode 100644
index 0000000..2f772ed
--- /dev/null
+++ b/libavcodec/aarch64/vp9dsp_init_aarch64.c
@@ -0,0 +1,139 @@ 
+/*
+ * Copyright (c) 2016 Google Inc.
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+
+#include "libavutil/attributes.h"
+#include "libavutil/aarch64/cpu.h"
+#include "libavcodec/vp9.h"
+
+#define declare_fpel(type, sz)                                          \
+void ff_vp9_##type##sz##_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                              const uint8_t *src, ptrdiff_t src_stride, \
+                              int h, int mx, int my)
+
+#define declare_copy_avg(sz) \
+    declare_fpel(copy, sz);  \
+    declare_fpel(avg , sz)
+
+#define decl_mc_func(op, filter, dir, sz)                                                \
+void ff_vp9_##op##_##filter##sz##_##dir##_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                                               const uint8_t *src, ptrdiff_t src_stride, \
+                                               int h, int mx, int my)
+
+#define define_8tap_2d_fn(op, filter, sz)                                         \
+static void op##_##filter##sz##_hv_neon(uint8_t *dst, ptrdiff_t dst_stride,       \
+                                        const uint8_t *src, ptrdiff_t src_stride, \
+                                        int h, int mx, int my)                    \
+{                                                                                 \
+    LOCAL_ALIGNED_16(uint8_t, temp, [72 * 64]);                                   \
+    /* We only need h + 7 lines, but the horizontal filter assumes an             \
+     * even number of rows, so filter h + 8 lines here. */                        \
+    ff_vp9_put_##filter##sz##_h_neon(temp, 64,                                    \
+                                     src - 3 * src_stride, src_stride,            \
+                                     h + 8, mx, 0);                               \
+    ff_vp9_##op##_##filter##sz##_v_neon(dst, dst_stride,                          \
+                                        temp + 3 * 64, 64,                        \
+                                        h, 0, my);                                \
+}
+
+#define decl_filter_funcs(op, dir, sz)  \
+    decl_mc_func(op, regular, dir, sz); \
+    decl_mc_func(op, sharp,   dir, sz); \
+    decl_mc_func(op, smooth,  dir, sz)
+
+#define decl_mc_funcs(sz)           \
+    decl_filter_funcs(put, h,  sz); \
+    decl_filter_funcs(avg, h,  sz); \
+    decl_filter_funcs(put, v,  sz); \
+    decl_filter_funcs(avg, v,  sz); \
+    decl_filter_funcs(put, hv, sz); \
+    decl_filter_funcs(avg, hv, sz)
+
+declare_copy_avg(64);
+declare_copy_avg(32);
+declare_copy_avg(16);
+declare_copy_avg(8);
+declare_copy_avg(4);
+
+decl_mc_funcs(64);
+decl_mc_funcs(32);
+decl_mc_funcs(16);
+decl_mc_funcs(8);
+decl_mc_funcs(4);
+
+#define define_8tap_2d_funcs(sz)        \
+    define_8tap_2d_fn(put, regular, sz) \
+    define_8tap_2d_fn(put, sharp,   sz) \
+    define_8tap_2d_fn(put, smooth,  sz) \
+    define_8tap_2d_fn(avg, regular, sz) \
+    define_8tap_2d_fn(avg, sharp,   sz) \
+    define_8tap_2d_fn(avg, smooth,  sz)
+
+define_8tap_2d_funcs(64)
+define_8tap_2d_funcs(32)
+define_8tap_2d_funcs(16)
+define_8tap_2d_funcs(8)
+define_8tap_2d_funcs(4)
+
+av_cold void ff_vp9dsp_init_aarch64(VP9DSPContext *dsp)
+{
+    int cpu_flags = av_get_cpu_flags();
+
+    if (have_neon(cpu_flags)) {
+#define init_fpel(idx1, idx2, sz, type) \
+    dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_8TAP_SHARP  ][idx2][0][0] = \
+    dsp->mc[idx1][FILTER_BILINEAR    ][idx2][0][0] = ff_vp9_##type##sz##_neon
+
+#define init_copy_avg(idx, sz) \
+    init_fpel(idx, 0, sz, copy); \
+    init_fpel(idx, 1, sz, avg)
+
+#define init_mc_func(idx1, idx2, op, filter, fname, dir, mx, my, sz, pfx) \
+    dsp->mc[idx1][filter][idx2][mx][my] = pfx##op##_##fname##sz##_##dir##_neon
+
+#define init_mc_funcs(idx, dir, mx, my, sz, pfx) \
+    init_mc_func(idx, 0, put, FILTER_8TAP_REGULAR, regular, dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 0, put, FILTER_8TAP_SHARP,   sharp,   dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 0, put, FILTER_8TAP_SMOOTH,  smooth,  dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_REGULAR, regular, dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_SHARP,   sharp,   dir, mx, my, sz, pfx); \
+    init_mc_func(idx, 1, avg, FILTER_8TAP_SMOOTH,  smooth,  dir, mx, my, sz, pfx)
+
+#define init_mc_funcs_dirs(idx, sz) \
+    init_mc_funcs(idx, h,  1, 0, sz, ff_vp9_); \
+    init_mc_funcs(idx, v,  0, 1, sz, ff_vp9_); \
+    init_mc_funcs(idx, hv, 1, 1, sz,)
+
+        init_copy_avg(0, 64);
+        init_copy_avg(1, 32);
+        init_copy_avg(2, 16);
+        init_copy_avg(3, 8);
+        init_copy_avg(4, 4);
+
+        init_mc_funcs_dirs(0, 64);
+        init_mc_funcs_dirs(1, 32);
+        init_mc_funcs_dirs(2, 16);
+        init_mc_funcs_dirs(3, 8);
+        init_mc_funcs_dirs(4, 4);
+    }
+}
diff --git a/libavcodec/aarch64/vp9mc_neon.S b/libavcodec/aarch64/vp9mc_neon.S
new file mode 100644
index 0000000..a677087
--- /dev/null
+++ b/libavcodec/aarch64/vp9mc_neon.S
@@ -0,0 +1,748 @@ 
+/*
+ * Copyright (c) 2016 Google Inc.
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libavutil/aarch64/asm.S"
+
+const regular_filter, align=4
+        .short  0,  1,  -5, 126,   8,  -3,  1,  0
+        .short -1,  3, -10, 122,  18,  -6,  2,  0
+        .short -1,  4, -13, 118,  27,  -9,  3, -1
+        .short -1,  4, -16, 112,  37, -11,  4, -1
+        .short -1,  5, -18, 105,  48, -14,  4, -1
+        .short -1,  5, -19,  97,  58, -16,  5, -1
+        .short -1,  6, -19,  88,  68, -18,  5, -1
+        .short -1,  6, -19,  78,  78, -19,  6, -1
+        .short -1,  5, -18,  68,  88, -19,  6, -1
+        .short -1,  5, -16,  58,  97, -19,  5, -1
+        .short -1,  4, -14,  48, 105, -18,  5, -1
+        .short -1,  4, -11,  37, 112, -16,  4, -1
+        .short -1,  3,  -9,  27, 118, -13,  4, -1
+        .short  0,  2,  -6,  18, 122, -10,  3, -1
+        .short  0,  1,  -3,   8, 126,  -5,  1,  0
+endconst
+
+const sharp_filter, align=4
+        .short -1,  3,  -7, 127,   8,  -3,  1,  0
+        .short -2,  5, -13, 125,  17,  -6,  3, -1
+        .short -3,  7, -17, 121,  27, -10,  5, -2
+        .short -4,  9, -20, 115,  37, -13,  6, -2
+        .short -4, 10, -23, 108,  48, -16,  8, -3
+        .short -4, 10, -24, 100,  59, -19,  9, -3
+        .short -4, 11, -24,  90,  70, -21, 10, -4
+        .short -4, 11, -23,  80,  80, -23, 11, -4
+        .short -4, 10, -21,  70,  90, -24, 11, -4
+        .short -3,  9, -19,  59, 100, -24, 10, -4
+        .short -3,  8, -16,  48, 108, -23, 10, -4
+        .short -2,  6, -13,  37, 115, -20,  9, -4
+        .short -2,  5, -10,  27, 121, -17,  7, -3
+        .short -1,  3,  -6,  17, 125, -13,  5, -2
+        .short  0,  1,  -3,   8, 127,  -7,  3, -1
+endconst
+
+const smooth_filter, align=4
+        .short -3, -1,  32,  64,  38,   1, -3,  0
+        .short -2, -2,  29,  63,  41,   2, -3,  0
+        .short -2, -2,  26,  63,  43,   4, -4,  0
+        .short -2, -3,  24,  62,  46,   5, -4,  0
+        .short -2, -3,  21,  60,  49,   7, -4,  0
+        .short -1, -4,  18,  59,  51,   9, -4,  0
+        .short -1, -4,  16,  57,  53,  12, -4, -1
+        .short -1, -4,  14,  55,  55,  14, -4, -1
+        .short -1, -4,  12,  53,  57,  16, -4, -1
+        .short  0, -4,   9,  51,  59,  18, -4, -1
+        .short  0, -4,   7,  49,  60,  21, -3, -2
+        .short  0, -4,   5,  46,  62,  24, -3, -2
+        .short  0, -4,   4,  43,  63,  26, -2, -2
+        .short  0, -3,   2,  41,  63,  29, -2, -2
+        .short  0, -3,   1,  38,  64,  32, -1, -3
+endconst
+
+// All public functions in this file have the following signature:
+// typedef void (*vp9_mc_func)(uint8_t *dst, ptrdiff_t dst_stride,
+//                            const uint8_t *ref, ptrdiff_t ref_stride,
+//                            int h, int mx, int my);
+
+function ff_vp9_copy64_neon, export=1
+1:
+        ldp             x5,  x6,  [x2]
+        stp             x5,  x6,  [x0]
+        ldp             x5,  x6,  [x2, #16]
+        stp             x5,  x6,  [x0, #16]
+        subs            w4,  w4,  #1
+        ldp             x5,  x6,  [x2, #32]
+        stp             x5,  x6,  [x0, #32]
+        ldp             x5,  x6,  [x2, #48]
+        stp             x5,  x6,  [x0, #48]
+        add             x2,  x2,  x3
+        add             x0,  x0,  x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg64_neon, export=1
+        sub             x1,  x1,  #48
+        sub             x3,  x3,  #48
+1:
+        ld1             {v4.16b},  [x2], #16
+        ld1             {v0.16b},  [x0], #16
+        ld1             {v5.16b},  [x2], #16
+        ld1             {v1.16b},  [x0], #16
+        urhadd          v0.16b,  v0.16b,  v4.16b
+        ld1             {v6.16b},  [x2], #16
+        ld1             {v2.16b},  [x0], #16
+        urhadd          v1.16b,  v1.16b,  v5.16b
+        ld1             {v7.16b},  [x2], x3
+        ld1             {v3.16b},  [x0]
+        urhadd          v2.16b,  v2.16b,  v6.16b
+        sub             x0,  x0,  #48
+        urhadd          v3.16b,  v3.16b,  v7.16b
+        st1             {v0.16b},  [x0], #16
+        st1             {v1.16b},  [x0], #16
+        st1             {v2.16b},  [x0], #16
+        st1             {v3.16b},  [x0], x1
+        subs            w4,  w4,  #1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_copy32_neon, export=1
+1:
+        ldp             x5,  x6,  [x2]
+        stp             x5,  x6,  [x0]
+        subs            w4,  w4,  #1
+        ldp             x5,  x6,  [x2, #16]
+        stp             x5,  x6,  [x0, #16]
+        add             x2,  x2,  x3
+        add             x0,  x0,  x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg32_neon, export=1
+        sub             x1,  x1,  #16
+        sub             x3,  x3,  #16
+1:
+        ld1             {v2.16b},  [x2], #16
+        ld1             {v0.16b},  [x0], #16
+        ld1             {v3.16b},  [x2], x3
+        urhadd          v0.16b,  v0.16b,  v2.16b
+        ld1             {v1.16b},  [x0]
+        urhadd          v1.16b,  v1.16b,  v3.16b
+        sub             x0,  x0,  #16
+        st1             {v0.16b},  [x0], #16
+        st1             {v1.16b},  [x0], x1
+        subs            w4,  w4,  #1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_copy16_neon, export=1
+        add             x5,  x0,  x1
+        add             x1,  x1,  x1
+        add             x6,  x2,  x3
+        add             x3,  x3,  x3
+1:
+        ld1             {v0.16b},  [x2], x3
+        ld1             {v1.16b},  [x6], x3
+        ld1             {v2.16b},  [x2], x3
+        ld1             {v3.16b},  [x6], x3
+        subs            w4,  w4,  #4
+        st1             {v0.16b},  [x0], x1
+        st1             {v1.16b},  [x5], x1
+        st1             {v2.16b},  [x0], x1
+        st1             {v3.16b},  [x5], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg16_neon, export=1
+1:
+        ld1             {v2.16b},  [x2], x3
+        ld1             {v0.16b},  [x0], x1
+        ld1             {v3.16b},  [x2], x3
+        urhadd          v0.16b,  v0.16b,  v2.16b
+        ld1             {v1.16b},  [x0]
+        sub             x0,  x0,  x1
+        urhadd          v1.16b,  v1.16b,  v3.16b
+        subs            w4,  w4,  #2
+        st1             {v0.16b},  [x0], x1
+        st1             {v1.16b},  [x0], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_copy8_neon, export=1
+1:
+        ld1             {v0.8b},  [x2], x3
+        ld1             {v1.8b},  [x2], x3
+        subs            w4,  w4,  #2
+        st1             {v0.8b},  [x0], x1
+        st1             {v1.8b},  [x0], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg8_neon, export=1
+1:
+        ld1             {v2.8b},  [x2], x3
+        ld1             {v0.8b},  [x0], x1
+        ld1             {v3.8b},  [x2], x3
+        urhadd          v0.8b,  v0.8b,  v2.8b
+        ld1             {v1.8b},  [x0]
+        sub             x0,  x0,  x1
+        urhadd          v1.8b,  v1.8b,  v3.8b
+        subs            w4,  w4,  #2
+        st1             {v0.8b},  [x0], x1
+        st1             {v1.8b},  [x0], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_copy4_neon, export=1
+1:
+        ld1             {v0.s}[0], [x2], x3
+        ld1             {v1.s}[0], [x2], x3
+        st1             {v0.s}[0], [x0], x1
+        ld1             {v2.s}[0], [x2], x3
+        st1             {v1.s}[0], [x0], x1
+        ld1             {v3.s}[0], [x2], x3
+        subs            w4,  w4,  #4
+        st1             {v2.s}[0], [x0], x1
+        st1             {v3.s}[0], [x0], x1
+        b.ne            1b
+        ret
+endfunc
+
+function ff_vp9_avg4_neon, export=1
+1:
+        ld1r            {v4.2s}, [x2], x3
+        ld1r            {v0.2s}, [x0], x1
+        ld1r            {v5.2s}, [x2], x3
+        ld1r            {v1.2s}, [x0], x1
+        ld1r            {v6.2s}, [x2], x3
+        ld1r            {v2.2s}, [x0], x1
+        ld1r            {v7.2s}, [x2], x3
+        ld1r            {v3.2s}, [x0], x1
+        sub             x0,  x0,  x1, lsl #2
+        subs            w4,  w4,  #4
+        urhadd          v0.8b,  v0.8b,  v4.8b
+        urhadd          v1.8b,  v1.8b,  v5.8b
+        urhadd          v2.8b,  v2.8b,  v6.8b
+        urhadd          v3.8b,  v3.8b,  v7.8b
+        st1             {v0.s}[0], [x0], x1
+        st1             {v1.s}[0], [x0], x1
+        st1             {v2.s}[0], [x0], x1
+        st1             {v3.s}[0], [x0], x1
+        b.ne            1b
+        ret
+endfunc
+
+
+// Extract a vector from src1-src2 and src4-src5 (src1-src3 and src4-src6
+// for size >= 16), and multiply-accumulate into dst1 and dst3 (or
+// dst1-dst2 and dst3-dst4 for size >= 16)
+.macro extmla dst1, dst2, dst3, dst4, src1, src2, src3, src4, src5, src6, offset, size
+        ext             v20.16b, \src1, \src2, #(2*\offset)
+        ext             v22.16b, \src4, \src5, #(2*\offset)
+.if \size >= 16
+        mla             \dst1, v20.8h, v0.h[\offset]
+        ext             v21.16b, \src2, \src3, #(2*\offset)
+        mla             \dst3, v22.8h, v0.h[\offset]
+        ext             v23.16b, \src5, \src6, #(2*\offset)
+        mla             \dst2, v21.8h, v0.h[\offset]
+        mla             \dst4, v23.8h, v0.h[\offset]
+.else
+        mla             \dst1, v20.8h, v0.h[\offset]
+        mla             \dst3, v22.8h, v0.h[\offset]
+.endif
+.endm
+// The same as above, but don't accumulate straight into the
+// destination, but use a temp register and accumulate with saturation.
+.macro extmulqadd dst1, dst2, dst3, dst4, src1, src2, src3, src4, src5, src6, offset, size
+        ext             v20.16b, \src1, \src2, #(2*\offset)
+        ext             v22.16b, \src4, \src5, #(2*\offset)
+.if \size >= 16
+        mul             v20.8h, v20.8h, v0.h[\offset]
+        ext             v21.16b, \src2, \src3, #(2*\offset)
+        mul             v22.8h, v22.8h, v0.h[\offset]
+        ext             v23.16b, \src5, \src6, #(2*\offset)
+        mul             v21.8h, v21.8h, v0.h[\offset]
+        mul             v23.8h, v23.8h, v0.h[\offset]
+.else
+        mul             v20.8h, v20.8h, v0.h[\offset]
+        mul             v22.8h, v22.8h, v0.h[\offset]
+.endif
+        sqadd           \dst1, \dst1, v20.8h
+        sqadd           \dst3, \dst3, v22.8h
+.if \size >= 16
+        sqadd           \dst2, \dst2, v21.8h
+        sqadd           \dst4, \dst4, v23.8h
+.endif
+.endm
+
+
+// Instantiate a horizontal filter function for the given size.
+// This can work on 4, 8 or 16 pixels in parallel; for larger
+// widths it will do 16 pixels at a time and loop horizontally.
+// The actual width is passed in x9, and the height in w4.
+// idx2 is the index of the largest filter coefficient (3 or 4)
+// and idx1 is the other one of them.
+.macro do_8tap_h type, size, idx1, idx2
+function \type\()_8tap_\size\()h_\idx1\idx2
+        sub             x2,  x2,  #3
+        add             x6,  x0,  x1
+        add             x7,  x2,  x3
+        add             x1,  x1,  x1
+        add             x3,  x3,  x3
+        // Only size > 16 loops horizontally and needs
+        // reduced dst stride
+.if \size > 16
+        sub             x1,  x1,  x9
+.endif
+        // size >= 16 loads two qwords and increments r2,
+        // for size 4/8 it's enough with one qword and no
+        // postincrement
+.if \size >= 16
+        sub             x3,  x3,  x9
+        sub             x3,  x3,  #8
+.endif
+        // Load the filter vector
+        ld1             {v0.8h},  [x5]
+1:
+.if \size > 16
+        mov             x5,  x9
+.endif
+        // Load src
+.if \size >= 16
+        ld1             {v4.16b},  [x2], #16
+        ld1             {v16.16b}, [x7], #16
+        ld1             {v6.8b},   [x2], #8
+        ld1             {v18.8b},  [x7], #8
+.else
+        ld1             {v4.16b},  [x2]
+        ld1             {v16.16b}, [x7]
+.endif
+        uxtl2           v5.8h,  v4.16b
+        uxtl            v4.8h,  v4.8b
+        uxtl2           v17.8h, v16.16b
+        uxtl            v16.8h, v16.8b
+.if \size >= 16
+        uxtl            v6.8h,  v6.8b
+        uxtl            v18.8h, v18.8b
+.endif
+2:
+
+        // Accumulate, adding idx2 last with a separate
+        // saturating add. The positive filter coefficients
+        // for all indices except idx2 must add up to less
+        // than 127 for this not to overflow.
+        mul             v1.8h,  v4.8h,  v0.h[0]
+        mul             v24.8h, v16.8h, v0.h[0]
+.if \size >= 16
+        mul             v2.8h,  v5.8h,  v0.h[0]
+        mul             v25.8h, v17.8h, v0.h[0]
+.endif
+        extmla          v1.8h,  v2.8h,  v24.8h, v25.8h, v4.16b,  v5.16b,  v6.16b,  v16.16b, v17.16b, v18.16b, 1,     \size
+        extmla          v1.8h,  v2.8h,  v24.8h, v25.8h, v4.16b,  v5.16b,  v6.16b,  v16.16b, v17.16b, v18.16b, 2,     \size
+        extmla          v1.8h,  v2.8h,  v24.8h, v25.8h, v4.16b,  v5.16b,  v6.16b,  v16.16b, v17.16b, v18.16b, \idx1, \size
+        extmla          v1.8h,  v2.8h,  v24.8h, v25.8h, v4.16b,  v5.16b,  v6.16b,  v16.16b, v17.16b, v18.16b, 5,     \size
+        extmla          v1.8h,  v2.8h,  v24.8h, v25.8h, v4.16b,  v5.16b,  v6.16b,  v16.16b, v17.16b, v18.16b, 6,     \size
+        extmla          v1.8h,  v2.8h,  v24.8h, v25.8h, v4.16b,  v5.16b,  v6.16b,  v16.16b, v17.16b, v18.16b, 7,     \size
+        extmulqadd      v1.8h,  v2.8h,  v24.8h, v25.8h, v4.16b,  v5.16b,  v6.16b,  v16.16b, v17.16b, v18.16b, \idx2, \size
+
+        // Round, shift and saturate
+        sqrshrun        v1.8b,   v1.8h,  #7
+        sqrshrun        v24.8b,  v24.8h, #7
+.if \size >= 16
+        sqrshrun2       v1.16b,  v2.8h,  #7
+        sqrshrun2       v24.16b, v25.8h, #7
+.endif
+        // Average
+.ifc \type,avg
+.if \size >= 16
+        ld1             {v2.16b}, [x0]
+        ld1             {v3.16b}, [x6]
+        urhadd          v1.16b,  v1.16b,  v2.16b
+        urhadd          v24.16b, v24.16b, v3.16b
+.elseif \size == 8
+        ld1             {v2.8b},  [x0]
+        ld1             {v3.8b},  [x6]
+        urhadd          v1.8b,  v1.8b,  v2.8b
+        urhadd          v24.8b, v24.8b, v3.8b
+.else
+        ld1r            {v2.2s},  [x0]
+        ld1r            {v3.2s},  [x6]
+        urhadd          v1.8b,  v1.8b,  v2.8b
+        urhadd          v24.8b, v24.8b, v3.8b
+.endif
+.endif
+        // Store and loop horizontally (for size > 16)
+.if \size > 16
+        st1             {v1.16b},  [x0], #16
+        st1             {v24.16b}, [x6], #16
+        mov             v4.16b,  v6.16b
+        mov             v16.16b, v18.16b
+        subs            w5,  w5,  #16
+        beq             3f
+        ld1             {v6.16b},  [x2], #16
+        ld1             {v18.16b}, [x7], #16
+        uxtl            v5.8h,  v6.8b
+        uxtl2           v6.8h,  v6.16b
+        uxtl            v17.8h, v18.8b
+        uxtl2           v18.8h, v18.16b
+        b               2b
+.elseif \size == 16
+        st1             {v1.16b},   [x0]
+        st1             {v24.16b},  [x6]
+.elseif \size == 8
+        st1             {v1.8b},    [x0]
+        st1             {v24.8b},   [x6]
+.else // \size == 4
+        st1             {v1.s}[0],  [x0]
+        st1             {v24.s}[0], [x6]
+.endif
+3:
+        // Loop vertically
+        add             x0,  x0,  x1
+        add             x6,  x6,  x1
+        add             x2,  x2,  x3
+        add             x7,  x7,  x3
+        subs            w4,  w4,  #2
+        b.ne            1b
+        ret
+endfunc
+.endm
+
+.macro do_8tap_h_size size
+do_8tap_h put, \size, 3, 4
+do_8tap_h avg, \size, 3, 4
+do_8tap_h put, \size, 4, 3
+do_8tap_h avg, \size, 4, 3
+.endm
+
+do_8tap_h_size 4
+do_8tap_h_size 8
+do_8tap_h_size 16
+do_8tap_h_size 32
+
+.macro do_8tap_h_func type, filter, size
+function ff_vp9_\type\()_\filter\()\size\()_h_neon, export=1
+        movrel          x6,  \filter\()_filter-16
+        cmp             w5,  #8
+        add             x5,  x6,  w5, uxtw #4
+        mov             x9,  #\size
+.if \size > 16
+        bge             \type\()_8tap_32h_34
+        b               \type\()_8tap_32h_43
+.else
+        bge             \type\()_8tap_\size\()h_34
+        b               \type\()_8tap_\size\()h_43
+.endif
+endfunc
+.endm
+
+.macro do_8tap_h_filters size
+do_8tap_h_func put, regular, \size
+do_8tap_h_func avg, regular, \size
+do_8tap_h_func put, sharp,   \size
+do_8tap_h_func avg, sharp,   \size
+do_8tap_h_func put, smooth,  \size
+do_8tap_h_func avg, smooth,  \size
+.endm
+
+do_8tap_h_filters 64
+do_8tap_h_filters 32
+do_8tap_h_filters 16
+do_8tap_h_filters 8
+do_8tap_h_filters 4
+
+
+// Vertical filters
+
+// Round, shift and saturate and store reg1-reg2 over 4 lines
+.macro do_store4 reg1, reg2, tmp1, tmp2, type
+        sqrshrun        \reg1\().8b,  \reg1\().8h, #7
+        sqrshrun        \reg2\().8b,  \reg2\().8h, #7
+.ifc \type,avg
+        ld1r            {\tmp1\().2s},     [x0], x1
+        ld1r            {\tmp2\().2s},     [x0], x1
+        ld1             {\tmp1\().s}[1],  [x0], x1
+        ld1             {\tmp2\().s}[1],  [x0], x1
+        urhadd          \reg1\().8b,  \reg1\().8b,  \tmp1\().8b
+        urhadd          \reg2\().8b,  \reg2\().8b,  \tmp2\().8b
+        sub             x0,  x0,  x1, lsl #2
+.endif
+        st1             {\reg1\().s}[0],  [x0], x1
+        st1             {\reg2\().s}[0],  [x0], x1
+        st1             {\reg1\().s}[1],  [x0], x1
+        st1             {\reg2\().s}[1],  [x0], x1
+.endm
+
+// Round, shift and saturate and store reg1-4
+.macro do_store reg1, reg2, reg3, reg4, tmp1, tmp2, tmp3, tmp4, type
+        sqrshrun        \reg1\().8b,  \reg1\().8h, #7
+        sqrshrun        \reg2\().8b,  \reg2\().8h, #7
+        sqrshrun        \reg3\().8b,  \reg3\().8h, #7
+        sqrshrun        \reg4\().8b,  \reg4\().8h, #7
+.ifc \type,avg
+        ld1             {\tmp1\().8b},  [x0], x1
+        ld1             {\tmp2\().8b},  [x0], x1
+        ld1             {\tmp3\().8b},  [x0], x1
+        ld1             {\tmp4\().8b},  [x0], x1
+        urhadd          \reg1\().8b,  \reg1\().8b,  \tmp1\().8b
+        urhadd          \reg2\().8b,  \reg2\().8b,  \tmp2\().8b
+        urhadd          \reg3\().8b,  \reg3\().8b,  \tmp3\().8b
+        urhadd          \reg4\().8b,  \reg4\().8b,  \tmp4\().8b
+        sub             x0,  x0,  x1, lsl #2
+.endif
+        st1             {\reg1\().8b},  [x0], x1
+        st1             {\reg2\().8b},  [x0], x1
+        st1             {\reg3\().8b},  [x0], x1
+        st1             {\reg4\().8b},  [x0], x1
+.endm
+
+// Evaluate the filter twice in parallel, from the inputs src1-src9 into dst1-dst2
+// (src1-src8 into dst1, src2-src9 into dst2), adding idx2 separately
+// at the end with saturation
+.macro convolve dst1, dst2, src1, src2, src3, src4, src5, src6, src7, src8, src9, idx1, idx2, tmp1, tmp2
+        mul             \dst1\().8h, \src1\().8h, v0.h[0]
+        mul             \dst2\().8h, \src2\().8h, v0.h[0]
+        mla             \dst1\().8h, \src2\().8h, v0.h[1]
+        mla             \dst2\().8h, \src3\().8h, v0.h[1]
+        mla             \dst1\().8h, \src3\().8h, v0.h[2]
+        mla             \dst2\().8h, \src4\().8h, v0.h[2]
+.if \idx1 == 3
+        mla             \dst1\().8h, \src4\().8h, v0.h[3]
+        mla             \dst2\().8h, \src5\().8h, v0.h[3]
+.else
+        mla             \dst1\().8h, \src5\().8h, v0.h[4]
+        mla             \dst2\().8h, \src6\().8h, v0.h[4]
+.endif
+        mla             \dst1\().8h, \src6\().8h, v0.h[5]
+        mla             \dst2\().8h, \src7\().8h, v0.h[5]
+        mla             \dst1\().8h, \src7\().8h, v0.h[6]
+        mla             \dst2\().8h, \src8\().8h, v0.h[6]
+        mla             \dst1\().8h, \src8\().8h, v0.h[7]
+        mla             \dst2\().8h, \src9\().8h, v0.h[7]
+.if \idx2 == 3
+        mul             \tmp1\().8h, \src4\().8h, v0.h[3]
+        mul             \tmp2\().8h, \src5\().8h, v0.h[3]
+.else
+        mul             \tmp1\().8h, \src5\().8h, v0.h[4]
+        mul             \tmp2\().8h, \src6\().8h, v0.h[4]
+.endif
+        sqadd           \dst1\().8h, \dst1\().8h, \tmp1\().8h
+        sqadd           \dst2\().8h, \dst2\().8h, \tmp2\().8h
+.endm
+
+// Load pixels and extend them to 16 bit
+.macro loadl dst1, dst2, dst3, dst4
+        ld1             {v1.8b}, [x2], x3
+        ld1             {v2.8b}, [x2], x3
+        ld1             {v3.8b}, [x2], x3
+.ifnb \dst4
+        ld1             {v4.8b}, [x2], x3
+.endif
+        uxtl            \dst1\().8h, v1.8b
+        uxtl            \dst2\().8h, v2.8b
+        uxtl            \dst3\().8h, v3.8b
+.ifnb \dst4
+        uxtl            \dst4\().8h, v4.8b
+.endif
+.endm
+
+// Instantiate a vertical filter function for filtering 8 pixels at a time.
+// The height is passed in x4 and the width in x5.
+// idx2 is the index of the largest filter coefficient (3 or 4)
+// and idx1 is the other one of them.
+.macro do_8tap_8v type, idx1, idx2
+function \type\()_8tap_8v_\idx1\idx2
+        sub             x2,  x2,  x3, lsl #1
+        sub             x2,  x2,  x3
+        ld1             {v0.8h},  [x6]
+1:
+        mov             x6,  x4
+
+        loadl           v17, v18, v19
+
+        loadl           v20, v21, v22, v23
+2:
+        loadl           v24, v25, v26, v27
+        convolve        v1,  v2,  v17, v18, v19, v20, v21, v22, v23, v24, v25, \idx1, \idx2, v5,  v6
+        convolve        v3,  v4,  v19, v20, v21, v22, v23, v24, v25, v26, v27, \idx1, \idx2, v5,  v6
+        do_store        v1,  v2,  v3,  v4,  v5,  v6,  v7,  v28, \type
+
+        subs            x6,  x6,  #4
+        b.eq            8f
+
+        loadl           v16, v17, v18, v19
+        convolve        v1,  v2,  v21, v22, v23, v24, v25, v26, v27, v16, v17, \idx1, \idx2, v5,  v6
+        convolve        v3,  v4,  v23, v24, v25, v26, v27, v16, v17, v18, v19, \idx1, \idx2, v5,  v6
+        do_store        v1,  v2,  v3,  v4,  v5,  v6,  v7,  v28, \type
+
+        subs            x6,  x6,  #4
+        b.eq            8f
+
+        loadl           v20, v21, v22, v23
+        convolve        v1,  v2,  v25, v26, v27, v16, v17, v18, v19, v20, v21, \idx1, \idx2, v5,  v6
+        convolve        v3,  v4,  v27, v16, v17, v18, v19, v20, v21, v22, v23, \idx1, \idx2, v5,  v6
+        do_store        v1,  v2,  v3,  v4,  v5,  v6,  v7,  v28, \type
+
+        subs            x6,  x6,  #4
+        b.ne            2b
+
+8:
+        subs            x5,  x5,  #8
+        b.eq            9f
+        // x0 -= h * dst_stride
+        msub            x0,  x1,  x4, x0
+        // x2 -= h * src_stride
+        msub            x2,  x3,  x4, x2
+        // x2 -= 8 * src_stride
+        sub             x2,  x2,  x3, lsl #3
+        // x2 += 1 * src_stride
+        add             x2,  x2,  x3
+        add             x2,  x2,  #8
+        add             x0,  x0,  #8
+        b               1b
+9:
+        ret
+endfunc
+.endm
+
+do_8tap_8v put, 3, 4
+do_8tap_8v put, 4, 3
+do_8tap_8v avg, 3, 4
+do_8tap_8v avg, 4, 3
+
+
+// Instantiate a vertical filter function for filtering a 4 pixels wide
+// slice. The first half of the registers contain one row, while the second
+// half of a register contains the second-next row (also stored in the first
+// half of the register two steps ahead). The convolution does two outputs
+// at a time; the output of v17-v24 into one, and v18-v25 into another one.
+// The first half of first output is the first output row, the first half
+// of the other output is the second output row. The second halves of the
+// registers are rows 3 and 4.
+// This only is designed to work for 4 or 8 output lines.
+.macro do_8tap_4v type, idx1, idx2
+function \type\()_8tap_4v_\idx1\idx2
+        sub             x2,  x2,  x3, lsl #1
+        sub             x2,  x2,  x3
+        ld1             {v0.8h},  [x6]
+
+        ld1r            {v1.2s},    [x2], x3
+        ld1r            {v2.2s},    [x2], x3
+        ld1r            {v3.2s},    [x2], x3
+        ld1r            {v4.2s},    [x2], x3
+        ld1r            {v5.2s},    [x2], x3
+        ld1r            {v6.2s},    [x2], x3
+        ld1r            {v7.2s},    [x2], x3
+        ld1r            {v30.2s},   [x2], x3
+        ld1r            {v31.2s},   [x2]
+        sub             x2,  x2,  x3, lsl #2
+        sub             x2,  x2,  x3, lsl #1
+        ld1             {v1.s}[1],  [x2], x3
+        ld1             {v2.s}[1],  [x2], x3
+        uxtl            v17.8h, v1.8b
+        ld1             {v3.s}[1],  [x2], x3
+        uxtl            v18.8h, v2.8b
+        ld1             {v4.s}[1],  [x2], x3
+        uxtl            v19.8h, v3.8b
+        ld1             {v5.s}[1],  [x2], x3
+        uxtl            v20.8h, v4.8b
+        ld1             {v6.s}[1],  [x2], x3
+        uxtl            v21.8h, v5.8b
+        ld1             {v7.s}[1],  [x2], x3
+        uxtl            v22.8h, v6.8b
+        ld1             {v30.s}[1], [x2], x3
+        uxtl            v23.8h, v7.8b
+        ld1             {v31.s}[1], [x2]
+        sub             x2,  x2,  x3
+
+        uxtl            v24.8h, v30.8b
+        uxtl            v25.8h, v31.8b
+
+        convolve        v1,  v2,  v17, v18, v19, v20, v21, v22, v23, v24, v25, \idx1, \idx2, v3,  v4
+        do_store4       v1,  v2,  v5,  v6,  \type
+
+        subs            x4,  x4,  #4
+        b.eq            9f
+
+        ld1r            {v1.2s},    [x2], x3
+        ld1r            {v2.2s},    [x2], x3
+        ld1r            {v3.2s},    [x2], x3
+        ld1r            {v4.2s},    [x2], x3
+        sub             x2,  x2,  x3, lsl #1
+        ld1             {v1.s}[1],  [x2], x3
+        ld1             {v2.s}[1],  [x2], x3
+        uxtl            v26.8h, v1.8b
+        ld1             {v3.s}[1],  [x2], x3
+        uxtl            v27.8h, v2.8b
+        ld1             {v4.s}[1],  [x2], x3
+
+        uxtl            v28.8h, v3.8b
+        uxtl            v29.8h, v4.8b
+
+        convolve        v1,  v2,  v21, v22, v23, v24, v25, v26, v27, v28, v29, \idx1, \idx2, v3,  v4
+        do_store4       v1,  v2,  v5,  v6,  \type
+
+9:
+        ret
+endfunc
+.endm
+
+do_8tap_4v put, 3, 4
+do_8tap_4v put, 4, 3
+do_8tap_4v avg, 3, 4
+do_8tap_4v avg, 4, 3
+
+
+.macro do_8tap_v_func type, filter, size
+function ff_vp9_\type\()_\filter\()\size\()_v_neon, export=1
+        uxtw            x4,  w4
+        movrel          x5,  \filter\()_filter-16
+        cmp             w6,  #8
+        add             x6,  x5,  w6, uxtw #4
+        mov             x5,  #\size
+.if \size >= 8
+        b.ge            \type\()_8tap_8v_34
+        b               \type\()_8tap_8v_43
+.else
+        b.ge            \type\()_8tap_4v_34
+        b               \type\()_8tap_4v_43
+.endif
+endfunc
+.endm
+
+.macro do_8tap_v_filters size
+do_8tap_v_func put, regular, \size
+do_8tap_v_func avg, regular, \size
+do_8tap_v_func put, sharp,   \size
+do_8tap_v_func avg, sharp,   \size
+do_8tap_v_func put, smooth,  \size
+do_8tap_v_func avg, smooth,  \size
+.endm
+
+do_8tap_v_filters 64
+do_8tap_v_filters 32
+do_8tap_v_filters 16
+do_8tap_v_filters 8
+do_8tap_v_filters 4
diff --git a/libavcodec/vp9.h b/libavcodec/vp9.h
index 77a197b..9d721c4 100644
--- a/libavcodec/vp9.h
+++ b/libavcodec/vp9.h
@@ -432,6 +432,7 @@  typedef struct VP9Context {
 
 void ff_vp9dsp_init(VP9DSPContext *dsp);
 
+void ff_vp9dsp_init_aarch64(VP9DSPContext *dsp);
 void ff_vp9dsp_init_arm(VP9DSPContext *dsp);
 void ff_vp9dsp_init_x86(VP9DSPContext *dsp);
 
diff --git a/libavcodec/vp9dsp.c b/libavcodec/vp9dsp.c
index 0eca389..c198a47 100644
--- a/libavcodec/vp9dsp.c
+++ b/libavcodec/vp9dsp.c
@@ -2164,6 +2164,8 @@  av_cold void ff_vp9dsp_init(VP9DSPContext *dsp)
     vp9dsp_loopfilter_init(dsp);
     vp9dsp_mc_init(dsp);
 
+    if (ARCH_AARCH64)
+        ff_vp9dsp_init_aarch64(dsp);
     if (ARCH_ARM)
         ff_vp9dsp_init_arm(dsp);
     if (ARCH_X86)