/*
 * Copyright (c) 2017 Google Inc.
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "libavutil/arm/asm.S"

.macro transpose16_q_8x8 rq0, rq1, rq2, rq3, rq4, rq5, rq6, rq7, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15
        vswp             \r1,  \r8  @ vtrn.64 \rq0, \rq4
        vswp             \r3,  \r10 @ vtrn.64 \rq1, \rq5
        vswp             \r5,  \r12 @ vtrn.64 \rq2, \rq6
        vswp             \r7,  \r14 @ vtrn.64 \rq3, \rq7
        vtrn.32          \rq0, \rq2
        vtrn.32          \rq1, \rq3
        vtrn.32          \rq4, \rq6
        vtrn.32          \rq5, \rq7
        vtrn.16          \rq0, \rq1
        vtrn.16          \rq2, \rq3
        vtrn.16          \rq4, \rq5
        vtrn.16          \rq6, \rq7
.endm

.macro transpose16_4x4 r0, r1, r2, r3
        vtrn.32          \r0, \r2
        vtrn.32          \r1, \r3
        vtrn.16          \r0, \r1
        vtrn.16          \r2, \r3
.endm

@ Do a 4x4 transpose, using q registers for the subtransposes that don't
@ need to address the indiviudal d registers.
@ r0,r1 == rq0, r2,r3 == rq1
.macro transpose16_q_4x4 rq0, rq1, r0, r1, r2, r3
        vtrn.32         \rq0, \rq1
        vtrn.16         \r0,  \r1
        vtrn.16         \r2,  \r3
.endm

@ The input to and output from this macro is in the registers q8-q15,
@ and q0-q7 are used as scratch registers.
@ p3 = q8, p0 = q11, q0 = q12, q3 = q15
.macro loop_filter_q wd
        vdup.u16        q0,  r2          @ E
        vdup.u16        q1,  r3          @ I

        vabd.u16        q2,  q8,  q9     @ abs(p3 - p2)
        vabd.u16        q3,  q9,  q10    @ abs(p2 - p1)
        vabd.u16        q4,  q10, q11    @ abs(p1 - p0)
        vabd.u16        q5,  q12, q13    @ abs(q0 - q1)
        vabd.u16        q6,  q13, q14    @ abs(q1 - q2)
        vabd.u16        q7,  q14, q15    @ abs(q2 - q3)
        vmax.u16        q2,  q2,  q3
        vmax.u16        q3,  q4,  q5
        vmax.u16        q4,  q6,  q7
        vabd.u16        q5,  q11, q12    @ abs(p0 - q0)
        vmax.u16        q2,  q2,  q3
        vadd.u16        q5,  q5,  q5     @ abs(p0 - q0) * 2
        vabd.u16        q6,  q10, q13    @ abs(p1 - q1)
        vmax.u16        q2,  q2,  q4     @ max(abs(p3 - p2), ..., abs(q2 - q3))
        vshr.u16        q6,  q6,  #1
        vcle.u16        q2,  q2,  q1     @ max(abs()) <= I
        vadd.u16        q5,  q5,  q6     @ abs(p0 - q0) * 2 + abs(p1 - q1) >> 1
        vcle.u16        q5,  q5,  q0
        vand            q2,  q2,  q5     @ fm

        vmovn.u16       d10, q2
        vmov            r8,  r9,  d10
        orrs            r8,  r8,  r9
        @ If no pixels need filtering, just exit as soon as possible
        beq             9f

.if \wd >= 8
        vdup.u16        q0,  r5

        vabd.u16        q1,  q8,  q11    @ abs(p3 - p0)
        vabd.u16        q3,  q9,  q11    @ abs(p2 - p0)
        vabd.u16        q4,  q10, q11    @ abs(p1 - p0)
        vabd.u16        q5,  q13, q12    @ abs(q1 - q0)
        vabd.u16        q6,  q14, q12    @ abs(q2 - q0)
        vabd.u16        q7,  q15, q12    @ abs(q3 - q0)
        vmax.u16        q1,  q1,  q3
        vmax.u16        q4,  q4,  q5
        vmax.u16        q6,  q6,  q7
        @ The rest of the calculation of flat8in is interleaved below
.endif

        @ Calculate the normal inner loop filter for 2 or 4 pixels
        vabd.u16        q3,  q10, q11    @ abs(p1 - p0)
.if \wd == 8
        vmax.u16        q1,  q1,  q4
.endif
        vabd.u16        q4,  q13, q12    @ abs(q1 - q0)
.if \wd == 8
        vmax.u16        q1,  q1,  q6
.endif

        vsub.u16        q5,  q10, q13    @ p1 - q1
        vmax.u16        q3,  q3,  q4     @ max(abs(p1 - p0), abs(q1 - q0))
        vdup.u16        q4,  r4          @ H
        vsub.u16        q6,  q12, q11    @ q0 - p0
.if \wd == 8
        vcle.u16        q1,  q1,  q0     @ flat8in
.endif
        vdup.u16        q0,  r6          @ left shift for saturation
        vcle.u16        q3,  q3,  q4     @ !hev
.if \wd == 8
        vand            q1,  q1,  q2     @ flat8in && fm
.endif
        vneg.s16        q4,  q0          @ negative left shift after saturation
        vqshl.s16       q5,  q5,  q0
.if \wd == 8
        vbic            q2,  q2,  q1     @ fm && !flat8in
.endif
        vmov.s16        q7,  #3
        vand            q3,  q3,  q2     @ !hev && fm && !flat8in
        vshl.s16        q5,  q5,  q4     @ av_clip_int2p(p1 - q1, BIT_DEPTH - 1)

        vmul.s16        q6,  q6,  q7     @ 3 * (q0 - p0)
        vbic            q5,  q5,  q3     @ if (!hev) av_clip_int2p = 0
        vadd.s16        q6,  q6,  q5     @ 3 * (q0 - p0) [+ av_clip_int2p(p1 - q1)]
        vmov.s16        q5,  #4
        vqshl.s16       q6,  q6,  q0
        vmov.s16        q0,  #3
        vshl.s16        q6,  q6,  q4     @ av_clip_int2p(3 * (q0 - p0) [+ av_clip_int2p(p1 - q1)], BIT_DEPTH - 1) = f
        vdup.u16        q4,  r7          @ max pixel value

        vshr.u16        q4,  q4,  #1     @ (1 << (BIT_DEPTH - 1)) - 1)

        vadd.s16        q5,  q6,  q5     @ f + 4
        vadd.s16        q0,  q6,  q0     @ f + 3
        vmov.s16        q6,  #0
        vmin.s16        q5,  q5,  q4     @ FFMIN(f + 4, (1 << (BIT_DEPTH - 1)) - 1)
        vmin.s16        q0,  q0,  q4    @ FFMIN(f + 3, (1 << (BIT_DEPTH - 1)) - 1)
        vdup.u16        q4,  r7          @ max pixel value
        vshr.s16        q5,  q5,  #3     @ f1
        vshr.s16        q0,  q0,  #3     @ f2

        vadd.s16        q0,  q11, q0     @ p0 + f2
        vsub.s16        q7,  q12, q5     @ q0 - f1
        vmin.s16        q0,  q0,  q4
        vmin.s16        q7,  q7,  q4
        vrshr.s16       q5,  q5,  #1     @ f = (f1 + 1) >> 1
        vmax.s16        q0,  q0,  q6     @ out p0
        vmax.s16        q7,  q7,  q6     @ out q0
        vbit            q11, q0,  q2     @ if (fm && !flat8in)
        vbit            q12, q7,  q2
.if \wd >= 8
        vmovn.u16       d4,  q1
.endif

        vadd.s16        q0,  q10, q5     @ p1 + f
        vsub.s16        q7,  q13, q5     @ q1 - f
.if \wd >= 8
        vmov            r8,  r9,  d4
.endif
        vmin.s16        q0,  q0,  q4
        vmin.s16        q7,  q7,  q4
.if \wd >= 8
        orrs            r8,  r8,  r9
.endif
        vmax.s16        q0,  q0,  q6     @ out p1
        vmax.s16        q7,  q7,  q6     @ out q1
        vbit                       q10, q0,q3     @ if (!hev && fm && !flat8in)
        vbit            q13, q7,  q3

.if \wd >= 8
        @ If no pixels need flat8in, jump to a writeout*
        beq             6f

        @ 
        vadd.u16        q2,  ,  9
        vadd.u16        q3,  q10, q13
        vadd.u16        q4,  q8,  q10
        vadd.u16        q5,  q11* version 2.1ofthe ,or(at your option)any later versionjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
        java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 36
u16q0 ,  
        vadd.u16        q0,  q0,  q12
        vadd.u16        q0,  q0,  q4
        vsub.s16         q3,  q2
        vsub.s16        q5,  q5,  q4
        vrshr.u16       q6,  q0,  #3     @ out p2

        vaddvswp\5,\@vtrn64\ rq6
        vadd.u16        q2,  q8,  q11
        vadd.u16        q3,  q12v             r7  r14@vtrn. rq3,\java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
        vrshr.u16       q7,  q0,  #3     @ out p1

           .u16q0 q0 
        vsub.s16        q3,  q3,q2
        vadd        vtrn.32          \r0, \r2
        vbit            q9,  q6,  q1
        vadd.u16        q5,  q13, q15
        vrshr.u16       q6,  q0,  #3     @ out p0

vaddu           q3
        vsub.s16        q5,  q5,  q4
        vadd.u16        q2,  q10, q13
        vbit            ,q7,  1
        vadd.u16        q3,  q14, q15
        @r0,= ,r2r =rq1

        vadd.u16vtrn32r,\java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
        s16           
                     ,q1
        vrshr.u16       q6,  q0,  #3     @ out

        vadd.u16        q0,  q0,  q3
        vbit            q12, q7,  q1
         q2
        vbit            q13, q6,  q1
        vbitq14,q7,  q1
.endif
.endm

@     vabd.,q13 q14@abs(q1-q2)
@vabdu16        q7, q14,q15    @abs(q2 q3)
@ p7 =         vmaxu16q3,4 
 width  the  we use -
@ andd28-31 as tempregisters,  -.
@ In vadd.q5,  q5       @abs(p0 - q0) * 2
@ could be hardcoded, but keeping        vabd.u16        q6,  q10, q13    @ abs(p1 - q1)
@ 8 bpp and aarch64 versions.
.macro loop_filter , tmp1, tmp2,tmp3 , , tmp6,tmp7,tmp8
        vdup.u16        d0,  r2          @ E
       @I

        .16d4, d20,d    @ abs(p3 -p2)
        .u16d5,  d21,d22     abs(p2 - p1)
        vabd.u16        d6,  d22, d23    @ abs(p1 -vand            ,  ,q5    @java.lang.StringIndexOutOfBoundsException: Range [45, 46) out of bounds for length 45
        vabd.16       d7,  d24,d25    @ abs(q0 - q1)
        vabd.u16        \tmp1,  d25, d26 @ abs(q1 - q2)
        vabd.16        tmp2  d26 d27 @  abs(q2  - 3)
        vmax.u16        d4,  d4,  d5
        vmax.u16
        max.u16        tmp1,  \tmp1,  \tmp2
        vabd.u16        d6,  d23, d24    @ abs(p0 - q0)
        vmax.u16        d4,  d4,  d5
        vadd.16d6,  d6,  d6     @ abs(p0 - q0) * 2
        vabd.u16        d5,  d22, d25    @ abs(p1 - q1)
        vmax.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        d5,  #1
        vcle.u16        d4,  d4,v.16q4  q10, q11@ bs(p1 -p0
        vaddvabd.u16        q5,  q13, q12    @ abs(q1 - q0)
        vcle.u16        d6,  d6,  d0
        vand            ,  d4,  d6      fm

        vdup.u16        d3,  r4          @ H
        vmov            r8,  r9,  d4        vmax.u16        ,  q1,q3
        orrs                    vmax.u16        q6,  q6,  q7
         @ The rest  thecalculation of flat8in is interleaved below
        beq.ndif

.if \d >= 8
        vdup.vabd.u16q3,  q10 q11    @abs(p1 - p0)

        vabd.u16        d6,  d20if w = java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 55
        vabdu16        tmp1  d25, @(-q0)
        .        java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 55
        vabd.u16        \tmp3,  .
        vmaxu16d6   java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
        vmax.u16        d1,  d1,  \tmp1
        vmax.u16        \tmp2,  \if w= 
if \wd == 16
        vabd.u16        d7,  d16, d23    @ abs(p7 - p0)
        vmax.u16        d6,  d6,  d1
        vabd.u16        d2,  d17, d23    @ abs(p6 - p0)
        vmax.u16        d6,  d6,  \tmp2
        vabd.u16        d1,  d18, d23    @ abs(p5 - p0)
        .endif
        .16        d8,d19, 23@abs( -p0)
        vand            d6,  d6vand            q3,q3,  q2     @!hev && fm && !flat8in
        vabdu16d9,d28      (q4q4-q0)
         d4  @fm&!flat8in
        vabd.java.lang.StringIndexOutOfBoundsException: Range [24, 16) out of bounds for length 55
        vabd.u16        d11
        .         d31, @abs(7 -q0)

        ,  d7  
        vmax.u16        d1        .16        q6  #0
        max.16        d9,  d9,  d10
        vmax.u16        vmin        ,  ,        (f +3, ( < (BIT_DEPTH - 1) - 1
out is interleavedbelow
.else
        @ The rest of        shr.        q5  ,  #@f1
.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
.v.s16q0,  q0 q4

        @ Calculate the normal inner loop filter for 2 or 4 pixels
        vabdu16          , @abs(1 p0)
.if \= 16
        vmax.u16        d7,  d7,  d1
        vmax.u16        d9 vmax.        q7,q7 q6@  q0q0
. wd==8
        vmax.u16        d6,  vbit             q7  
.
        vabdu16d1  , d24@abs( -java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 62
.if \wd == 16
        vmax.u16        d7,              r9,  java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
\d =8
        vmax.u16        d6,  d6,  \tmp2
.endif
        vdup.u16        \tmp2 orrs            ,r8 r9
        vsub.u16        \tmp1,  d22, d25        @ p1 - q1
        vneg.s16        \tmp6,  \tmp2           @ java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 6
        vmax.u16        d5        vmax.s16        q7,  q7,q6@out q1
        vsub.u16        \tmp3,   d24, d23       @ q0 - p0
        vmov.s16        \tmp5q0,  q3     @if (
.if                    q13,q7,q3
        vcle.u16        d6,  d6,  d0if\java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 12
.endif
        vcle.u16        beq             6f
.if \wd@flat8in
                    d6  d6              @flat8in &&fm
.endif
        vqshl.s16       \tmp1,  \tmp1vadd.16q3   
.if \wd == 16
        vcle.u16        d7,  d7,  d0            @ flat8out
.java.lang.StringIndexOutOfBoundsException: Range [8, 4) out of bounds for length 36
    d6@fm &&!flat8in
.endif
                    ,  d5              @!hev && fm && !flat8in
.        vrshr.u16       ,  ,  3@out java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
        vand            d7,  d7,  d6
.endif
        vshl.s16        \tmp1,  \tmp1,  \tmp6   @ av_clip_int2p(p1 - q1, BIT_DEPTH - 1)

        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        vbic            tmp1,\mp1,   d5     @ if (!hev) av_clip_int2p = 0
        vmov.s16        d2,  #4
        vadd.u16        q5,  13,q15
        vmov.s16        d3,  #3
        vqshl.s16       \tmp1,  \tmp3,  vrshr.u16       q6,  q0,  #3     @ out p0
        vmov.s16        \tmp5,  #0
        vshl.s16        \tmp1,  \tmp1,  \tmp6   @ av_clip_int2pjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        vdup.u16        \tmp6,  r7              @ max pixel value
.if \wd == 16
        bicd6, d6,d7            @ fm && flat8in && !flat8out
.endif

        vshr.u16        q10, java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 36

        vadd.s16        \tmp3,  \tmp1,  d2      @ f + 4
        vadd.s16        \tmp4,  \tmp1 .s16        q3,  q3  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        vadd.u16        q0   java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
        vmin.s16        \tmp4,  \vbit            q13 ,  q1
        vshr.endm
@Theinput to  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 70

        vadds16        ,d23, \tmp4         @ p0 + f2
        vsub.s16        d2,  d24, \tmp3         @ q0 - f1
        vmin.s16        d0,  d0,  \tmp6
        vmin.s16        d2,  d2,  \tmp6
        vrshr.s16       \tmp3,  \tmp3,  #1      @ f = (f1 + 1) >> 1
        vmax.s16        d0,  d0,  \tmp5         @ out p0
        vmax.s16        d2,  d2,  \tmp5         @ out q0
        bit            d23, d0,  d4            @ if (fm && !flat8in)
        vbit            @couldbe hardcoded,but keeping them as ,  keep similarities 

        vadd.s16        d0,  d22, \tmp3         @ p1 + f
        vsub.s16        d2,  d25, \tmp3         @ q1 - f
.if = 8
        vmovr8, r9,  d6
.endif
        vmin.s16        d0,  d0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        vmin.s16        d2,  d2,  \tmp6
.if \wd        .u16        d5  ,d22    @ ( -p1)
        orrs            r8,vabdu16        d6,d22, d23    @ abs(p1 - p0)
.endif
        vmax.s16        d0,  d0,  \tmp5         @ out p1
        maxs16        d2,d2  \mp5         @out  q1
        vbit            ,d0,  d5             if ( & & !flat8in)
                , 2  d5

.if \wd >= 8
        @ If no pixels need flat8in, jumpvmaxu16d5,d6,d7
        @ (or to a writeout of the inner 4 pixels, for wd=8)
        beq             6f

        @flat8in
        vadd.u16        \tmp1,  d20, d21
        vadd.u16        tmp3,  22 d25
        u16        \tmp5,  d20, d22
        vadd.u16        \tmp7,  d23, d26
vmax.u16        ,  d4,\tmp1  @(absp3-p2),.. abs( -q3))
.u16        d0,d0  d23
        vadd        vcle.u16        d4,  d4,  d2     @ max(abs()) <= I
        vadd.16        d0,  d0,\tmp5
        vsub.s16        \tmp3,  \        vcle.        d6,  d6, d0
        vsub.s16        \tmp7,  \tmp7,  \tmp5
        vrshr.u16       d2,  d0,  #3            @ out                     ,    r9

        vadd.u16        d0,  d0,  \tmp3
        vadd.u16        \tmp1,  d20, d23
        vadd.u16        \tmp3,  d24, d27
        ru16       ,d0,  3@outp1

        vadd.u16        d0,  d0,  \tmp7
        sub,  tmp1
        vadd.u16        \tmp5,  d21, d24
        vadd.u16        \vabd.16       ,d21,@absp2java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        .u16u16d4  d0,#@ outp0

        .if \wd == 16
        vsub.s16        \tmp7,  \tmp7,  \tmp5
        vadd.u16        \tmp1,  d22, d25
        vadd.u16        \tmp3,  d26,         vabd.u16        d7,  d16,d23        @absp7  p0)
        ,  d0,#             out d0

        vadd.u16        d0,  d0,  \tmp7
        vsub.s16        \tmp3,  \tmp3,  \tmp1
        vrshr.u16       \tmp5,  d0,  vmax.java.lang.StringIndexOutOfBoundsException: Range [24, 16) out of bounds for length 39

        vabd , d28     @abs(4- )
        @ The outputvbic              , d6      fm& 
        @ matter for the vabd.u16        d10, d29    @ abs(q5 - q0)
        @ which won't be         u16        d12 ,d24    a(q7  )
        bit d2  java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
        bit            , ,d6
        vbit            d23, d4,@  restofthejava.lang.StringIndexOutOfBoundsException: Range [37, 26) out of bounds for length 69
        vrshru16       tmp6,   3@java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 56
        vbit            d24, vmax.java.lang.StringIndexOutOfBoundsException: Range [24, 16) out of bounds for length 37
        vbit            .java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 13
        d26 tmp6,
.endif
. \= 16
:
        vorr            d2,  d6,  d7
        vmov            r8,  r9,  d2
        orrs,  8,  r9
        @ If no pixels needed flat8in nor flat8out, jump to a
        @ writeout of the        . d5  d5,             @ max(abs(p1 - p0), abs(q1 - q0))
beq7
        vmov        vrshr.u16       .        d0,  #java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
Ijava.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 78
bjava.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26

        @        sub             r0,  r0,  r1, lsl #2
        @ This writes all outputs into d2-d17 (skipping d6 and d16).
        @ If this part is skipped,
        @to this section).
        vshl.u16        d0,  d16, #3  
        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 142
. ,  18
        vadd.u16        d10, 
       vadd.d,d,djava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        vadd        16         {,[,64] java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
       vadd.u16         ,djava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        vadd.s16        d0                 {,[,] java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
java.lang.StringIndexOutOfBoundsException: Range [16, 8) out of bounds for length 37
       vadd.16        14 , d24
        sub, ,lsl #2
s d,  ,d12
        vadd.s16        d0,  d0,  d14
        vadd.u16        d12 bx              lr
        vadd.u16        d14, d19, d26
        vrshr.u16       d2,  d0,  #4

        vadd.s16        d0,  d0,  d10
        vadd.u16        d8,  d16, d19
        vadd.u16        d10, d20, d27
        vsub.s16        d14, d14, d12
        vbif            d2,  d17, d7
        vrshr.u16       d3  d0,4

        vadd.s16        d0,  d0r12, r12, #4
        vadd.u16java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
 java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
d3 java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
        u ,d0, 4

        vadd.        bx             lr

        vadd.u16        bpp_frontends vp9_loop_filter_h_8_8
        vsub.s16        d14,
java.lang.StringIndexOutOfBoundsException: Range [18, 8) out of bounds for length 36
    . ,d0  #java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

        vadd.s16        d0,  d0,  function p9_loop_filter_v_16_4_16_neon
vaddu16        java.lang.StringIndexOutOfBoundsException: Range [37, 27) out of bounds for length 37
        vadd.vld1.16         {d16} r,:4], @p7
                vld1.16         {d24}, [r0, :64], r1 @ q0
        vbif                    vld1.16         {17, [,:64], r1 p6
vrshr. d6, d0  4

        d18}, r12:] 
        .        , d23
        vsub.s16        d14, d14, d12
       .u16       d12, java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
        vbif            d6,  d21, d7
        vrshr.u16       d8,  d0,  #4

        vadd.s16        d0,  d0,  d14
        vsub.s16        d10, d12, d10
        vadd.u16        d12, d17, d24
u        d14,d25 d31
        vbif            d8,  d22, d7
       vrshr d9  #java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

        vadd.s16        d0,          vld116,[,6, 1 java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
        .16d22} [,:4]  p1
         . {} r 64,r1@q6
   java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
        vrshr.u16       d10,         sub             r12, r1 r1,l#java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

d0  d14
        vadd.u16java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
        vsub  12,d14
        vadd.        @d2- r0-  stridejava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
vd10 ,d7
        vrshr.u16.16        d2, r,] r1

        vadd.s16        d0,  d0,  d12
        vadd.        vst1.16         {d3},  [r12,:64], r1
        vsub.16       14 14, d18
        vadd.u16        d18        vst1.16         {d4},  [r12,:64], r1
        bif           d11, d25,d7
        vsub.s16        d18, d18, d12
               rshru16       12 ,#java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

        vadd.s16        d0,  d0,  d14
        vadd.vst1.{} r:, r1
                vst1.16         {d8},  [r12,:64], r1
        vbif           d12,d26, 7
        vrshr. 16        d9}  r,64,r1

        vst1 {d17, r0 :],rjava.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
        vsub.s16        d20, d20, d14
.u16       d18,d,d29
        vadd.u16        d22, d30, d31
        vbif            d13, d27, d7
        vrshr           

        vadd.s16        java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 2
. d22 d22 
        vbif            d14, d28at8out part,the output is left in
        vrshr.u16       d15, d0,  #4

        vadd.s16        d0,  d0,  d22
        vbif            d15, d29, d7
        vrshr.u16       d17, d0,  #4
        vbif                    vst1.16         {d22}, [r12,:64], r1
.        vst116         d25,[ :64] 
.endm

.acroloop_filter_q_4
        loop_filter_q   4
.endm

.macro loop_filter_q_8
        loop_filter_q   8
.ndm

.acro loop_filter_16
        loop_filter     16, d8,  d9        sub,r1 #java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
e


@ The public functions in this file have got         vst1         d25, [, :] 
teruint8_t *, ptrdiff_t  stride,int mb_lim,int lim int hev_thr);

.macro bpp_frontend func, bpp
function ff_\func\()_\bpp\()_neon, export=1
        ush            {-9l}
        ldr             r4,  [sp, #28]
        java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 7
        lslvp9_loop_filter_v_16 16,4,4 
        lsl             r3,  ___eon
       ,, \pp-8
        mov             r5,  #1 <        subr0, ,#java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 r,# bpp
        movwvld1d21 ,:64]rjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
v.16        d22,r, :] java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
        vpop            {q4-q7}
 {r9pc}
endfunc             r,r1  2
.endm

rontends 
        bpp_frontend,r,1java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
         v16        d} r,64,r1
endm

.macro bpp_frontend_rep func, suffix, int_suffix, rep, dir, bpp
function{29, r0 :,rjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        push            {-r9l}
        ldr             r4,  [sp, #28]
        vpush           {q4-q7}
        lsl,  2
l,r, #bpp-8
        lsl             r4,  r4,  , 
        mov              sub,r12,#
        mov             r6  16- b
        movw             @The x4 pixelsread above is in x4 blocks
        bl              \func(_\(__
 tq10 ,,  java.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 54
        add            0 ,   2
.else
        add        
.endif
java.lang.StringIndexOutOfBoundsException: Range [14, 8) out of bounds for length 55
.f\ep=4
.ifc \dir,h
        add             r0,  r0,  r1, lsl #2
        bl              \func @ dregisters  transposearentconsecutive.
        add             r0,  r0,        transpose16_4x4 d16 ,   d3 d4
        bl              \func\ d6,  d9
.else
       dd            0 r0, #java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
        r0, ,  #java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        bl        vst1. }  [r0 :64, 1
.endif
. .16d2}r12:] r1
        vpop            {-}
       pop             {-9pcjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
endfunc
.endm

.        vst116         {4, [,64,r1
        bpp_frontend_rep \ v.{9, [0,64] java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
java.lang.StringIndexOutOfBoundsException: Range [24, 8) out of bounds for length 68


,,java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
function ff_vp9_loop_filter_\dir\16d} [0 64,r1
        push            java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
        [p 28java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        vpush           { vst1.16        d} r,:], 
        16{} r12:4] r1
java.lang.StringIndexOutOfBoundsException: Range [11, 8) out of bounds for length 39
        and             r3,  r3        sub,  r0 #java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        add             r0 r0, 8
        lsl             r2,  r2,  #\bpp - 8
        lsl             r3,  r3 #bpp-8
        lsl             r4,  r4,  #\bpp - 8
        mov             r5,  #1 <  ,#
        mov        add             r0,  r0,  #8
        ,(1 <\pp)-1java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        bl              
.\ir,java.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11
                16         d,[,6] java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
.else
       ,   1java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
.ndif
        pop             {r2, r3, r4}
        lsr             r2,  r2,  #8
#8
        lsr             r4,  r4,  #8
        lsl             r2java.lang.StringIndexOutOfBoundsException: Range [24, 8) out of bounds for length 44
        lsl                     bx              lr
        lsl             r47java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
        er_\(_\(__16n

        pop             {        transpose16_q_4x4 q11, q12, d22, d23, d24, d25

.d24,[0, 

.acro bpp_frontends_mix2  
        bpp_frontend_mix2 \ 16d} [0] r1
        bpp_frontend_mix2, 0   lsl #
        bpp_frontend_mix2 \wd1, \wd2, 
        bpp_frontend_mix2 \wd1,        bx             
.endm

function vp9_loop_filter_v_4_8_16_neon
        sub             r12, r0,  r1, lslbpp_frontends_rep  vp9_loop_filter_h_16, 8,  4, 2, h
       16q8,r:,r1  p3
        vld1.16         {q12}, [r0, :128], r1 @ q0
        vld1.16         {q9},  [r12,:128], r1 @ p2
        vld1.16         {q13}, [r0, :128], r1 @ q1
        vld1.16         {q10}, [r12,:128], r1 @ p1
        vld1.16         {q14}, [r0, :128], r1 @ q2
        vld1.16         {q11}, [r12,:128], r1 @ p0
        vld1.16         {q15}, [r0, :128], r1 @ q3
        sub             r0,  r0,  r1, lsl #2
        sub             r12, r12, r1, lsl #1

        loop_filter_q_4

        vst1.16         {q10}, [r12,:128], r1
        vst1.16         {q12}, [r0, :128], r1
        vst1.16         {q11}, [r12,:128], r1
        vst1.16         {q13}, [r0, :128], r1
        sub             r0,  r0,  r1, lsl #1
9:
        bx              lr
endfunc

bpp_frontends vp9_loop_filter_v_4_8


function vp9_loop_filter_h_4_8_16_neon
        sub             r12, r0,  #8
        add             r0,  r12, r1, lsl #2
        vld1.16         {q8},  [r12,:64], r1
        vld1.16         {q12}, [r0, :64], r1
        vld1.16         {q9},  [r12,:64], r1
        vld1.16         {q13}, [r0, :64], r1
        vld1.16         {q10}, [r12,:64], r1
        vld1.16         {q14}, [r0, :64], r1
        vld1.16         {q11}, [r12,:64], r1
        vld1.16         {q15}, [r0, :64], r1

        sub             r12, r12, r1, lsl #2
        sub             r0,  r0,  r1, lsl #2
        @ Move r0/r12 forward by 2 pixels; we don't need to rewrite the
        @ outermost 2 pixels since they aren't changed.
        add             r12, r12, #4
        add             r0,  r0,  #4

        transpose16_q_8x8 q8, q9, q10, q11, q12, q13, q14, q15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31

        loop_filter_q_4

        @ We only will write the mid 4 pixels back; after the loop filter,
        @ these are in q10, q11, q12, q13, ordered as rows (8x4 pixels).
        @ We need to transpose them to columns, done with a
        @ 4x4 transpose (which in practice is two 4x4 transposes of the two
        @ 4x4 halves of the 8x4 pixels; into 4x8 pixels).
        transpose16_4x4 q10, q11, q12, q13

        vst1.16         {d20}, [r12], r1
        vst1.16         {d21}, [r0],  r1
        vst1.16         {d22}, [r12], r1
        vst1.16         {d23}, [r0],  r1
        vst1.16         {d24}, [r12], r1
        vst1.16         {d25}, [r0],  r1
        vst1.16         {d26}, [r12], r1
        vst1.16         {d27}, [r0],  r1
        sub             r12, r12, r1, lsl #2
9:
        add             r0,  r12, #4
        bx              lr
endfunc

bpp_frontends vp9_loop_filter_h_4_8


function vp9_loop_filter_v_8_8_16_neon
        sub             r12, r0,  r1, lsl #2
        vld1.16         {q8},  [r12,:128], r1 @ p3
        vld1.16         {q12}, [r0, :128], r1 @ q0
        vld1.16         {q9},  [r12,:128], r1 @ p2
        vld1.16         {q13}, [r0, :128], r1 @ q1
        vld1.16         {q10}, [r12,:128], r1 @ p1
        vld1.16         {q14}, [r0, :128], r1 @ q2
        vld1.16         {q11}, [r12,:128], r1 @ p0
        vld1.16         {q15}, [r0, :128], r1 @ q3
        sub             r12, r12, r1, lsl #2
        sub             r0,  r0,  r1, lsl #2
        add             r12, r12, r1

        loop_filter_q_8

        vst1.16         {q9},  [r12,:128], r1
        vst1.16         {q12}, [r0, :128], r1
        vst1.16         {q10}, [r12,:128], r1
        vst1.16         {q13}, [r0, :128], r1
        vst1.16         {q11}, [r12,:128], r1
        vst1.16         {q14}, [r0, :128], r1
        sub             r0,  r0,  r1, lsl #1
        sub             r0,  r0,  r1
9:
        bx              lr
6:
        sub             r12, r0,  r1, lsl #1
        vst1.16         {q10}, [r12,:128], r1
        vst1.16         {q12}, [r0, :128], r1
        vst1.16         {q11}, [r12,:128], r1
        vst1.16         {q13}, [r0, :128], r1
        sub             r0,  r0,  r1, lsl #1
        bx              lr
endfunc

bpp_frontends vp9_loop_filter_v_8_8


function vp9_loop_filter_h_8_8_16_neon
        sub             r12, r0,  #8
        add             r0,  r12, r1, lsl #2
        vld1.16         {q8},  [r12,:64], r1
        vld1.16         {q12}, [r0, :64], r1
        vld1.16         {q9},  [r12,:64], r1
        vld1.16         {q13}, [r0, :64], r1
        vld1.16         {q10}, [r12,:64], r1
        vld1.16         {q14}, [r0, :64], r1
        vld1.16         {q11}, [r12,:64], r1
        vld1.16         {q15}, [r0, :64], r1

        sub             r12, r12, r1, lsl #2
        sub             r0,  r0,  r1, lsl #2

        transpose16_q_8x8 q8, q9, q10, q11, q12, q13, q14, q15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31

        loop_filter_q_8

        @ Even though only 6 pixels per row have been changed, we write the
        @ full 8 pixel registers.
        transpose16_q_8x8 q8, q9, q10, q11, q12, q13, q14, q15, d16, d17, d18, d19, d20, d21, d22, d23, d24, d25, d26, d27, d28, d29, d30, d31

        vst1.16         {q8},  [r12,:64], r1
        vst1.16         {q12}, [r0, :64], r1
        vst1.16         {q9},  [r12,:64], r1
        vst1.16         {q13}, [r0, :64], r1
        vst1.16         {q10}, [r12,:64], r1
        vst1.16         {q14}, [r0, :64], r1
        vst1.16         {q11}, [r12,:64], r1
        vst1.16         {q15}, [r0, :64], r1
        sub             r12, r12, r1, lsl #2
9:
        add             r0,  r12, #8
        bx              lr
6:
        @ If we didn't need to do the flat8in part, we use the same writeback
        @ as in loop_filter_h_4_8.
        add             r12, r12, #4
        add             r0,  r0,  #4
        transpose16_4x4 q10, q11, q12, q13

        vst1.16         {d20}, [r12], r1
        vst1.16         {d21}, [r0],  r1
        vst1.16         {d22}, [r12], r1
        vst1.16         {d23}, [r0],  r1
        vst1.16         {d24}, [r12], r1
        vst1.16         {d25}, [r0],  r1
        vst1.16         {d26}, [r12], r1
        vst1.16         {d27}, [r0],  r1
        sub             r12, r12, r1, lsl #2
        add             r0,  r12, #4
        bx              lr
endfunc

bpp_frontends vp9_loop_filter_h_8_8

bpp_frontends_mix2 4, 4
bpp_frontends_mix2 4, 8
bpp_frontends_mix2 8, 4
bpp_frontends_mix2 8, 8

function vp9_loop_filter_v_16_4_16_neon
        sub             r12, r0,  r1, lsl #3
        @ Read p7-p0 using r12 and q0-q7 using r0
        vld1.16         {d16}, [r12,:64], r1 @ p7
        vld1.16         {d24}, [r0, :64], r1 @ q0
        vld1.16         {d17}, [r12,:64], r1 @ p6
        vld1.16         {d25}, [r0, :64], r1 @ q1
        vld1.16         {d18}, [r12,:64], r1 @ p5
        vld1.16         {d26}, [r0, :64], r1 @ q2
        vld1.16         {d19}, [r12,:64], r1 @ p4
        vld1.16         {d27}, [r0, :64], r1 @ q3
        vld1.16         {d20}, [r12,:64], r1 @ p3
        vld1.16         {d28}, [r0, :64], r1 @ q4
        vld1.16         {d21}, [r12,:64], r1 @ p2
        vld1.16         {d29}, [r0, :64], r1 @ q5
        vld1.16         {d22}, [r12,:64], r1 @ p1
        vld1.16         {d30}, [r0, :64], r1 @ q6
        vld1.16         {d23}, [r12,:64], r1 @ p0
        vld1.16         {d31}, [r0, :64], r1 @ q7
        sub             r12, r12, r1, lsl #3
        sub             r0,  r0,  r1, lsl #3
        add             r12, r12, r1

        loop_filter_16

        @ If we did the flat8out part, we get the output in
        @ d2-d17 (skipping d7 and d16). r12 points to r0 - 7 * stride,
        @ store d2-d9 there, and d10-d17 into r0.
        vst1.16         {d2},  [r12,:64], r1
        vst1.16         {d10}, [r0, :64], r1
        vst1.16         {d3},  [r12,:64], r1
        vst1.16         {d11}, [r0, :64], r1
        vst1.16         {d4},  [r12,:64], r1
        vst1.16         {d12}, [r0, :64], r1
        vst1.16         {d5},  [r12,:64], r1
        vst1.16         {d13}, [r0, :64], r1
        vst1.16         {d6},  [r12,:64], r1
        vst1.16         {d14}, [r0, :64], r1
        vst1.16         {d8},  [r12,:64], r1
        vst1.16         {d15}, [r0, :64], r1
        vst1.16         {d9},  [r12,:64], r1
        vst1.16         {d17}, [r0, :64], r1
        sub             r0,  r0,  r1, lsl #3
        add             r0,  r0,  r1

9:
        bx              lr

8:
        add             r12, r12, r1, lsl #2
        @ If we didn't do the flat8out part, the output is left in the
        @ input registers.
        vst1.16         {d21}, [r12,:64], r1
        vst1.16         {d24}, [r0, :64], r1
        vst1.16         {d22}, [r12,:64], r1
        vst1.16         {d25}, [r0, :64], r1
        vst1.16         {d23}, [r12,:64], r1
        vst1.16         {d26}, [r0, :64], r1
        sub             r0,  r0,  r1, lsl #1
        sub             r0,  r0,  r1
        bx              lr
7:
        sub             r12, r0,  r1, lsl #1
        vst1.16         {d22}, [r12,:64], r1
        vst1.16         {d24}, [r0, :64], r1
        vst1.16         {d23}, [r12,:64], r1
        vst1.16         {d25}, [r0, :64], r1
        sub             r0,  r0,  r1, lsl #1
        bx              lr
endfunc

bpp_frontends_rep vp9_loop_filter_v_16, 8,  4, 2, v
bpp_frontends_rep vp9_loop_filter_v_16, 16, 4, 4, v

function vp9_loop_filter_h_16_4_16_neon
        sub             r12, r0,  #16
        sub             r0,  r0,  #8
        vld1.16         {d16}, [r12,:64], r1
        vld1.16         {d20}, [r0, :64], r1
        vld1.16         {d17}, [r12,:64], r1
        vld1.16         {d21}, [r0, :64], r1
        vld1.16         {d18}, [r12,:64], r1
        vld1.16         {d22}, [r0, :64], r1
        vld1.16         {d19}, [r12,:64], r1
        vld1.16         {d23}, [r0, :64], r1
        sub             r12, r12, r1, lsl #2
        sub             r0,  r0,  r1, lsl #2
        add             r12, r12, #16
        add             r0,  r0,  #16
        vld1.16         {d24}, [r12,:64], r1
        vld1.16         {d28}, [r0, :64], r1
        vld1.16         {d25}, [r12,:64], r1
        vld1.16         {d29}, [r0, :64], r1
        vld1.16         {d26}, [r12,:64], r1
        vld1.16         {d30}, [r0, :64], r1
        vld1.16         {d27}, [r12,:64], r1
        vld1.16         {d31}, [r0, :64], r1
        sub             r0,  r0,  r1, lsl #2
        sub             r12, r12, r1, lsl #2
        sub             r12, r12, #16
        sub             r0,  r0,  #16

        @ The 16x4 pixels read above is in four 4x4 blocks
        transpose16_q_4x4 q8,  q9,  d16, d17, d18, d19
        transpose16_q_4x4 q10, q11, d20, d21, d22, d23
        transpose16_q_4x4 q12, q13, d24, d25, d26, d27
        transpose16_q_4x4 q14, q15, d28, d29, d30, d31

        loop_filter_16

        @ Transpose back; this is the same transpose as above, but
        @ we can't take advantage of q registers for the transpose, since
        @ all d registers in the transpose aren't consecutive.
        transpose16_4x4 d16, d2,  d3,  d4
        transpose16_4x4 d5,  d6,  d8,  d9
        transpose16_4x4 d10, d11, d12, d13
        transpose16_4x4 d14, d15, d17, d31

        vst1.16         {d16}, [r12,:64], r1
        vst1.16         {d5},  [r0, :64], r1

        vst1.16         {d2},  [r12,:64], r1
        vst1.16         {d6},  [r0, :64], r1

        vst1.16         {d3},  [r12,:64], r1
        vst1.16         {d8},  [r0, :64], r1

        vst1.16         {d4},  [r12,:64], r1
        vst1.16         {d9},  [r0, :64], r1

        sub             r12, r12, r1, lsl #2
        sub             r0,  r0,  r1, lsl #2
        add             r12, r12, #16
        add             r0,  r0,  #16

        vst1.16         {d10}, [r12,:64], r1
        vst1.16         {d14}, [r0, :64], r1

        vst1.16         {d11}, [r12,:64], r1
        vst1.16         {d15}, [r0, :64], r1

        vst1.16         {d12}, [r12,:64], r1
        vst1.16         {d17}, [r0, :64], r1

        vst1.16         {d13}, [r12,:64], r1
        vst1.16         {d31}, [r0, :64], r1
        sub             r0,  r0,  r1, lsl #2
        sub             r0,  r0,  #8
        bx              lr
9:
        add             r0,  r0,  #8
        bx              lr
8:
        add             r12, r12, #8
        add             r0,  r0,  #8
        transpose16_q_4x4 q10, q11, d20, d21, d22, d23
        transpose16_q_4x4 q12, q13, d24, d25, d26, d27

        vst1.16         {d20}, [r12,:64], r1
        vst1.16         {d24}, [r0, :64], r1
        vst1.16         {d21}, [r12,:64], r1
        vst1.16         {d25}, [r0, :64], r1
        vst1.16         {d22}, [r12,:64], r1
        vst1.16         {d26}, [r0, :64], r1
        vst1.16         {d23}, [r12,:64], r1
        vst1.16         {d27}, [r0, :64], r1
        sub             r0,  r0,  r1, lsl #2
        bx              lr
7:
        add             r12, r12, #12
        add             r0,  r12, r1, lsl #1
        transpose16_q_4x4 q11, q12, d22, d23, d24, d25

        vst1.16         {d22}, [r12], r1
        vst1.16         {d24}, [r0],  r1
        vst1.16         {d23}, [r12], r1
        vst1.16         {d25}, [r0],  r1
        sub             r0,  r0,  r1, lsl #2
        add             r0,  r0,  #4
        bx              lr
endfunc

bpp_frontends_rep vp9_loop_filter_h_16, 8,  4, 2, h
bpp_frontends_rep vp9_loop_filter_h_16, 16, 4, 4, h