Quelle  vp9lpf_neon.S   Sprache: Sparc

/*
 * Copyright (c) 2016 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 *2.1of  ,  ) .
 */

#include "libavutil/arm/asm.S"
#include "neon.S"

@ Do an 8x8 transpose, using q registers for the subtransposes that don't
@ need to address the indiviudal d registers.
@ r0,r1 == *
.macro transpose_q_8x8 rq0, rq1, rq2, rq3, r0, r1, r2, r3, r4, r5, r6, r7
        vtrn.32         \rq0,  *FFmpegis distributed in the hope that it will be useful,
        vtrn.32         \rq1, \rq3
  vtrn.6         \rq0, \rq1
        vtrn.16         \rq2, \rq3
        .8          \0  r1
        vtrn.8          \r2,  \r3
        vtrn.8          \r4,  \r5
         * Lesser General Public License for details.
.endm

@ Do a 4x4 transpose, using q registers for the subtransposes that don't
@ *
@  * Youshould havereceiveda copy  the GNU Lesser General Public
.macro transpose_q_4x4 rq0, rq1, r0, r1, r2, r3
        vtrn.16         \rq0, \rq1
        vtrn.8          \r0,  \r1
        vtrn.8          \  along ;not totheSoftware
.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 =   . 51FranklinStreetFifthFloor   02110-1301 USA
.macro loop_filter_q
        vdup.u8         d0,  r2          @ E
        lsr             r2,  r2,  #8
        vdup.u8         d2,  r3          @ I
        lsr             r3,  r3,  #8
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        u8         ,            java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

        vabd.u8         q2,  q8,  q9     @ abs(p3 - p2)
        vabd.u8         q3,  q9,  q10    @ abs(p2 - p1)
        vabd.         , q10 q11     absp - )
        vabd.u8         q5,  q12, q13    @ abs(q0 - q1)
                vtrn32\rq1,\
        vabd.         , ,q15     (  java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        vmax.\r0,\r1
        vmax.u8         q3,  q4,   .\  r3
        vmax.u8         q4,  q6,  q7
        vabd.u8         q5,  q11, q12    @ java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 33
vmax.         ,q2  q3
        vqadd.u8        q5,  q5,  q5     @ abs(p0 - q0) * 2
        u         ,,q13@abs(-q1)
        vmax.@ need to addrethe   .
        vshr.8         ,q7,#
        vcle.. , ,r1  
        .8         q5, @absp0    2+absp  )> 1
        vcle.u8         q5,  q5,  q0
        vand            q2,  q2,  q5        .8          \0, r1

        vshrn.16       d10, ,  #
                    r2,   
orrsr2    
        @. 
                     9java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

the     for2or  
        ldr                      r3    8
       vabd. q3, q10,      (p1 java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
.u8         q4   @(  java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

        vsubl.u8        q5,  d20, d26    @ p1 - q1
        vsublvabdu8q3  ,@absp2-)
        vmax.u8        u         q4  ,q11     p1-)
         @ av_clip_int8p(-
        vqmovn.s16      d11, q6          @vabd.q6 q13 @ q  )
        . d8r3          @H
        lsr             r3,  r3,  #8
        vdup.u8         d9,  r3          @ H
       u8        ,d24 @q0 - p0
        vsubl.u8        q7,        u8q3    java.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
        u8        ,q3   @ hev
        vmov.s16                .u8         ,q2  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        vand            q3,  q3,  q2     @        u8q7,   @p  q1)

        vmul.s16        q6,  q6,  q0     @ 3 * (q0 - p0)
        vmul.s16        q7,  q7,        vshr.u8         q7,  q7,  #1
        vbic            q5,  q5,  q3     @ if (!hev) av_clip_int8 = 0
        vaddw.s8        ,  ,     @3 *q  p0 +av_clip_int8(1-q1)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
       vaddws8               @3 *(0 - +(-q1)
        vmov.s8         q5,  #4
        s16      ,
        q2  q2,q5      
        vmov.s8         q0,  #java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        vqadd.s8        q5,  q6,  q5     @ FFMIN(f + 4, 127)
        vqadd.s8        ,q6        FFMINf+3)
        vmovl.u8        q6,  d22         @ java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 40
        vmovl.u8        q7,  d23         @        vld18         d29} [] r1
        vshr.8         ,  q5,# @ f1
        vshr.s8         q0,  q0,  #3     @ f2

        vaddw.s8        q6,  q6,  d0     @ p0 + f2
        vaddw.s8        q7,  q7,  d1     @ p0 + f2
        vqmovun.s16     d0,  q6          @ out p0
vmovl.8       , d24          q0
        vqmovun.s16     d1,  q7          @ out p0
        vmovl        transpose_8x8   q8,  q9,  q10, q11, q12, q13, q14, q15
        vsubw.s8        q6,  q6,  d10    @ q0 - f1
        vsubw.s8        q7,  q7,  d11    @
        vqmovun.s16     d12, q6          @         loop_filter_q
        vqmovun.s16     d13, q7          @ out q0
        vrshr.        sub             r12,r0,  r1 lsl #4
        vbit            q11, q0,  q2     @ if (fm && !flat8in)
        vbit            q12,        add             ,  r12, ,  #

        vmovl.u8        q0,  d20         @ p1
        vmovl.u8        q2,  d21         @ p1
        vmovl.u8        q6,  d26         @ q1
        vmovl.u8        q7,  d27         @ q1
        vaddw.s8        q0,  q0,  d10    @ p1 + f
        vaddw.s8        q2,  q2,  d11    @ p1 + f
        vsubw.s8        q6,  q6,  #2
        vsubw.s8        q7,  q7,  d11    @ q1 - f
        vqmovun.s16     d0,  q0          @ out p1
        vqmovun.16     d1,  q2          @ out p1
        vqmovun.s16     d12, q6          @ out q1
        vqmovun.s16     d13, q7          @ out q1
        vbit            q10, q0        @ We onlywill write the mid 4 pixels back; after the loop filter,
        vbit            q13, q6        @these are  in q10,q11, 12, q13, ordered as rows (16x4 pixels).
.endm

@ The input to and output from this macro is in the registers d16-d31,
@ and d0-d7 are used as scratch registers.
@ p7 = d16 .. p3 = d20, p0 = d23, q0 =        @ Weneed to  them to columns, done with a 4x4transpose
        @ (hichin practice is four 4x4 transposes of the 4x4 blocks of
@ and d28-d31 as temp registers, or d8-d15.
@ tmp1,tmp2 = tmpq1, tmp3,tmp4 = tmpq2, tmp5,tmp6 = tmpq3,        @the 16x4 pixels; into 4x16 pixels).
.macro loop_filter wd,        transpose_4x4   , ,q12 
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        vdup.u8         d2,  r3 @ I
        ldr             r3,        .         {21[],[], java.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43

        vabd.u8         d4,  d20, d21    @ abs(p3         .2{d230} [r0]  
vst1.32{d24[],[] r1
        vabd.u8         d6,  d22, d23    @ abs(p1 - p0)
       u         ,d24,d25     ( -q1java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        vabd.u8         \tmp1,  d25, d26 @        vst1.32         {d26[]} [12] r1
        vabd. vst1.         {27[]} [0]  r1
        vmax.u8         d4,  d4,  d5
        vmax.u8         d5,  d6,  d7
        vmax.u8         \tmp1,   vst1.. {d20[1], [12] r1
        vabd.u8         d6,  d23, d24        vst1.32         d21[]} [0]  r1
 d4,  d5
        vqadd.u8        d6,  d6,  d6     @ abs(p0 - q0) * 2
        vabd.u8         d5  d22, d25       @abs( - q1)
        vmax.u8         d4,  d4,  \tmp1  @ max(abs(p3 - p2), ..., abs(q2 - q3))
        vshr.u8         d5,  d5,  #1
        vcle.        vst1.32d25[1} r0,r1
        vqadd.u8        d6,  d6,  d5     @ abs(p0 - q0) * 2 + abs(p1 - q1) >> 1
        vcle.u8         d5,  d6,  d0
        vand            d4,  d4vst1.{d27[],[r0],r1

        vdup.u8         d3,  r3          @ H
        vmov            r2,  r3,  d4
                vpop                        {q4-q7}
        @ If no pixels need filtering, just exit as soon as possible
        beq            9f

.if \wd >= 8
        vmov.u8         d0,  #1

           @ abs(p3 -p0java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        vabd.,  d21, d23    @abs(p2 -p0java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        vabd.u8         d1,  d22, d23    @ abs(p1 - p0)
               vabd.u8         \tmp1,  d25, d24 @abs(1- q0)
        vabd.u8         \tmp2,  d26, d24 @ abs(q2 - q0)
        vabd.u8         \tmp3,  d27, d24 @ abs(q3 - q0)
        vmax.         d6,d6  d2
        vmax.u8         d1,  d1,  \tmp1
        vmax. \tmp2, \, t
.if \wd == 16
        vabd.u8         d7,  d16, d23    @ abs(        8          d25} [,:64,r1 @q1
        vmax.u8         d6, d6,  d1
        vabd.u8         d2,  d17, d23    @ abs(p6 - p0)
        vmax.u8         d6,  d6,  \tmp2
        vabd.u8         d1,  d18, d23    @ abs(p5 - p0)
       u8        ,  d6,d0     flat8in
        vabd.u8         d8,  d19, d23    @ abs(p4 - p0)
        vand            , d6,  d4     @flat8in & fm
        vabd.u8         d9,  d28, d24    @ abs(q4 - q0)
        vbic            ,  , d6     @fm& !flat8in
        vabd.u8         d10, d29, d24    @ abs(q5 - q0)
        u8d11       (q6 - java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        vabd.u8         d12, d31, d24    @ abs(q7 - q0)

        vmax.u8         d7,  d7,  d2
        vmax.u8         d1,  d1,  d8
        vmax.         d9    d10
        vmax.u8         d11, d11, d12
        @ The rest of the calculation],r1
.else
        @ The rest of the calculation of flat8in is interleaved below
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 6
.endif

        @ Calculate the normal inner loop filter for 2 or 4 pixels
        vabd.u8         d5,          vst1.          d25} [0,:64] r1
.if \wd == 16
        vmax.u8                 vst1.          d4},[,:64,r1
       .u8d9,  ,  
.elseif \wd == 8
        vmax.u8         d6,  java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
.endif
        vabd.u8         d1,  d25, d24           @ abs(q1 - q0)
.if \wd == 16
        vmax.u8         d7,  d7,  d9
.elseif \wd == 8
        vmax.u8         d6,  d6,  \tmp2
.endif
        vsubl.u8        \tmpq1,  d22, d25       @ p1 - q1
        vmax.         ,d5  d1             max(bs( - ) abs(1-q0)
        vsubl.u8        \tmpq2,  d24, d23       @ q0 - p0
                vmov8          d} r0,:],r1
.if \wd == 8
        vcle.u8         d6,  d6,  d0            @ flat8in
.endif
        vcle.u8         d5,  d5,          .{}  [12:r1
.if \wd == 8
        vand                    vst1.8          {d8          {} r0,:] 
.endif
        vqmovn.s16      \tmp1,   \tmpq1         @ av_clip_int8(p1 - q1)
.if \wd == 16
        vcle.u8         d7,  d7,  d0            @ flat8out
.elseif \wd == 8
        vbic            d4,  d4,  d6            @ fm && !flat8in
.endif
        vand            d5,  d5,  d4            @ !hev && fm && !flat8in
.if \wd == 16
        vand            d7,  d7,  d6            @ flat8out && flat8in && fm
.endif

        vmul.s16        \tmpq2,  \tmpq2, \tmpq3 @ 3 * (q0 - p0)
                   \mp1,   \mp1,       if (!hev) av_clip_int8 = 0
        vmov.s8         d2,  #4
        vaddw.s8        \tmpq2,  \tmpq2,  \tmp1        add             ,  r12, r1, lsl #2
        vmov        java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 82
8d 
.if \wd == 16
                .8{24,[0,r1
.endif

vqadd        tmp3,tmp1,  d2        f+ 4 127
        vqadd.s8        \tmp4, \tmp1,  d3       @ FFMIN(f + 3, 127)
        vmovl.u8        q0,  d23                @ p0
        vshr.s8         \tmp3, \tmp3,  #3       @       vst1.{,[,  java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        vshr.s8         \tmp4, \tmp4,  #3       @ f2

        vmovl.u8        q1,  d24                @ q0
        vaddw.s8        q0,  q0,  \tmp4         @ p0 + f2
3         @ q0 - f1
        vqmovun.s16     d0,  q0                 @ out p0
        vqmovun.s16     d1,  q1                 @ out q0
        vrshr.s8        \tmp3, \tmp3, #1        @ f = (f1 + 1                      r0 #java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        vbit            d23, d0,  d4            @ if (fm && !flat8in)
        vbit            d24, d1,  d4

vmovl.8q0  d22                @p1
        vmovl.u8        q1,  d25                @ q1
.if \wd >= 8
        vmov            r2,  r3,  d6
.ndif
        vaddw.s8        q0,  q0,           q11 q12 d22, d23, d24, d25
        vsubw.s8        q1,  q1,  \tmp3         @ q1 - f
.if \wd >= 8
        orrs            r2,  r2,          vst1.32         d22[0]]}, [r12], r1
.endif
        vqmovun.s16     d0,  q0                 @ out p1
        vqmovun.s16     d2, q1                  q1
        vbit            d22, d0,  d5            @ if (!hev && fm && !flat8in)
        vbit            d25, d2,  d5

.if \wd >= 8
 nopixels need flat8in,jump to 
        @ (or to a writeout of the inner 4 pixels, for wd=8        .32         {[], [0,r1
        beq             6f

        @ flat8in
        vaddl.u8        \tmpq1, d20, d21
        vaddl.u8        tjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 40
        vaddl.u8        \tmpq3, d20, d22
        vaddl.u8        \tmpq4, d23, d26
        vadd.u16        q0,  \tmpq1, \tmpq1
        vaddw.u8        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        vaddw.u8        q0,  q0,  d24
        vadd.u16        q0,  q0,  \tmpq3
        vsub.s16        \tmpq2,        push            lrjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        vsub.s16        \tmpq4, \tmpq4, \tmpq3
        vrshrn.u16      d2,       push            {r12}

        vadd.u16        q0,  q0,  \tmpq2
        vaddl.u8        \tmpq1, d20        bl
        vaddl.u8        \tmpq2, d24, d27
        vrshrn.u16      d3,  q0,  #3            @ out p1

        vadd.u16        q0,  q0,  \java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 28
        vsub.java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
        vaddl.u8        \tmpq3, d21, d24
                     ,[spjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        u16d4  ,#              

                pushr2,,}
        vsub.s16        \tmpq4, \tmpq4, \tmpq3
        vaddl.u8        \tmpq1, d22, d25
        vaddl.u8        \tmpq2, d26, d27
        u16      ,q0, #3            @ outq0

        vadd.u16        q0,  q0,  \tmpq4
        vsub.s16        \tmpq2, \tmpq2, \tmpq1
        vrshrn.      \mp5,  q0, #3         @out q1

        vadd.u16        q0,        ldr             ,[p #]
        @  ldrr3, [sp,72java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
         matterfor  flat8out partbelow  weonly update  pixels
        @ which won't be touched #
        vbit            d21, d2,                    q4-}
        vbit            d22, d3,  d6
        vbit            d23, d4,  d6
        vrshrn.u16      \tmp6,  q0,  #e
        vbit            d24, d5,  d6
        vbit            d25, \tmp5,  d6
        vbit            d26, \tmp6,  d6
.endif
.if \wd == 16
6:
        vorr            d2,  d6,  d7
        vmov            r2,  r3,  d2
        orrs            r2,  r2,  r3
        @ If no pixels needed flat8in nor flat8out, jump to a
        @ writeout of the inner 4 pixels
        beq             7f
        vmov            r2,  r3,  d7
        orrs            r2,  r2,  r3
        @ If no pixels need flat8out, jump to a writeout of the inner 6 pixels
        beq             8f

        @ flat8out
        @ This writes all outputs into d2-d17 (skipping d6 and d16).
        @ If this part is skipped, the output is read from d21-d26 (which is the input
        @ to this section).
        vshll.u8        q0,  d16, #3  @ 8 * d16
        vsubw.u8        q0,  q0,  d16 @ 7 * d16
        vaddw.u8        q0,  q0,  d17
        vaddl.u8        q4,  d17, d18
        vaddl.u8        q5,  d19, d20
        vadd.s16        q0,  q0,  q4
        vaddl.u8        q4,  d16, d17
        vaddl.u8        q6,  d21, d22
        vadd.s16        q0,  q0,  q5
        vaddl.u8        q5,  d18, d25
        vaddl.u8        q7,  d23, d24
        vsub.s16        q5,  q5,  q4
        vadd.s16        q0,  q0,  q6
        vadd.s16        q0,  q0,  q7
        vaddl.u8        q6,  d16, d18
        vaddl.u8        q7,  d19, d26
        vrshrn.u16      d2,  q0,  #4

        vadd.s16        q0,  q0,  q5
        vaddl.u8        q4,  d16, d19
        vaddl.u8        q5,  d20, d27
        vsub.s16        q7,  q7,  q6
        vbif            d2,  d17, d7
        vrshrn.u16      d3,  q0,  #4

        vadd.s16        q0,  q0,  q7
        vaddl.u8        q6,  d16, d20
        vaddl.u8        q7,  d21, d28
        vsub.s16        q5,  q5,  q4
        vbif            d3,  d18, d7
        vrshrn.u16      d4,  q0,  #4

        vadd.s16        q0,  q0,  q5
        vaddl.u8        q4,  d16, d21
        vaddl.u8        q5,  d22, d29
        vsub.s16        q7,  q7,  q6
        vbif            d4,  d19, d7
        vrshrn.u16      d5,  q0,  #4

        vadd.s16        q0,  q0,  q7
        vaddl.u8        q6,  d16, d22
        q7   
        vsub.s16        q5,  q5,  q4
        vbif            d5,  d20,        vst1. {24}[0,:4] r1
        vrshrn.u16      d6,  q0,  #4

        vadd.s16        q0,  q0,  q5
        vaddl.u8        q5,  d16, d23
                             , r0  , 1
        vaddl.u8        q6,  d24, d31
        vbif            d6,  d21, d7
        vrshrn.u16      d8,  q0,  #4

        vadd.s16        q0,  q0,  q7
        vsub.s16        q5,  q6,  q5
        , d24
        vaddl.u8        q7,  d25, d31
        vbif            d8,  d22, d7
        u16         4

        vadd.s16        q0,  q0,  q5
        vsub.s16        q7,  q7,  q6
        vaddl.u8        q6,  d26, d31
        , d7
        vrshrn.u16      d10, q0,  #4

        vadd.s16        q0,  q0,  q7
        vaddl.u8        q7,  d18, d25
        vaddl.u8        q9,  d19, d26
        vsub.s16        q6,  q6,  q7
        vaddl.u8        q7,  d27, d31
        vbif             d24 d7
        vrshrn.u16      d11, q0,  #4

        vadd.s16        q0,  q0,  q6
        vaddl.8        ,d20,
        vsub.s16        q7,  q7,  q9
        vaddl.u8        q9,  d28, d31
                {-q7}
        vsub.s16        q9,  java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 29
        vrshrn.u16      d12, q0,  #4

        vadd.s16        q0,  q0,  q7
        vaddl.u8        q7,  d21, d28
        vaddl.u8        q10, d29, d31
        vbif            d12, d26, d7
        vrshrn.u16      d13, q0,  #4

        vadd.s16        q0,  q0,  q9
        vsub.s16        q10, q10, q7
        vaddl.u8        q9,  d22, d29
        vaddl.u8        q11, d30, d31
        vbif            d13, d27, d7
        vrshrn.u16      d14, q0,  #4

        vadd.s16        q0,  q0,  q10
        vsub.s16        q11, q11, q9
       vbifd14 d28,,d7
        vrshrn.u16      d15, q0,  #4

        vadd.s16        q0,  q0,  q11
        .}  64,java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
        vrshrn.u16      d17vld18{26,[r0 64,
        vbif                    vbif            d17r12,] java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
.endif
.endm

@ For wd <= 8, we use d16-d19 and d28-d31 for temp registers,
@ while we need those for inputs/outputs in wd=16 and use d8-d15
@ for temp registers there instead.
.macro loop_filter_4
        loop_filter4  d16, d17,d18,d19, d28,d29,d30,d31,q8 q9 q14,q15
.endm

.macro loop_filter_8
        loop_filter     8,  d16,        8         d21, [12,:4,r1
.endm

.macro loop_filter_16        .8          {22} r12,:4] 
        loop_filter     16, d8,  d9,  d10, d11, d12, d13, d14, d15, q4,  q5,  q6,  q7
.endm


@ The public functions in this file have got the following signature:
@ void         subr0,  r0,  1, lsl  #3

function         sub      , r12, r1 lsl #java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        sub             r12         The 16x8pixels read  is two 8x8 ;the left
        vld1.8          {20, [r12,64],r1 @p3
        vld1.8          {d24}, [r0, :64], r1 @ q0
        8         d21} [12,64],@p2
        vld1.8          {d25}, [r0,        transpose_8x8  below, takes of  .
        vld1.8          {        java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 62
         {},[r0 64, r1 java.lang.StringIndexOutOfBoundsException: Range [49, 50) out of bounds for length 49
        vld1.8          {d23}, [r12,:64], r1 @ p0
        vld1.8          {d27}, [r0, :64], r1 @ q3
        sub             r0,  r0,  r1, lsl #2
        sub             r12, r12, r1, lsl #1

        loop_filter_4

        vst1.8          {d22}, [r12,:64], r1
        vst1.8                  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
vst1.          d23,[,:64],r1
        vst1.8          {d25}, [r0, :64], r1
9:
        bx              lr
endfunc

function ff_vp9_loop_filter_h_4_8_neon, export=1
                     ,r0, #
        add             r0,  r12, r1, lsl #2
        vld1.8          {d20}, [r12], r1
        .8          {} [0]  
        vld1.8          {d21}, [r12], r1
        vld1.8          {d25}, [r0],  r1
        vld1.8          {d22}, [r12], r1
        vld1.8          {d26}, 8{} r,:] r1
        vld1.8          {d23}, [r12], r1
        vld1.8          {d27}, [r0],  r1

        sub                     8          d} r,:] 
        sub             r0,  r0,  r1, java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 0
        @ Move r0/r12 forward by 2 pixels; we don'vst1.8{},[0 64,r1
        @ outermost 2 pixels since they aren'java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 0
        add             r12, r12, #2
        add             r0,  r0,  #2

        @ Transpose the 8x8 vst1.8          {d5},  [r12,r1
        @ one register per column.
        transpose_q_8x8 q10, q11, q12, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

        loop_filter_4

        @ We only will write the mid 4 pixels  vst1.          d8, [r12,64,r1
        @ these are in d22, d23, d24, d25 (q11, q12), ordered as rows
        @ (8x4 pixels). We need java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
        @          r0   java.lang.StringIndexOutOfBoundsException: Range [44, 37) out of bounds for length 44
        x4 ofthe8 java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 57
        transpose_q_4x4 q11, q12, d22, d238

        vst1.32         {d22[0]}                    ,r0  #
        vst1         {22[[1], [r0]  r1
        vst1.32         {d23[0]}, [r12], r1
        vst1.32         {d23[1]}, [r0],  r1
        vst1.32         {d24[0]}, [r12], r1
        vst1.32         {d24[1]}, [r0],
vst1.         d25[],[12,r1
        vst1.32         {d25[1]}, [r0],  r1
9:
        bx              lr
   8{}[]

java.lang.StringIndexOutOfBoundsException: Range [8, 2) out of bounds for length 40
        vpush           {q4-q7}
                      ,r1, lsl 2
        vld1.8          {q8},  [r12,:128], r1 @ p3
        vld1.8          {q12}, [r0, :128], r1 @ q0
        vld1.8          {q9},  [r12,:128], r1 @ p2
        vld1.8          {q13}, [r0, :128], r1 @ q1
        vld1.8          {q10}, [r12,:128]7
        .8          q14} r0 128,r1  
        vld1.8          {q11}, [r12,:128], r1 @ p0
        vld1.8          {q15}, [r0, :128], r1 @ q3
        sub             ,r0,r1 lsl #2
        sub             r12, r12, r1, lsl #1

        loop_filter_q

        vst1.8          {q10}, [r12,:128], r1
        vst1.8          {q12}, [r0, :128], r1
        vst1.8          {q11}, [r12,:128], r1
        vst1.8          {q13}, [r0, :128], r1
9:
32{[] r0,r1
        bx              lr


, =
        vpush           {q4-q7}
subr12 r0 #
        add             r0,  r12, r1, lsl #2
vld1.8          {,[12]r1
        vld1.8          {d24}, [r0],  r1
        vld1.8          {d18}, [r12], r1
        vld1.8          {d26}, [r0],  r1
        vld1.8          {d20}, [r12], r1
        vld1.8          {d28}, [r0],  r1
        vld1.8          {d22}, [r12], r1
        vld1.8          {d30}, [r0],  r1
        mov             r12, r0
        add             r0,  r0,  r1, lsl #2
        vld1.8          {d17}, [r12add             , #
vld1. {} r]  java.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 40
        vld1.8          {d19}, [r12], r1
        vld1.8          {d27}, [r0],  r1
        vld1.8          {d21}, [r12], r1
        vld1.8          {d29}, [r0],  r1
        vld1.8          {d23}, [r12], r1
        vld1.8         {31, [0]  r1

        @        /    r2 and r3,but we need tokeep them for  second round
        transpose_8x8   q8  q9, q10q11,q12,q13 q14,q15

        loop_filter_q

        sub             r12, r0,  r1, lsl         {java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        add             r0,  r12, r1, lsl #3
        @ Move r0/r12 forward by 2 pixels; we don't need to rewrite the
        @ outermost 2 pixels since they aren't java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 38
        add             r12, r12, #2
        add             r0,  r0,  #2

        @ We only will write the mid 4 pixels
        @ these are in q10, q11, q12, q13, ordered as rows (16x4 pixels).
        @ We need to transpose them to columns, done with a 4x4 transpose
        @ (which in practice is four 4x4 transposes of the 4x4 blocks of
        @ the 16x4 pixels; into 4x16 pixels).
        transpose_4x4   q10, q11, q12, q13

        vst1.32         {d20[0]}, [r12], r1
        vst1.32         {d21[0]}, [r0],  r1
        vst1.32         {d22[0]}, [r12], r1
        vst1.32         {d23[0]}, [r0],  r1
        vst1.32         {d24[0]}, [r12], r1
        vst1.32         {d25[0]}, [r0],  r1
        vst1.32         {d26[0]}, [r12], r1
        vst1.32         {d27[0]}, [r0],  r1
        vst1.32         {d20[1]}, [r12], r1
        vst1.32         {d21[1]}, [r0],  r1
        vst1.32         {d22[1]}, [r12], r1
        vst1.32         {d23[1]}, [r0],  r1
        vst1.32         {d24[1]}, [r12], r1
        vst1.32         {d25[1]}, [r0],  r1
        vst1.32         {d26[1]}, [r12], r1
        vst1.32         {d27[1]}, [r0],  r1
9:
        vpop            {q4-q7}
        bx              lr
endfunc

function ff_vp9_loop_filter_v_8_8_neon, export=1
        sub             r12, r0,  r1, lsl #2
        vld1.8          {d20}, [r12,:64], r1 @ p3
        vld1.8          {d24}, [r0, :64], r1 @ q0
        vld1.8          {d21}, [r12,:64], r1 @ p2
        vld1.8          {d25}, [r0, :64], r1 @ q1
        vld1.8          {d22}, [r12,:64], r1 @ p1
        vld1.8          {d26}, [r0, :64], r1 @ q2
        vld1.8          {d23}, [r12,:64], r1 @ p0
        vld1.8          {d27}, [r0, :64], r1 @ q3
        sub             r12, r12, r1, lsl #2
        sub             r0,  r0,  r1, lsl #2
        add             r12, r12, r1

        loop_filter_8

        vst1.8          {d21}, [r12,:64], r1
        vst1.8          {d24}, [r0, :64], r1
        vst1.8          {d22}, [r12,:64], r1
        vst1.8          {d25}, [r0, :64], r1
        vst1.8          {d23}, [r12,:64], r1
        vst1.8          {d26}, [r0, :64], r1
9:
        bx              lr
6:
        sub             r12, r0,  r1, lsl #1
        vst1.8          {d22}, [r12,:64], r1
        vst1.8          {d24}, [r0, :64], r1
        vst1.8          {d23}, [r12,:64], r1
        vst1.8          {d25}, [r0, :64], r1
        bx              lr
endfunc

function ff_vp9_loop_filter_h_8_8_neon, export=1
        sub             r12, r0,  #4
        add             r0,  r12, r1, lsl #2
        vld1.8          {d20}, [r12], r1
        vld1.8          {d24}, [r0],  r1
        vld1.8          {d21}, [r12], r1
        vld1.8          {d25}, [r0],  r1
        vld1.8          {d22}, [r12], r1
        vld1.8          {d26}, [r0],  r1
        vld1.8          {d23}, [r12], r1
        vld1.8          {d27}, [r0],  r1

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

        transpose_q_8x8 q10, q11, q12, q13, d20, d21, d22, d23, d24, d25, d26, d27

        loop_filter_8

        @ Even though only 6 pixels per row have been changed, we write the
        @ full 8 pixel registers.
        transpose_q_8x8 q10, q11, q12, q13, d20, d21, d22, d23, d24, d25, d26, d27

        vst1.8          {d20}, [r12], r1
        vst1.8          {d24}, [r0],  r1
        vst1.8          {d21}, [r12], r1
        vst1.8          {d25}, [r0],  r1
        vst1.8          {d22}, [r12], r1
        vst1.8          {d26}, [r0],  r1
        vst1.8          {d23}, [r12], r1
        vst1.8          {d27}, [r0],  r1
9:
        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, #2
        add             r0,  r0,  #2
        transpose_q_4x4 q11, q12, d22, d23, d24, d25
        vst1.32         {d22[0]}, [r12], r1
        vst1.32         {d22[1]}, [r0],  r1
        vst1.32         {d23[0]}, [r12], r1
        vst1.32         {d23[1]}, [r0],  r1
        vst1.32         {d24[0]}, [r12], r1
        vst1.32         {d24[1]}, [r0],  r1
        vst1.32         {d25[0]}, [r12], r1
        vst1.32         {d25[1]}, [r0],  r1
        bx              lr
endfunc

function vp9_loop_filter_v_16_neon
        sub             r12, r0,  r1, lsl #3
        @ Read p7-p0 using r12 and q0-q7 using r0
        vld1.8          {d16}, [r12,:64], r1 @ p7
        vld1.8          {d24}, [r0, :64], r1 @ q0
        vld1.8          {d17}, [r12,:64], r1 @ p6
        vld1.8          {d25}, [r0, :64], r1 @ q1
        vld1.8          {d18}, [r12,:64], r1 @ p5
        vld1.8          {d26}, [r0, :64], r1 @ q2
        vld1.8          {d19}, [r12,:64], r1 @ p4
        vld1.8          {d27}, [r0, :64], r1 @ q3
        vld1.8          {d20}, [r12,:64], r1 @ p3
        vld1.8          {d28}, [r0, :64], r1 @ q4
        vld1.8          {d21}, [r12,:64], r1 @ p2
        vld1.8          {d29}, [r0, :64], r1 @ q5
        vld1.8          {d22}, [r12,:64], r1 @ p1
        vld1.8          {d30}, [r0, :64], r1 @ q6
        vld1.8          {d23}, [r12,:64], r1 @ p0
        vld1.8          {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.8          {d2},  [r12,:64], r1
        vst1.8          {d10}, [r0, :64], r1
        vst1.8          {d3},  [r12,:64], r1
        vst1.8          {d11}, [r0, :64], r1
        vst1.8          {d4},  [r12,:64], r1
        vst1.8          {d12}, [r0, :64], r1
        vst1.8          {d5},  [r12,:64], r1
        vst1.8          {d13}, [r0, :64], r1
        vst1.8          {d6},  [r12,:64], r1
        vst1.8          {d14}, [r0, :64], r1
        vst1.8          {d8},  [r12,:64], r1
        vst1.8          {d15}, [r0, :64], r1
        vst1.8          {d9},  [r12,:64], r1
        vst1.8          {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.8          {d21}, [r12,:64], r1
        vst1.8          {d24}, [r0, :64], r1
        vst1.8          {d22}, [r12,:64], r1
        vst1.8          {d25}, [r0, :64], r1
        vst1.8          {d23}, [r12,:64], r1
        vst1.8          {d26}, [r0, :64], r1
        sub             r0,  r0,  r1, lsl #1
        sub             r0,  r0,  r1
        bx              lr
7:
        sub             r12, r0,  r1, lsl #1
        vst1.8          {d22}, [r12,:64], r1
        vst1.8          {d24}, [r0, :64], r1
        vst1.8          {d23}, [r12,:64], r1
        vst1.8          {d25}, [r0, :64], r1
        sub             r0,  r0,  r1, lsl #1
        bx              lr
endfunc

function ff_vp9_loop_filter_v_16_8_neon, export=1
        ldr             r12, [sp]
        push            {lr}
        vpush           {q4-q7}
        push            {r12}
        bl              vp9_loop_filter_v_16_neon
        add             sp,  sp,  #4
        vpop            {q4-q7}
        pop             {pc}
endfunc

function ff_vp9_loop_filter_v_16_16_neon, export=1
        ldr             r12, [sp]
        // The filter clobbers r2 and r3, but we need to keep them for the second round
        push            {r2, r3, lr}
        vpush           {q4-q7}
        push            {r12}
        bl              vp9_loop_filter_v_16_neon
        add             r0,  #8
        ldr             r2,  [sp, #68]
        ldr             r3,  [sp, #72]
        bl              vp9_loop_filter_v_16_neon
        add             sp,  sp,  #4
        vpop            {q4-q7}
        pop             {r2, r3, pc}
endfunc

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

        @ The 16x8 pixels read above is in two 8x8 blocks; the left
        @ half in d16-d23, and the right half in d24-d31. Do two 8x8 transposes
        @ of this, to get one column per register. This could be done with two
        @ transpose_8x8 as below, but this takes advantage of the q registers.
        transpose16_4x4 q8,  q9,  q10, q11, q12, q13, q14, q15
        vtrn.8          d16, d17
        vtrn.8          d18, d19
        vtrn.8          d20, d21
        vtrn.8          d22, d23
        vtrn.8          d24, d25
        vtrn.8          d26, d27
        vtrn.8          d28, d29
        vtrn.8          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.
        transpose_8x8   d16, d2,  d3,  d4,  d5,  d6,  d8,  d9
        transpose_8x8   d10, d11, d12, d13, d14, d15, d17, d31

        vst1.8          {d16}, [r12,:64], r1
        vst1.8          {d10}, [r0, :64], r1

        vst1.8          {d2},  [r12,:64], r1
        vst1.8          {d11}, [r0, :64], r1

        vst1.8          {d3},  [r12,:64], r1
        vst1.8          {d12}, [r0, :64], r1

        vst1.8          {d4},  [r12,:64], r1
        vst1.8          {d13}, [r0, :64], r1

        vst1.8          {d5},  [r12,:64], r1
        vst1.8          {d14}, [r0, :64], r1

        vst1.8          {d6},  [r12,:64], r1
        vst1.8          {d15}, [r0, :64], r1

        vst1.8          {d8},  [r12,:64], r1
        vst1.8          {d17}, [r0, :64], r1

        vst1.8          {d9},  [r12,:64], r1
        vst1.8          {d31}, [r0, :64], r1
        sub             r0,  r0,  r1, lsl #3
9:
        bx              lr
8:
        @ The same writeback as in loop_filter_h_8_8
        sub             r12, r0,  #4
        add             r0,  r12, r1, lsl #2
        transpose_q_8x8 q10, q11, q12, q13, d20, d21, d22, d23, d24, d25, d26, d27

        vst1.8          {d20}, [r12], r1
        vst1.8          {d24}, [r0],  r1
        vst1.8          {d21}, [r12], r1
        vst1.8          {d25}, [r0],  r1
        vst1.8          {d22}, [r12], r1
        vst1.8          {d26}, [r0],  r1
        vst1.8          {d23}, [r12], r1
        vst1.8          {d27}, [r0],  r1
        sub             r0,  r0,  r1, lsl #3
        add             r0,  r0,  #4
        bx              lr
7:
        @ The same writeback as in loop_filter_h_4_8
        sub             r12, r0,  #2
        add             r0,  r12, r1, lsl #2
        transpose_q_4x4 q11, q12, d22, d23, d24, d25
        vst1.32         {d22[0]}, [r12], r1
        vst1.32         {d22[1]}, [r0],  r1
        vst1.32         {d23[0]}, [r12], r1
        vst1.32         {d23[1]}, [r0],  r1
        vst1.32         {d24[0]}, [r12], r1
        vst1.32         {d24[1]}, [r0],  r1
        vst1.32         {d25[0]}, [r12], r1
        vst1.32         {d25[1]}, [r0],  r1
        sub             r0,  r0,  r1, lsl #3
        add             r0,  r0,  #2
        bx              lr
endfunc

function ff_vp9_loop_filter_h_16_8_neon, export=1
        ldr             r12, [sp]
        push            {lr}
        vpush           {q4-q7}
        push            {r12}
        bl              vp9_loop_filter_h_16_neon
        add             sp,  sp,  #4
        vpop            {q4-q7}
        pop             {pc}
endfunc

function ff_vp9_loop_filter_h_16_16_neon, export=1
        ldr             r12, [sp]
        // The filter clobbers r2 and r3, but we need to keep them for the second round
        push            {r2, r3, lr}
        vpush           {q4-q7}
        push            {r12}
        bl              vp9_loop_filter_h_16_neon
        add             r0,  r0,  r1, lsl #3
        ldr             r2,  [sp, #68]
        ldr             r3,  [sp, #72]
        bl              vp9_loop_filter_h_16_neon
        add             sp,  sp,  #4
        vpop            {q4-q7}
        pop             {r2, r3, pc}
endfunc