Merge "VP8 for ARMv8 by using NEON intrinsics 14"

6 files changed, 1749 insertions, 1931 deletions

diff --git a/vp8/common/arm/neon/sixtappredict16x16_neon.asm b/vp8/common/arm/neon/sixtappredict16x16_neon.asm
deleted file mode 100644
index dd27719bf..000000000
--- a/vp8/common/arm/neon/sixtappredict16x16_neon.asm
+++ /dev/null
@@ -1,495 +0,0 @@
-;
-;  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
-;
-;  Use of this source code is governed by a BSD-style license
-;  that can be found in the LICENSE file in the root of the source
-;  tree. An additional intellectual property rights grant can be found
-;  in the file PATENTS.  All contributing project authors may
-;  be found in the AUTHORS file in the root of the source tree.
-;
-
-
-    EXPORT  |vp8_sixtap_predict16x16_neon|
-    ARM
-    REQUIRE8
-    PRESERVE8
-
-    AREA ||.text||, CODE, READONLY, ALIGN=2
-
-filter16_coeff
-    DCD     0,  0,  128,    0,   0,  0,   0,  0
-    DCD     0, -6,  123,   12,  -1,  0,   0,  0
-    DCD     2, -11, 108,   36,  -8,  1,   0,  0
-    DCD     0, -9,   93,   50,  -6,  0,   0,  0
-    DCD     3, -16,  77,   77, -16,  3,   0,  0
-    DCD     0, -6,   50,   93,  -9,  0,   0,  0
-    DCD     1, -8,   36,  108, -11,  2,   0,  0
-    DCD     0, -1,   12,  123,  -6,   0,  0,  0
-
-; r0    unsigned char  *src_ptr,
-; r1    int  src_pixels_per_line,
-; r2    int  xoffset,
-; r3    int  yoffset,
-; r4    unsigned char *dst_ptr,
-; stack(r5) int  dst_pitch
-
-;Note: To take advantage of 8-bit mulplication instruction in NEON. First apply abs() to
-; filter coeffs to make them u8. Then, use vmlsl for negtive coeffs. After multiplication,
-; the result can be negtive. So, I treat the result as s16. But, since it is also possible
-; that the result can be a large positive number (> 2^15-1), which could be confused as a
-; negtive number. To avoid that error, apply filter coeffs in the order of 0, 1, 4 ,5 ,2,
-; which ensures that the result stays in s16 range. Finally, saturated add the result by
-; applying 3rd filter coeff. Same applys to other filter functions.
-
-|vp8_sixtap_predict16x16_neon| PROC
-    push            {r4-r5, lr}
-    vpush           {d8-d15}
-
-    adr             r12, filter16_coeff
-    ldr             r4, [sp, #76]           ;load parameters from stack
-    ldr             r5, [sp, #80]           ;load parameters from stack
-
-    cmp             r2, #0                  ;skip first_pass filter if xoffset=0
-    beq             secondpass_filter16x16_only
-
-    add             r2, r12, r2, lsl #5     ;calculate filter location
-
-    cmp             r3, #0                  ;skip second_pass filter if yoffset=0
-
-    vld1.s32        {q14, q15}, [r2]        ;load first_pass filter
-
-    beq             firstpass_filter16x16_only
-
-    sub             sp, sp, #336            ;reserve space on stack for temporary storage
-    mov             lr, sp
-
-    vabs.s32        q12, q14
-    vabs.s32        q13, q15
-
-    mov             r2, #7                  ;loop counter
-    sub             r0, r0, #2              ;move srcptr back to (line-2) and (column-2)
-    sub             r0, r0, r1, lsl #1
-
-    vdup.8          d0, d24[0]              ;first_pass filter (d0-d5)
-    vdup.8          d1, d24[4]
-    vdup.8          d2, d25[0]
-    vdup.8          d3, d25[4]
-    vdup.8          d4, d26[0]
-    vdup.8          d5, d26[4]
-
-;First Pass: output_height lines x output_width columns (21x16)
-filt_blk2d_fp16x16_loop_neon
-    vld1.u8         {d6, d7, d8}, [r0], r1      ;load src data
-    vld1.u8         {d9, d10, d11}, [r0], r1
-    vld1.u8         {d12, d13, d14}, [r0], r1
-
-    pld             [r0]
-    pld             [r0, r1]
-    pld             [r0, r1, lsl #1]
-
-    vmull.u8        q8, d6, d0              ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q9, d7, d0
-    vmull.u8        q10, d9, d0
-    vmull.u8        q11, d10, d0
-    vmull.u8        q12, d12, d0
-    vmull.u8        q13, d13, d0
-
-    vext.8          d28, d6, d7, #1         ;construct src_ptr[-1]
-    vext.8          d29, d9, d10, #1
-    vext.8          d30, d12, d13, #1
-
-    vmlsl.u8        q8, d28, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q10, d29, d1
-    vmlsl.u8        q12, d30, d1
-
-    vext.8          d28, d7, d8, #1
-    vext.8          d29, d10, d11, #1
-    vext.8          d30, d13, d14, #1
-
-    vmlsl.u8        q9, d28, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q11, d29, d1
-    vmlsl.u8        q13, d30, d1
-
-    vext.8          d28, d6, d7, #4         ;construct src_ptr[2]
-    vext.8          d29, d9, d10, #4
-    vext.8          d30, d12, d13, #4
-
-    vmlsl.u8        q8, d28, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q10, d29, d4
-    vmlsl.u8        q12, d30, d4
-
-    vext.8          d28, d7, d8, #4
-    vext.8          d29, d10, d11, #4
-    vext.8          d30, d13, d14, #4
-
-    vmlsl.u8        q9, d28, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q11, d29, d4
-    vmlsl.u8        q13, d30, d4
-
-    vext.8          d28, d6, d7, #5         ;construct src_ptr[3]
-    vext.8          d29, d9, d10, #5
-    vext.8          d30, d12, d13, #5
-
-    vmlal.u8        q8, d28, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q10, d29, d5
-    vmlal.u8        q12, d30, d5
-
-    vext.8          d28, d7, d8, #5
-    vext.8          d29, d10, d11, #5
-    vext.8          d30, d13, d14, #5
-
-    vmlal.u8        q9, d28, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q11, d29, d5
-    vmlal.u8        q13, d30, d5
-
-    vext.8          d28, d6, d7, #2         ;construct src_ptr[0]
-    vext.8          d29, d9, d10, #2
-    vext.8          d30, d12, d13, #2
-
-    vmlal.u8        q8, d28, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q10, d29, d2
-    vmlal.u8        q12, d30, d2
-
-    vext.8          d28, d7, d8, #2
-    vext.8          d29, d10, d11, #2
-    vext.8          d30, d13, d14, #2
-
-    vmlal.u8        q9, d28, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q11, d29, d2
-    vmlal.u8        q13, d30, d2
-
-    vext.8          d28, d6, d7, #3         ;construct src_ptr[1]
-    vext.8          d29, d9, d10, #3
-    vext.8          d30, d12, d13, #3
-
-    vext.8          d15, d7, d8, #3
-    vext.8          d31, d10, d11, #3
-    vext.8          d6, d13, d14, #3
-
-    vmull.u8        q4, d28, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q5, d29, d3
-    vmull.u8        q6, d30, d3
-
-    vqadd.s16       q8, q4                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q10, q5
-    vqadd.s16       q12, q6
-
-    vmull.u8        q6, d15, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q7, d31, d3
-    vmull.u8        q3, d6, d3
-
-    subs            r2, r2, #1
-
-    vqadd.s16       q9, q6
-    vqadd.s16       q11, q7
-    vqadd.s16       q13, q3
-
-    vqrshrun.s16    d6, q8, #7              ;shift/round/saturate to u8
-    vqrshrun.s16    d7, q9, #7
-    vqrshrun.s16    d8, q10, #7
-    vqrshrun.s16    d9, q11, #7
-    vqrshrun.s16    d10, q12, #7
-    vqrshrun.s16    d11, q13, #7
-
-    vst1.u8         {d6, d7, d8}, [lr]!     ;store result
-    vst1.u8         {d9, d10, d11}, [lr]!
-
-    bne             filt_blk2d_fp16x16_loop_neon
-
-;Second pass: 16x16
-;secondpass_filter - do first 8-columns and then second 8-columns
-    add             r3, r12, r3, lsl #5
-    sub             lr, lr, #336
-
-    vld1.s32        {q5, q6}, [r3]          ;load second_pass filter
-    mov             r3, #2                  ;loop counter
-
-    vabs.s32        q7, q5
-    vabs.s32        q8, q6
-
-    mov             r2, #16
-
-    vdup.8          d0, d14[0]              ;second_pass filter parameters (d0-d5)
-    vdup.8          d1, d14[4]
-    vdup.8          d2, d15[0]
-    vdup.8          d3, d15[4]
-    vdup.8          d4, d16[0]
-    vdup.8          d5, d16[4]
-
-filt_blk2d_sp16x16_outloop_neon
-    vld1.u8         {d18}, [lr], r2         ;load src data
-    vld1.u8         {d19}, [lr], r2
-    vld1.u8         {d20}, [lr], r2
-    vld1.u8         {d21}, [lr], r2
-    mov             r12, #4                 ;loop counter
-    vld1.u8         {d22}, [lr], r2
-
-secondpass_inner_loop_neon
-    vld1.u8         {d23}, [lr], r2         ;load src data
-    vld1.u8         {d24}, [lr], r2
-    vld1.u8         {d25}, [lr], r2
-    vld1.u8         {d26}, [lr], r2
-
-    vmull.u8        q3, d18, d0             ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q4, d19, d0
-    vmull.u8        q5, d20, d0
-    vmull.u8        q6, d21, d0
-
-    vmlsl.u8        q3, d19, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q4, d20, d1
-    vmlsl.u8        q5, d21, d1
-    vmlsl.u8        q6, d22, d1
-
-    vmlsl.u8        q3, d22, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q4, d23, d4
-    vmlsl.u8        q5, d24, d4
-    vmlsl.u8        q6, d25, d4
-
-    vmlal.u8        q3, d20, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q4, d21, d2
-    vmlal.u8        q5, d22, d2
-    vmlal.u8        q6, d23, d2
-
-    vmlal.u8        q3, d23, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q4, d24, d5
-    vmlal.u8        q5, d25, d5
-    vmlal.u8        q6, d26, d5
-
-    vmull.u8        q7, d21, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q8, d22, d3
-    vmull.u8        q9, d23, d3
-    vmull.u8        q10, d24, d3
-
-    subs            r12, r12, #1
-
-    vqadd.s16       q7, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q4
-    vqadd.s16       q9, q5
-    vqadd.s16       q10, q6
-
-    vqrshrun.s16    d6, q7, #7              ;shift/round/saturate to u8
-    vqrshrun.s16    d7, q8, #7
-    vqrshrun.s16    d8, q9, #7
-    vqrshrun.s16    d9, q10, #7
-
-    vst1.u8         {d6}, [r4], r5          ;store result
-    vmov            q9, q11
-    vst1.u8         {d7}, [r4], r5
-    vmov            q10, q12
-    vst1.u8         {d8}, [r4], r5
-    vmov            d22, d26
-    vst1.u8         {d9}, [r4], r5
-
-    bne             secondpass_inner_loop_neon
-
-    subs            r3, r3, #1
-    sub             lr, lr, #336
-    add             lr, lr, #8
-
-    sub             r4, r4, r5, lsl #4
-    add             r4, r4, #8
-
-    bne filt_blk2d_sp16x16_outloop_neon
-
-    add             sp, sp, #336
-
-    vpop            {d8-d15}
-    pop             {r4-r5,pc}
-
-;--------------------
-firstpass_filter16x16_only
-    vabs.s32        q12, q14
-    vabs.s32        q13, q15
-
-    mov             r2, #8                  ;loop counter
-    sub             r0, r0, #2              ;move srcptr back to (column-2)
-
-    vdup.8          d0, d24[0]              ;first_pass filter (d0-d5)
-    vdup.8          d1, d24[4]
-    vdup.8          d2, d25[0]
-    vdup.8          d3, d25[4]
-    vdup.8          d4, d26[0]
-    vdup.8          d5, d26[4]
-
-;First Pass: output_height lines x output_width columns (16x16)
-filt_blk2d_fpo16x16_loop_neon
-    vld1.u8         {d6, d7, d8}, [r0], r1      ;load src data
-    vld1.u8         {d9, d10, d11}, [r0], r1
-
-    pld             [r0]
-    pld             [r0, r1]
-
-    vmull.u8        q6, d6, d0              ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q7, d7, d0
-    vmull.u8        q8, d9, d0
-    vmull.u8        q9, d10, d0
-
-    vext.8          d20, d6, d7, #1         ;construct src_ptr[-1]
-    vext.8          d21, d9, d10, #1
-    vext.8          d22, d7, d8, #1
-    vext.8          d23, d10, d11, #1
-    vext.8          d24, d6, d7, #4         ;construct src_ptr[2]
-    vext.8          d25, d9, d10, #4
-    vext.8          d26, d7, d8, #4
-    vext.8          d27, d10, d11, #4
-    vext.8          d28, d6, d7, #5         ;construct src_ptr[3]
-    vext.8          d29, d9, d10, #5
-
-    vmlsl.u8        q6, d20, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q8, d21, d1
-    vmlsl.u8        q7, d22, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q9, d23, d1
-    vmlsl.u8        q6, d24, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q8, d25, d4
-    vmlsl.u8        q7, d26, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q9, d27, d4
-    vmlal.u8        q6, d28, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q8, d29, d5
-
-    vext.8          d20, d7, d8, #5
-    vext.8          d21, d10, d11, #5
-    vext.8          d22, d6, d7, #2         ;construct src_ptr[0]
-    vext.8          d23, d9, d10, #2
-    vext.8          d24, d7, d8, #2
-    vext.8          d25, d10, d11, #2
-
-    vext.8          d26, d6, d7, #3         ;construct src_ptr[1]
-    vext.8          d27, d9, d10, #3
-    vext.8          d28, d7, d8, #3
-    vext.8          d29, d10, d11, #3
-
-    vmlal.u8        q7, d20, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q9, d21, d5
-    vmlal.u8        q6, d22, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q8, d23, d2
-    vmlal.u8        q7, d24, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q9, d25, d2
-
-    vmull.u8        q10, d26, d3            ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q11, d27, d3
-    vmull.u8        q12, d28, d3            ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q15, d29, d3
-
-    vqadd.s16       q6, q10                 ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q11
-    vqadd.s16       q7, q12
-    vqadd.s16       q9, q15
-
-    subs            r2, r2, #1
-
-    vqrshrun.s16    d6, q6, #7              ;shift/round/saturate to u8
-    vqrshrun.s16    d7, q7, #7
-    vqrshrun.s16    d8, q8, #7
-    vqrshrun.s16    d9, q9, #7
-
-    vst1.u8         {q3}, [r4], r5              ;store result
-    vst1.u8         {q4}, [r4], r5
-
-    bne             filt_blk2d_fpo16x16_loop_neon
-
-    vpop            {d8-d15}
-    pop             {r4-r5,pc}
-
-;--------------------
-secondpass_filter16x16_only
-;Second pass: 16x16
-    add             r3, r12, r3, lsl #5
-    sub             r0, r0, r1, lsl #1
-
-    vld1.s32        {q5, q6}, [r3]          ;load second_pass filter
-    mov             r3, #2                  ;loop counter
-
-    vabs.s32        q7, q5
-    vabs.s32        q8, q6
-
-    vdup.8          d0, d14[0]              ;second_pass filter parameters (d0-d5)
-    vdup.8          d1, d14[4]
-    vdup.8          d2, d15[0]
-    vdup.8          d3, d15[4]
-    vdup.8          d4, d16[0]
-    vdup.8          d5, d16[4]
-
-filt_blk2d_spo16x16_outloop_neon
-    vld1.u8         {d18}, [r0], r1         ;load src data
-    vld1.u8         {d19}, [r0], r1
-    vld1.u8         {d20}, [r0], r1
-    vld1.u8         {d21}, [r0], r1
-    mov             r12, #4                 ;loop counter
-    vld1.u8         {d22}, [r0], r1
-
-secondpass_only_inner_loop_neon
-    vld1.u8         {d23}, [r0], r1         ;load src data
-    vld1.u8         {d24}, [r0], r1
-    vld1.u8         {d25}, [r0], r1
-    vld1.u8         {d26}, [r0], r1
-
-    vmull.u8        q3, d18, d0             ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q4, d19, d0
-    vmull.u8        q5, d20, d0
-    vmull.u8        q6, d21, d0
-
-    vmlsl.u8        q3, d19, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q4, d20, d1
-    vmlsl.u8        q5, d21, d1
-    vmlsl.u8        q6, d22, d1
-
-    vmlsl.u8        q3, d22, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q4, d23, d4
-    vmlsl.u8        q5, d24, d4
-    vmlsl.u8        q6, d25, d4
-
-    vmlal.u8        q3, d20, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q4, d21, d2
-    vmlal.u8        q5, d22, d2
-    vmlal.u8        q6, d23, d2
-
-    vmlal.u8        q3, d23, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q4, d24, d5
-    vmlal.u8        q5, d25, d5
-    vmlal.u8        q6, d26, d5
-
-    vmull.u8        q7, d21, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q8, d22, d3
-    vmull.u8        q9, d23, d3
-    vmull.u8        q10, d24, d3
-
-    subs            r12, r12, #1
-
-    vqadd.s16       q7, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q4
-    vqadd.s16       q9, q5
-    vqadd.s16       q10, q6
-
-    vqrshrun.s16    d6, q7, #7              ;shift/round/saturate to u8
-    vqrshrun.s16    d7, q8, #7
-    vqrshrun.s16    d8, q9, #7
-    vqrshrun.s16    d9, q10, #7
-
-    vst1.u8         {d6}, [r4], r5          ;store result
-    vmov            q9, q11
-    vst1.u8         {d7}, [r4], r5
-    vmov            q10, q12
-    vst1.u8         {d8}, [r4], r5
-    vmov            d22, d26
-    vst1.u8         {d9}, [r4], r5
-
-    bne             secondpass_only_inner_loop_neon
-
-    subs            r3, r3, #1
-    sub             r0, r0, r1, lsl #4
-    sub             r0, r0, r1, lsl #2
-    sub             r0, r0, r1
-    add             r0, r0, #8
-
-    sub             r4, r4, r5, lsl #4
-    add             r4, r4, #8
-
-    bne filt_blk2d_spo16x16_outloop_neon
-
-    vpop            {d8-d15}
-    pop             {r4-r5,pc}
-
-    ENDP
-
-;-----------------
-    END
diff --git a/vp8/common/arm/neon/sixtappredict4x4_neon.asm b/vp8/common/arm/neon/sixtappredict4x4_neon.asm
deleted file mode 100644
index e32e71305..000000000
--- a/vp8/common/arm/neon/sixtappredict4x4_neon.asm
+++ /dev/null
@@ -1,426 +0,0 @@
-;
-;  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
-;
-;  Use of this source code is governed by a BSD-style license
-;  that can be found in the LICENSE file in the root of the source
-;  tree. An additional intellectual property rights grant can be found
-;  in the file PATENTS.  All contributing project authors may
-;  be found in the AUTHORS file in the root of the source tree.
-;
-
-
-    EXPORT  |vp8_sixtap_predict4x4_neon|
-    ARM
-    REQUIRE8
-    PRESERVE8
-
-    AREA ||.text||, CODE, READONLY, ALIGN=2
-
-filter4_coeff
-    DCD     0,  0,  128,    0,   0,  0,   0,  0
-    DCD     0, -6,  123,   12,  -1,  0,   0,  0
-    DCD     2, -11, 108,   36,  -8,  1,   0,  0
-    DCD     0, -9,   93,   50,  -6,  0,   0,  0
-    DCD     3, -16,  77,   77, -16,  3,   0,  0
-    DCD     0, -6,   50,   93,  -9,  0,   0,  0
-    DCD     1, -8,   36,  108, -11,  2,   0,  0
-    DCD     0, -1,   12,  123,  -6,   0,  0,  0
-
-; r0    unsigned char  *src_ptr,
-; r1    int  src_pixels_per_line,
-; r2    int  xoffset,
-; r3    int  yoffset,
-; stack(r4) unsigned char *dst_ptr,
-; stack(lr) int  dst_pitch
-
-|vp8_sixtap_predict4x4_neon| PROC
-    push            {r4, lr}
-    vpush           {d8-d15}
-
-    adr             r12, filter4_coeff
-    ldr             r4, [sp, #72]            ;load parameters from stack
-    ldr             lr, [sp, #76]           ;load parameters from stack
-
-    cmp             r2, #0                  ;skip first_pass filter if xoffset=0
-    beq             secondpass_filter4x4_only
-
-    add             r2, r12, r2, lsl #5     ;calculate filter location
-
-    cmp             r3, #0                  ;skip second_pass filter if yoffset=0
-    vld1.s32        {q14, q15}, [r2]        ;load first_pass filter
-
-    beq             firstpass_filter4x4_only
-
-    vabs.s32        q12, q14                ;get abs(filer_parameters)
-    vabs.s32        q13, q15
-
-    sub             r0, r0, #2              ;go back 2 columns of src data
-    sub             r0, r0, r1, lsl #1      ;go back 2 lines of src data
-
-;First pass: output_height lines x output_width columns (9x4)
-    vld1.u8         {q3}, [r0], r1          ;load first 4-line src data
-    vdup.8          d0, d24[0]              ;first_pass filter (d0-d5)
-    vld1.u8         {q4}, [r0], r1
-    vdup.8          d1, d24[4]
-    vld1.u8         {q5}, [r0], r1
-    vdup.8          d2, d25[0]
-    vld1.u8         {q6}, [r0], r1
-    vdup.8          d3, d25[4]
-    vdup.8          d4, d26[0]
-    vdup.8          d5, d26[4]
-
-    pld             [r0]
-    pld             [r0, r1]
-    pld             [r0, r1, lsl #1]
-
-    vext.8          d18, d6, d7, #5         ;construct src_ptr[3]
-    vext.8          d19, d8, d9, #5
-    vext.8          d20, d10, d11, #5
-    vext.8          d21, d12, d13, #5
-
-    vswp            d7, d8                  ;discard 2nd half data after src_ptr[3] is done
-    vswp            d11, d12
-
-    vzip.32         d18, d19                ;put 2-line data in 1 register (src_ptr[3])
-    vzip.32         d20, d21
-    vmull.u8        q7, d18, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmull.u8        q8, d20, d5
-
-    vmov            q4, q3                  ;keep original src data in q4 q6
-    vmov            q6, q5
-
-    vzip.32         d6, d7                  ;construct src_ptr[-2], and put 2-line data together
-    vzip.32         d10, d11
-    vshr.u64        q9, q4, #8              ;construct src_ptr[-1]
-    vshr.u64        q10, q6, #8
-    vmlal.u8        q7, d6, d0              ;+(src_ptr[-2] * vp8_filter[0])
-    vmlal.u8        q8, d10, d0
-
-    vzip.32         d18, d19                ;put 2-line data in 1 register (src_ptr[-1])
-    vzip.32         d20, d21
-    vshr.u64        q3, q4, #32             ;construct src_ptr[2]
-    vshr.u64        q5, q6, #32
-    vmlsl.u8        q7, d18, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q8, d20, d1
-
-    vzip.32         d6, d7                  ;put 2-line data in 1 register (src_ptr[2])
-    vzip.32         d10, d11
-    vshr.u64        q9, q4, #16             ;construct src_ptr[0]
-    vshr.u64        q10, q6, #16
-    vmlsl.u8        q7, d6, d4              ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q8, d10, d4
-
-    vzip.32         d18, d19                ;put 2-line data in 1 register (src_ptr[0])
-    vzip.32         d20, d21
-    vshr.u64        q3, q4, #24             ;construct src_ptr[1]
-    vshr.u64        q5, q6, #24
-    vmlal.u8        q7, d18, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q8, d20, d2
-
-    vzip.32         d6, d7                  ;put 2-line data in 1 register (src_ptr[1])
-    vzip.32         d10, d11
-    vmull.u8        q9, d6, d3              ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q10, d10, d3
-
-    vld1.u8         {q3}, [r0], r1          ;load rest 5-line src data
-    vld1.u8         {q4}, [r0], r1
-
-    vqadd.s16       q7, q9                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q10
-
-    vld1.u8         {q5}, [r0], r1
-    vld1.u8         {q6}, [r0], r1
-
-    vqrshrun.s16    d27, q7, #7             ;shift/round/saturate to u8
-    vqrshrun.s16    d28, q8, #7
-
-    ;First Pass on rest 5-line data
-    vld1.u8         {q11}, [r0], r1
-
-    vext.8          d18, d6, d7, #5         ;construct src_ptr[3]
-    vext.8          d19, d8, d9, #5
-    vext.8          d20, d10, d11, #5
-    vext.8          d21, d12, d13, #5
-
-    vswp            d7, d8                  ;discard 2nd half data after src_ptr[3] is done
-    vswp            d11, d12
-
-    vzip.32         d18, d19                ;put 2-line data in 1 register (src_ptr[3])
-    vzip.32         d20, d21
-    vext.8          d31, d22, d23, #5       ;construct src_ptr[3]
-    vmull.u8        q7, d18, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmull.u8        q8, d20, d5
-    vmull.u8        q12, d31, d5            ;(src_ptr[3] * vp8_filter[5])
-
-    vmov            q4, q3                  ;keep original src data in q4 q6
-    vmov            q6, q5
-
-    vzip.32         d6, d7                  ;construct src_ptr[-2], and put 2-line data together
-    vzip.32         d10, d11
-    vshr.u64        q9, q4, #8              ;construct src_ptr[-1]
-    vshr.u64        q10, q6, #8
-
-    vmlal.u8        q7, d6, d0              ;+(src_ptr[-2] * vp8_filter[0])
-    vmlal.u8        q8, d10, d0
-    vmlal.u8        q12, d22, d0            ;(src_ptr[-2] * vp8_filter[0])
-
-    vzip.32         d18, d19                ;put 2-line data in 1 register (src_ptr[-1])
-    vzip.32         d20, d21
-    vshr.u64        q3, q4, #32             ;construct src_ptr[2]
-    vshr.u64        q5, q6, #32
-    vext.8          d31, d22, d23, #1       ;construct src_ptr[-1]
-
-    vmlsl.u8        q7, d18, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q8, d20, d1
-    vmlsl.u8        q12, d31, d1            ;-(src_ptr[-1] * vp8_filter[1])
-
-    vzip.32         d6, d7                  ;put 2-line data in 1 register (src_ptr[2])
-    vzip.32         d10, d11
-    vshr.u64        q9, q4, #16             ;construct src_ptr[0]
-    vshr.u64        q10, q6, #16
-    vext.8          d31, d22, d23, #4       ;construct src_ptr[2]
-
-    vmlsl.u8        q7, d6, d4              ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q8, d10, d4
-    vmlsl.u8        q12, d31, d4            ;-(src_ptr[2] * vp8_filter[4])
-
-    vzip.32         d18, d19                ;put 2-line data in 1 register (src_ptr[0])
-    vzip.32         d20, d21
-    vshr.u64        q3, q4, #24             ;construct src_ptr[1]
-    vshr.u64        q5, q6, #24
-    vext.8          d31, d22, d23, #2       ;construct src_ptr[0]
-
-    vmlal.u8        q7, d18, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q8, d20, d2
-    vmlal.u8        q12, d31, d2            ;(src_ptr[0] * vp8_filter[2])
-
-    vzip.32         d6, d7                  ;put 2-line data in 1 register (src_ptr[1])
-    vzip.32         d10, d11
-    vext.8          d31, d22, d23, #3       ;construct src_ptr[1]
-    vmull.u8        q9, d6, d3              ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q10, d10, d3
-    vmull.u8        q11, d31, d3            ;(src_ptr[1] * vp8_filter[3])
-
-    add             r3, r12, r3, lsl #5
-
-    vqadd.s16       q7, q9                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q10
-    vqadd.s16       q12, q11
-
-    vext.8          d23, d27, d28, #4
-    vld1.s32        {q5, q6}, [r3]          ;load second_pass filter
-
-    vqrshrun.s16    d29, q7, #7             ;shift/round/saturate to u8
-    vqrshrun.s16    d30, q8, #7
-    vqrshrun.s16    d31, q12, #7
-
-;Second pass: 4x4
-    vabs.s32        q7, q5
-    vabs.s32        q8, q6
-
-    vext.8          d24, d28, d29, #4
-    vext.8          d25, d29, d30, #4
-    vext.8          d26, d30, d31, #4
-
-    vdup.8          d0, d14[0]              ;second_pass filter parameters (d0-d5)
-    vdup.8          d1, d14[4]
-    vdup.8          d2, d15[0]
-    vdup.8          d3, d15[4]
-    vdup.8          d4, d16[0]
-    vdup.8          d5, d16[4]
-
-    vmull.u8        q3, d27, d0             ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q4, d28, d0
-
-    vmull.u8        q5, d25, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmull.u8        q6, d26, d5
-
-    vmlsl.u8        q3, d29, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q4, d30, d4
-
-    vmlsl.u8        q5, d23, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q6, d24, d1
-
-    vmlal.u8        q3, d28, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q4, d29, d2
-
-    vmlal.u8        q5, d24, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmlal.u8        q6, d25, d3
-
-    add             r0, r4, lr
-    add             r1, r0, lr
-    add             r2, r1, lr
-
-    vqadd.s16       q5, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q6, q4
-
-    vqrshrun.s16    d3, q5, #7              ;shift/round/saturate to u8
-    vqrshrun.s16    d4, q6, #7
-
-    vst1.32         {d3[0]}, [r4]           ;store result
-    vst1.32         {d3[1]}, [r0]
-    vst1.32         {d4[0]}, [r1]
-    vst1.32         {d4[1]}, [r2]
-
-    vpop            {d8-d15}
-    pop             {r4, pc}
-
-
-;---------------------
-firstpass_filter4x4_only
-    vabs.s32        q12, q14                ;get abs(filer_parameters)
-    vabs.s32        q13, q15
-
-    sub             r0, r0, #2              ;go back 2 columns of src data
-
-;First pass: output_height lines x output_width columns (4x4)
-    vld1.u8         {q3}, [r0], r1          ;load first 4-line src data
-    vdup.8          d0, d24[0]              ;first_pass filter (d0-d5)
-    vld1.u8         {q4}, [r0], r1
-    vdup.8          d1, d24[4]
-    vld1.u8         {q5}, [r0], r1
-    vdup.8          d2, d25[0]
-    vld1.u8         {q6}, [r0], r1
-
-    vdup.8          d3, d25[4]
-    vdup.8          d4, d26[0]
-    vdup.8          d5, d26[4]
-
-    vext.8          d18, d6, d7, #5         ;construct src_ptr[3]
-    vext.8          d19, d8, d9, #5
-    vext.8          d20, d10, d11, #5
-    vext.8          d21, d12, d13, #5
-
-    vswp            d7, d8                  ;discard 2nd half data after src_ptr[3] is done
-    vswp            d11, d12
-
-    vzip.32         d18, d19                ;put 2-line data in 1 register (src_ptr[3])
-    vzip.32         d20, d21
-    vmull.u8        q7, d18, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmull.u8        q8, d20, d5
-
-    vmov            q4, q3                  ;keep original src data in q4 q6
-    vmov            q6, q5
-
-    vzip.32         d6, d7                  ;construct src_ptr[-2], and put 2-line data together
-    vzip.32         d10, d11
-    vshr.u64        q9, q4, #8              ;construct src_ptr[-1]
-    vshr.u64        q10, q6, #8
-    vmlal.u8        q7, d6, d0              ;+(src_ptr[-2] * vp8_filter[0])
-    vmlal.u8        q8, d10, d0
-
-    vzip.32         d18, d19                ;put 2-line data in 1 register (src_ptr[-1])
-    vzip.32         d20, d21
-    vshr.u64        q3, q4, #32             ;construct src_ptr[2]
-    vshr.u64        q5, q6, #32
-    vmlsl.u8        q7, d18, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q8, d20, d1
-
-    vzip.32         d6, d7                  ;put 2-line data in 1 register (src_ptr[2])
-    vzip.32         d10, d11
-    vshr.u64        q9, q4, #16             ;construct src_ptr[0]
-    vshr.u64        q10, q6, #16
-    vmlsl.u8        q7, d6, d4              ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q8, d10, d4
-
-    vzip.32         d18, d19                ;put 2-line data in 1 register (src_ptr[0])
-    vzip.32         d20, d21
-    vshr.u64        q3, q4, #24             ;construct src_ptr[1]
-    vshr.u64        q5, q6, #24
-    vmlal.u8        q7, d18, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q8, d20, d2
-
-    vzip.32         d6, d7                  ;put 2-line data in 1 register (src_ptr[1])
-    vzip.32         d10, d11
-    vmull.u8        q9, d6, d3              ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q10, d10, d3
-
-    add             r0, r4, lr
-    add             r1, r0, lr
-    add             r2, r1, lr
-
-    vqadd.s16       q7, q9                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q10
-
-    vqrshrun.s16    d27, q7, #7             ;shift/round/saturate to u8
-    vqrshrun.s16    d28, q8, #7
-
-    vst1.32         {d27[0]}, [r4]          ;store result
-    vst1.32         {d27[1]}, [r0]
-    vst1.32         {d28[0]}, [r1]
-    vst1.32         {d28[1]}, [r2]
-
-    vpop            {d8-d15}
-    pop             {r4, pc}
-
-
-;---------------------
-secondpass_filter4x4_only
-    sub             r0, r0, r1, lsl #1
-    add             r3, r12, r3, lsl #5
-
-    vld1.32         {d27[0]}, [r0], r1      ;load src data
-    vld1.s32        {q5, q6}, [r3]          ;load second_pass filter
-    vld1.32         {d27[1]}, [r0], r1
-    vabs.s32        q7, q5
-    vld1.32         {d28[0]}, [r0], r1
-    vabs.s32        q8, q6
-    vld1.32         {d28[1]}, [r0], r1
-    vdup.8          d0, d14[0]              ;second_pass filter parameters (d0-d5)
-    vld1.32         {d29[0]}, [r0], r1
-    vdup.8          d1, d14[4]
-    vld1.32         {d29[1]}, [r0], r1
-    vdup.8          d2, d15[0]
-    vld1.32         {d30[0]}, [r0], r1
-    vdup.8          d3, d15[4]
-    vld1.32         {d30[1]}, [r0], r1
-    vdup.8          d4, d16[0]
-    vld1.32         {d31[0]}, [r0], r1
-    vdup.8          d5, d16[4]
-
-    vext.8          d23, d27, d28, #4
-    vext.8          d24, d28, d29, #4
-    vext.8          d25, d29, d30, #4
-    vext.8          d26, d30, d31, #4
-
-    vmull.u8        q3, d27, d0             ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q4, d28, d0
-
-    vmull.u8        q5, d25, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmull.u8        q6, d26, d5
-
-    vmlsl.u8        q3, d29, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q4, d30, d4
-
-    vmlsl.u8        q5, d23, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q6, d24, d1
-
-    vmlal.u8        q3, d28, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q4, d29, d2
-
-    vmlal.u8        q5, d24, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmlal.u8        q6, d25, d3
-
-    add             r0, r4, lr
-    add             r1, r0, lr
-    add             r2, r1, lr
-
-    vqadd.s16       q5, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q6, q4
-
-    vqrshrun.s16    d3, q5, #7              ;shift/round/saturate to u8
-    vqrshrun.s16    d4, q6, #7
-
-    vst1.32         {d3[0]}, [r4]           ;store result
-    vst1.32         {d3[1]}, [r0]
-    vst1.32         {d4[0]}, [r1]
-    vst1.32         {d4[1]}, [r2]
-
-    vpop            {d8-d15}
-    pop             {r4, pc}
-
-    ENDP
-
-;-----------------
-
-    END
diff --git a/vp8/common/arm/neon/sixtappredict8x4_neon.asm b/vp8/common/arm/neon/sixtappredict8x4_neon.asm
deleted file mode 100644
index d19bf8920..000000000
--- a/vp8/common/arm/neon/sixtappredict8x4_neon.asm
+++ /dev/null
@@ -1,478 +0,0 @@
-;
-;  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
-;
-;  Use of this source code is governed by a BSD-style license
-;  that can be found in the LICENSE file in the root of the source
-;  tree. An additional intellectual property rights grant can be found
-;  in the file PATENTS.  All contributing project authors may
-;  be found in the AUTHORS file in the root of the source tree.
-;
-
-
-    EXPORT  |vp8_sixtap_predict8x4_neon|
-    ARM
-    REQUIRE8
-    PRESERVE8
-
-    AREA ||.text||, CODE, READONLY, ALIGN=2
-
-filter8_coeff
-    DCD     0,  0,  128,    0,   0,  0,   0,  0
-    DCD     0, -6,  123,   12,  -1,  0,   0,  0
-    DCD     2, -11, 108,   36,  -8,  1,   0,  0
-    DCD     0, -9,   93,   50,  -6,  0,   0,  0
-    DCD     3, -16,  77,   77, -16,  3,   0,  0
-    DCD     0, -6,   50,   93,  -9,  0,   0,  0
-    DCD     1, -8,   36,  108, -11,  2,   0,  0
-    DCD     0, -1,   12,  123,  -6,   0,  0,  0
-
-; r0    unsigned char  *src_ptr,
-; r1    int  src_pixels_per_line,
-; r2    int  xoffset,
-; r3    int  yoffset,
-; r4    unsigned char *dst_ptr,
-; stack(r5) int  dst_pitch
-
-|vp8_sixtap_predict8x4_neon| PROC
-    push            {r4-r5, lr}
-    vpush           {d8-d15}
-
-    adr             r12, filter8_coeff
-    ldr             r4, [sp, #76]           ;load parameters from stack
-    ldr             r5, [sp, #80]           ;load parameters from stack
-
-    cmp             r2, #0                  ;skip first_pass filter if xoffset=0
-    beq             secondpass_filter8x4_only
-
-    add             r2, r12, r2, lsl #5     ;calculate filter location
-
-    cmp             r3, #0                  ;skip second_pass filter if yoffset=0
-
-    vld1.s32        {q14, q15}, [r2]        ;load first_pass filter
-
-    beq             firstpass_filter8x4_only
-
-    sub             sp, sp, #32             ;reserve space on stack for temporary storage
-    vabs.s32        q12, q14
-    vabs.s32        q13, q15
-
-    sub             r0, r0, #2              ;move srcptr back to (line-2) and (column-2)
-    mov             lr, sp
-    sub             r0, r0, r1, lsl #1
-
-    vdup.8          d0, d24[0]              ;first_pass filter (d0-d5)
-    vdup.8          d1, d24[4]
-    vdup.8          d2, d25[0]
-
-;First pass: output_height lines x output_width columns (9x8)
-    vld1.u8         {q3}, [r0], r1          ;load src data
-    vdup.8          d3, d25[4]
-    vld1.u8         {q4}, [r0], r1
-    vdup.8          d4, d26[0]
-    vld1.u8         {q5}, [r0], r1
-    vdup.8          d5, d26[4]
-    vld1.u8         {q6}, [r0], r1
-
-    pld             [r0]
-    pld             [r0, r1]
-    pld             [r0, r1, lsl #1]
-
-    vmull.u8        q7, d6, d0              ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q8, d8, d0
-    vmull.u8        q9, d10, d0
-    vmull.u8        q10, d12, d0
-
-    vext.8          d28, d6, d7, #1         ;construct src_ptr[-1]
-    vext.8          d29, d8, d9, #1
-    vext.8          d30, d10, d11, #1
-    vext.8          d31, d12, d13, #1
-
-    vmlsl.u8        q7, d28, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q8, d29, d1
-    vmlsl.u8        q9, d30, d1
-    vmlsl.u8        q10, d31, d1
-
-    vext.8          d28, d6, d7, #4         ;construct src_ptr[2]
-    vext.8          d29, d8, d9, #4
-    vext.8          d30, d10, d11, #4
-    vext.8          d31, d12, d13, #4
-
-    vmlsl.u8        q7, d28, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q8, d29, d4
-    vmlsl.u8        q9, d30, d4
-    vmlsl.u8        q10, d31, d4
-
-    vext.8          d28, d6, d7, #2         ;construct src_ptr[0]
-    vext.8          d29, d8, d9, #2
-    vext.8          d30, d10, d11, #2
-    vext.8          d31, d12, d13, #2
-
-    vmlal.u8        q7, d28, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q8, d29, d2
-    vmlal.u8        q9, d30, d2
-    vmlal.u8        q10, d31, d2
-
-    vext.8          d28, d6, d7, #5         ;construct src_ptr[3]
-    vext.8          d29, d8, d9, #5
-    vext.8          d30, d10, d11, #5
-    vext.8          d31, d12, d13, #5
-
-    vmlal.u8        q7, d28, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q8, d29, d5
-    vmlal.u8        q9, d30, d5
-    vmlal.u8        q10, d31, d5
-
-    vext.8          d28, d6, d7, #3         ;construct src_ptr[1]
-    vext.8          d29, d8, d9, #3
-    vext.8          d30, d10, d11, #3
-    vext.8          d31, d12, d13, #3
-
-    vmull.u8        q3, d28, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q4, d29, d3
-    vmull.u8        q5, d30, d3
-    vmull.u8        q6, d31, d3
-
-    vqadd.s16       q7, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q4
-    vqadd.s16       q9, q5
-    vqadd.s16       q10, q6
-
-    vld1.u8         {q3}, [r0], r1          ;load src data
-
-    vqrshrun.s16    d22, q7, #7             ;shift/round/saturate to u8
-    vqrshrun.s16    d23, q8, #7
-    vqrshrun.s16    d24, q9, #7
-    vqrshrun.s16    d25, q10, #7
-
-    vld1.u8         {q4}, [r0], r1
-    vst1.u8         {d22}, [lr]!            ;store result
-    vld1.u8         {q5}, [r0], r1
-    vst1.u8         {d23}, [lr]!
-    vld1.u8         {q6}, [r0], r1
-    vst1.u8         {d24}, [lr]!
-    vld1.u8         {q7}, [r0], r1
-    vst1.u8         {d25}, [lr]!
-
-    ;first_pass filtering on the rest 5-line data
-    vmull.u8        q8, d6, d0              ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q9, d8, d0
-    vmull.u8        q10, d10, d0
-    vmull.u8        q11, d12, d0
-    vmull.u8        q12, d14, d0
-
-    vext.8          d27, d6, d7, #1         ;construct src_ptr[-1]
-    vext.8          d28, d8, d9, #1
-    vext.8          d29, d10, d11, #1
-    vext.8          d30, d12, d13, #1
-    vext.8          d31, d14, d15, #1
-
-    vmlsl.u8        q8, d27, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q9, d28, d1
-    vmlsl.u8        q10, d29, d1
-    vmlsl.u8        q11, d30, d1
-    vmlsl.u8        q12, d31, d1
-
-    vext.8          d27, d6, d7, #4         ;construct src_ptr[2]
-    vext.8          d28, d8, d9, #4
-    vext.8          d29, d10, d11, #4
-    vext.8          d30, d12, d13, #4
-    vext.8          d31, d14, d15, #4
-
-    vmlsl.u8        q8, d27, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q9, d28, d4
-    vmlsl.u8        q10, d29, d4
-    vmlsl.u8        q11, d30, d4
-    vmlsl.u8        q12, d31, d4
-
-    vext.8          d27, d6, d7, #2         ;construct src_ptr[0]
-    vext.8          d28, d8, d9, #2
-    vext.8          d29, d10, d11, #2
-    vext.8          d30, d12, d13, #2
-    vext.8          d31, d14, d15, #2
-
-    vmlal.u8        q8, d27, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q9, d28, d2
-    vmlal.u8        q10, d29, d2
-    vmlal.u8        q11, d30, d2
-    vmlal.u8        q12, d31, d2
-
-    vext.8          d27, d6, d7, #5         ;construct src_ptr[3]
-    vext.8          d28, d8, d9, #5
-    vext.8          d29, d10, d11, #5
-    vext.8          d30, d12, d13, #5
-    vext.8          d31, d14, d15, #5
-
-    vmlal.u8        q8, d27, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q9, d28, d5
-    vmlal.u8        q10, d29, d5
-    vmlal.u8        q11, d30, d5
-    vmlal.u8        q12, d31, d5
-
-    vext.8          d27, d6, d7, #3         ;construct src_ptr[1]
-    vext.8          d28, d8, d9, #3
-    vext.8          d29, d10, d11, #3
-    vext.8          d30, d12, d13, #3
-    vext.8          d31, d14, d15, #3
-
-    vmull.u8        q3, d27, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q4, d28, d3
-    vmull.u8        q5, d29, d3
-    vmull.u8        q6, d30, d3
-    vmull.u8        q7, d31, d3
-
-    vqadd.s16       q8, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q9, q4
-    vqadd.s16       q10, q5
-    vqadd.s16       q11, q6
-    vqadd.s16       q12, q7
-
-    vqrshrun.s16    d26, q8, #7             ;shift/round/saturate to u8
-    vqrshrun.s16    d27, q9, #7
-    vqrshrun.s16    d28, q10, #7
-    vqrshrun.s16    d29, q11, #7                ;load intermediate data from stack
-    vqrshrun.s16    d30, q12, #7
-
-;Second pass: 8x4
-;secondpass_filter
-    add             r3, r12, r3, lsl #5
-    sub             lr, lr, #32
-
-    vld1.s32        {q5, q6}, [r3]          ;load second_pass filter
-    vld1.u8         {q11}, [lr]!
-
-    vabs.s32        q7, q5
-    vabs.s32        q8, q6
-
-    vld1.u8         {q12}, [lr]!
-
-    vdup.8          d0, d14[0]              ;second_pass filter parameters (d0-d5)
-    vdup.8          d1, d14[4]
-    vdup.8          d2, d15[0]
-    vdup.8          d3, d15[4]
-    vdup.8          d4, d16[0]
-    vdup.8          d5, d16[4]
-
-    vmull.u8        q3, d22, d0             ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q4, d23, d0
-    vmull.u8        q5, d24, d0
-    vmull.u8        q6, d25, d0
-
-    vmlsl.u8        q3, d23, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q4, d24, d1
-    vmlsl.u8        q5, d25, d1
-    vmlsl.u8        q6, d26, d1
-
-    vmlsl.u8        q3, d26, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q4, d27, d4
-    vmlsl.u8        q5, d28, d4
-    vmlsl.u8        q6, d29, d4
-
-    vmlal.u8        q3, d24, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q4, d25, d2
-    vmlal.u8        q5, d26, d2
-    vmlal.u8        q6, d27, d2
-
-    vmlal.u8        q3, d27, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q4, d28, d5
-    vmlal.u8        q5, d29, d5
-    vmlal.u8        q6, d30, d5
-
-    vmull.u8        q7, d25, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q8, d26, d3
-    vmull.u8        q9, d27, d3
-    vmull.u8        q10, d28, d3
-
-    vqadd.s16       q7, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q4
-    vqadd.s16       q9, q5
-    vqadd.s16       q10, q6
-
-    vqrshrun.s16    d6, q7, #7              ;shift/round/saturate to u8
-    vqrshrun.s16    d7, q8, #7
-    vqrshrun.s16    d8, q9, #7
-    vqrshrun.s16    d9, q10, #7
-
-    vst1.u8         {d6}, [r4], r5          ;store result
-    vst1.u8         {d7}, [r4], r5
-    vst1.u8         {d8}, [r4], r5
-    vst1.u8         {d9}, [r4], r5
-
-    add             sp, sp, #32
-
-    vpop            {d8-d15}
-    pop             {r4-r5,pc}
-
-;--------------------
-firstpass_filter8x4_only
-    vabs.s32        q12, q14
-    vabs.s32        q13, q15
-
-    sub             r0, r0, #2              ;move srcptr back to (line-2) and (column-2)
-    vld1.u8         {q3}, [r0], r1          ;load src data
-
-    vdup.8          d0, d24[0]              ;first_pass filter (d0-d5)
-    vld1.u8         {q4}, [r0], r1
-    vdup.8          d1, d24[4]
-    vld1.u8         {q5}, [r0], r1
-    vdup.8          d2, d25[0]
-    vld1.u8         {q6}, [r0], r1
-    vdup.8          d3, d25[4]
-    vdup.8          d4, d26[0]
-    vdup.8          d5, d26[4]
-
-;First pass: output_height lines x output_width columns (4x8)
-    pld             [r0]
-    pld             [r0, r1]
-    pld             [r0, r1, lsl #1]
-
-    vmull.u8        q7, d6, d0              ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q8, d8, d0
-    vmull.u8        q9, d10, d0
-    vmull.u8        q10, d12, d0
-
-    vext.8          d28, d6, d7, #1         ;construct src_ptr[-1]
-    vext.8          d29, d8, d9, #1
-    vext.8          d30, d10, d11, #1
-    vext.8          d31, d12, d13, #1
-
-    vmlsl.u8        q7, d28, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q8, d29, d1
-    vmlsl.u8        q9, d30, d1
-    vmlsl.u8        q10, d31, d1
-
-    vext.8          d28, d6, d7, #4         ;construct src_ptr[2]
-    vext.8          d29, d8, d9, #4
-    vext.8          d30, d10, d11, #4
-    vext.8          d31, d12, d13, #4
-
-    vmlsl.u8        q7, d28, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q8, d29, d4
-    vmlsl.u8        q9, d30, d4
-    vmlsl.u8        q10, d31, d4
-
-    vext.8          d28, d6, d7, #2         ;construct src_ptr[0]
-    vext.8          d29, d8, d9, #2
-    vext.8          d30, d10, d11, #2
-    vext.8          d31, d12, d13, #2
-
-    vmlal.u8        q7, d28, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q8, d29, d2
-    vmlal.u8        q9, d30, d2
-    vmlal.u8        q10, d31, d2
-
-    vext.8          d28, d6, d7, #5         ;construct src_ptr[3]
-    vext.8          d29, d8, d9, #5
-    vext.8          d30, d10, d11, #5
-    vext.8          d31, d12, d13, #5
-
-    vmlal.u8        q7, d28, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q8, d29, d5
-    vmlal.u8        q9, d30, d5
-    vmlal.u8        q10, d31, d5
-
-    vext.8          d28, d6, d7, #3         ;construct src_ptr[1]
-    vext.8          d29, d8, d9, #3
-    vext.8          d30, d10, d11, #3
-    vext.8          d31, d12, d13, #3
-
-    vmull.u8        q3, d28, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q4, d29, d3
-    vmull.u8        q5, d30, d3
-    vmull.u8        q6, d31, d3
-
-    vqadd.s16       q7, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q4
-    vqadd.s16       q9, q5
-    vqadd.s16       q10, q6
-
-    vqrshrun.s16    d22, q7, #7             ;shift/round/saturate to u8
-    vqrshrun.s16    d23, q8, #7
-    vqrshrun.s16    d24, q9, #7
-    vqrshrun.s16    d25, q10, #7
-
-    vst1.u8         {d22}, [r4], r5         ;store result
-    vst1.u8         {d23}, [r4], r5
-    vst1.u8         {d24}, [r4], r5
-    vst1.u8         {d25}, [r4], r5
-
-    vpop            {d8-d15}
-    pop             {r4-r5,pc}
-
-;---------------------
-secondpass_filter8x4_only
-;Second pass: 8x4
-    add             r3, r12, r3, lsl #5
-    sub             r0, r0, r1, lsl #1
-    vld1.s32        {q5, q6}, [r3]          ;load second_pass filter
-    vabs.s32        q7, q5
-    vabs.s32        q8, q6
-
-    vld1.u8         {d22}, [r0], r1
-    vld1.u8         {d23}, [r0], r1
-    vld1.u8         {d24}, [r0], r1
-    vdup.8          d0, d14[0]              ;second_pass filter parameters (d0-d5)
-    vld1.u8         {d25}, [r0], r1
-    vdup.8          d1, d14[4]
-    vld1.u8         {d26}, [r0], r1
-    vdup.8          d2, d15[0]
-    vld1.u8         {d27}, [r0], r1
-    vdup.8          d3, d15[4]
-    vld1.u8         {d28}, [r0], r1
-    vdup.8          d4, d16[0]
-    vld1.u8         {d29}, [r0], r1
-    vdup.8          d5, d16[4]
-    vld1.u8         {d30}, [r0], r1
-
-    vmull.u8        q3, d22, d0             ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q4, d23, d0
-    vmull.u8        q5, d24, d0
-    vmull.u8        q6, d25, d0
-
-    vmlsl.u8        q3, d23, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q4, d24, d1
-    vmlsl.u8        q5, d25, d1
-    vmlsl.u8        q6, d26, d1
-
-    vmlsl.u8        q3, d26, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q4, d27, d4
-    vmlsl.u8        q5, d28, d4
-    vmlsl.u8        q6, d29, d4
-
-    vmlal.u8        q3, d24, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q4, d25, d2
-    vmlal.u8        q5, d26, d2
-    vmlal.u8        q6, d27, d2
-
-    vmlal.u8        q3, d27, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q4, d28, d5
-    vmlal.u8        q5, d29, d5
-    vmlal.u8        q6, d30, d5
-
-    vmull.u8        q7, d25, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q8, d26, d3
-    vmull.u8        q9, d27, d3
-    vmull.u8        q10, d28, d3
-
-    vqadd.s16       q7, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q4
-    vqadd.s16       q9, q5
-    vqadd.s16       q10, q6
-
-    vqrshrun.s16    d6, q7, #7              ;shift/round/saturate to u8
-    vqrshrun.s16    d7, q8, #7
-    vqrshrun.s16    d8, q9, #7
-    vqrshrun.s16    d9, q10, #7
-
-    vst1.u8         {d6}, [r4], r5          ;store result
-    vst1.u8         {d7}, [r4], r5
-    vst1.u8         {d8}, [r4], r5
-    vst1.u8         {d9}, [r4], r5
-
-    vpop            {d8-d15}
-    pop             {r4-r5,pc}
-
-    ENDP
-
-;-----------------
-
-    END
diff --git a/vp8/common/arm/neon/sixtappredict8x8_neon.asm b/vp8/common/arm/neon/sixtappredict8x8_neon.asm
deleted file mode 100644
index 4b049252c..000000000
--- a/vp8/common/arm/neon/sixtappredict8x8_neon.asm
+++ /dev/null
@@ -1,528 +0,0 @@
-;
-;  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
-;
-;  Use of this source code is governed by a BSD-style license
-;  that can be found in the LICENSE file in the root of the source
-;  tree. An additional intellectual property rights grant can be found
-;  in the file PATENTS.  All contributing project authors may
-;  be found in the AUTHORS file in the root of the source tree.
-;
-
-
-    EXPORT  |vp8_sixtap_predict8x8_neon|
-    ARM
-    REQUIRE8
-    PRESERVE8
-
-    AREA ||.text||, CODE, READONLY, ALIGN=2
-
-filter8_coeff
-    DCD     0,  0,  128,    0,   0,  0,   0,  0
-    DCD     0, -6,  123,   12,  -1,  0,   0,  0
-    DCD     2, -11, 108,   36,  -8,  1,   0,  0
-    DCD     0, -9,   93,   50,  -6,  0,   0,  0
-    DCD     3, -16,  77,   77, -16,  3,   0,  0
-    DCD     0, -6,   50,   93,  -9,  0,   0,  0
-    DCD     1, -8,   36,  108, -11,  2,   0,  0
-    DCD     0, -1,   12,  123,  -6,   0,  0,  0
-
-; r0    unsigned char  *src_ptr,
-; r1    int  src_pixels_per_line,
-; r2    int  xoffset,
-; r3    int  yoffset,
-; stack(r4) unsigned char *dst_ptr,
-; stack(r5) int  dst_pitch
-
-|vp8_sixtap_predict8x8_neon| PROC
-    push            {r4-r5, lr}
-    vpush           {d8-d15}
-    adr             r12, filter8_coeff
-
-    ldr             r4, [sp, #76]           ;load parameters from stack
-    ldr             r5, [sp, #80]           ;load parameters from stack
-
-    cmp             r2, #0                  ;skip first_pass filter if xoffset=0
-    beq             secondpass_filter8x8_only
-
-    add             r2, r12, r2, lsl #5     ;calculate filter location
-
-    cmp             r3, #0                  ;skip second_pass filter if yoffset=0
-
-    vld1.s32        {q14, q15}, [r2]        ;load first_pass filter
-
-    beq             firstpass_filter8x8_only
-
-    sub             sp, sp, #64             ;reserve space on stack for temporary storage
-    mov             lr, sp
-
-    vabs.s32        q12, q14
-    vabs.s32        q13, q15
-
-    mov             r2, #2                  ;loop counter
-    sub             r0, r0, #2              ;move srcptr back to (line-2) and (column-2)
-    sub             r0, r0, r1, lsl #1
-
-    vdup.8          d0, d24[0]              ;first_pass filter (d0-d5)
-    vdup.8          d1, d24[4]
-    vdup.8          d2, d25[0]
-
-;First pass: output_height lines x output_width columns (13x8)
-    vld1.u8         {q3}, [r0], r1          ;load src data
-    vdup.8          d3, d25[4]
-    vld1.u8         {q4}, [r0], r1
-    vdup.8          d4, d26[0]
-    vld1.u8         {q5}, [r0], r1
-    vdup.8          d5, d26[4]
-    vld1.u8         {q6}, [r0], r1
-
-filt_blk2d_fp8x8_loop_neon
-    pld             [r0]
-    pld             [r0, r1]
-    pld             [r0, r1, lsl #1]
-
-    vmull.u8        q7, d6, d0              ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q8, d8, d0
-    vmull.u8        q9, d10, d0
-    vmull.u8        q10, d12, d0
-
-    vext.8          d28, d6, d7, #1         ;construct src_ptr[-1]
-    vext.8          d29, d8, d9, #1
-    vext.8          d30, d10, d11, #1
-    vext.8          d31, d12, d13, #1
-
-    vmlsl.u8        q7, d28, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q8, d29, d1
-    vmlsl.u8        q9, d30, d1
-    vmlsl.u8        q10, d31, d1
-
-    vext.8          d28, d6, d7, #4         ;construct src_ptr[2]
-    vext.8          d29, d8, d9, #4
-    vext.8          d30, d10, d11, #4
-    vext.8          d31, d12, d13, #4
-
-    vmlsl.u8        q7, d28, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q8, d29, d4
-    vmlsl.u8        q9, d30, d4
-    vmlsl.u8        q10, d31, d4
-
-    vext.8          d28, d6, d7, #2         ;construct src_ptr[0]
-    vext.8          d29, d8, d9, #2
-    vext.8          d30, d10, d11, #2
-    vext.8          d31, d12, d13, #2
-
-    vmlal.u8        q7, d28, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q8, d29, d2
-    vmlal.u8        q9, d30, d2
-    vmlal.u8        q10, d31, d2
-
-    vext.8          d28, d6, d7, #5         ;construct src_ptr[3]
-    vext.8          d29, d8, d9, #5
-    vext.8          d30, d10, d11, #5
-    vext.8          d31, d12, d13, #5
-
-    vmlal.u8        q7, d28, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q8, d29, d5
-    vmlal.u8        q9, d30, d5
-    vmlal.u8        q10, d31, d5
-
-    vext.8          d28, d6, d7, #3         ;construct src_ptr[1]
-    vext.8          d29, d8, d9, #3
-    vext.8          d30, d10, d11, #3
-    vext.8          d31, d12, d13, #3
-
-    vmull.u8        q3, d28, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q4, d29, d3
-    vmull.u8        q5, d30, d3
-    vmull.u8        q6, d31, d3
-
-    subs            r2, r2, #1
-
-    vqadd.s16       q7, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q4
-    vqadd.s16       q9, q5
-    vqadd.s16       q10, q6
-
-    vld1.u8         {q3}, [r0], r1          ;load src data
-
-    vqrshrun.s16    d22, q7, #7             ;shift/round/saturate to u8
-    vqrshrun.s16    d23, q8, #7
-    vqrshrun.s16    d24, q9, #7
-    vqrshrun.s16    d25, q10, #7
-
-    vst1.u8         {d22}, [lr]!            ;store result
-    vld1.u8         {q4}, [r0], r1
-    vst1.u8         {d23}, [lr]!
-    vld1.u8         {q5}, [r0], r1
-    vst1.u8         {d24}, [lr]!
-    vld1.u8         {q6}, [r0], r1
-    vst1.u8         {d25}, [lr]!
-
-    bne             filt_blk2d_fp8x8_loop_neon
-
-    ;first_pass filtering on the rest 5-line data
-    ;vld1.u8            {q3}, [r0], r1          ;load src data
-    ;vld1.u8            {q4}, [r0], r1
-    ;vld1.u8            {q5}, [r0], r1
-    ;vld1.u8            {q6}, [r0], r1
-    vld1.u8         {q7}, [r0], r1
-
-    vmull.u8        q8, d6, d0              ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q9, d8, d0
-    vmull.u8        q10, d10, d0
-    vmull.u8        q11, d12, d0
-    vmull.u8        q12, d14, d0
-
-    vext.8          d27, d6, d7, #1         ;construct src_ptr[-1]
-    vext.8          d28, d8, d9, #1
-    vext.8          d29, d10, d11, #1
-    vext.8          d30, d12, d13, #1
-    vext.8          d31, d14, d15, #1
-
-    vmlsl.u8        q8, d27, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q9, d28, d1
-    vmlsl.u8        q10, d29, d1
-    vmlsl.u8        q11, d30, d1
-    vmlsl.u8        q12, d31, d1
-
-    vext.8          d27, d6, d7, #4         ;construct src_ptr[2]
-    vext.8          d28, d8, d9, #4
-    vext.8          d29, d10, d11, #4
-    vext.8          d30, d12, d13, #4
-    vext.8          d31, d14, d15, #4
-
-    vmlsl.u8        q8, d27, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q9, d28, d4
-    vmlsl.u8        q10, d29, d4
-    vmlsl.u8        q11, d30, d4
-    vmlsl.u8        q12, d31, d4
-
-    vext.8          d27, d6, d7, #2         ;construct src_ptr[0]
-    vext.8          d28, d8, d9, #2
-    vext.8          d29, d10, d11, #2
-    vext.8          d30, d12, d13, #2
-    vext.8          d31, d14, d15, #2
-
-    vmlal.u8        q8, d27, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q9, d28, d2
-    vmlal.u8        q10, d29, d2
-    vmlal.u8        q11, d30, d2
-    vmlal.u8        q12, d31, d2
-
-    vext.8          d27, d6, d7, #5         ;construct src_ptr[3]
-    vext.8          d28, d8, d9, #5
-    vext.8          d29, d10, d11, #5
-    vext.8          d30, d12, d13, #5
-    vext.8          d31, d14, d15, #5
-
-    vmlal.u8        q8, d27, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q9, d28, d5
-    vmlal.u8        q10, d29, d5
-    vmlal.u8        q11, d30, d5
-    vmlal.u8        q12, d31, d5
-
-    vext.8          d27, d6, d7, #3         ;construct src_ptr[1]
-    vext.8          d28, d8, d9, #3
-    vext.8          d29, d10, d11, #3
-    vext.8          d30, d12, d13, #3
-    vext.8          d31, d14, d15, #3
-
-    vmull.u8        q3, d27, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q4, d28, d3
-    vmull.u8        q5, d29, d3
-    vmull.u8        q6, d30, d3
-    vmull.u8        q7, d31, d3
-
-    vqadd.s16       q8, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q9, q4
-    vqadd.s16       q10, q5
-    vqadd.s16       q11, q6
-    vqadd.s16       q12, q7
-
-    add             r3, r12, r3, lsl #5
-
-    vqrshrun.s16    d26, q8, #7             ;shift/round/saturate to u8
-    sub             lr, lr, #64
-    vqrshrun.s16    d27, q9, #7
-    vld1.u8         {q9}, [lr]!             ;load intermediate data from stack
-    vqrshrun.s16    d28, q10, #7
-    vld1.u8         {q10}, [lr]!
-
-    vld1.s32        {q5, q6}, [r3]          ;load second_pass filter
-
-    vqrshrun.s16    d29, q11, #7
-    vld1.u8         {q11}, [lr]!
-
-    vabs.s32        q7, q5
-    vabs.s32        q8, q6
-
-    vqrshrun.s16    d30, q12, #7
-    vld1.u8         {q12}, [lr]!
-
-;Second pass: 8x8
-    mov             r3, #2                  ;loop counter
-
-    vdup.8          d0, d14[0]              ;second_pass filter parameters (d0-d5)
-    vdup.8          d1, d14[4]
-    vdup.8          d2, d15[0]
-    vdup.8          d3, d15[4]
-    vdup.8          d4, d16[0]
-    vdup.8          d5, d16[4]
-
-filt_blk2d_sp8x8_loop_neon
-    vmull.u8        q3, d18, d0             ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q4, d19, d0
-    vmull.u8        q5, d20, d0
-    vmull.u8        q6, d21, d0
-
-    vmlsl.u8        q3, d19, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q4, d20, d1
-    vmlsl.u8        q5, d21, d1
-    vmlsl.u8        q6, d22, d1
-
-    vmlsl.u8        q3, d22, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q4, d23, d4
-    vmlsl.u8        q5, d24, d4
-    vmlsl.u8        q6, d25, d4
-
-    vmlal.u8        q3, d20, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q4, d21, d2
-    vmlal.u8        q5, d22, d2
-    vmlal.u8        q6, d23, d2
-
-    vmlal.u8        q3, d23, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q4, d24, d5
-    vmlal.u8        q5, d25, d5
-    vmlal.u8        q6, d26, d5
-
-    vmull.u8        q7, d21, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q8, d22, d3
-    vmull.u8        q9, d23, d3
-    vmull.u8        q10, d24, d3
-
-    subs            r3, r3, #1
-
-    vqadd.s16       q7, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q4
-    vqadd.s16       q9, q5
-    vqadd.s16       q10, q6
-
-    vqrshrun.s16    d6, q7, #7              ;shift/round/saturate to u8
-    vqrshrun.s16    d7, q8, #7
-    vqrshrun.s16    d8, q9, #7
-    vqrshrun.s16    d9, q10, #7
-
-    vmov            q9, q11
-    vst1.u8         {d6}, [r4], r5          ;store result
-    vmov            q10, q12
-    vst1.u8         {d7}, [r4], r5
-    vmov            q11, q13
-    vst1.u8         {d8}, [r4], r5
-    vmov            q12, q14
-    vst1.u8         {d9}, [r4], r5
-    vmov            d26, d30
-
-    bne filt_blk2d_sp8x8_loop_neon
-
-    add             sp, sp, #64
-
-    vpop            {d8-d15}
-    pop             {r4-r5,pc}
-
-;---------------------
-firstpass_filter8x8_only
-    ;add                r2, r12, r2, lsl #5     ;calculate filter location
-    ;vld1.s32       {q14, q15}, [r2]        ;load first_pass filter
-    vabs.s32        q12, q14
-    vabs.s32        q13, q15
-
-    mov             r2, #2                  ;loop counter
-    sub             r0, r0, #2              ;move srcptr back to (line-2) and (column-2)
-
-    vdup.8          d0, d24[0]              ;first_pass filter (d0-d5)
-    vdup.8          d1, d24[4]
-    vdup.8          d2, d25[0]
-    vdup.8          d3, d25[4]
-    vdup.8          d4, d26[0]
-    vdup.8          d5, d26[4]
-
-;First pass: output_height lines x output_width columns (8x8)
-filt_blk2d_fpo8x8_loop_neon
-    vld1.u8         {q3}, [r0], r1          ;load src data
-    vld1.u8         {q4}, [r0], r1
-    vld1.u8         {q5}, [r0], r1
-    vld1.u8         {q6}, [r0], r1
-
-    pld             [r0]
-    pld             [r0, r1]
-    pld             [r0, r1, lsl #1]
-
-    vmull.u8        q7, d6, d0              ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q8, d8, d0
-    vmull.u8        q9, d10, d0
-    vmull.u8        q10, d12, d0
-
-    vext.8          d28, d6, d7, #1         ;construct src_ptr[-1]
-    vext.8          d29, d8, d9, #1
-    vext.8          d30, d10, d11, #1
-    vext.8          d31, d12, d13, #1
-
-    vmlsl.u8        q7, d28, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q8, d29, d1
-    vmlsl.u8        q9, d30, d1
-    vmlsl.u8        q10, d31, d1
-
-    vext.8          d28, d6, d7, #4         ;construct src_ptr[2]
-    vext.8          d29, d8, d9, #4
-    vext.8          d30, d10, d11, #4
-    vext.8          d31, d12, d13, #4
-
-    vmlsl.u8        q7, d28, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q8, d29, d4
-    vmlsl.u8        q9, d30, d4
-    vmlsl.u8        q10, d31, d4
-
-    vext.8          d28, d6, d7, #2         ;construct src_ptr[0]
-    vext.8          d29, d8, d9, #2
-    vext.8          d30, d10, d11, #2
-    vext.8          d31, d12, d13, #2
-
-    vmlal.u8        q7, d28, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q8, d29, d2
-    vmlal.u8        q9, d30, d2
-    vmlal.u8        q10, d31, d2
-
-    vext.8          d28, d6, d7, #5         ;construct src_ptr[3]
-    vext.8          d29, d8, d9, #5
-    vext.8          d30, d10, d11, #5
-    vext.8          d31, d12, d13, #5
-
-    vmlal.u8        q7, d28, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q8, d29, d5
-    vmlal.u8        q9, d30, d5
-    vmlal.u8        q10, d31, d5
-
-    vext.8          d28, d6, d7, #3         ;construct src_ptr[1]
-    vext.8          d29, d8, d9, #3
-    vext.8          d30, d10, d11, #3
-    vext.8          d31, d12, d13, #3
-
-    vmull.u8        q3, d28, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q4, d29, d3
-    vmull.u8        q5, d30, d3
-    vmull.u8        q6, d31, d3
- ;
-    vqadd.s16       q7, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q4
-    vqadd.s16       q9, q5
-    vqadd.s16       q10, q6
-
-    subs            r2, r2, #1
-
-    vqrshrun.s16    d22, q7, #7             ;shift/round/saturate to u8
-    vqrshrun.s16    d23, q8, #7
-    vqrshrun.s16    d24, q9, #7
-    vqrshrun.s16    d25, q10, #7
-
-    vst1.u8         {d22}, [r4], r5         ;store result
-    vst1.u8         {d23}, [r4], r5
-    vst1.u8         {d24}, [r4], r5
-    vst1.u8         {d25}, [r4], r5
-
-    bne             filt_blk2d_fpo8x8_loop_neon
-
-    vpop            {d8-d15}
-    pop             {r4-r5,pc}
-
-;---------------------
-secondpass_filter8x8_only
-    sub             r0, r0, r1, lsl #1
-    add             r3, r12, r3, lsl #5
-
-    vld1.u8         {d18}, [r0], r1         ;load src data
-    vld1.s32        {q5, q6}, [r3]          ;load second_pass filter
-    vld1.u8         {d19}, [r0], r1
-    vabs.s32        q7, q5
-    vld1.u8         {d20}, [r0], r1
-    vabs.s32        q8, q6
-    vld1.u8         {d21}, [r0], r1
-    mov             r3, #2                  ;loop counter
-    vld1.u8         {d22}, [r0], r1
-    vdup.8          d0, d14[0]              ;second_pass filter parameters (d0-d5)
-    vld1.u8         {d23}, [r0], r1
-    vdup.8          d1, d14[4]
-    vld1.u8         {d24}, [r0], r1
-    vdup.8          d2, d15[0]
-    vld1.u8         {d25}, [r0], r1
-    vdup.8          d3, d15[4]
-    vld1.u8         {d26}, [r0], r1
-    vdup.8          d4, d16[0]
-    vld1.u8         {d27}, [r0], r1
-    vdup.8          d5, d16[4]
-    vld1.u8         {d28}, [r0], r1
-    vld1.u8         {d29}, [r0], r1
-    vld1.u8         {d30}, [r0], r1
-
-;Second pass: 8x8
-filt_blk2d_spo8x8_loop_neon
-    vmull.u8        q3, d18, d0             ;(src_ptr[-2] * vp8_filter[0])
-    vmull.u8        q4, d19, d0
-    vmull.u8        q5, d20, d0
-    vmull.u8        q6, d21, d0
-
-    vmlsl.u8        q3, d19, d1             ;-(src_ptr[-1] * vp8_filter[1])
-    vmlsl.u8        q4, d20, d1
-    vmlsl.u8        q5, d21, d1
-    vmlsl.u8        q6, d22, d1
-
-    vmlsl.u8        q3, d22, d4             ;-(src_ptr[2] * vp8_filter[4])
-    vmlsl.u8        q4, d23, d4
-    vmlsl.u8        q5, d24, d4
-    vmlsl.u8        q6, d25, d4
-
-    vmlal.u8        q3, d20, d2             ;(src_ptr[0] * vp8_filter[2])
-    vmlal.u8        q4, d21, d2
-    vmlal.u8        q5, d22, d2
-    vmlal.u8        q6, d23, d2
-
-    vmlal.u8        q3, d23, d5             ;(src_ptr[3] * vp8_filter[5])
-    vmlal.u8        q4, d24, d5
-    vmlal.u8        q5, d25, d5
-    vmlal.u8        q6, d26, d5
-
-    vmull.u8        q7, d21, d3             ;(src_ptr[1] * vp8_filter[3])
-    vmull.u8        q8, d22, d3
-    vmull.u8        q9, d23, d3
-    vmull.u8        q10, d24, d3
-
-    subs            r3, r3, #1
-
-    vqadd.s16       q7, q3                  ;sum of all (src_data*filter_parameters)
-    vqadd.s16       q8, q4
-    vqadd.s16       q9, q5
-    vqadd.s16       q10, q6
-
-    vqrshrun.s16    d6, q7, #7              ;shift/round/saturate to u8
-    vqrshrun.s16    d7, q8, #7
-    vqrshrun.s16    d8, q9, #7
-    vqrshrun.s16    d9, q10, #7
-
-    vmov            q9, q11
-    vst1.u8         {d6}, [r4], r5          ;store result
-    vmov            q10, q12
-    vst1.u8         {d7}, [r4], r5
-    vmov            q11, q13
-    vst1.u8         {d8}, [r4], r5
-    vmov            q12, q14
-    vst1.u8         {d9}, [r4], r5
-    vmov            d26, d30
-
-    bne filt_blk2d_spo8x8_loop_neon
-
-    vpop            {d8-d15}
-    pop             {r4-r5,pc}
-
-    ENDP
-
-;-----------------
-
-    END
diff --git a/vp8/common/arm/neon/sixtappredict_neon.c b/vp8/common/arm/neon/sixtappredict_neon.c
new file mode 100644
index 000000000..22932e94a
--- /dev/null
+++ b/vp8/common/arm/neon/sixtappredict_neon.c
@@ -0,0 +1,1748 @@
+/*
+ *  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <arm_neon.h>
+
+static const int8_t vp8_sub_pel_filters[8][8] = {
+    {0,  0,  128,   0,   0, 0, 0, 0},  /* note that 1/8 pel positionyys are */
+    {0, -6,  123,  12,  -1, 0, 0, 0},  /*    just as per alpha -0.5 bicubic */
+    {2, -11, 108,  36,  -8, 1, 0, 0},  /* New 1/4 pel 6 tap filter */
+    {0, -9,   93,  50,  -6, 0, 0, 0},
+    {3, -16,  77,  77, -16, 3, 0, 0},  /* New 1/2 pel 6 tap filter */
+    {0, -6,   50,  93,  -9, 0, 0, 0},
+    {1, -8,   36, 108, -11, 2, 0, 0},  /* New 1/4 pel 6 tap filter */
+    {0, -1,   12, 123,  -6, 0, 0, 0},
+};
+
+void vp8_sixtap_predict4x4_neon(
+        unsigned char *src_ptr,
+        int src_pixels_per_line,
+        int xoffset,
+        int yoffset,
+        unsigned char *dst_ptr,
+        int dst_pitch) {
+    unsigned char *src;
+    uint8x8_t d0u8, d1u8, d2u8, d3u8, d4u8, d5u8, d18u8, d19u8, d20u8, d21u8;
+    uint8x8_t d23u8, d24u8, d25u8, d26u8, d27u8, d28u8, d29u8, d30u8, d31u8;
+    int8x8_t dtmps8, d0s8, d1s8, d2s8, d3s8, d4s8, d5s8;
+    uint32x2_t d27u32, d28u32, d29u32, d30u32, d31u32;
+    uint16x8_t q3u16, q4u16, q5u16, q6u16, q7u16;
+    uint16x8_t q8u16, q9u16, q10u16, q11u16, q12u16;
+    int16x8_t q3s16, q4s16, q5s16, q6s16, q7s16;
+    int16x8_t q8s16, q9s16, q10s16, q11s16, q12s16;
+    uint8x16_t q3u8, q4u8, q5u8, q6u8, q11u8;
+    uint64x2_t q3u64, q4u64, q5u64, q6u64, q9u64, q10u64;
+    uint32x2x2_t d0u32x2, d1u32x2;
+
+    if (xoffset == 0) {  // secondpass_filter4x4_only
+        // load second_pass filter
+        dtmps8 = vld1_s8(vp8_sub_pel_filters[yoffset]);
+        d0s8 = vdup_lane_s8(dtmps8, 0);
+        d1s8 = vdup_lane_s8(dtmps8, 1);
+        d2s8 = vdup_lane_s8(dtmps8, 2);
+        d3s8 = vdup_lane_s8(dtmps8, 3);
+        d4s8 = vdup_lane_s8(dtmps8, 4);
+        d5s8 = vdup_lane_s8(dtmps8, 5);
+        d0u8 = vreinterpret_u8_s8(vabs_s8(d0s8));
+        d1u8 = vreinterpret_u8_s8(vabs_s8(d1s8));
+        d2u8 = vreinterpret_u8_s8(vabs_s8(d2s8));
+        d3u8 = vreinterpret_u8_s8(vabs_s8(d3s8));
+        d4u8 = vreinterpret_u8_s8(vabs_s8(d4s8));
+        d5u8 = vreinterpret_u8_s8(vabs_s8(d5s8));
+
+        // load src data
+        src = src_ptr - src_pixels_per_line * 2;
+        d27u32 = vld1_lane_u32((const uint32_t *)src, d27u32, 0);
+        src += src_pixels_per_line;
+        d27u32 = vld1_lane_u32((const uint32_t *)src, d27u32, 1);
+        src += src_pixels_per_line;
+        d28u32 = vld1_lane_u32((const uint32_t *)src, d28u32, 0);
+        src += src_pixels_per_line;
+        d28u32 = vld1_lane_u32((const uint32_t *)src, d28u32, 1);
+        src += src_pixels_per_line;
+        d29u32 = vld1_lane_u32((const uint32_t *)src, d29u32, 0);
+        src += src_pixels_per_line;
+        d29u32 = vld1_lane_u32((const uint32_t *)src, d29u32, 1);
+        src += src_pixels_per_line;
+        d30u32 = vld1_lane_u32((const uint32_t *)src, d30u32, 0);
+        src += src_pixels_per_line;
+        d30u32 = vld1_lane_u32((const uint32_t *)src, d30u32, 1);
+        src += src_pixels_per_line;
+        d31u32 = vld1_lane_u32((const uint32_t *)src, d31u32, 0);
+
+        d27u8 = vreinterpret_u8_u32(d27u32);
+        d28u8 = vreinterpret_u8_u32(d28u32);
+        d29u8 = vreinterpret_u8_u32(d29u32);
+        d30u8 = vreinterpret_u8_u32(d30u32);
+        d31u8 = vreinterpret_u8_u32(d31u32);
+
+        d23u8 = vext_u8(d27u8, d28u8, 4);
+        d24u8 = vext_u8(d28u8, d29u8, 4);
+        d25u8 = vext_u8(d29u8, d30u8, 4);
+        d26u8 = vext_u8(d30u8, d31u8, 4);
+
+        q3u16 = vmull_u8(d27u8, d0u8);
+        q4u16 = vmull_u8(d28u8, d0u8);
+        q5u16 = vmull_u8(d25u8, d5u8);
+        q6u16 = vmull_u8(d26u8, d5u8);
+
+        q3u16 = vmlsl_u8(q3u16, d29u8, d4u8);
+        q4u16 = vmlsl_u8(q4u16, d30u8, d4u8);
+        q5u16 = vmlsl_u8(q5u16, d23u8, d1u8);
+        q6u16 = vmlsl_u8(q6u16, d24u8, d1u8);
+
+        q3u16 = vmlal_u8(q3u16, d28u8, d2u8);
+        q4u16 = vmlal_u8(q4u16, d29u8, d2u8);
+        q5u16 = vmlal_u8(q5u16, d24u8, d3u8);
+        q6u16 = vmlal_u8(q6u16, d25u8, d3u8);
+
+        q3s16 = vreinterpretq_s16_u16(q3u16);
+        q4s16 = vreinterpretq_s16_u16(q4u16);
+        q5s16 = vreinterpretq_s16_u16(q5u16);
+        q6s16 = vreinterpretq_s16_u16(q6u16);
+
+        q5s16 = vqaddq_s16(q5s16, q3s16);
+        q6s16 = vqaddq_s16(q6s16, q4s16);
+
+        d3u8 = vqrshrun_n_s16(q5s16, 7);
+        d4u8 = vqrshrun_n_s16(q6s16, 7);
+
+        vst1_lane_u32((uint32_t *)dst_ptr, vreinterpret_u32_u8(d3u8), 0);
+        dst_ptr += dst_pitch;
+        vst1_lane_u32((uint32_t *)dst_ptr, vreinterpret_u32_u8(d3u8), 1);
+        dst_ptr += dst_pitch;
+        vst1_lane_u32((uint32_t *)dst_ptr, vreinterpret_u32_u8(d4u8), 0);
+        dst_ptr += dst_pitch;
+        vst1_lane_u32((uint32_t *)dst_ptr, vreinterpret_u32_u8(d4u8), 1);
+        return;
+    }
+
+    // load first_pass filter
+    dtmps8 = vld1_s8(vp8_sub_pel_filters[xoffset]);
+    d0s8 = vdup_lane_s8(dtmps8, 0);
+    d1s8 = vdup_lane_s8(dtmps8, 1);
+    d2s8 = vdup_lane_s8(dtmps8, 2);
+    d3s8 = vdup_lane_s8(dtmps8, 3);
+    d4s8 = vdup_lane_s8(dtmps8, 4);
+    d5s8 = vdup_lane_s8(dtmps8, 5);
+    d0u8 = vreinterpret_u8_s8(vabs_s8(d0s8));
+    d1u8 = vreinterpret_u8_s8(vabs_s8(d1s8));
+    d2u8 = vreinterpret_u8_s8(vabs_s8(d2s8));
+    d3u8 = vreinterpret_u8_s8(vabs_s8(d3s8));
+    d4u8 = vreinterpret_u8_s8(vabs_s8(d4s8));
+    d5u8 = vreinterpret_u8_s8(vabs_s8(d5s8));
+
+    // First pass: output_height lines x output_width columns (9x4)
+
+    if (yoffset == 0)  // firstpass_filter4x4_only
+        src = src_ptr - 2;
+    else
+        src = src_ptr - 2 - (src_pixels_per_line * 2);
+
+    q3u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q4u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q5u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q6u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+
+    d18u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 5);
+    d19u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 5);
+    d20u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 5);
+    d21u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 5);
+
+    // vswp here
+    q3u8 = vcombine_u8(vget_low_u8(q3u8), vget_low_u8(q4u8));
+    q5u8 = vcombine_u8(vget_low_u8(q5u8), vget_low_u8(q6u8));
+
+    d0u32x2 = vzip_u32(vreinterpret_u32_u8(d18u8),  // d18 d19
+                       vreinterpret_u32_u8(d19u8));
+    d1u32x2 = vzip_u32(vreinterpret_u32_u8(d20u8),  // d20 d21
+                       vreinterpret_u32_u8(d21u8));
+    q7u16 = vmull_u8(vreinterpret_u8_u32(d0u32x2.val[0]), d5u8);
+    q8u16 = vmull_u8(vreinterpret_u8_u32(d1u32x2.val[0]), d5u8);
+
+    // keep original src data in q4 q6
+    q4u64 = vreinterpretq_u64_u8(q3u8);
+    q6u64 = vreinterpretq_u64_u8(q5u8);
+
+    d0u32x2 = vzip_u32(vreinterpret_u32_u8(vget_low_u8(q3u8)),  // d6 d7
+                       vreinterpret_u32_u8(vget_high_u8(q3u8)));
+    d1u32x2 = vzip_u32(vreinterpret_u32_u8(vget_low_u8(q5u8)),  // d10 d11
+                       vreinterpret_u32_u8(vget_high_u8(q5u8)));
+    q9u64 = vshrq_n_u64(q4u64, 8);
+    q10u64 = vshrq_n_u64(q6u64, 8);
+    q7u16 = vmlal_u8(q7u16, vreinterpret_u8_u32(d0u32x2.val[0]), d0u8);
+    q8u16 = vmlal_u8(q8u16, vreinterpret_u8_u32(d1u32x2.val[0]), d0u8);
+
+    d0u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q9u64)),   // d18 d19
+                       vreinterpret_u32_u64(vget_high_u64(q9u64)));
+    d1u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q10u64)),  // d20 d211
+                       vreinterpret_u32_u64(vget_high_u64(q10u64)));
+    q3u64 = vshrq_n_u64(q4u64, 32);
+    q5u64 = vshrq_n_u64(q6u64, 32);
+    q7u16 = vmlsl_u8(q7u16, vreinterpret_u8_u32(d0u32x2.val[0]), d1u8);
+    q8u16 = vmlsl_u8(q8u16, vreinterpret_u8_u32(d1u32x2.val[0]), d1u8);
+
+    d0u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q3u64)),  // d6 d7
+                       vreinterpret_u32_u64(vget_high_u64(q3u64)));
+    d1u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q5u64)),  // d10 d11
+                       vreinterpret_u32_u64(vget_high_u64(q5u64)));
+    q9u64 = vshrq_n_u64(q4u64, 16);
+    q10u64 = vshrq_n_u64(q6u64, 16);
+    q7u16 = vmlsl_u8(q7u16, vreinterpret_u8_u32(d0u32x2.val[0]), d4u8);
+    q8u16 = vmlsl_u8(q8u16, vreinterpret_u8_u32(d1u32x2.val[0]), d4u8);
+
+    d0u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q9u64)),   // d18 d19
+                       vreinterpret_u32_u64(vget_high_u64(q9u64)));
+    d1u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q10u64)),  // d20 d211
+                       vreinterpret_u32_u64(vget_high_u64(q10u64)));
+    q3u64 = vshrq_n_u64(q4u64, 24);
+    q5u64 = vshrq_n_u64(q6u64, 24);
+    q7u16 = vmlal_u8(q7u16, vreinterpret_u8_u32(d0u32x2.val[0]), d2u8);
+    q8u16 = vmlal_u8(q8u16, vreinterpret_u8_u32(d1u32x2.val[0]), d2u8);
+
+    d0u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q3u64)),  // d6 d7
+                       vreinterpret_u32_u64(vget_high_u64(q3u64)));
+    d1u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q5u64)),  // d10 d11
+                       vreinterpret_u32_u64(vget_high_u64(q5u64)));
+    q9u16 = vmull_u8(vreinterpret_u8_u32(d0u32x2.val[0]), d3u8);
+    q10u16 = vmull_u8(vreinterpret_u8_u32(d1u32x2.val[0]), d3u8);
+
+    q7s16 = vreinterpretq_s16_u16(q7u16);
+    q8s16 = vreinterpretq_s16_u16(q8u16);
+    q9s16 = vreinterpretq_s16_u16(q9u16);
+    q10s16 = vreinterpretq_s16_u16(q10u16);
+    q7s16 = vqaddq_s16(q7s16, q9s16);
+    q8s16 = vqaddq_s16(q8s16, q10s16);
+
+    d27u8 = vqrshrun_n_s16(q7s16, 7);
+    d28u8 = vqrshrun_n_s16(q8s16, 7);
+
+    if (yoffset == 0) {  // firstpass_filter4x4_only
+        vst1_lane_u32((uint32_t *)dst_ptr, vreinterpret_u32_u8(d27u8), 0);
+        dst_ptr += dst_pitch;
+        vst1_lane_u32((uint32_t *)dst_ptr, vreinterpret_u32_u8(d27u8), 1);
+        dst_ptr += dst_pitch;
+        vst1_lane_u32((uint32_t *)dst_ptr, vreinterpret_u32_u8(d28u8), 0);
+        dst_ptr += dst_pitch;
+        vst1_lane_u32((uint32_t *)dst_ptr, vreinterpret_u32_u8(d28u8), 1);
+        return;
+    }
+
+    // First Pass on rest 5-line data
+    q3u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q4u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q5u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q6u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q11u8 = vld1q_u8(src);
+
+    d18u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 5);
+    d19u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 5);
+    d20u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 5);
+    d21u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 5);
+
+    // vswp here
+    q3u8 = vcombine_u8(vget_low_u8(q3u8), vget_low_u8(q4u8));
+    q5u8 = vcombine_u8(vget_low_u8(q5u8), vget_low_u8(q6u8));
+
+    d0u32x2 = vzip_u32(vreinterpret_u32_u8(d18u8),  // d18 d19
+                       vreinterpret_u32_u8(d19u8));
+    d1u32x2 = vzip_u32(vreinterpret_u32_u8(d20u8),  // d20 d21
+                       vreinterpret_u32_u8(d21u8));
+    d31u8 = vext_u8(vget_low_u8(q11u8), vget_high_u8(q11u8), 5);
+    q7u16 = vmull_u8(vreinterpret_u8_u32(d0u32x2.val[0]), d5u8);
+    q8u16 = vmull_u8(vreinterpret_u8_u32(d1u32x2.val[0]), d5u8);
+    q12u16 = vmull_u8(d31u8, d5u8);
+
+    q4u64 = vreinterpretq_u64_u8(q3u8);
+    q6u64 = vreinterpretq_u64_u8(q5u8);
+
+    d0u32x2 = vzip_u32(vreinterpret_u32_u8(vget_low_u8(q3u8)),  // d6 d7
+                       vreinterpret_u32_u8(vget_high_u8(q3u8)));
+    d1u32x2 = vzip_u32(vreinterpret_u32_u8(vget_low_u8(q5u8)),  // d10 d11
+                       vreinterpret_u32_u8(vget_high_u8(q5u8)));
+    q9u64 = vshrq_n_u64(q4u64, 8);
+    q10u64 = vshrq_n_u64(q6u64, 8);
+    q7u16 = vmlal_u8(q7u16, vreinterpret_u8_u32(d0u32x2.val[0]), d0u8);
+    q8u16 = vmlal_u8(q8u16, vreinterpret_u8_u32(d1u32x2.val[0]), d0u8);
+    q12u16 = vmlal_u8(q12u16, vget_low_u8(q11u8), d0u8);
+
+    d0u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q9u64)),   // d18 d19
+                       vreinterpret_u32_u64(vget_high_u64(q9u64)));
+    d1u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q10u64)),  // d20 d211
+                       vreinterpret_u32_u64(vget_high_u64(q10u64)));
+    q3u64 = vshrq_n_u64(q4u64, 32);
+    q5u64 = vshrq_n_u64(q6u64, 32);
+    d31u8 = vext_u8(vget_low_u8(q11u8), vget_high_u8(q11u8), 1);
+    q7u16 = vmlsl_u8(q7u16, vreinterpret_u8_u32(d0u32x2.val[0]), d1u8);
+    q8u16 = vmlsl_u8(q8u16, vreinterpret_u8_u32(d1u32x2.val[0]), d1u8);
+    q12u16 = vmlsl_u8(q12u16, d31u8, d1u8);
+
+    d0u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q3u64)),  // d6 d7
+                       vreinterpret_u32_u64(vget_high_u64(q3u64)));
+    d1u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q5u64)),  // d10 d11
+                       vreinterpret_u32_u64(vget_high_u64(q5u64)));
+    q9u64 = vshrq_n_u64(q4u64, 16);
+    q10u64 = vshrq_n_u64(q6u64, 16);
+    d31u8 = vext_u8(vget_low_u8(q11u8), vget_high_u8(q11u8), 4);
+    q7u16 = vmlsl_u8(q7u16, vreinterpret_u8_u32(d0u32x2.val[0]), d4u8);
+    q8u16 = vmlsl_u8(q8u16, vreinterpret_u8_u32(d1u32x2.val[0]), d4u8);
+    q12u16 = vmlsl_u8(q12u16, d31u8, d4u8);
+
+    d0u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q9u64)),   // d18 d19
+                       vreinterpret_u32_u64(vget_high_u64(q9u64)));
+    d1u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q10u64)),  // d20 d211
+                       vreinterpret_u32_u64(vget_high_u64(q10u64)));
+    q3u64 = vshrq_n_u64(q4u64, 24);
+    q5u64 = vshrq_n_u64(q6u64, 24);
+    d31u8 = vext_u8(vget_low_u8(q11u8), vget_high_u8(q11u8), 2);
+    q7u16 = vmlal_u8(q7u16, vreinterpret_u8_u32(d0u32x2.val[0]), d2u8);
+    q8u16 = vmlal_u8(q8u16, vreinterpret_u8_u32(d1u32x2.val[0]), d2u8);
+    q12u16 = vmlal_u8(q12u16, d31u8, d2u8);
+
+    d0u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q3u64)),  // d6 d7
+                       vreinterpret_u32_u64(vget_high_u64(q3u64)));
+    d1u32x2 = vzip_u32(vreinterpret_u32_u64(vget_low_u64(q5u64)),  // d10 d11
+                       vreinterpret_u32_u64(vget_high_u64(q5u64)));
+    d31u8 = vext_u8(vget_low_u8(q11u8), vget_high_u8(q11u8), 3);
+    q9u16 = vmull_u8(vreinterpret_u8_u32(d0u32x2.val[0]), d3u8);
+    q10u16 = vmull_u8(vreinterpret_u8_u32(d1u32x2.val[0]), d3u8);
+    q11u16 = vmull_u8(d31u8, d3u8);
+
+    q7s16 = vreinterpretq_s16_u16(q7u16);
+    q8s16 = vreinterpretq_s16_u16(q8u16);
+    q9s16 = vreinterpretq_s16_u16(q9u16);
+    q10s16 = vreinterpretq_s16_u16(q10u16);
+    q11s16 = vreinterpretq_s16_u16(q11u16);
+    q12s16 = vreinterpretq_s16_u16(q12u16);
+    q7s16 = vqaddq_s16(q7s16, q9s16);
+    q8s16 = vqaddq_s16(q8s16, q10s16);
+    q12s16 = vqaddq_s16(q12s16, q11s16);
+
+    d29u8 = vqrshrun_n_s16(q7s16, 7);
+    d30u8 = vqrshrun_n_s16(q8s16, 7);
+    d31u8 = vqrshrun_n_s16(q12s16, 7);
+
+    // Second pass: 4x4
+    dtmps8 = vld1_s8(vp8_sub_pel_filters[yoffset]);
+    d0s8 = vdup_lane_s8(dtmps8, 0);
+    d1s8 = vdup_lane_s8(dtmps8, 1);
+    d2s8 = vdup_lane_s8(dtmps8, 2);
+    d3s8 = vdup_lane_s8(dtmps8, 3);
+    d4s8 = vdup_lane_s8(dtmps8, 4);
+    d5s8 = vdup_lane_s8(dtmps8, 5);
+    d0u8 = vreinterpret_u8_s8(vabs_s8(d0s8));
+    d1u8 = vreinterpret_u8_s8(vabs_s8(d1s8));
+    d2u8 = vreinterpret_u8_s8(vabs_s8(d2s8));
+    d3u8 = vreinterpret_u8_s8(vabs_s8(d3s8));
+    d4u8 = vreinterpret_u8_s8(vabs_s8(d4s8));
+    d5u8 = vreinterpret_u8_s8(vabs_s8(d5s8));
+
+    d23u8 = vext_u8(d27u8, d28u8, 4);
+    d24u8 = vext_u8(d28u8, d29u8, 4);
+    d25u8 = vext_u8(d29u8, d30u8, 4);
+    d26u8 = vext_u8(d30u8, d31u8, 4);
+
+    q3u16 = vmull_u8(d27u8, d0u8);
+    q4u16 = vmull_u8(d28u8, d0u8);
+    q5u16 = vmull_u8(d25u8, d5u8);
+    q6u16 = vmull_u8(d26u8, d5u8);
+
+    q3u16 = vmlsl_u8(q3u16, d29u8, d4u8);
+    q4u16 = vmlsl_u8(q4u16, d30u8, d4u8);
+    q5u16 = vmlsl_u8(q5u16, d23u8, d1u8);
+    q6u16 = vmlsl_u8(q6u16, d24u8, d1u8);
+
+    q3u16 = vmlal_u8(q3u16, d28u8, d2u8);
+    q4u16 = vmlal_u8(q4u16, d29u8, d2u8);
+    q5u16 = vmlal_u8(q5u16, d24u8, d3u8);
+    q6u16 = vmlal_u8(q6u16, d25u8, d3u8);
+
+    q3s16 = vreinterpretq_s16_u16(q3u16);
+    q4s16 = vreinterpretq_s16_u16(q4u16);
+    q5s16 = vreinterpretq_s16_u16(q5u16);
+    q6s16 = vreinterpretq_s16_u16(q6u16);
+
+    q5s16 = vqaddq_s16(q5s16, q3s16);
+    q6s16 = vqaddq_s16(q6s16, q4s16);
+
+    d3u8 = vqrshrun_n_s16(q5s16, 7);
+    d4u8 = vqrshrun_n_s16(q6s16, 7);
+
+    vst1_lane_u32((uint32_t *)dst_ptr, vreinterpret_u32_u8(d3u8), 0);
+    dst_ptr += dst_pitch;
+    vst1_lane_u32((uint32_t *)dst_ptr, vreinterpret_u32_u8(d3u8), 1);
+    dst_ptr += dst_pitch;
+    vst1_lane_u32((uint32_t *)dst_ptr, vreinterpret_u32_u8(d4u8), 0);
+    dst_ptr += dst_pitch;
+    vst1_lane_u32((uint32_t *)dst_ptr, vreinterpret_u32_u8(d4u8), 1);
+    return;
+}
+
+void vp8_sixtap_predict8x4_neon(
+        unsigned char *src_ptr,
+        int src_pixels_per_line,
+        int xoffset,
+        int yoffset,
+        unsigned char *dst_ptr,
+        int dst_pitch) {
+    unsigned char *src;
+    uint8x8_t d0u8, d1u8, d2u8, d3u8, d4u8, d5u8, d6u8, d7u8, d8u8, d9u8;
+    uint8x8_t d22u8, d23u8, d24u8, d25u8, d26u8;
+    uint8x8_t d27u8, d28u8, d29u8, d30u8, d31u8;
+    int8x8_t dtmps8, d0s8, d1s8, d2s8, d3s8, d4s8, d5s8;
+    uint16x8_t q3u16, q4u16, q5u16, q6u16, q7u16;
+    uint16x8_t q8u16, q9u16, q10u16, q11u16, q12u16;
+    int16x8_t q3s16, q4s16, q5s16, q6s16, q7s16;
+    int16x8_t q8s16, q9s16, q10s16, q11s16, q12s16;
+    uint8x16_t q3u8, q4u8, q5u8, q6u8, q7u8;
+
+    if (xoffset == 0) {  // secondpass_filter8x4_only
+        // load second_pass filter
+        dtmps8 = vld1_s8(vp8_sub_pel_filters[yoffset]);
+        d0s8 = vdup_lane_s8(dtmps8, 0);
+        d1s8 = vdup_lane_s8(dtmps8, 1);
+        d2s8 = vdup_lane_s8(dtmps8, 2);
+        d3s8 = vdup_lane_s8(dtmps8, 3);
+        d4s8 = vdup_lane_s8(dtmps8, 4);
+        d5s8 = vdup_lane_s8(dtmps8, 5);
+        d0u8 = vreinterpret_u8_s8(vabs_s8(d0s8));
+        d1u8 = vreinterpret_u8_s8(vabs_s8(d1s8));
+        d2u8 = vreinterpret_u8_s8(vabs_s8(d2s8));
+        d3u8 = vreinterpret_u8_s8(vabs_s8(d3s8));
+        d4u8 = vreinterpret_u8_s8(vabs_s8(d4s8));
+        d5u8 = vreinterpret_u8_s8(vabs_s8(d5s8));
+
+        // load src data
+        src = src_ptr - src_pixels_per_line * 2;
+        d22u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d23u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d24u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d25u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d26u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d27u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d28u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d29u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d30u8 = vld1_u8(src);
+
+        q3u16 = vmull_u8(d22u8, d0u8);
+        q4u16 = vmull_u8(d23u8, d0u8);
+        q5u16 = vmull_u8(d24u8, d0u8);
+        q6u16 = vmull_u8(d25u8, d0u8);
+
+        q3u16 = vmlsl_u8(q3u16, d23u8, d1u8);
+        q4u16 = vmlsl_u8(q4u16, d24u8, d1u8);
+        q5u16 = vmlsl_u8(q5u16, d25u8, d1u8);
+        q6u16 = vmlsl_u8(q6u16, d26u8, d1u8);
+
+        q3u16 = vmlsl_u8(q3u16, d26u8, d4u8);
+        q4u16 = vmlsl_u8(q4u16, d27u8, d4u8);
+        q5u16 = vmlsl_u8(q5u16, d28u8, d4u8);
+        q6u16 = vmlsl_u8(q6u16, d29u8, d4u8);
+
+        q3u16 = vmlal_u8(q3u16, d24u8, d2u8);
+        q4u16 = vmlal_u8(q4u16, d25u8, d2u8);
+        q5u16 = vmlal_u8(q5u16, d26u8, d2u8);
+        q6u16 = vmlal_u8(q6u16, d27u8, d2u8);
+
+        q3u16 = vmlal_u8(q3u16, d27u8, d5u8);
+        q4u16 = vmlal_u8(q4u16, d28u8, d5u8);
+        q5u16 = vmlal_u8(q5u16, d29u8, d5u8);
+        q6u16 = vmlal_u8(q6u16, d30u8, d5u8);
+
+        q7u16 = vmull_u8(d25u8, d3u8);
+        q8u16 = vmull_u8(d26u8, d3u8);
+        q9u16 = vmull_u8(d27u8, d3u8);
+        q10u16 = vmull_u8(d28u8, d3u8);
+
+        q3s16 = vreinterpretq_s16_u16(q3u16);
+        q4s16 = vreinterpretq_s16_u16(q4u16);
+        q5s16 = vreinterpretq_s16_u16(q5u16);
+        q6s16 = vreinterpretq_s16_u16(q6u16);
+        q7s16 = vreinterpretq_s16_u16(q7u16);
+        q8s16 = vreinterpretq_s16_u16(q8u16);
+        q9s16 = vreinterpretq_s16_u16(q9u16);
+        q10s16 = vreinterpretq_s16_u16(q10u16);
+
+        q7s16 = vqaddq_s16(q7s16, q3s16);
+        q8s16 = vqaddq_s16(q8s16, q4s16);
+        q9s16 = vqaddq_s16(q9s16, q5s16);
+        q10s16 = vqaddq_s16(q10s16, q6s16);
+
+        d6u8 = vqrshrun_n_s16(q7s16, 7);
+        d7u8 = vqrshrun_n_s16(q8s16, 7);
+        d8u8 = vqrshrun_n_s16(q9s16, 7);
+        d9u8 = vqrshrun_n_s16(q10s16, 7);
+
+        vst1_u8(dst_ptr, d6u8);
+        dst_ptr += dst_pitch;
+        vst1_u8(dst_ptr, d7u8);
+        dst_ptr += dst_pitch;
+        vst1_u8(dst_ptr, d8u8);
+        dst_ptr += dst_pitch;
+        vst1_u8(dst_ptr, d9u8);
+        return;
+    }
+
+    // load first_pass filter
+    dtmps8 = vld1_s8(vp8_sub_pel_filters[xoffset]);
+    d0s8 = vdup_lane_s8(dtmps8, 0);
+    d1s8 = vdup_lane_s8(dtmps8, 1);
+    d2s8 = vdup_lane_s8(dtmps8, 2);
+    d3s8 = vdup_lane_s8(dtmps8, 3);
+    d4s8 = vdup_lane_s8(dtmps8, 4);
+    d5s8 = vdup_lane_s8(dtmps8, 5);
+    d0u8 = vreinterpret_u8_s8(vabs_s8(d0s8));
+    d1u8 = vreinterpret_u8_s8(vabs_s8(d1s8));
+    d2u8 = vreinterpret_u8_s8(vabs_s8(d2s8));
+    d3u8 = vreinterpret_u8_s8(vabs_s8(d3s8));
+    d4u8 = vreinterpret_u8_s8(vabs_s8(d4s8));
+    d5u8 = vreinterpret_u8_s8(vabs_s8(d5s8));
+
+    // First pass: output_height lines x output_width columns (9x4)
+    if (yoffset == 0)  // firstpass_filter4x4_only
+        src = src_ptr - 2;
+    else
+        src = src_ptr - 2 - (src_pixels_per_line * 2);
+    q3u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q4u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q5u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q6u8 = vld1q_u8(src);
+
+    q7u16  = vmull_u8(vget_low_u8(q3u8), d0u8);
+    q8u16  = vmull_u8(vget_low_u8(q4u8), d0u8);
+    q9u16  = vmull_u8(vget_low_u8(q5u8), d0u8);
+    q10u16 = vmull_u8(vget_low_u8(q6u8), d0u8);
+
+    d28u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 1);
+    d29u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 1);
+    d30u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 1);
+    d31u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 1);
+
+    q7u16  = vmlsl_u8(q7u16, d28u8, d1u8);
+    q8u16  = vmlsl_u8(q8u16, d29u8, d1u8);
+    q9u16  = vmlsl_u8(q9u16, d30u8, d1u8);
+    q10u16 = vmlsl_u8(q10u16, d31u8, d1u8);
+
+    d28u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 4);
+    d29u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 4);
+    d30u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 4);
+    d31u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 4);
+
+    q7u16  = vmlsl_u8(q7u16, d28u8, d4u8);
+    q8u16  = vmlsl_u8(q8u16, d29u8, d4u8);
+    q9u16  = vmlsl_u8(q9u16, d30u8, d4u8);
+    q10u16 = vmlsl_u8(q10u16, d31u8, d4u8);
+
+    d28u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 2);
+    d29u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 2);
+    d30u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 2);
+    d31u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 2);
+
+    q7u16  = vmlal_u8(q7u16, d28u8, d2u8);
+    q8u16  = vmlal_u8(q8u16, d29u8, d2u8);
+    q9u16  = vmlal_u8(q9u16, d30u8, d2u8);
+    q10u16 = vmlal_u8(q10u16, d31u8, d2u8);
+
+    d28u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 5);
+    d29u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 5);
+    d30u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 5);
+    d31u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 5);
+
+    q7u16 = vmlal_u8(q7u16, d28u8, d5u8);
+    q8u16 = vmlal_u8(q8u16, d29u8, d5u8);
+    q9u16 = vmlal_u8(q9u16, d30u8, d5u8);
+    q10u16 = vmlal_u8(q10u16, d31u8, d5u8);
+
+    d28u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 3);
+    d29u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 3);
+    d30u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 3);
+    d31u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 3);
+
+    q3u16 = vmull_u8(d28u8, d3u8);
+    q4u16 = vmull_u8(d29u8, d3u8);
+    q5u16 = vmull_u8(d30u8, d3u8);
+    q6u16 = vmull_u8(d31u8, d3u8);
+
+    q3s16 = vreinterpretq_s16_u16(q3u16);
+    q4s16 = vreinterpretq_s16_u16(q4u16);
+    q5s16 = vreinterpretq_s16_u16(q5u16);
+    q6s16 = vreinterpretq_s16_u16(q6u16);
+    q7s16 = vreinterpretq_s16_u16(q7u16);
+    q8s16 = vreinterpretq_s16_u16(q8u16);
+    q9s16 = vreinterpretq_s16_u16(q9u16);
+    q10s16 = vreinterpretq_s16_u16(q10u16);
+
+    q7s16 = vqaddq_s16(q7s16, q3s16);
+    q8s16 = vqaddq_s16(q8s16, q4s16);
+    q9s16 = vqaddq_s16(q9s16, q5s16);
+    q10s16 = vqaddq_s16(q10s16, q6s16);
+
+    d22u8 = vqrshrun_n_s16(q7s16, 7);
+    d23u8 = vqrshrun_n_s16(q8s16, 7);
+    d24u8 = vqrshrun_n_s16(q9s16, 7);
+    d25u8 = vqrshrun_n_s16(q10s16, 7);
+
+    if (yoffset == 0) {  // firstpass_filter8x4_only
+        vst1_u8(dst_ptr, d22u8);
+        dst_ptr += dst_pitch;
+        vst1_u8(dst_ptr, d23u8);
+        dst_ptr += dst_pitch;
+        vst1_u8(dst_ptr, d24u8);
+        dst_ptr += dst_pitch;
+        vst1_u8(dst_ptr, d25u8);
+        return;
+    }
+
+    // First Pass on rest 5-line data
+    src += src_pixels_per_line;
+    q3u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q4u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q5u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q6u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q7u8 = vld1q_u8(src);
+
+    q8u16 = vmull_u8(vget_low_u8(q3u8), d0u8);
+    q9u16 = vmull_u8(vget_low_u8(q4u8), d0u8);
+    q10u16 = vmull_u8(vget_low_u8(q5u8), d0u8);
+    q11u16 = vmull_u8(vget_low_u8(q6u8), d0u8);
+    q12u16 = vmull_u8(vget_low_u8(q7u8), d0u8);
+
+    d27u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 1);
+    d28u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 1);
+    d29u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 1);
+    d30u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 1);
+    d31u8 = vext_u8(vget_low_u8(q7u8), vget_high_u8(q7u8), 1);
+
+    q8u16  = vmlsl_u8(q8u16, d27u8, d1u8);
+    q9u16  = vmlsl_u8(q9u16, d28u8, d1u8);
+    q10u16 = vmlsl_u8(q10u16, d29u8, d1u8);
+    q11u16 = vmlsl_u8(q11u16, d30u8, d1u8);
+    q12u16 = vmlsl_u8(q12u16, d31u8, d1u8);
+
+    d27u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 4);
+    d28u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 4);
+    d29u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 4);
+    d30u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 4);
+    d31u8 = vext_u8(vget_low_u8(q7u8), vget_high_u8(q7u8), 4);
+
+    q8u16  = vmlsl_u8(q8u16, d27u8, d4u8);
+    q9u16  = vmlsl_u8(q9u16, d28u8, d4u8);
+    q10u16 = vmlsl_u8(q10u16, d29u8, d4u8);
+    q11u16 = vmlsl_u8(q11u16, d30u8, d4u8);
+    q12u16 = vmlsl_u8(q12u16, d31u8, d4u8);
+
+    d27u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 2);
+    d28u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 2);
+    d29u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 2);
+    d30u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 2);
+    d31u8 = vext_u8(vget_low_u8(q7u8), vget_high_u8(q7u8), 2);
+
+    q8u16  = vmlal_u8(q8u16, d27u8, d2u8);
+    q9u16  = vmlal_u8(q9u16, d28u8, d2u8);
+    q10u16 = vmlal_u8(q10u16, d29u8, d2u8);
+    q11u16 = vmlal_u8(q11u16, d30u8, d2u8);
+    q12u16 = vmlal_u8(q12u16, d31u8, d2u8);
+
+    d27u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 5);
+    d28u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 5);
+    d29u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 5);
+    d30u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 5);
+    d31u8 = vext_u8(vget_low_u8(q7u8), vget_high_u8(q7u8), 5);
+
+    q8u16  = vmlal_u8(q8u16, d27u8, d5u8);
+    q9u16  = vmlal_u8(q9u16, d28u8, d5u8);
+    q10u16 = vmlal_u8(q10u16, d29u8, d5u8);
+    q11u16 = vmlal_u8(q11u16, d30u8, d5u8);
+    q12u16 = vmlal_u8(q12u16, d31u8, d5u8);
+
+    d27u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 3);
+    d28u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 3);
+    d29u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 3);
+    d30u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 3);
+    d31u8 = vext_u8(vget_low_u8(q7u8), vget_high_u8(q7u8), 3);
+
+    q3u16 = vmull_u8(d27u8, d3u8);
+    q4u16 = vmull_u8(d28u8, d3u8);
+    q5u16 = vmull_u8(d29u8, d3u8);
+    q6u16 = vmull_u8(d30u8, d3u8);
+    q7u16 = vmull_u8(d31u8, d3u8);
+
+    q3s16 = vreinterpretq_s16_u16(q3u16);
+    q4s16 = vreinterpretq_s16_u16(q4u16);
+    q5s16 = vreinterpretq_s16_u16(q5u16);
+    q6s16 = vreinterpretq_s16_u16(q6u16);
+    q7s16 = vreinterpretq_s16_u16(q7u16);
+    q8s16 = vreinterpretq_s16_u16(q8u16);
+    q9s16 = vreinterpretq_s16_u16(q9u16);
+    q10s16 = vreinterpretq_s16_u16(q10u16);
+    q11s16 = vreinterpretq_s16_u16(q11u16);
+    q12s16 = vreinterpretq_s16_u16(q12u16);
+
+    q8s16 = vqaddq_s16(q8s16, q3s16);
+    q9s16 = vqaddq_s16(q9s16, q4s16);
+    q10s16 = vqaddq_s16(q10s16, q5s16);
+    q11s16 = vqaddq_s16(q11s16, q6s16);
+    q12s16 = vqaddq_s16(q12s16, q7s16);
+
+    d26u8 = vqrshrun_n_s16(q8s16, 7);
+    d27u8 = vqrshrun_n_s16(q9s16, 7);
+    d28u8 = vqrshrun_n_s16(q10s16, 7);
+    d29u8 = vqrshrun_n_s16(q11s16, 7);
+    d30u8 = vqrshrun_n_s16(q12s16, 7);
+
+    // Second pass: 8x4
+    dtmps8 = vld1_s8(vp8_sub_pel_filters[yoffset]);
+    d0s8 = vdup_lane_s8(dtmps8, 0);
+    d1s8 = vdup_lane_s8(dtmps8, 1);
+    d2s8 = vdup_lane_s8(dtmps8, 2);
+    d3s8 = vdup_lane_s8(dtmps8, 3);
+    d4s8 = vdup_lane_s8(dtmps8, 4);
+    d5s8 = vdup_lane_s8(dtmps8, 5);
+    d0u8 = vreinterpret_u8_s8(vabs_s8(d0s8));
+    d1u8 = vreinterpret_u8_s8(vabs_s8(d1s8));
+    d2u8 = vreinterpret_u8_s8(vabs_s8(d2s8));
+    d3u8 = vreinterpret_u8_s8(vabs_s8(d3s8));
+    d4u8 = vreinterpret_u8_s8(vabs_s8(d4s8));
+    d5u8 = vreinterpret_u8_s8(vabs_s8(d5s8));
+
+    q3u16 = vmull_u8(d22u8, d0u8);
+    q4u16 = vmull_u8(d23u8, d0u8);
+    q5u16 = vmull_u8(d24u8, d0u8);
+    q6u16 = vmull_u8(d25u8, d0u8);
+
+    q3u16 = vmlsl_u8(q3u16, d23u8, d1u8);
+    q4u16 = vmlsl_u8(q4u16, d24u8, d1u8);
+    q5u16 = vmlsl_u8(q5u16, d25u8, d1u8);
+    q6u16 = vmlsl_u8(q6u16, d26u8, d1u8);
+
+    q3u16 = vmlsl_u8(q3u16, d26u8, d4u8);
+    q4u16 = vmlsl_u8(q4u16, d27u8, d4u8);
+    q5u16 = vmlsl_u8(q5u16, d28u8, d4u8);
+    q6u16 = vmlsl_u8(q6u16, d29u8, d4u8);
+
+    q3u16 = vmlal_u8(q3u16, d24u8, d2u8);
+    q4u16 = vmlal_u8(q4u16, d25u8, d2u8);
+    q5u16 = vmlal_u8(q5u16, d26u8, d2u8);
+    q6u16 = vmlal_u8(q6u16, d27u8, d2u8);
+
+    q3u16 = vmlal_u8(q3u16, d27u8, d5u8);
+    q4u16 = vmlal_u8(q4u16, d28u8, d5u8);
+    q5u16 = vmlal_u8(q5u16, d29u8, d5u8);
+    q6u16 = vmlal_u8(q6u16, d30u8, d5u8);
+
+    q7u16 = vmull_u8(d25u8, d3u8);
+    q8u16 = vmull_u8(d26u8, d3u8);
+    q9u16 = vmull_u8(d27u8, d3u8);
+    q10u16 = vmull_u8(d28u8, d3u8);
+
+    q3s16 = vreinterpretq_s16_u16(q3u16);
+    q4s16 = vreinterpretq_s16_u16(q4u16);
+    q5s16 = vreinterpretq_s16_u16(q5u16);
+    q6s16 = vreinterpretq_s16_u16(q6u16);
+    q7s16 = vreinterpretq_s16_u16(q7u16);
+    q8s16 = vreinterpretq_s16_u16(q8u16);
+    q9s16 = vreinterpretq_s16_u16(q9u16);
+    q10s16 = vreinterpretq_s16_u16(q10u16);
+
+    q7s16 = vqaddq_s16(q7s16, q3s16);
+    q8s16 = vqaddq_s16(q8s16, q4s16);
+    q9s16 = vqaddq_s16(q9s16, q5s16);
+    q10s16 = vqaddq_s16(q10s16, q6s16);
+
+    d6u8 = vqrshrun_n_s16(q7s16, 7);
+    d7u8 = vqrshrun_n_s16(q8s16, 7);
+    d8u8 = vqrshrun_n_s16(q9s16, 7);
+    d9u8 = vqrshrun_n_s16(q10s16, 7);
+
+    vst1_u8(dst_ptr, d6u8);
+    dst_ptr += dst_pitch;
+    vst1_u8(dst_ptr, d7u8);
+    dst_ptr += dst_pitch;
+    vst1_u8(dst_ptr, d8u8);
+    dst_ptr += dst_pitch;
+    vst1_u8(dst_ptr, d9u8);
+    return;
+}
+
+void vp8_sixtap_predict8x8_neon(
+        unsigned char *src_ptr,
+        int src_pixels_per_line,
+        int xoffset,
+        int yoffset,
+        unsigned char *dst_ptr,
+        int dst_pitch) {
+    unsigned char *src, *tmpp;
+    unsigned char tmp[64];
+    int i;
+    uint8x8_t d0u8, d1u8, d2u8, d3u8, d4u8, d5u8, d6u8, d7u8, d8u8, d9u8;
+    uint8x8_t d18u8, d19u8, d20u8, d21u8, d22u8, d23u8, d24u8, d25u8;
+    uint8x8_t d26u8, d27u8, d28u8, d29u8, d30u8, d31u8;
+    int8x8_t dtmps8, d0s8, d1s8, d2s8, d3s8, d4s8, d5s8;
+    uint16x8_t q3u16, q4u16, q5u16, q6u16, q7u16;
+    uint16x8_t q8u16, q9u16, q10u16, q11u16, q12u16;
+    int16x8_t q3s16, q4s16, q5s16, q6s16, q7s16;
+    int16x8_t q8s16, q9s16, q10s16, q11s16, q12s16;
+    uint8x16_t q3u8, q4u8, q5u8, q6u8, q7u8, q9u8, q10u8, q11u8, q12u8;
+
+    if (xoffset == 0) {  // secondpass_filter8x8_only
+        // load second_pass filter
+        dtmps8 = vld1_s8(vp8_sub_pel_filters[yoffset]);
+        d0s8 = vdup_lane_s8(dtmps8, 0);
+        d1s8 = vdup_lane_s8(dtmps8, 1);
+        d2s8 = vdup_lane_s8(dtmps8, 2);
+        d3s8 = vdup_lane_s8(dtmps8, 3);
+        d4s8 = vdup_lane_s8(dtmps8, 4);
+        d5s8 = vdup_lane_s8(dtmps8, 5);
+        d0u8 = vreinterpret_u8_s8(vabs_s8(d0s8));
+        d1u8 = vreinterpret_u8_s8(vabs_s8(d1s8));
+        d2u8 = vreinterpret_u8_s8(vabs_s8(d2s8));
+        d3u8 = vreinterpret_u8_s8(vabs_s8(d3s8));
+        d4u8 = vreinterpret_u8_s8(vabs_s8(d4s8));
+        d5u8 = vreinterpret_u8_s8(vabs_s8(d5s8));
+
+        // load src data
+        src = src_ptr - src_pixels_per_line * 2;
+        d18u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d19u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d20u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d21u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d22u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d23u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d24u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d25u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d26u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d27u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d28u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d29u8 = vld1_u8(src);
+        src += src_pixels_per_line;
+        d30u8 = vld1_u8(src);
+
+        for (i = 2; i > 0; i--) {
+            q3u16 = vmull_u8(d18u8, d0u8);
+            q4u16 = vmull_u8(d19u8, d0u8);
+            q5u16 = vmull_u8(d20u8, d0u8);
+            q6u16 = vmull_u8(d21u8, d0u8);
+
+            q3u16 = vmlsl_u8(q3u16, d19u8, d1u8);
+            q4u16 = vmlsl_u8(q4u16, d20u8, d1u8);
+            q5u16 = vmlsl_u8(q5u16, d21u8, d1u8);
+            q6u16 = vmlsl_u8(q6u16, d22u8, d1u8);
+
+            q3u16 = vmlsl_u8(q3u16, d22u8, d4u8);
+            q4u16 = vmlsl_u8(q4u16, d23u8, d4u8);
+            q5u16 = vmlsl_u8(q5u16, d24u8, d4u8);
+            q6u16 = vmlsl_u8(q6u16, d25u8, d4u8);
+
+            q3u16 = vmlal_u8(q3u16, d20u8, d2u8);
+            q4u16 = vmlal_u8(q4u16, d21u8, d2u8);
+            q5u16 = vmlal_u8(q5u16, d22u8, d2u8);
+            q6u16 = vmlal_u8(q6u16, d23u8, d2u8);
+
+            q3u16 = vmlal_u8(q3u16, d23u8, d5u8);
+            q4u16 = vmlal_u8(q4u16, d24u8, d5u8);
+            q5u16 = vmlal_u8(q5u16, d25u8, d5u8);
+            q6u16 = vmlal_u8(q6u16, d26u8, d5u8);
+
+            q7u16 = vmull_u8(d21u8, d3u8);
+            q8u16 = vmull_u8(d22u8, d3u8);
+            q9u16 = vmull_u8(d23u8, d3u8);
+            q10u16 = vmull_u8(d24u8, d3u8);
+
+            q3s16 = vreinterpretq_s16_u16(q3u16);
+            q4s16 = vreinterpretq_s16_u16(q4u16);
+            q5s16 = vreinterpretq_s16_u16(q5u16);
+            q6s16 = vreinterpretq_s16_u16(q6u16);
+            q7s16 = vreinterpretq_s16_u16(q7u16);
+            q8s16 = vreinterpretq_s16_u16(q8u16);
+            q9s16 = vreinterpretq_s16_u16(q9u16);
+            q10s16 = vreinterpretq_s16_u16(q10u16);
+
+            q7s16 = vqaddq_s16(q7s16, q3s16);
+            q8s16 = vqaddq_s16(q8s16, q4s16);
+            q9s16 = vqaddq_s16(q9s16, q5s16);
+            q10s16 = vqaddq_s16(q10s16, q6s16);
+
+            d6u8 = vqrshrun_n_s16(q7s16, 7);
+            d7u8 = vqrshrun_n_s16(q8s16, 7);
+            d8u8 = vqrshrun_n_s16(q9s16, 7);
+            d9u8 = vqrshrun_n_s16(q10s16, 7);
+
+            d18u8 = d22u8;
+            d19u8 = d23u8;
+            d20u8 = d24u8;
+            d21u8 = d25u8;
+            d22u8 = d26u8;
+            d23u8 = d27u8;
+            d24u8 = d28u8;
+            d25u8 = d29u8;
+            d26u8 = d30u8;
+
+            vst1_u8(dst_ptr, d6u8);
+            dst_ptr += dst_pitch;
+            vst1_u8(dst_ptr, d7u8);
+            dst_ptr += dst_pitch;
+            vst1_u8(dst_ptr, d8u8);
+            dst_ptr += dst_pitch;
+            vst1_u8(dst_ptr, d9u8);
+            dst_ptr += dst_pitch;
+        }
+        return;
+    }
+
+    // load first_pass filter
+    dtmps8 = vld1_s8(vp8_sub_pel_filters[xoffset]);
+    d0s8 = vdup_lane_s8(dtmps8, 0);
+    d1s8 = vdup_lane_s8(dtmps8, 1);
+    d2s8 = vdup_lane_s8(dtmps8, 2);
+    d3s8 = vdup_lane_s8(dtmps8, 3);
+    d4s8 = vdup_lane_s8(dtmps8, 4);
+    d5s8 = vdup_lane_s8(dtmps8, 5);
+    d0u8 = vreinterpret_u8_s8(vabs_s8(d0s8));
+    d1u8 = vreinterpret_u8_s8(vabs_s8(d1s8));
+    d2u8 = vreinterpret_u8_s8(vabs_s8(d2s8));
+    d3u8 = vreinterpret_u8_s8(vabs_s8(d3s8));
+    d4u8 = vreinterpret_u8_s8(vabs_s8(d4s8));
+    d5u8 = vreinterpret_u8_s8(vabs_s8(d5s8));
+
+    // First pass: output_height lines x output_width columns (9x4)
+    if (yoffset == 0)  // firstpass_filter4x4_only
+        src = src_ptr - 2;
+    else
+        src = src_ptr - 2 - (src_pixels_per_line * 2);
+
+    tmpp = tmp;
+    for (i = 2; i > 0; i--) {
+        q3u8 = vld1q_u8(src);
+        src += src_pixels_per_line;
+        q4u8 = vld1q_u8(src);
+        src += src_pixels_per_line;
+        q5u8 = vld1q_u8(src);
+        src += src_pixels_per_line;
+        q6u8 = vld1q_u8(src);
+        src += src_pixels_per_line;
+
+        __builtin_prefetch(src);
+        __builtin_prefetch(src + src_pixels_per_line);
+        __builtin_prefetch(src + src_pixels_per_line * 2);
+
+        q7u16 = vmull_u8(vget_low_u8(q3u8), d0u8);
+        q8u16 = vmull_u8(vget_low_u8(q4u8), d0u8);
+        q9u16 = vmull_u8(vget_low_u8(q5u8), d0u8);
+        q10u16 = vmull_u8(vget_low_u8(q6u8), d0u8);
+
+        d28u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 1);
+        d29u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 1);
+        d30u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 1);
+        d31u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 1);
+
+        q7u16 = vmlsl_u8(q7u16, d28u8, d1u8);
+        q8u16 = vmlsl_u8(q8u16, d29u8, d1u8);
+        q9u16 = vmlsl_u8(q9u16, d30u8, d1u8);
+        q10u16 = vmlsl_u8(q10u16, d31u8, d1u8);
+
+        d28u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 4);
+        d29u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 4);
+        d30u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 4);
+        d31u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 4);
+
+        q7u16 = vmlsl_u8(q7u16, d28u8, d4u8);
+        q8u16 = vmlsl_u8(q8u16, d29u8, d4u8);
+        q9u16 = vmlsl_u8(q9u16, d30u8, d4u8);
+        q10u16 = vmlsl_u8(q10u16, d31u8, d4u8);
+
+        d28u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 2);
+        d29u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 2);
+        d30u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 2);
+        d31u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 2);
+
+        q7u16 = vmlal_u8(q7u16, d28u8, d2u8);
+        q8u16 = vmlal_u8(q8u16, d29u8, d2u8);
+        q9u16 = vmlal_u8(q9u16, d30u8, d2u8);
+        q10u16 = vmlal_u8(q10u16, d31u8, d2u8);
+
+        d28u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 5);
+        d29u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 5);
+        d30u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 5);
+        d31u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 5);
+
+        q7u16 = vmlal_u8(q7u16, d28u8, d5u8);
+        q8u16 = vmlal_u8(q8u16, d29u8, d5u8);
+        q9u16 = vmlal_u8(q9u16, d30u8, d5u8);
+        q10u16 = vmlal_u8(q10u16, d31u8, d5u8);
+
+        d28u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 3);
+        d29u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 3);
+        d30u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 3);
+        d31u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 3);
+
+        q3u16 = vmull_u8(d28u8, d3u8);
+        q4u16 = vmull_u8(d29u8, d3u8);
+        q5u16 = vmull_u8(d30u8, d3u8);
+        q6u16 = vmull_u8(d31u8, d3u8);
+
+        q3s16 = vreinterpretq_s16_u16(q3u16);
+        q4s16 = vreinterpretq_s16_u16(q4u16);
+        q5s16 = vreinterpretq_s16_u16(q5u16);
+        q6s16 = vreinterpretq_s16_u16(q6u16);
+        q7s16 = vreinterpretq_s16_u16(q7u16);
+        q8s16 = vreinterpretq_s16_u16(q8u16);
+        q9s16 = vreinterpretq_s16_u16(q9u16);
+        q10s16 = vreinterpretq_s16_u16(q10u16);
+
+        q7s16 = vqaddq_s16(q7s16, q3s16);
+        q8s16 = vqaddq_s16(q8s16, q4s16);
+        q9s16 = vqaddq_s16(q9s16, q5s16);
+        q10s16 = vqaddq_s16(q10s16, q6s16);
+
+        d22u8 = vqrshrun_n_s16(q7s16, 7);
+        d23u8 = vqrshrun_n_s16(q8s16, 7);
+        d24u8 = vqrshrun_n_s16(q9s16, 7);
+        d25u8 = vqrshrun_n_s16(q10s16, 7);
+
+        if (yoffset == 0) {  // firstpass_filter8x4_only
+            vst1_u8(dst_ptr, d22u8);
+            dst_ptr += dst_pitch;
+            vst1_u8(dst_ptr, d23u8);
+            dst_ptr += dst_pitch;
+            vst1_u8(dst_ptr, d24u8);
+            dst_ptr += dst_pitch;
+            vst1_u8(dst_ptr, d25u8);
+            dst_ptr += dst_pitch;
+        } else {
+            vst1_u8(tmpp, d22u8);
+            tmpp += 8;
+            vst1_u8(tmpp, d23u8);
+            tmpp += 8;
+            vst1_u8(tmpp, d24u8);
+            tmpp += 8;
+            vst1_u8(tmpp, d25u8);
+            tmpp += 8;
+        }
+    }
+    if (yoffset == 0)
+        return;
+
+    // First Pass on rest 5-line data
+    q3u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q4u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q5u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q6u8 = vld1q_u8(src);
+    src += src_pixels_per_line;
+    q7u8 = vld1q_u8(src);
+
+    q8u16 = vmull_u8(vget_low_u8(q3u8), d0u8);
+    q9u16 = vmull_u8(vget_low_u8(q4u8), d0u8);
+    q10u16 = vmull_u8(vget_low_u8(q5u8), d0u8);
+    q11u16 = vmull_u8(vget_low_u8(q6u8), d0u8);
+    q12u16 = vmull_u8(vget_low_u8(q7u8), d0u8);
+
+    d27u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 1);
+    d28u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 1);
+    d29u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 1);
+    d30u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 1);
+    d31u8 = vext_u8(vget_low_u8(q7u8), vget_high_u8(q7u8), 1);
+
+    q8u16 = vmlsl_u8(q8u16, d27u8, d1u8);
+    q9u16 = vmlsl_u8(q9u16, d28u8, d1u8);
+    q10u16 = vmlsl_u8(q10u16, d29u8, d1u8);
+    q11u16 = vmlsl_u8(q11u16, d30u8, d1u8);
+    q12u16 = vmlsl_u8(q12u16, d31u8, d1u8);
+
+    d27u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 4);
+    d28u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 4);
+    d29u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 4);
+    d30u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 4);
+    d31u8 = vext_u8(vget_low_u8(q7u8), vget_high_u8(q7u8), 4);
+
+    q8u16 = vmlsl_u8(q8u16, d27u8, d4u8);
+    q9u16 = vmlsl_u8(q9u16, d28u8, d4u8);
+    q10u16 = vmlsl_u8(q10u16, d29u8, d4u8);
+    q11u16 = vmlsl_u8(q11u16, d30u8, d4u8);
+    q12u16 = vmlsl_u8(q12u16, d31u8, d4u8);
+
+    d27u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 2);
+    d28u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 2);
+    d29u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 2);
+    d30u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 2);
+    d31u8 = vext_u8(vget_low_u8(q7u8), vget_high_u8(q7u8), 2);
+
+    q8u16 = vmlal_u8(q8u16, d27u8, d2u8);
+    q9u16 = vmlal_u8(q9u16, d28u8, d2u8);
+    q10u16 = vmlal_u8(q10u16, d29u8, d2u8);
+    q11u16 = vmlal_u8(q11u16, d30u8, d2u8);
+    q12u16 = vmlal_u8(q12u16, d31u8, d2u8);
+
+    d27u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 5);
+    d28u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 5);
+    d29u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 5);
+    d30u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 5);
+    d31u8 = vext_u8(vget_low_u8(q7u8), vget_high_u8(q7u8), 5);
+
+    q8u16 = vmlal_u8(q8u16, d27u8, d5u8);
+    q9u16 = vmlal_u8(q9u16, d28u8, d5u8);
+    q10u16 = vmlal_u8(q10u16, d29u8, d5u8);
+    q11u16 = vmlal_u8(q11u16, d30u8, d5u8);
+    q12u16 = vmlal_u8(q12u16, d31u8, d5u8);
+
+    d27u8 = vext_u8(vget_low_u8(q3u8), vget_high_u8(q3u8), 3);
+    d28u8 = vext_u8(vget_low_u8(q4u8), vget_high_u8(q4u8), 3);
+    d29u8 = vext_u8(vget_low_u8(q5u8), vget_high_u8(q5u8), 3);
+    d30u8 = vext_u8(vget_low_u8(q6u8), vget_high_u8(q6u8), 3);
+    d31u8 = vext_u8(vget_low_u8(q7u8), vget_high_u8(q7u8), 3);
+
+    q3u16 = vmull_u8(d27u8, d3u8);
+    q4u16 = vmull_u8(d28u8, d3u8);
+    q5u16 = vmull_u8(d29u8, d3u8);
+    q6u16 = vmull_u8(d30u8, d3u8);
+    q7u16 = vmull_u8(d31u8, d3u8);
+
+    q3s16 = vreinterpretq_s16_u16(q3u16);
+    q4s16 = vreinterpretq_s16_u16(q4u16);
+    q5s16 = vreinterpretq_s16_u16(q5u16);
+    q6s16 = vreinterpretq_s16_u16(q6u16);
+    q7s16 = vreinterpretq_s16_u16(q7u16);
+    q8s16 = vreinterpretq_s16_u16(q8u16);
+    q9s16 = vreinterpretq_s16_u16(q9u16);
+    q10s16 = vreinterpretq_s16_u16(q10u16);
+    q11s16 = vreinterpretq_s16_u16(q11u16);
+    q12s16 = vreinterpretq_s16_u16(q12u16);
+
+    q8s16 = vqaddq_s16(q8s16, q3s16);
+    q9s16 = vqaddq_s16(q9s16, q4s16);
+    q10s16 = vqaddq_s16(q10s16, q5s16);
+    q11s16 = vqaddq_s16(q11s16, q6s16);
+    q12s16 = vqaddq_s16(q12s16, q7s16);
+
+    d26u8 = vqrshrun_n_s16(q8s16, 7);
+    d27u8 = vqrshrun_n_s16(q9s16, 7);
+    d28u8 = vqrshrun_n_s16(q10s16, 7);
+    d29u8 = vqrshrun_n_s16(q11s16, 7);
+    d30u8 = vqrshrun_n_s16(q12s16, 7);
+
+    // Second pass: 8x8
+    dtmps8 = vld1_s8(vp8_sub_pel_filters[yoffset]);
+    d0s8 = vdup_lane_s8(dtmps8, 0);
+    d1s8 = vdup_lane_s8(dtmps8, 1);
+    d2s8 = vdup_lane_s8(dtmps8, 2);
+    d3s8 = vdup_lane_s8(dtmps8, 3);
+    d4s8 = vdup_lane_s8(dtmps8, 4);
+    d5s8 = vdup_lane_s8(dtmps8, 5);
+    d0u8 = vreinterpret_u8_s8(vabs_s8(d0s8));
+    d1u8 = vreinterpret_u8_s8(vabs_s8(d1s8));
+    d2u8 = vreinterpret_u8_s8(vabs_s8(d2s8));
+    d3u8 = vreinterpret_u8_s8(vabs_s8(d3s8));
+    d4u8 = vreinterpret_u8_s8(vabs_s8(d4s8));
+    d5u8 = vreinterpret_u8_s8(vabs_s8(d5s8));
+
+    tmpp = tmp;
+    q9u8 = vld1q_u8(tmpp);
+    tmpp += 16;
+    q10u8 = vld1q_u8(tmpp);
+    tmpp += 16;
+    q11u8 = vld1q_u8(tmpp);
+    tmpp += 16;
+    q12u8 = vld1q_u8(tmpp);
+
+    d18u8 = vget_low_u8(q9u8);
+    d19u8 = vget_high_u8(q9u8);
+    d20u8 = vget_low_u8(q10u8);
+    d21u8 = vget_high_u8(q10u8);
+    d22u8 = vget_low_u8(q11u8);
+    d23u8 = vget_high_u8(q11u8);
+    d24u8 = vget_low_u8(q12u8);
+    d25u8 = vget_high_u8(q12u8);
+
+    for (i = 2; i > 0; i--) {
+        q3u16 = vmull_u8(d18u8, d0u8);
+        q4u16 = vmull_u8(d19u8, d0u8);
+        q5u16 = vmull_u8(d20u8, d0u8);
+        q6u16 = vmull_u8(d21u8, d0u8);
+
+        q3u16 = vmlsl_u8(q3u16, d19u8, d1u8);
+        q4u16 = vmlsl_u8(q4u16, d20u8, d1u8);
+        q5u16 = vmlsl_u8(q5u16, d21u8, d1u8);
+        q6u16 = vmlsl_u8(q6u16, d22u8, d1u8);
+
+        q3u16 = vmlsl_u8(q3u16, d22u8, d4u8);
+        q4u16 = vmlsl_u8(q4u16, d23u8, d4u8);
+        q5u16 = vmlsl_u8(q5u16, d24u8, d4u8);
+        q6u16 = vmlsl_u8(q6u16, d25u8, d4u8);
+
+        q3u16 = vmlal_u8(q3u16, d20u8, d2u8);
+        q4u16 = vmlal_u8(q4u16, d21u8, d2u8);
+        q5u16 = vmlal_u8(q5u16, d22u8, d2u8);
+        q6u16 = vmlal_u8(q6u16, d23u8, d2u8);
+
+        q3u16 = vmlal_u8(q3u16, d23u8, d5u8);
+        q4u16 = vmlal_u8(q4u16, d24u8, d5u8);
+        q5u16 = vmlal_u8(q5u16, d25u8, d5u8);
+        q6u16 = vmlal_u8(q6u16, d26u8, d5u8);
+
+        q7u16 = vmull_u8(d21u8, d3u8);
+        q8u16 = vmull_u8(d22u8, d3u8);
+        q9u16 = vmull_u8(d23u8, d3u8);
+        q10u16 = vmull_u8(d24u8, d3u8);
+
+        q3s16 = vreinterpretq_s16_u16(q3u16);
+        q4s16 = vreinterpretq_s16_u16(q4u16);
+        q5s16 = vreinterpretq_s16_u16(q5u16);
+        q6s16 = vreinterpretq_s16_u16(q6u16);
+        q7s16 = vreinterpretq_s16_u16(q7u16);
+        q8s16 = vreinterpretq_s16_u16(q8u16);
+        q9s16 = vreinterpretq_s16_u16(q9u16);
+        q10s16 = vreinterpretq_s16_u16(q10u16);
+
+        q7s16 = vqaddq_s16(q7s16, q3s16);
+        q8s16 = vqaddq_s16(q8s16, q4s16);
+        q9s16 = vqaddq_s16(q9s16, q5s16);
+        q10s16 = vqaddq_s16(q10s16, q6s16);
+
+        d6u8 = vqrshrun_n_s16(q7s16, 7);
+        d7u8 = vqrshrun_n_s16(q8s16, 7);
+        d8u8 = vqrshrun_n_s16(q9s16, 7);
+        d9u8 = vqrshrun_n_s16(q10s16, 7);
+
+        d18u8 = d22u8;
+        d19u8 = d23u8;
+        d20u8 = d24u8;
+        d21u8 = d25u8;
+        d22u8 = d26u8;
+        d23u8 = d27u8;
+        d24u8 = d28u8;
+        d25u8 = d29u8;
+        d26u8 = d30u8;
+
+        vst1_u8(dst_ptr, d6u8);
+        dst_ptr += dst_pitch;
+        vst1_u8(dst_ptr, d7u8);
+        dst_ptr += dst_pitch;
+        vst1_u8(dst_ptr, d8u8);
+        dst_ptr += dst_pitch;
+        vst1_u8(dst_ptr, d9u8);
+        dst_ptr += dst_pitch;
+    }
+    return;
+}
+
+void vp8_sixtap_predict16x16_neon(
+        unsigned char *src_ptr,
+        int src_pixels_per_line,
+        int xoffset,
+        int yoffset,
+        unsigned char *dst_ptr,
+        int dst_pitch) {
+    unsigned char *src, *src_tmp, *dst, *tmpp;
+    unsigned char tmp[336];
+    int i, j;
+    uint8x8_t d0u8, d1u8, d2u8, d3u8, d4u8, d5u8, d6u8, d7u8, d8u8, d9u8;
+    uint8x8_t d10u8, d11u8, d12u8, d13u8, d14u8, d15u8, d18u8, d19u8;
+    uint8x8_t d20u8, d21u8, d22u8, d23u8, d24u8, d25u8, d26u8, d27u8;
+    uint8x8_t d28u8, d29u8, d30u8, d31u8;
+    int8x8_t dtmps8, d0s8, d1s8, d2s8, d3s8, d4s8, d5s8;
+    uint8x16_t q3u8, q4u8;
+    uint16x8_t q3u16, q4u16, q5u16, q6u16, q7u16, q8u16, q9u16, q10u16;
+    uint16x8_t q11u16, q12u16, q13u16, q15u16;
+    int16x8_t q3s16, q4s16, q5s16, q6s16, q7s16, q8s16, q9s16, q10s16;
+    int16x8_t q11s16, q12s16, q13s16, q15s16;
+
+    if (xoffset == 0) {  // secondpass_filter8x8_only
+        // load second_pass filter
+        dtmps8 = vld1_s8(vp8_sub_pel_filters[yoffset]);
+        d0s8 = vdup_lane_s8(dtmps8, 0);
+        d1s8 = vdup_lane_s8(dtmps8, 1);
+        d2s8 = vdup_lane_s8(dtmps8, 2);
+        d3s8 = vdup_lane_s8(dtmps8, 3);
+        d4s8 = vdup_lane_s8(dtmps8, 4);
+        d5s8 = vdup_lane_s8(dtmps8, 5);
+        d0u8 = vreinterpret_u8_s8(vabs_s8(d0s8));
+        d1u8 = vreinterpret_u8_s8(vabs_s8(d1s8));
+        d2u8 = vreinterpret_u8_s8(vabs_s8(d2s8));
+        d3u8 = vreinterpret_u8_s8(vabs_s8(d3s8));
+        d4u8 = vreinterpret_u8_s8(vabs_s8(d4s8));
+        d5u8 = vreinterpret_u8_s8(vabs_s8(d5s8));
+
+        // load src data
+        src_tmp = src_ptr - src_pixels_per_line * 2;
+        for (i = 0; i < 2; i++) {
+            src = src_tmp + i * 8;
+            dst = dst_ptr + i * 8;
+            d18u8 = vld1_u8(src);
+            src += src_pixels_per_line;
+            d19u8 = vld1_u8(src);
+            src += src_pixels_per_line;
+            d20u8 = vld1_u8(src);
+            src += src_pixels_per_line;
+            d21u8 = vld1_u8(src);
+            src += src_pixels_per_line;
+            d22u8 = vld1_u8(src);
+            src += src_pixels_per_line;
+            for (j = 0; j < 4; j++) {
+                d23u8 = vld1_u8(src);
+                src += src_pixels_per_line;
+                d24u8 = vld1_u8(src);
+                src += src_pixels_per_line;
+                d25u8 = vld1_u8(src);
+                src += src_pixels_per_line;
+                d26u8 = vld1_u8(src);
+                src += src_pixels_per_line;
+
+                q3u16 = vmull_u8(d18u8, d0u8);
+                q4u16 = vmull_u8(d19u8, d0u8);
+                q5u16 = vmull_u8(d20u8, d0u8);
+                q6u16 = vmull_u8(d21u8, d0u8);
+
+                q3u16 = vmlsl_u8(q3u16, d19u8, d1u8);
+                q4u16 = vmlsl_u8(q4u16, d20u8, d1u8);
+                q5u16 = vmlsl_u8(q5u16, d21u8, d1u8);
+                q6u16 = vmlsl_u8(q6u16, d22u8, d1u8);
+
+                q3u16 = vmlsl_u8(q3u16, d22u8, d4u8);
+                q4u16 = vmlsl_u8(q4u16, d23u8, d4u8);
+                q5u16 = vmlsl_u8(q5u16, d24u8, d4u8);
+                q6u16 = vmlsl_u8(q6u16, d25u8, d4u8);
+
+                q3u16 = vmlal_u8(q3u16, d20u8, d2u8);
+                q4u16 = vmlal_u8(q4u16, d21u8, d2u8);
+                q5u16 = vmlal_u8(q5u16, d22u8, d2u8);
+                q6u16 = vmlal_u8(q6u16, d23u8, d2u8);
+
+                q3u16 = vmlal_u8(q3u16, d23u8, d5u8);
+                q4u16 = vmlal_u8(q4u16, d24u8, d5u8);
+                q5u16 = vmlal_u8(q5u16, d25u8, d5u8);
+                q6u16 = vmlal_u8(q6u16, d26u8, d5u8);
+
+                q7u16 = vmull_u8(d21u8, d3u8);
+                q8u16 = vmull_u8(d22u8, d3u8);
+                q9u16 = vmull_u8(d23u8, d3u8);
+                q10u16 = vmull_u8(d24u8, d3u8);
+
+                q3s16 = vreinterpretq_s16_u16(q3u16);
+                q4s16 = vreinterpretq_s16_u16(q4u16);
+                q5s16 = vreinterpretq_s16_u16(q5u16);
+                q6s16 = vreinterpretq_s16_u16(q6u16);
+                q7s16 = vreinterpretq_s16_u16(q7u16);
+                q8s16 = vreinterpretq_s16_u16(q8u16);
+                q9s16 = vreinterpretq_s16_u16(q9u16);
+                q10s16 = vreinterpretq_s16_u16(q10u16);
+
+                q7s16 = vqaddq_s16(q7s16, q3s16);
+                q8s16 = vqaddq_s16(q8s16, q4s16);
+                q9s16 = vqaddq_s16(q9s16, q5s16);
+                q10s16 = vqaddq_s16(q10s16, q6s16);
+
+                d6u8 = vqrshrun_n_s16(q7s16, 7);
+                d7u8 = vqrshrun_n_s16(q8s16, 7);
+                d8u8 = vqrshrun_n_s16(q9s16, 7);
+                d9u8 = vqrshrun_n_s16(q10s16, 7);
+
+                d18u8 = d22u8;
+                d19u8 = d23u8;
+                d20u8 = d24u8;
+                d21u8 = d25u8;
+                d22u8 = d26u8;
+
+                vst1_u8(dst, d6u8);
+                dst += dst_pitch;
+                vst1_u8(dst, d7u8);
+                dst += dst_pitch;
+                vst1_u8(dst, d8u8);
+                dst += dst_pitch;
+                vst1_u8(dst, d9u8);
+                dst += dst_pitch;
+            }
+        }
+        return;
+    }
+
+    // load first_pass filter
+    dtmps8 = vld1_s8(vp8_sub_pel_filters[xoffset]);
+    d0s8 = vdup_lane_s8(dtmps8, 0);
+    d1s8 = vdup_lane_s8(dtmps8, 1);
+    d2s8 = vdup_lane_s8(dtmps8, 2);
+    d3s8 = vdup_lane_s8(dtmps8, 3);
+    d4s8 = vdup_lane_s8(dtmps8, 4);
+    d5s8 = vdup_lane_s8(dtmps8, 5);
+    d0u8 = vreinterpret_u8_s8(vabs_s8(d0s8));
+    d1u8 = vreinterpret_u8_s8(vabs_s8(d1s8));
+    d2u8 = vreinterpret_u8_s8(vabs_s8(d2s8));
+    d3u8 = vreinterpret_u8_s8(vabs_s8(d3s8));
+    d4u8 = vreinterpret_u8_s8(vabs_s8(d4s8));
+    d5u8 = vreinterpret_u8_s8(vabs_s8(d5s8));
+
+    // First pass: output_height lines x output_width columns (9x4)
+    if (yoffset == 0) {  // firstpass_filter4x4_only
+        src = src_ptr - 2;
+        dst = dst_ptr;
+        for (i = 0; i < 8; i++) {
+            d6u8 = vld1_u8(src);
+            d7u8 = vld1_u8(src + 8);
+            d8u8 = vld1_u8(src + 16);
+            src += src_pixels_per_line;
+            d9u8 = vld1_u8(src);
+            d10u8 = vld1_u8(src + 8);
+            d11u8 = vld1_u8(src + 16);
+            src += src_pixels_per_line;
+
+            __builtin_prefetch(src);
+            __builtin_prefetch(src + src_pixels_per_line);
+
+            q6u16 = vmull_u8(d6u8, d0u8);
+            q7u16 = vmull_u8(d7u8, d0u8);
+            q8u16 = vmull_u8(d9u8, d0u8);
+            q9u16 = vmull_u8(d10u8, d0u8);
+
+            d20u8 = vext_u8(d6u8, d7u8, 1);
+            d21u8 = vext_u8(d9u8, d10u8, 1);
+            d22u8 = vext_u8(d7u8, d8u8, 1);
+            d23u8 = vext_u8(d10u8, d11u8, 1);
+            d24u8 = vext_u8(d6u8, d7u8, 4);
+            d25u8 = vext_u8(d9u8, d10u8, 4);
+            d26u8 = vext_u8(d7u8, d8u8, 4);
+            d27u8 = vext_u8(d10u8, d11u8, 4);
+            d28u8 = vext_u8(d6u8, d7u8, 5);
+            d29u8 = vext_u8(d9u8, d10u8, 5);
+
+            q6u16 = vmlsl_u8(q6u16, d20u8, d1u8);
+            q8u16 = vmlsl_u8(q8u16, d21u8, d1u8);
+            q7u16 = vmlsl_u8(q7u16, d22u8, d1u8);
+            q9u16 = vmlsl_u8(q9u16, d23u8, d1u8);
+            q6u16 = vmlsl_u8(q6u16, d24u8, d4u8);
+            q8u16 = vmlsl_u8(q8u16, d25u8, d4u8);
+            q7u16 = vmlsl_u8(q7u16, d26u8, d4u8);
+            q9u16 = vmlsl_u8(q9u16, d27u8, d4u8);
+            q6u16 = vmlal_u8(q6u16, d28u8, d5u8);
+            q8u16 = vmlal_u8(q8u16, d29u8, d5u8);
+
+            d20u8 = vext_u8(d7u8, d8u8, 5);
+            d21u8 = vext_u8(d10u8, d11u8, 5);
+            d22u8 = vext_u8(d6u8, d7u8, 2);
+            d23u8 = vext_u8(d9u8, d10u8, 2);
+            d24u8 = vext_u8(d7u8, d8u8, 2);
+            d25u8 = vext_u8(d10u8, d11u8, 2);
+            d26u8 = vext_u8(d6u8, d7u8, 3);
+            d27u8 = vext_u8(d9u8, d10u8, 3);
+            d28u8 = vext_u8(d7u8, d8u8, 3);
+            d29u8 = vext_u8(d10u8, d11u8, 3);
+
+            q7u16 = vmlal_u8(q7u16, d20u8, d5u8);
+            q9u16 = vmlal_u8(q9u16, d21u8, d5u8);
+            q6u16 = vmlal_u8(q6u16, d22u8, d2u8);
+            q8u16 = vmlal_u8(q8u16, d23u8, d2u8);
+            q7u16 = vmlal_u8(q7u16, d24u8, d2u8);
+            q9u16 = vmlal_u8(q9u16, d25u8, d2u8);
+
+            q10u16 = vmull_u8(d26u8, d3u8);
+            q11u16 = vmull_u8(d27u8, d3u8);
+            q12u16 = vmull_u8(d28u8, d3u8);
+            q15u16 = vmull_u8(d29u8, d3u8);
+
+            q6s16 = vreinterpretq_s16_u16(q6u16);
+            q7s16 = vreinterpretq_s16_u16(q7u16);
+            q8s16 = vreinterpretq_s16_u16(q8u16);
+            q9s16 = vreinterpretq_s16_u16(q9u16);
+            q10s16 = vreinterpretq_s16_u16(q10u16);
+            q11s16 = vreinterpretq_s16_u16(q11u16);
+            q12s16 = vreinterpretq_s16_u16(q12u16);
+            q15s16 = vreinterpretq_s16_u16(q15u16);
+
+            q6s16 = vqaddq_s16(q6s16, q10s16);
+            q8s16 = vqaddq_s16(q8s16, q11s16);
+            q7s16 = vqaddq_s16(q7s16, q12s16);
+            q9s16 = vqaddq_s16(q9s16, q15s16);
+
+            d6u8 = vqrshrun_n_s16(q6s16, 7);
+            d7u8 = vqrshrun_n_s16(q7s16, 7);
+            d8u8 = vqrshrun_n_s16(q8s16, 7);
+            d9u8 = vqrshrun_n_s16(q9s16, 7);
+
+            q3u8 = vcombine_u8(d6u8, d7u8);
+            q4u8 = vcombine_u8(d8u8, d9u8);
+            vst1q_u8(dst, q3u8);
+            dst += dst_pitch;
+            vst1q_u8(dst, q4u8);
+            dst += dst_pitch;
+        }
+        return;
+    }
+
+    src = src_ptr - 2 - src_pixels_per_line * 2;
+    tmpp = tmp;
+    for (i = 0; i < 7; i++) {
+        d6u8 = vld1_u8(src);
+        d7u8 = vld1_u8(src + 8);
+        d8u8 = vld1_u8(src + 16);
+        src += src_pixels_per_line;
+        d9u8 = vld1_u8(src);
+        d10u8 = vld1_u8(src + 8);
+        d11u8 = vld1_u8(src + 16);
+        src += src_pixels_per_line;
+        d12u8 = vld1_u8(src);
+        d13u8 = vld1_u8(src + 8);
+        d14u8 = vld1_u8(src + 16);
+        src += src_pixels_per_line;
+
+        __builtin_prefetch(src);
+        __builtin_prefetch(src + src_pixels_per_line);
+        __builtin_prefetch(src + src_pixels_per_line * 2);
+
+        q8u16 = vmull_u8(d6u8, d0u8);
+        q9u16 = vmull_u8(d7u8, d0u8);
+        q10u16 = vmull_u8(d9u8, d0u8);
+        q11u16 = vmull_u8(d10u8, d0u8);
+        q12u16 = vmull_u8(d12u8, d0u8);
+        q13u16 = vmull_u8(d13u8, d0u8);
+
+        d28u8 = vext_u8(d6u8, d7u8, 1);
+        d29u8 = vext_u8(d9u8, d10u8, 1);
+        d30u8 = vext_u8(d12u8, d13u8, 1);
+        q8u16 = vmlsl_u8(q8u16, d28u8, d1u8);
+        q10u16 = vmlsl_u8(q10u16, d29u8, d1u8);
+        q12u16 = vmlsl_u8(q12u16, d30u8, d1u8);
+        d28u8 = vext_u8(d7u8, d8u8, 1);
+        d29u8 = vext_u8(d10u8, d11u8, 1);
+        d30u8 = vext_u8(d13u8, d14u8, 1);
+        q9u16  = vmlsl_u8(q9u16, d28u8, d1u8);
+        q11u16 = vmlsl_u8(q11u16, d29u8, d1u8);
+        q13u16 = vmlsl_u8(q13u16, d30u8, d1u8);
+
+        d28u8 = vext_u8(d6u8, d7u8, 4);
+        d29u8 = vext_u8(d9u8, d10u8, 4);
+        d30u8 = vext_u8(d12u8, d13u8, 4);
+        q8u16 = vmlsl_u8(q8u16, d28u8, d4u8);
+        q10u16 = vmlsl_u8(q10u16, d29u8, d4u8);
+        q12u16 = vmlsl_u8(q12u16, d30u8, d4u8);
+        d28u8 = vext_u8(d7u8, d8u8, 4);
+        d29u8 = vext_u8(d10u8, d11u8, 4);
+        d30u8 = vext_u8(d13u8, d14u8, 4);
+        q9u16 = vmlsl_u8(q9u16, d28u8, d4u8);
+        q11u16 = vmlsl_u8(q11u16, d29u8, d4u8);
+        q13u16 = vmlsl_u8(q13u16, d30u8, d4u8);
+
+        d28u8 = vext_u8(d6u8, d7u8, 5);
+        d29u8 = vext_u8(d9u8, d10u8, 5);
+        d30u8 = vext_u8(d12u8, d13u8, 5);
+        q8u16 = vmlal_u8(q8u16, d28u8, d5u8);
+        q10u16 = vmlal_u8(q10u16, d29u8, d5u8);
+        q12u16 = vmlal_u8(q12u16, d30u8, d5u8);
+        d28u8 = vext_u8(d7u8, d8u8, 5);
+        d29u8 = vext_u8(d10u8, d11u8, 5);
+        d30u8 = vext_u8(d13u8, d14u8, 5);
+        q9u16 = vmlal_u8(q9u16, d28u8, d5u8);
+        q11u16 = vmlal_u8(q11u16, d29u8, d5u8);
+        q13u16 = vmlal_u8(q13u16, d30u8, d5u8);
+
+        d28u8 = vext_u8(d6u8, d7u8, 2);
+        d29u8 = vext_u8(d9u8, d10u8, 2);
+        d30u8 = vext_u8(d12u8, d13u8, 2);
+        q8u16 = vmlal_u8(q8u16, d28u8, d2u8);
+        q10u16 = vmlal_u8(q10u16, d29u8, d2u8);
+        q12u16 = vmlal_u8(q12u16, d30u8, d2u8);
+        d28u8 = vext_u8(d7u8, d8u8, 2);
+        d29u8 = vext_u8(d10u8, d11u8, 2);
+        d30u8 = vext_u8(d13u8, d14u8, 2);
+        q9u16 = vmlal_u8(q9u16, d28u8, d2u8);
+        q11u16 = vmlal_u8(q11u16, d29u8, d2u8);
+        q13u16 = vmlal_u8(q13u16, d30u8, d2u8);
+
+        d28u8 = vext_u8(d6u8, d7u8, 3);
+        d29u8 = vext_u8(d9u8, d10u8, 3);
+        d30u8 = vext_u8(d12u8, d13u8, 3);
+        d15u8 = vext_u8(d7u8, d8u8, 3);
+        d31u8 = vext_u8(d10u8, d11u8, 3);
+        d6u8  = vext_u8(d13u8, d14u8, 3);
+        q4u16 = vmull_u8(d28u8, d3u8);
+        q5u16 = vmull_u8(d29u8, d3u8);
+        q6u16 = vmull_u8(d30u8, d3u8);
+        q4s16 = vreinterpretq_s16_u16(q4u16);
+        q5s16 = vreinterpretq_s16_u16(q5u16);
+        q6s16 = vreinterpretq_s16_u16(q6u16);
+        q8s16 = vreinterpretq_s16_u16(q8u16);
+        q10s16 = vreinterpretq_s16_u16(q10u16);
+        q12s16 = vreinterpretq_s16_u16(q12u16);
+        q8s16 = vqaddq_s16(q8s16, q4s16);
+        q10s16 = vqaddq_s16(q10s16, q5s16);
+        q12s16 = vqaddq_s16(q12s16, q6s16);
+
+        q6u16 = vmull_u8(d15u8, d3u8);
+        q7u16 = vmull_u8(d31u8, d3u8);
+        q3u16 = vmull_u8(d6u8, d3u8);
+        q3s16 = vreinterpretq_s16_u16(q3u16);
+        q6s16 = vreinterpretq_s16_u16(q6u16);
+        q7s16 = vreinterpretq_s16_u16(q7u16);
+        q9s16 = vreinterpretq_s16_u16(q9u16);
+        q11s16 = vreinterpretq_s16_u16(q11u16);
+        q13s16 = vreinterpretq_s16_u16(q13u16);
+        q9s16 = vqaddq_s16(q9s16, q6s16);
+        q11s16 = vqaddq_s16(q11s16, q7s16);
+        q13s16 = vqaddq_s16(q13s16, q3s16);
+
+        d6u8 = vqrshrun_n_s16(q8s16, 7);
+        d7u8 = vqrshrun_n_s16(q9s16, 7);
+        d8u8 = vqrshrun_n_s16(q10s16, 7);
+        d9u8 = vqrshrun_n_s16(q11s16, 7);
+        d10u8 = vqrshrun_n_s16(q12s16, 7);
+        d11u8 = vqrshrun_n_s16(q13s16, 7);
+
+        vst1_u8(tmpp, d6u8);
+        tmpp += 8;
+        vst1_u8(tmpp, d7u8);
+        tmpp += 8;
+        vst1_u8(tmpp, d8u8);
+        tmpp += 8;
+        vst1_u8(tmpp, d9u8);
+        tmpp += 8;
+        vst1_u8(tmpp, d10u8);
+        tmpp += 8;
+        vst1_u8(tmpp, d11u8);
+        tmpp += 8;
+    }
+
+    // Second pass: 16x16
+    dtmps8 = vld1_s8(vp8_sub_pel_filters[yoffset]);
+    d0s8 = vdup_lane_s8(dtmps8, 0);
+    d1s8 = vdup_lane_s8(dtmps8, 1);
+    d2s8 = vdup_lane_s8(dtmps8, 2);
+    d3s8 = vdup_lane_s8(dtmps8, 3);
+    d4s8 = vdup_lane_s8(dtmps8, 4);
+    d5s8 = vdup_lane_s8(dtmps8, 5);
+    d0u8 = vreinterpret_u8_s8(vabs_s8(d0s8));
+    d1u8 = vreinterpret_u8_s8(vabs_s8(d1s8));
+    d2u8 = vreinterpret_u8_s8(vabs_s8(d2s8));
+    d3u8 = vreinterpret_u8_s8(vabs_s8(d3s8));
+    d4u8 = vreinterpret_u8_s8(vabs_s8(d4s8));
+    d5u8 = vreinterpret_u8_s8(vabs_s8(d5s8));
+
+    for (i = 0; i < 2; i++) {
+        dst = dst_ptr + 8 * i;
+        tmpp = tmp + 8 * i;
+        d18u8 = vld1_u8(tmpp);
+        tmpp += 16;
+        d19u8 = vld1_u8(tmpp);
+        tmpp += 16;
+        d20u8 = vld1_u8(tmpp);
+        tmpp += 16;
+        d21u8 = vld1_u8(tmpp);
+        tmpp += 16;
+        d22u8 = vld1_u8(tmpp);
+        tmpp += 16;
+        for (j = 0; j < 4; j++) {
+            d23u8 = vld1_u8(tmpp);
+            tmpp += 16;
+            d24u8 = vld1_u8(tmpp);
+            tmpp += 16;
+            d25u8 = vld1_u8(tmpp);
+            tmpp += 16;
+            d26u8 = vld1_u8(tmpp);
+            tmpp += 16;
+
+            q3u16 = vmull_u8(d18u8, d0u8);
+            q4u16 = vmull_u8(d19u8, d0u8);
+            q5u16 = vmull_u8(d20u8, d0u8);
+            q6u16 = vmull_u8(d21u8, d0u8);
+
+            q3u16 = vmlsl_u8(q3u16, d19u8, d1u8);
+            q4u16 = vmlsl_u8(q4u16, d20u8, d1u8);
+            q5u16 = vmlsl_u8(q5u16, d21u8, d1u8);
+            q6u16 = vmlsl_u8(q6u16, d22u8, d1u8);
+
+            q3u16 = vmlsl_u8(q3u16, d22u8, d4u8);
+            q4u16 = vmlsl_u8(q4u16, d23u8, d4u8);
+            q5u16 = vmlsl_u8(q5u16, d24u8, d4u8);
+            q6u16 = vmlsl_u8(q6u16, d25u8, d4u8);
+
+            q3u16 = vmlal_u8(q3u16, d20u8, d2u8);
+            q4u16 = vmlal_u8(q4u16, d21u8, d2u8);
+            q5u16 = vmlal_u8(q5u16, d22u8, d2u8);
+            q6u16 = vmlal_u8(q6u16, d23u8, d2u8);
+
+            q3u16 = vmlal_u8(q3u16, d23u8, d5u8);
+            q4u16 = vmlal_u8(q4u16, d24u8, d5u8);
+            q5u16 = vmlal_u8(q5u16, d25u8, d5u8);
+            q6u16 = vmlal_u8(q6u16, d26u8, d5u8);
+
+            q7u16 = vmull_u8(d21u8, d3u8);
+            q8u16 = vmull_u8(d22u8, d3u8);
+            q9u16 = vmull_u8(d23u8, d3u8);
+            q10u16 = vmull_u8(d24u8, d3u8);
+
+            q3s16 = vreinterpretq_s16_u16(q3u16);
+            q4s16 = vreinterpretq_s16_u16(q4u16);
+            q5s16 = vreinterpretq_s16_u16(q5u16);
+            q6s16 = vreinterpretq_s16_u16(q6u16);
+            q7s16 = vreinterpretq_s16_u16(q7u16);
+            q8s16 = vreinterpretq_s16_u16(q8u16);
+            q9s16 = vreinterpretq_s16_u16(q9u16);
+            q10s16 = vreinterpretq_s16_u16(q10u16);
+
+            q7s16 = vqaddq_s16(q7s16, q3s16);
+            q8s16 = vqaddq_s16(q8s16, q4s16);
+            q9s16 = vqaddq_s16(q9s16, q5s16);
+            q10s16 = vqaddq_s16(q10s16, q6s16);
+
+            d6u8 = vqrshrun_n_s16(q7s16, 7);
+            d7u8 = vqrshrun_n_s16(q8s16, 7);
+            d8u8 = vqrshrun_n_s16(q9s16, 7);
+            d9u8 = vqrshrun_n_s16(q10s16, 7);
+
+            d18u8 = d22u8;
+            d19u8 = d23u8;
+            d20u8 = d24u8;
+            d21u8 = d25u8;
+            d22u8 = d26u8;
+
+            vst1_u8(dst, d6u8);
+            dst += dst_pitch;
+            vst1_u8(dst, d7u8);
+            dst += dst_pitch;
+            vst1_u8(dst, d8u8);
+            dst += dst_pitch;
+            vst1_u8(dst, d9u8);
+            dst += dst_pitch;
+        }
+    }
+    return;
+}
diff --git a/vp8/vp8_common.mk b/vp8/vp8_common.mk
index 2c611ede5..6a8db2b48 100644
--- a/vp8/vp8_common.mk
+++ b/vp8/vp8_common.mk
@@ -159,10 +159,6 @@ VP8_COMMON_SRCS-$(HAVE_MEDIA)  += common/arm/armv6/vp8_variance_halfpixvar16x16_
 VP8_COMMON_SRCS-$(HAVE_MEDIA)  += common/arm/armv6/vp8_variance_halfpixvar16x16_hv_armv6$(ASM)
 
 # common (neon)
-VP8_COMMON_SRCS-$(HAVE_NEON)  += common/arm/neon/sixtappredict4x4_neon$(ASM)
-VP8_COMMON_SRCS-$(HAVE_NEON)  += common/arm/neon/sixtappredict8x4_neon$(ASM)
-VP8_COMMON_SRCS-$(HAVE_NEON)  += common/arm/neon/sixtappredict8x8_neon$(ASM)
-VP8_COMMON_SRCS-$(HAVE_NEON)  += common/arm/neon/sixtappredict16x16_neon$(ASM)
 VP8_COMMON_SRCS-$(HAVE_NEON)  += common/arm/neon/buildintrapredictorsmby_neon$(ASM)
 VP8_COMMON_SRCS-$(HAVE_NEON)  += common/arm/neon/idct_dequant_0_2x_neon$(ASM)
 VP8_COMMON_SRCS-$(HAVE_NEON)  += common/arm/neon/idct_blk_neon.c
@@ -185,6 +181,7 @@ VP8_COMMON_SRCS-$(HAVE_NEON)  += common/arm/neon/loopfiltersimpleverticaledge_ne
 VP8_COMMON_SRCS-$(HAVE_NEON)  += common/arm/neon/mbloopfilter_neon.c
 VP8_COMMON_SRCS-$(HAVE_NEON)  += common/arm/neon/sad_neon.c
 VP8_COMMON_SRCS-$(HAVE_NEON)  += common/arm/neon/shortidct4x4llm_neon.c
+VP8_COMMON_SRCS-$(HAVE_NEON)  += common/arm/neon/sixtappredict_neon.c
 
 
 $(eval $(call rtcd_h_template,vp8_rtcd,vp8/common/rtcd_defs.pl))