Quelle  filmgrain16.S

/*
 * Copyright © 2021, VideoLAN and dav1d authors
 * Copyright © 2021, Martin Storsjo
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "src/arm/asm.S"
#include "util.S"
#include "src/arm/asm-offsets.h"

#define GRAIN_WIDTH 82
#define GRAIN_HEIGHT 73

#define SUB_GRAIN_WIDTH 44
#define SUB_GRAIN_HEIGHT 38

.macro increment_seed steps, shift=1
        lsr             r11, r2,  #3
        lsr             r12, r2,  #12
        lsr             lr,  r2,  #1
        eor             r11, r2,  r11                     // (r >> 0) ^ (r >> 3)
        eor             r12, r12, lr                      // (r >> 12) ^ (r >> 1)
        eor             r11, r11, r12                     // (r >> 0) ^ (r >> 3) ^ (r >> 12) ^ (r >> 1)
.if \shift
        lsr             r2,  r2,  #\steps
.endif
        and             r11, r11, #((1 << \steps) - 1)    // bit
.if \shift
        orr             r2,  r2,  r11, lsl #(16 - \steps) // *state
.else
        orr             r2,  r2,  r11, lsl #16            // *state
.endif
.endm

.macro read_rand dest, bits, age
        ubfx            \dest,  r2,   #16 - \bits - \age, #\bits
.endm

.macro read_shift_rand dest, bits
        ubfx            \dest,  r2,   #17 - \bits, #\bits
        lsr             r2,  r2,  #1
.endm

// special calling convention:
// r2 holds seed
// r3 holds dav1d_gaussian_sequence
// clobbers r11-r12
// returns in d0-d1
function get_gaussian_neon
        push            {r5-r6,lr}
        increment_seed  4
        read_rand       r5,  11,  3
        read_rand       r6,  11,  2
        add             r5,  r3,  r5,  lsl #1
        add             r6,  r3,  r6,  lsl #1
        vld1.16         {d0[0]}, [r5]
        read_rand       r5,  11,  1
        vld1.16         {d0[1]}, [r6]
        add             r5,  r3,  r5,  lsl #1
        read_rand       r6, 11,  0
        increment_seed  4
        add             r6,  r3,  r6,  lsl #1
        vld1.16         {d0[2]}, [r5]
        read_rand       r5,  11,  3
        vld1.16         {d0[3]}, [r6]
        add             r5,  r3,  r5,  lsl #1
        read_rand       r6,  11,  2
        vld1.16         {d1[0]}, [r5]
        add             r6,  r3,  r6,  lsl #1
        read_rand       r5,  11,  1
        vld1.16         {d1[1]}, [r6]
        read_rand       r6,  11,  0
        add             r5,  r3,  r5,  lsl #1
        add             r6,  r3,  r6,  lsl #1
        vld1.16         {d1[2]}, [r5]
        vld1.16         {d1[3]}, [r6]
        pop             {r5-r6,pc}
endfunc

function get_grain_2_neon
        push            {r11,lr}
        increment_seed  2
        read_rand       r11, 11,  1
        read_rand       r12, 11,  0
        add             r11, r3,  r11, lsl #1
        add             r12, r3,  r12, lsl #1
        vld1.16         {d0[0]}, [r11]
        vld1.16         {d0[1]}, [r12]
        vrshl.s16       d0,  d0,  d30
        pop             {r11,pc}
endfunc

.macro get_grain_2 dst
        bl              get_grain_2_neon
.ifnc \dst, d0
        vmov            \dst, d0
.endif
.endm

function get_grain_4_neon
        push            {r11,lr}
        increment_seed  4
        read_rand       r11, 11,  3
        read_rand       r12, 11,  2
        add             r11, r3,  r11, lsl #1
        add             r12, r3,  r12, lsl #1
        vld1.16         {d0[0]}, [r11]
        read_rand       r11, 11,  1
        vld1.16         {d0[1]}, [r12]
        read_rand       r12, 11,  0
        add             r11, r3,  r11, lsl #1
        add             r12, r3,  r12, lsl #1
        vld1.16         {d0[2]}, [r11]
        vld1.16         {d0[3]}, [r12]
        vrshl.s16       d0,  d0,  d30
        pop             {r11,pc}
endfunc

.macro get_grain_4 dst
        bl              get_grain_4_neon
.ifnc \dst, d0
        vmov            \dst, d0
.endif
.endm

// r1 holds the number of entries to produce
// r6, r8 and r10 hold the previous output entries
// q0 holds the vector of produced entries
// q1 holds the input vector of sums from above
.macro output_lag n
function output_lag\n\()_neon
        push            {r0, lr}
.if \n == 1
        mvn             lr,  r5                   // grain_min = ~grain_max
.else
        mov             r0,  #1
        mov             lr,  #1
        sub             r7,  r7,  #1
        sub             r9,  r9,  #1
        lsl             r0,  r0,  r7
        lsl             lr,  lr,  r9
        add             r7,  r7,  #1
        add             r9,  r9,  #1
.endif
1:
        read_shift_rand r12, 11
        vmov.32         r11, d2[0]
        lsl             r12, r12, #1
        vext.8          q0,  q0,  q0,  #2
        ldrsh           r12, [r3, r12]
.if \n == 1
        mla             r11, r6,  r4,  r11        // sum (above) + *coeff * prev output
        add             r6,  r11, r8              // 1 << (ar_coeff_shift - 1)
        add             r12, r12, r10
        asr             r6,  r6,  r7              // >> ar_coeff_shift
        asr             r12, r12, r9              // >> (4 - bitdepth_min_8 + grain_scale_shift)
        add             r6,  r6,  r12
        cmp             r6,  r5
.elseif \n == 2
        mla             r11, r8,  r4,  r11        // sum (above) + *coeff * prev output 1
        mla             r11, r6,  r10, r11        // += *coeff * prev output 2
        mov             r8,  r6
        add             r6,  r11, r0              // 1 << (ar_coeff_shift - 1)
        add             r12, r12, lr              // 1 << (4 - bitdepth_min_8 + grain_scale_shift - 1)
        asr             r6,  r6,  r7              // >> ar_coeff_shift
        asr             r12, r12, r9              // >> (4 - bitdepth_min_8 + grain_scale_shift)
        add             r6,  r6,  r12
        push            {lr}
        cmp             r6,  r5
        mvn             lr,  r5                   // grain_min = ~grain_max
.else
        push            {r1-r3}
        sbfx            r1,  r4,  #0,  #8
        sbfx            r2,  r4,  #8,  #8
        sbfx            r3,  r4,  #16, #8
        mla             r11, r10, r1,  r11        // sum (above) + *coeff * prev output 1
        mla             r11, r8,  r2,  r11        // sum (above) + *coeff * prev output 2
        mla             r11, r6,  r3,  r11        // += *coeff * prev output 3
        pop             {r1-r3}
        mov             r10, r8
        mov             r8,  r6

        add             r6,  r11, r0              // 1 << (ar_coeff_shift - 1)
        add             r12, r12, lr              // 1 << (4 - bitdepth_min_8 + grain_scale_shift - 1)
        asr             r6,  r6,  r7              // >> ar_coeff_shift
        asr             r12, r12, r9              // >> (4 - bitdepth_min_8 + grain_scale_shift)
        add             r6,  r6,  r12
        push            {lr}
        cmp             r6,  r5
        mvn             lr,  r5                   // grain_min = ~grain_max
.endif
        it              gt
        movgt           r6,  r5
        cmp             r6,  lr
        it              lt
        movlt           r6,  lr
.if \n >= 2
        pop             {lr}
.endif
        subs            r1,  r1,  #1
        vext.8          q1,  q1,  q1,  #4
        vmov.16         d1[3], r6
        bgt             1b
        pop             {r0, pc}
endfunc
.endm

output_lag 1
output_lag 2
output_lag 3


function sum_lag1_above_neon
        sub             r12, r0,  #1*GRAIN_WIDTH*2 - 16
        vld1.16         {q10}, [r12] // load top right

        vext.8          q0,  q8,  q9,  #14 // top left, top mid
        vext.8          q1,  q9,  q10, #2  // top left, top mid

        vmull.s16       q2,  d18, d28
        vmlal.s16       q2,  d0,  d27
        vmlal.s16       q2,  d2,  d29
        vmull.s16       q3,  d19, d28
        vmlal.s16       q3,  d1,  d27
        vmlal.s16       q3,  d3,  d29

        vmov            q8,  q9
        vmov            q9,  q10

        bx              lr
endfunc

.macro sum_lag_n_body lag, type, uv_layout, edge, elems, uv_coeff
.ifc \lag\()_\edge, lag3_left
        bl              sum_lag3_left_above_neon
.else
        bl              sum_\lag\()_above_neon
.endif
.ifc \type, uv_420
        vpush           {q6-q7}
        add             r12, r11, #GRAIN_WIDTH*2
        vld1.16         {q0, q1}, [r11]!
        vld1.16         {q6, q7}, [r12]!
        vpadd.i16       d0,  d0,  d1
        vpadd.i16       d1,  d2,  d3
        vpadd.i16       d12, d12, d13
        vpadd.i16       d13, d14, d15
        vadd.i16        q0,  q0,  q6
        vpop            {q6-q7}
        vrshr.s16       q0,  q0,  #2
.endif
.ifc \type, uv_422
        vld1.16         {q0, q1}, [r11]!
        vpadd.i16       d0,  d0,  d1
        vpadd.i16       d1,  d2,  d3
        vrshr.s16       q0,  q0,  #1
.endif
.ifc \type, uv_444
        vld1.16         {q0}, [r11]!
.endif
.if \uv_layout
.ifnb \uv_coeff
        vdup.8          d13, \uv_coeff
        vmovl.s8        q6,  d13
.endif
        vmlal.s16       q2,  d0,  d13
        vmlal.s16       q3,  d1,  d13
.endif
.if \uv_layout && \elems == 8
        b               sum_\lag\()_y_\edge\()_start
.elseif \uv_layout == 444 && \elems == 7
        b               sum_\lag\()_y_\edge\()_start
.elseif \uv_layout == 422 && \elems == 1
        b               sum_\lag\()_uv_420_\edge\()_start
.else
sum_\lag\()_\type\()_\edge\()_start:
        push            {r11}
.if \elems > 4
.ifc \edge, left
        increment_seed  4
        read_rand       r11, 11,  3
        read_rand       r12, 11,  2
        add             r11, r3,  r11, lsl #1
        add             r12, r3,  r12, lsl #1
        vld1.16         {d1[1]}, [r11]
        read_rand       r11, 11,  1
        vld1.16         {d1[2]}, [r12]
        add             r11, r3,  r11, lsl #1
        vld1.16         {d1[3]}, [r11]
        lsl             r2,  r2,  #1             // shift back the state as if we'd done increment_seed with shift=0
        vrshl.s16       d1,  d1,  d30
        vext.8          q2,  q2,  q2,  #12
.ifc \lag, lag3
        vmov.s16        r10, d1[1]
.endif
.ifnc \lag, lag1
        vmov.s16        r8,  d1[2]
.endif
        vmov.s16        r6,  d1[3]

        vmov            q1,  q2
        mov             r1,  #1
        bl              output_\lag\()_neon
.else
        increment_seed  4, shift=0
        vmov            q1,  q2
        mov             r1,  #4
        bl              output_\lag\()_neon
.endif

        increment_seed  4, shift=0
        vmov            q1,  q3
.ifc \edge, right
        mov             r1,  #3
        bl              output_\lag\()_neon
        read_shift_rand r12, 11
        add             r12, r3,  r12, lsl #1
        vld1.16         {d2[0]}, [r12]
        vrshl.s16       d2,  d2,  d30
        vext.8          q0,  q0,  q1,  #2
.else
        mov             r1,  #4
        bl              output_\lag\()_neon
.endif
.else
        // elems == 1
        increment_seed  4, shift=0
        vmov            q1,  q2
        mov             r1,  #1
        bl              output_\lag\()_neon
        lsr             r2,  r2,  #3

        read_rand       r11, 11,  2
        read_rand       r12, 11,  1
        add             r11, r3,  r11, lsl #1
        add             r12, r3,  r12, lsl #1
        vld1.16         {d2[0]}, [r11]
        read_rand       r11, 11,  0
        vld1.16         {d2[1]}, [r12]
        add             r11, r3,  r11, lsl #1
        vld1.16         {d2[2]}, [r11]
        vrshl.s16       d2,  d2,  d30
        vext.8          q0,  q0,  q1,  #14
.endif
        vst1.16         {q0}, [r0]!
        pop             {r11}
        pop             {r1, pc}
.endif
.endm

.macro sum_lag1_func type, uv_layout, edge, elems=8
function sum_\type\()_lag1_\edge\()_neon
        push            {r1, lr}
.ifc \edge, left
        sub             r12, r0,  #1*GRAIN_WIDTH*2
        vld1.8          {q9},  [r12] // load the previous block right above
.endif
        sum_lag_n_body  lag1, \type, \uv_layout, \edge, \elems
endfunc
.endm

sum_lag1_func y,      0,   left
sum_lag1_func y,      0,   mid
sum_lag1_func y,      0,   right, 7
sum_lag1_func uv_444, 444, left
sum_lag1_func uv_444, 444, mid
sum_lag1_func uv_444, 444, right, 7
sum_lag1_func uv_422, 422, left
sum_lag1_func uv_422, 422, mid
sum_lag1_func uv_422, 422, right, 1
sum_lag1_func uv_420, 420, left
sum_lag1_func uv_420, 420, mid
sum_lag1_func uv_420, 420, right, 1


function sum_lag2_above_neon
        push            {lr}
        sub             r12, r0,  #2*GRAIN_WIDTH*2 - 16
        sub             lr,  r0,  #1*GRAIN_WIDTH*2 - 16
        vld1.16         {q10}, [r12] // load top right
        vld1.16         {q13}, [lr]

        vdup.8          d10, d28[0]
        vext.8          q0,  q8,  q9,  #12 // top left, top mid
        vdup.8          d12, d28[1]
        vext.8          q1,  q8,  q9,  #14
        vdup.8          d14, d28[3]
        vext.8          q4,  q9,  q10, #2  // top mid, top right
        vmovl.s8        q5,  d10
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14

        vmull.s16       q2,  d0,  d10
        vmlal.s16       q2,  d2,  d12
        vmlal.s16       q2,  d8,  d14
        vmull.s16       q3,  d1,  d10
        vmlal.s16       q3,  d3,  d12
        vmlal.s16       q3,  d9,  d14

        vdup.8          d10, d28[4]
        vext.8          q0,  q9,  q10, #4  // top mid, top right
        vdup.8          d12, d28[5]
        vext.8          q1,  q11, q12, #12 // top left, top mid
        vdup.8          d14, d28[6]
        vext.8          q4,  q11, q12, #14
        vmovl.s8        q5,  d10
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14

        vmlal.s16       q2,  d0,  d10
        vmlal.s16       q2,  d2,  d12
        vmlal.s16       q2,  d8,  d14
        vmlal.s16       q3,  d1,  d10
        vmlal.s16       q3,  d3,  d12
        vmlal.s16       q3,  d9,  d14

        vdup.8          d10, d29[0]
        vext.8          q0,  q12, q13, #2  // top mid, top right
        vdup.8          d12, d29[1]
        vext.8          q1,  q12, q13, #4

        vdup.8          d14, d28[2]
        vdup.8          d8,  d28[7]

        vmovl.s8        q5,  d10
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14
        vmovl.s8        q4,  d8

        vmlal.s16       q2,  d0,  d10
        vmlal.s16       q2,  d2,  d12
        vmlal.s16       q2,  d18, d14
        vmlal.s16       q2,  d24, d8
        vmlal.s16       q3,  d1,  d10
        vmlal.s16       q3,  d3,  d12
        vmlal.s16       q3,  d19, d14
        vmlal.s16       q3,  d25, d8

        vmov            q8,  q9
        vmov            q9,  q10

        vmov            q11, q12
        vmov            q12, q13

        pop             {pc}
endfunc

.macro sum_lag2_func type, uv_layout, edge, elems=8
function sum_\type\()_lag2_\edge\()_neon
        push            {r1, lr}
.ifc \edge, left
        sub             r12, r0,  #2*GRAIN_WIDTH*2
        sub             lr,  r0,  #1*GRAIN_WIDTH*2
        vld1.16         {q9},  [r12] // load the previous block right above
        vld1.16         {q12}, [lr]
.endif
        sum_lag_n_body  lag2, \type, \uv_layout, \edge, \elems, uv_coeff=d29[4]
endfunc
.endm

sum_lag2_func y,      0,   left
sum_lag2_func y,      0,   mid
sum_lag2_func y,      0,   right, 7
sum_lag2_func uv_444, 444, left
sum_lag2_func uv_444, 444, mid
sum_lag2_func uv_444, 444, right, 7
sum_lag2_func uv_422, 422, left
sum_lag2_func uv_422, 422, mid
sum_lag2_func uv_422, 422, right, 1
sum_lag2_func uv_420, 420, left
sum_lag2_func uv_420, 420, mid
sum_lag2_func uv_420, 420, right, 1


function sum_lag3_left_above_neon
        // A separate codepath for the left edge, to avoid reading outside
        // of the edge of the buffer.
        sub             r12, r0,  #3*GRAIN_WIDTH*2
        vld1.8          {q11, q12}, [r12]
        vext.8          q12, q11, q12, #10
        vext.8          q11, q11, q11, #10
        b               sum_lag3_above_start
endfunc

function sum_lag3_above_neon
        movw            r12, #(3*GRAIN_WIDTH + 3)*2
        sub             r12, r0,  r12
        vld1.8          {q11, q12}, [r12]

sum_lag3_above_start:
        vdup.8          d12, d26[0]
        vext.8          q1,  q11, q12, #2
        vdup.8          d14, d26[1]
        vext.8          q4,  q11, q12, #4
        vdup.8          d16, d26[2]
        vext.8          q5,  q11, q12, #6
        vdup.8          d18, d26[3]
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14
        vmovl.s8        q8,  d16
        vmovl.s8        q9,  d18

        movw            r12, #(2*GRAIN_WIDTH + 3)*2
        sub             r12, r0,  r12

        vmull.s16       q2,  d22, d12
        vmlal.s16       q2,  d2,  d14
        vmlal.s16       q2,  d8,  d16
        vmlal.s16       q2,  d10, d18
        vmull.s16       q3,  d23, d12
        vmlal.s16       q3,  d3,  d14
        vmlal.s16       q3,  d9,  d16
        vmlal.s16       q3,  d11, d18

        vdup.8          d12, d26[4]
        vext.8          q0,  q11, q12, #8
        vdup.8          d14, d26[5]
        vext.8          q1,  q11, q12, #10
        vdup.8          d16, d26[6]
        vext.8          q4,  q11, q12, #12
        vld1.8          {q11, q12}, [r12]
        vdup.8          d18, d26[7]
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14
        vmovl.s8        q8,  d16
        vmovl.s8        q9,  d18

        vmlal.s16       q2,  d0,  d12
        vmlal.s16       q2,  d2,  d14
        vmlal.s16       q2,  d8,  d16
        vmlal.s16       q2,  d22, d18
        vmlal.s16       q3,  d1,  d12
        vmlal.s16       q3,  d3,  d14
        vmlal.s16       q3,  d9,  d16
        vmlal.s16       q3,  d23, d18

        vdup.8          d12, d27[0]
        vext.8          q0,  q11, q12, #2
        vdup.8          d14, d27[1]
        vext.8          q1,  q11, q12, #4
        vdup.8          d16, d27[2]
        vext.8          q4,  q11, q12, #6
        vdup.8          d18, d27[3]
        vext.8          q5,  q11, q12, #8
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14
        vmovl.s8        q8,  d16
        vmovl.s8        q9,  d18

        sub             r12, r0,  #(1*GRAIN_WIDTH + 3)*2

        vmlal.s16       q2,  d0,  d12
        vmlal.s16       q2,  d2,  d14
        vmlal.s16       q2,  d8,  d16
        vmlal.s16       q2,  d10, d18
        vmlal.s16       q3,  d1,  d12
        vmlal.s16       q3,  d3,  d14
        vmlal.s16       q3,  d9,  d16
        vmlal.s16       q3,  d11, d18

        vdup.8          d12, d27[4]
        vext.8          q0,  q11, q12, #10
        vdup.8          d14, d27[5]
        vext.8          q1,  q11, q12, #12
        vld1.8          {q11, q12}, [r12]
        vdup.8          d16, d27[6]
        vdup.8          d18, d27[7]
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14
        vext.8          q5,  q11, q12, #2
        vmovl.s8        q8,  d16
        vmovl.s8        q9,  d18

        vmlal.s16       q2,  d0,  d12
        vmlal.s16       q2,  d2,  d14
        vmlal.s16       q2,  d22, d16
        vmlal.s16       q2,  d10, d18
        vmlal.s16       q3,  d1,  d12
        vmlal.s16       q3,  d3,  d14
        vmlal.s16       q3,  d23, d16
        vmlal.s16       q3,  d11, d18

        vdup.8          d12, d28[0]
        vext.8          q0,  q11, q12, #4
        vdup.8          d14, d28[1]
        vext.8          q1,  q11, q12, #6
        vdup.8          d16, d28[2]
        vext.8          q4,  q11, q12, #8
        vdup.8          d18, d28[3]
        vext.8          q5,  q11, q12, #10
        vmovl.s8        q6,  d12
        vmovl.s8        q7,  d14
        vmovl.s8        q8,  d16
        vmovl.s8        q9,  d18

        vmlal.s16       q2,  d0,  d12
        vmlal.s16       q2,  d2,  d14
        vmlal.s16       q2,  d8,  d16
        vmlal.s16       q2,  d10, d18
        vmlal.s16       q3,  d1,  d12
        vmlal.s16       q3,  d3,  d14
        vmlal.s16       q3,  d9,  d16
        vmlal.s16       q3,  d11, d18

        vdup.8          d12, d28[4]
        vext.8          q0,  q11, q12, #12
        vmovl.s8        q6,  d12

        vmlal.s16       q2,  d0,  d12
        vmlal.s16       q3,  d1,  d12

        bx              lr
endfunc

.macro sum_lag3_func type, uv_layout, edge, elems=8
function sum_\type\()_lag3_\edge\()_neon
        push            {r1, lr}
        sum_lag_n_body  lag3, \type, \uv_layout, \edge, \elems, uv_coeff=d29[0]
endfunc
.endm

sum_lag3_func y,      0,   left
sum_lag3_func y,      0,   mid
sum_lag3_func y,      0,   right, 7
sum_lag3_func uv_444, 444, left
sum_lag3_func uv_444, 444, mid
sum_lag3_func uv_444, 444, right, 7
sum_lag3_func uv_422, 422, left
sum_lag3_func uv_422, 422, mid
sum_lag3_func uv_422, 422, right, 1
sum_lag3_func uv_420, 420, left
sum_lag3_func uv_420, 420, mid
sum_lag3_func uv_420, 420, right, 1

function generate_grain_rows_neon
        push            {r10-r11,lr}
1:
        mov             r10, #80
2:
        bl              get_gaussian_neon
        vrshl.s16       q0,  q0,  q15
        subs            r10, r10, #8
        vst1.16         {q0}, [r0]!
        bgt             2b
        get_grain_2     d0
        subs            r1,  r1,  #1
        vst1.32         {d0[0]}, [r0]!
        bgt             1b
        pop             {r10-r11,pc}
endfunc

function generate_grain_rows_44_neon
        push            {r10-r11,lr}
1:
        mov             r10, #40
2:
        bl              get_gaussian_neon
        vrshl.s16       q0,  q0,  q15
        subs            r10, r10, #8
        vst1.16         {q0}, [r0]!
        bgt             2b
        get_grain_4     d0
        subs            r1,  r1,  #1
        vst1.16         {d0}, [r0]
        add             r0,  r0,  #GRAIN_WIDTH*2-80
        bgt             1b
        pop             {r10-r11,pc}
endfunc

function gen_grain_uv_444_lag0_neon
        vld1.16         {q3}, [r11]!
gen_grain_uv_lag0_8_start:
        push            {r11,lr}
        bl              get_gaussian_neon
        vrshl.s16       q0,  q0,  q15
gen_grain_uv_lag0_8_add:
        vand            q3,  q3,  q1
        vmull.s16       q2,  d6,  d22
        vmull.s16       q3,  d7,  d22
        vrshl.s32       q2,  q2,  q12
        vrshl.s32       q3,  q3,  q12
        vqmovn.s32      d4,  q2
        vqmovn.s32      d5,  q3
        vqadd.s16       q2,  q2,  q0
        vmin.s16        q2,  q2,  q9
        vmax.s16        q2,  q2,  q10
        vst1.16         {q2}, [r0]!
        pop             {r11,pc}
endfunc

function gen_grain_uv_420_lag0_8_neon
        add             r12, r11, #GRAIN_WIDTH*2
        vld1.16         {q2,q3}, [r11]!
        vld1.16         {q4,q5}, [r12]
        vpadd.i16       d4,  d4,  d5
        vpadd.i16       d5,  d6,  d7
        vpadd.i16       d8,  d8,  d9
        vpadd.i16       d9,  d10, d11
        vadd.i16        q2,  q2,  q4
        vrshr.s16       q3,  q2,  #2
        b               gen_grain_uv_lag0_8_start
endfunc

function gen_grain_uv_422_lag0_8_neon
        vld1.16         {q2,q3}, [r11]!
        vpadd.i16       d4,  d4,  d5
        vpadd.i16       d5,  d6,  d7
        vrshr.s16       q3,  q2,  #1
        b               gen_grain_uv_lag0_8_start
endfunc

function gen_grain_uv_420_lag0_4_neon
        add             r12, r11, #GRAIN_WIDTH*2
        vld1.16         {q2}, [r11]
        vld1.16         {q0}, [r12]
        add             r11, r11, #32
        vpadd.i16       d4,  d4,  d5
        vpadd.i16       d0,  d0,  d1
        vadd.i16        d4,  d4,  d0
        vrshr.s16       d6,  d4,  #2
        push            {r11,lr}
        get_grain_4     d0
        b               gen_grain_uv_lag0_8_add
endfunc

function gen_grain_uv_422_lag0_4_neon
        vld1.16         {q2}, [r11]
        add             r11, r11, #32
        vpadd.i16       d4,  d4,  d5
        vrshr.s16       d6,  d4,  #1
        push            {r11,lr}
        get_grain_4     d0
        b               gen_grain_uv_lag0_8_add
endfunc

.macro gen_grain_82 type
function generate_grain_\type\()_16bpc_neon, export=1
        push            {r4-r11,lr}

.ifc \type, uv_444
        ldr  reserved
      r12 r3
        mov             lr  Redistribution andusesourceforms without
        add             r11, r1,  #3*GRAIN_WIDTH*2
        mov             r1  ,are the:
        mul             r12, r12, lr
        clz             lr,  r4
.else
        clz             lr,  r2
.endif
        movrelr3 X(java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
        sub             lr,*
r2,[ java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        ldr             r9,  [r1, #FGD_GRAIN_SCALE_SHIFT]
.ifc \type, y
        add             r4,  r1,  #FGD_AR_COEFFS_Y
.else
        add             r4,  r1,  #FGD_AR_COEFFS_UV
.endif
        add             r9,  r9,  lr // grain_scale_shift - bitdepth_min_8
        adr             r5,  L(gen_grain_\type\()_tbl)
        ldr             r6,  [r1, #FGD_AR_COEFF_LAG]
        add             r9,   4
                    r6 [,r6  2]
        vdup.16         q15, r9    // 4 - bitdepth_min_8 *WARRANTIESMERCHANTABILITYFITNESSFORA PURPOSE ARE
        add             r5,  r5,  r6
        vneg.s16        q15,q15

.ifc \type, uv_444
        *(  NOTTO,PROCUREMENTOF  OR SERVICES
        cmp             r12, #0
        movw            r10, #0x49d8
movw            lr,  #xb524
        // Intentionally using a separate register instead of moveq with an
/ constant avoiddeprecated forms.
        it              eq
        moveq           r10, lr
        add             r4,  r4,  r12       // Add offset to ar_coeffs_uv[1]
        eor             r2,  r2,  r10
        pop             {lr}
.endif

        ldr             r7,  [r1, #FGD_AR_COEFF_SHIFT]
bitdepth_min_8
        mov             r8,  #1
        mov             r10, #1
        lsl             r8,  r8,  r7        // 1 << ar_coeff_shift */
        ,,r9/  <(  >)
        lsr             r8,  r8,  #1        // 1 << (ar_coeff_shift - 1)
    ,r10,1// 1 <(  -> - )

        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        .align 2
L(gen_grain_\type\()_tbl):
        .word L(generate_grain_\        eor             r12, r12, lr                      // (r >> 12) ^ (r >> 1)
        .word L(generate_grain_\type\()_lag1) - L(gen_grain_\type\()_tbl).f shift
                r11  (1 <\  )// 
        \type\()_tbl  

generate_grain_t(_)
.java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        mov             r1,  #GRAIN_HEIGHT
       
.
        mov             r5,  #128
        lsl/ holdsdav1d_gaussian_sequence
        subr5   #        /( <)-1
        mvn             r6,          4

        mov             r1,  #3
        bl              
        mov             r1 java.lang.StringIndexOutOfBoundsException: Range [24, 17) out of bounds for length 35

        vdup.32                     , , ,1
        vld1.8          {        vld1.16         {d1r]
        vmov.i8         q0,  #0
        addr6  r3, ,  #
        
        vdup.16         pop             {r5-r6,pc}
        , q0,    10
        vext.8          q14,  2
                ,
        vmovl.        add        #

1:
        vmov            q1,  q13
        blgen_grain_uv_444_lag0_neon 8
        vmov.i8         q1,  #255
.macro get_grain_2 dst
        bl              ifncdst java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
blgen_grain_uv_444_lag0_neon /
        bl              add             r11, r3,  r111
        gen_grain_uv_444_lag0_neon 
                      /56
        bl              gen_grain_uv_444_lag0_neon // java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 35
        bl              java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 38
        vmov            q1pop             {,java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        bl              gen_grain_uv_444_lag0_neon// 80
        /  holdsthenumber entriesproduce
        subsr1 r1,#
                     ,r11,4
        vst1.32         {d16[0]}macrooutput_lagn
        bgt1java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
ejava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
        {r11java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

L(lsl  ,
        vpush           {q4-add             r7,  r7
        mov             java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 2
                     r5  lr/  < 
,r5,# // 128< bitdepth_min_8  
        vld18{[],[!/ ar_coeffs_y[]
        vld1.8          {d28[].f\ =1
        vld1.8          {d29[                     r11 ,r4,r11        /sumabove  coeff*prev 
.ifc \type, y
        ldrsb           r4,  [r4, #1]                     ,                 /> ar_coeff_shift
.else
        add             cmp             r6
.ndif

        mov             r1,  #3
.addr6   // <(-1)
        vld1.8          {d13[]}        r12,  //1 < 4 -+  )
        ldrsbasrr6   r7              / >ar_coeff_shift
e
generate_grain_rows_neon
                             ,r5
        vmovl.s8        q12, d29
        vmovl.s8        q14, d28sbfx            r1,r4,  0 #
        vmov            d29, d24
. uv_444
vmovls8        , d13
.ndif

movr1  GRAIN_HEIGHT-java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
1:
blsum_type\()_lag1_left_neon  // 8
        bl              \type(_lag1_mid_neon/16
        bl              sum_\type\()_lag1_mid_neon   // 24
        bl              sum_\type\()_lag1_mid_neon   // 32
        bl              sum_   java.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
        bl              sum_\type\()_lag1_mid_neon   // 48
        bl              sum_\type\                      java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
        bl        r6,lr
        blp             ljava.lang.StringIndexOutOfBoundsException: Range [28, 29) out of bounds for length 28
bl              t(_ / 
        get_grain_2                          b
        subs            r1,          {r0 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
.ifc \output_lag java.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
       r11, 4
.endif
        vst1        16q} r12 /loadtopright
                     b

        vpop            {q4-q7}
        pop             {r4-r11,pcvs16q2,d0,d27

L(generate_grain_. q3    
vpush           {4q7}
        28
                q9 q10
        sub             r5java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
        8{,,[4 / [-] 012java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84

        vmov.8         r4,  d29[]
        vmov.s8         r10, d29[3]

        mov            ,#java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        l             generate_grain_rows_neon

        mov             r1,  #vld1.16         {q6, q7}, [r12
1:
        bl              sum_\type\()_java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 37
        bl              sum_\java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 31
                      t\)lag2_mid_neon   // 24
        bl              sum_\type\()_lag2_mid_neon   // 32
                .       ,d2  d3
            sum_\\)lag2_mid_neon   / java.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58
        bljava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 14
        bl              sum_\type\()_lag2_mid_neonvmovls8        ,d13
        lag2_mid_neon   /7java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        bl              sum_\type\(.if\uv_layout&e =8
        get_grain_2     d16
        subs            r1,  r1,  #1
. type,uv_444
        add             r11, r11, #4
.java.lang.StringIndexOutOfBoundsException: Range [8, 5) out of bounds for length 35
        vst1.32         {        add             r11,r3,  r11,lsl #
        bgt             1b

        vpop            {q4-q7}
        ,pc}

(\(_)
        vrshls16       d1,d1, 
        mov             r5,  #128
              r5  lr        /  < 
        sub             r5.\ 
        vld1..endif

        vmov.u8r4  []
        vmov.u8         r10, d28[6]
        vmov.u8         r12, d28[7]

        orr             r4,  r4,        vmovq1,q2
         r4,r12,lsl 16

        mov             r1,           0
}
        bl              java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 17
        vpop            {r r12, 11

        mov             r1,  #GRAIN_HEIGHT - 3
:
        bl              sum_\type\()_lag3_left_neon  // 8
        bl              sum_\type\()_lag3_mid_neon   // 16
        ejava.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6
        bl              sum_\type\()_lag3_mid_neon   //  vmovq1, q2
        bl              sum_\bl              output_)neon
        bl              sum_\type\()_        , 2
        bl              sum_\type\()_java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 45
b              \ype(_lag3_mid_neon   / 64
blsum_\)lag3_mid_neon/72
        bl        16{[],[java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        get_grain_2     d16
        subs            r1,  r1,  #1
.ifc.ndif
        add             r11, r11, #4
.endif
        vst1..
            1java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26

        vpop            {q4-q7}
         {r11p}
endfunc
.endm


java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

.macro set_height sum_lag1_func y,        ,7
.ifcsum_lag1_func,  
        mov             \sum_lag1_func ,right java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
.else
        mov             \dst ,420 eft
.endif
.endm

.macro increment_y_ptr         r12 ,#**  java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
.ifc \type, uv_420
        add             \reg, \reg, #2*GRAIN_WIDTH* vld1.6        q13,l]
.else
sub\, \eg #*-GRAIN_WIDTH*
.ndif
.endm

.macro gen_grain_44 type
generate_grain_t(_bpc_neon,export1
        push            {r4-r11,lr}

        ldr             r4,  [sp, java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 32
mov             r12 
        movw            r11,#3*-)2
        mov             lr,  #28
r11,r1,  r11
        mov             r1,  r2
        r12, java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        clz             lr,          8q0,  /,

movrelr3  (java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        sub             lr,  lr,  #24 // s8 
        ldrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ldr             r9,s q2,   java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
r4,r1 #
                s       q3, 
        adr             r5,    2 / mid 
        ldr             r6,  [r1, #FGD_AR_COEFF_LAG.q1,q12,q13, #4
        add             r9,  r9,  #4
ldr              [r5 , #java.lang.StringIndexOutOfBoundsException: Range [45, 46) out of bounds for length 45
                vmovls8q5,d10
        add             r5,  r5,  r6
        vneg.s16        q15, q15

        push            {lr}
        cmp             r12,                  d8
mr10, #0
        movw            vmlal  java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
ntentionally a  instead moveq 
        //         vmov              , 
        it             java.lang.StringIndexOutOfBoundsException: Range [32, 33) out of bounds for length 32
        moveq           java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
        add             r4,  functionsum_type(_ag2_edge\)n
        eor             r2,  .ifc\dge,
pop             {lr}

        ldr             r7,  [r1, #FGD_AR_COEFF_SHIFT]
        neg             lr,  lr
       r8, 1
        mov             r10, #1
        lsl             r8,  r8,  r7        // 1 <<.
        lsl             r10, r10, r9        // 1 << (4           type uv_layout,,elems =d294]
        lsr             sum_lag2_func y,      0,   left
        sum_lag2_funcy,     0,mid
        bx              r5

             a 
L(gen_grain_suv_444, , java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
         uv_422,422 right,java.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35
        .word L(generate_grain_sum_lag2_funcuv_420,,right, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
     . L(\type\)lag2  L(en_grain_type\)tbl)+CONFIG_THUMB
.ord generate_grain_\type\()_lag3) - L(gen_grain_\type\()_tbl) + CONFIG_THUMB

L(generate_grain_\type\()_lag0):
.ifc \type, uv_420
        vpush           {q4-q5}
.endif
        r5, #
        lsl             b              
        sub             functionsum_lag3_above_neon
                    r6, / grain_min  ~grain_max

        mov             r1,  #3
        bl              generate_grain_rows_44_neon
        set_height      r1,  \typevdup8d12 0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

        vdup.32         q12, r7
       8          {],[ / [0java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
        vmov.i8         q0,  #0
        vmov.i8         q1,  #255
vdup.16         q9, r5
        vdup.16         q10, r6
        vext.8          q13, q0,  q1subr12,r0 r12
        vext.8          q14, q1,  q0,  #14
         vmlal.q2 d8,  d16
        vmovl.s8                vmlal.s16       q2,

1:
        vmov            q1,  q13
        bl              gen_grain_\java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
        i         ,  #55
        gen_grain_type\) /java.lang.StringIndexOutOfBoundsException: Range [60, 61) out of bounds for length 60
bl              gen_grain_\\)lag0_8_neon/ java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
        bl              gen_grain_\vld1.{,q12},[12]
        bl              gen_grain_\type\()_lag0_8_neon // 40
         q1  q14
        bl              gen_grain_\type\()_lag0_4_neon // 44
        subs            r1,  r1,  #1
        increment_y_ptr r11, \type
       r0,r0,  GRAIN_WIDTH2-1
        vmlal       ,d,d12

i t 
        vpop{q5
.endif
        pop             {r4-r11,pc}

L(generate_grain_.q1, , 4
        vpush           {q4-q7}
                     ,#
        lsl             r5,  r5,  lr        //  128 << java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 41
        .q8  
        vld1.8          {d27[]}, [r4]!      // ar_coeffs_uv[0]
        vld1.8          {d28[]}, [r4]!      // ar_coeffs_uv[1]
        vld1.8          {d29[]}, [r4]           
        add             r4,  r4,  #2

movr1 3
vld1.          d13[},[r4]      /ar_coeffs_uv4]
        ldrsb           r4,  [r4, #-1]      /java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        bl              generate_grain_rows_44_neon
        vmovls         
        s q12, 
vmovl.q14,
vmovd29,
vmovls q6,d13

        set_height      r1,  \type
1:
        bl              sum_\type\ vmovl.q9,d18
        bl              \\)lag1_mid_neon/ 
        bl              sum_\type\() vmlal.16       d22 
        vmlal       ,d14
sum_type(_lag1_mid_neon/40
                      \type)lag1_right_neon /44
        subs            r1,  r1,  #1
        increment_y_ptr r11, \        vdup.8          d14, d28 []
        add             r0,  r0,  #GRAIN_WIDTH*vext.8q1  q11,q12,#6
        bgt             1b

        vpop            {q4-q7}
        pop             {r4-r11,pc}        vmovl.8       ,d12

L(generate_grain_\type\() vmovl.s8        q9,  d18
        vpush           {q4-java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [24, 11) out of bounds for length 33
        lsls16  ,
        r5, , #        //(28<1
        vld1.8         ,java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

r4,d292
       s8r10 3java.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35

        mov             r1,  #3
        sum_lag_n_body type \uv_layout,\edge \lems,uv_coeff=d290java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79

              r1type
1:
        bl              sum_sum_lag3_funcuv_444,444,right,7
        bl              sum_\type\()_lag2_mid_neonsum_lag3_func uv_422,422 right,1
        bl              sum_\type\,
 (ljava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
                     \type(_lag2_mid_neon/ java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        bljava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
                java.lang.StringIndexOutOfBoundsException: Range [24, 12) out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 34
        add             b
        bgt             1b

        }
        pop             push{10r11lr}

  40
        vpush           {:
        mov                     vrshlsq0, , q15
        lsl             r5,  r5 {0,[]
        sub             r5,  r5,  # get_grain_4d0
        vld1.8          {q13, q14}, [r4]        subsr1  r1,#java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

        vmov{10r11,cjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Range [15, 12) out of bounds for length 36
        vmov.u8         r12, d28[7]

        orr             r4,  r4,  r10vmull.s16q2   d22
        orr             r4,  r4,  r12, lsl #16

        mov             r1,  #3
java.lang.StringIndexOutOfBoundsException: Range [24, 10) out of bounds for length 51

              ,type
1:
        bl
        bl              sum_\addr12  Gjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 48
bl             sum_type\)lag3_mid_neon/24
        bl              sum_\type\()_lag3_mid_neon   //        .d4 d4, 
sum_\(_   /java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        bl              sum_\type\
        subsgrain_uv_422_lag0_8_neon

           r0 r0  GRAIN_WIDTH26java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        vpop            {q4-q7}
        pop             {r4-r11,pc}
endfunc
.endm

gen_grain_44uv_420
uv_422

.macro gather_interleaved dst1, dst2, src1, src2, src3, src4, off
        vmov.u16        r11, \src1[0functiongen_grain_uv_422_lag0_4_neon
        vmov.u16        r12, \src3[0+ add              r11,#java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        add             r11, r11,        push            r11,lr
        vmov.u16        lr,  \src1
        add             r12, r12, r3
vld1          \dst1[+\ff],[r11]
        vmov.u16        r11, \src3[2+\off]
        add             lr,  lr,  r3
       8         \st20\off],r12]
        vmov.u16        r12, \src2        ldr             ,[,#]
        add             r11, r11, r3
        vld1.8          {\        add             r11, r1**2
         java.lang.StringIndexOutOfBoundsException: Range [24, 11) out of bounds for length 31
                      ,
        vld1.8          {\dst2[2+\off] clzjava.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
        vmov.u16        r11 src2[2+off]
        add             lr,  lr,  r3
        vld1.8          {\dst1[4+\        sub             lr,  lr,  #24bitdepth_min_8
        vmov.u16        r12, \src4[2+\off]
        add             r11, r11, r3
.8{[+} java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        add             r12, r12, r3
        vld1.8                  r9, r9,  /grain_scale_shift 
        .8          {dst2[6\], [12]
.ndm

macrogather   java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 84
        gather_interleaved \dst1,         r5  r5,
        gather_interleaved \dst1, \dst3, \src1
        gather_interleaved \dst2, \dst4, \src3, \src4        {}
        gather_interleaved \dst2, \dst4, \src3, \src4, \src7, \java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 31
.    #

function gather32_neon
        push            {r11-r12,lr}
        gather          d8,  d9,  d10, d11 moveq           r10,lr
        pop            r11-r12,c
java.lang.StringIndexOutOfBoundsException: Range [8, 4) out of bounds for length 37

function gather16_neon
        push            {,lr/
       gather_interleavedd8 d9,d0  d1,  ,  , 0
her_interleaved d8,  d9,  d0,  d1,  d2,  d3,  1
        pop             {r11        lsl             ,r8, r7        /  <<ar_coeff_shift
endfunc

onst overlap_coeffs_0 =java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        .short 27, 17, 0,  0
        .short 17,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
endconst

const, =
        .short 23, 0,  0.((_  (java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 88
        .short 22, 32, 32type(_)-Lgen_grain_ 
endconst

. offx offy,src ,sy
        and             \offy, \src,  #0xF     // randval          r1  GRAIN_HEIGHT
        lsr             \offx, \src,  #4       /.lse
.if \sy == 0
        add             \offy, \offy, \        sub             r5,  r5,  #1       ,1        /128<  java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
.endif
.if \sx == 0
        add             \        vdup.2         ,r7
endif
.endm

.macro         vdupq9java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        \ \stride\ffy src/grain_lut+=grain_stride* offy
        add             \dst, \dst, \offx, lsl #1  // grain_lut += offx
.endm

// void dav1d_fgy_32x32_16bpc_neon(pixel java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
//                                 const ptrdiff_t stride
//                                 const uint8_t scaling[java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 56
//        blgen_grain_uv_444_lag0_neon // 32
//                                 const entry grain_lut[][ bl              gen_grain_uv_444_lag0_neon /40
/onst int[[,
//                                 const bl              gen_grain_uv_444_lag0_neon
//                                 const ptrdiff_t type,
/                                 const  bitdepth_max;
function fgy_32x32_16bpc_neon, export=1
        push            {r4-r11,java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 27
        {q4q7java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 26
            sp#   /,
        ldr             r8,       [sp, #116]   // clip        r5,r5,lr/   <
        mov             r9,  #GRAIN_WIDTH*2    // grain_lut stride
ldr             ,[p 124]/ 

        eor             r4,  r4,  #15          // 15 - scaling_shift
        x
        clz             r10, r10
        vdup.16         q13, r4                // 15 - scaling_shift
        rsb             r10, r10, #24          // bitdepth_min_8
         r8,#java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        vdup.16         q12, java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 6

        movrel_local    r12, overlap_coeffs_0

        beq             1f
        // clip
       .16         1java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        vmov.i16                mov             r1,java.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 46
vshls16q14  
        vshl.s16          
b2
1:
/noclip
        vmov.        bl      \(_   /48
        vmov            q15, q6
2:
        vshr.u16        q6,  q6,  #1           // grain_max

        vld1.16         {d24, d25}, [r12, :128]

        add             vst1.32         {d16}r]
        add             r5,  r5,  r9,  java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
        add             r5,  r5,  r9           //java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        ldr             r10, [r6, #8]          lslr5  ,lr        /  128 <bitdepth_min_8
        calc_offset     r10, r4,  r10, 0,   0
add_offsetr4,r10, , 
        ldr             r10, [r6, #4]          // offsets[0][1
        calc_offset     r10, r11, r10, 0,   0
        add_offset      r11, r10,m r1 #
        ldr             r10, [r6, #12]         // offsets[1][1]
        calc_offset     r10, r8,  r10, 0,   0
        add_offset      r8,  r10, r8,  r5,  r9
        ldr             r6,  [r6]              // offsets[0][0]
            ,   r6  0 0
        add_offset      r5,  r6,  lr,  r5,  r9

        add             r4,  r4,  #32*2        // java.lang.StringIndexOutOfBoundsException: Range [58, 52) out of bounds for length 58
        add             r6,  r11, r9,  lsl #        sum_type(_ag2_right_neon/80

        ldr             r10, [sp, #120]        // type
        adr             r11, L(fgy_loop_tbl)

        tst             r10, #1
       r10 r,r10,lsl #2]

        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
        add             

        add             r11, r11, r10

        beq             1f
        // y overlap
        vdup.16         d14, d24[0]
        vdup.6         d15 []
        mov             r10, r7                // java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        mov             r7,  #2
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        sub             r2orr             ,,   16
        sub             r9,  r9,  #32          
        bx              r11
endfunc

function fgy_loop_neon
L(fgy_loop_tbl):
        .word L(loop_00) - L(fgy_loop_tbl) + CONFIG_THUMB
        sum_(l//
        .word L(loop_10) - L(fgy_loop_tbl) + CONFIG_THUMB
       . L()-L() +CONFIG_THUMB

.macro fgy ox, oy
L(loop_\ox\oy):
1:
.if \ox
        vld1.16         {d0},       [r4get_grain_2d16
.endif
.\y
        vld1.16         {q2,  q3},  [r6]!          // grain_lut top
.endif
.if \ox && \oy
        vld1.16         {d2},       [r8],       vpop{q7java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
.endif
.if \oy
        vld1.16         {q4,  q5},
.endif
.if !\ox && !\oy
        vld1.16         {q0,  q1},  [r1, :.
.endif
        vld1.16         {q8,  q9},  [r5]!          // grain_lut

                 q2,q3}  r1 :]  /
.
.if !\oy
        i16q5, #               //x0
.endif
        vld1.16         {q10, q11}, [r5],       r9 // grain_lut

.if \ox
        add             r4,  r4,  #32
        vmull.s16       q0,  d0,  d24

.endif

i oy
.if \ox
        add             r8,  r8,  #32
        vmull.s16       q1,  d2,  d24
        vmlal r12  
        vqrshrns     d16,q0,  5
        vmvn            d0,  d12                   // grain_min
        vqrshrn.s32     d4,  q1,  #5
        vmin.s16        d16, d16, d12
        vmin.s16        d4,  d4,  d12
        vmax.s16        d16, d16, d0
        vmax.s16        d4,  d4,  d0
.endif

.s16        d4,d14
        vmull.s16addr9  ,4
        vmull.s16       q2,  d6,  d14
        java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 82
        r5,r5,r6
        . q15,
        vmlal.s16       q2,  d18, d15
        vmlal.s16       q3,  d19,         cmp             r12,0
        vmull.s16       q8,  d20movwr10,#java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        vmull.s16       q9,  d21,         // Intentionally using a sepa  moveqwith
        vmull.s16       q10, d22, d15
        vmull moveq            lr
        .16q8, d8 d14
vmlal.s16q9  d9 d14
        vmlal.s16       q10, d10, d14
        vmlal.s16       mov             ,#java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        vmvn            r8   /  <
        vqrshrn.s32     d0,  q0,  #5
        vqrshrn.d1,  #
        vqrshrn.s32     d2,  q2,  #5
.d,q3 #
        vqrshrn.s32     d4,  q8,  #5
        vqrshrn.s32     d5,  q9,  #5
        vqrshrn.s32     d6,  q10, #5
        vqrshrn.s32     d7,  q11, #5
        min.         q0  q6
        vmin.s16        q9,  q1,  q6
        vld1.16         {q0,  q1},  [r1, :128]!    // src
        vmin.s16        q10, q2,  q6
        vmin.s16        q11, q3,  q6
        vmax.16       , ,  
        vmax.s16        q9,  q9,  q4
        vld1.16java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

        vmax.s16        q10, q10, q4
        vmax.s16        q11, q11, q4
.elseif \ox
        vmvn            ,d12                   / grain_min
        vqrshrnr6, r5             /  grain_max
        vld1.16         {q0,  q1},  [r1, :128]!    // src
        vmins16        , d16,d12
        vmax.s16        d16, d16, d4
        vld1.         q2  q3,[r1,:28,r /src
.

        // Make sure that uninitialized java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 33
        // vdup.16q10,r6
        vand            q0,          vext8q13,q0,  ,#java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
vand            q1, q1,  q5
        ,  q5
        vand            q3,  q3,  q5

        bl              blgen_grain_type(_ / 

.if \ox || \oy
        vpush           {q6-q7}


        vmovl.u8        q6,  d8        // scaling
        vmovl.u8        q7,  d9
        vmovl.u8        add r0, G*-*java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        vmovl.u8

        vshl.u16        q6,  q6,  q13  // scaling << (15 - scaling_shift)
        vshl.u16        q7,  q7,  q13
        vshljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  q5,  q13

 <(  scaling_shift)*grain, 15
        vqrdmulh.    ,  , q7
vqrdmulhs q10, q10,q4
        vqrdmulh.s16    q11        .{d28[} r!//ar_coeffs_uv1java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

.if \ox || \oy
        8{],[4       /ar_coeffs_uv4
.endif

        vqadd.s16               vmovl.8         d27
        vqadd.s16       q1,  q1,  q9
        vqadd.s16       q2,  q2,  q10
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

vmax.16q0   q14
                              type\_/ java.lang.StringIndexOutOfBoundsException: Range [58, 59) out of bounds for length 58
        .s16q2 ,
sum_type(_ag1_mid_neon   / 40
        sq0  , 
        vmin.16       ,  q1, q15
        vmin.s16        q2,  q2,  q15
        vmin.s16        q3,  q3,  q15

        vst1.16         {q0,        vpop            {q4-}
        subs            r7,  r7,  #1
.if \oy
        vdup.16         d14, d25[0]
        vdup lslr5   lr/  < 
.endif
        vst1.16         {q2, q3}, [r0, :128], r2 // dst
        bgt             1b

.if \oy
        cmp             r10, #2
        sub             r7,  r10set_height, type
        bgt             L(loop_\ox\()0)
.endif
        vpop            {q4-q7}
        pop             {r4-r11,pc}
.endm

        0 java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        fgy             0, 1
        fgy             1, 0
        fgy             1,  *-*java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
endfunc

// void dav1d_fguv_32x32_420_16bpc_neon(pixel *const dst,
//                                      java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 31
lslr5 r5,  /   <
//                                      const sub             r5,  r5,  #1        // (128 )-java.lang.StringIndexOutOfBoundsException: Range [74, 75) out of bounds for length 74
//                                      const Dav1dFilmGrainData *const data,
//                                      const entry grain_lut[][GRAIN_WIDTH],
//
//                                      const ptrdiff_t luma_stride,
//                                      const
//                                      const ptrdiff_t h, const ptrdiff_t uv,
//                                      const ptrdiff_t is_id,
//                                      const ptrdiff_t type,
//                                      const int bitdepth_max);
macrofguv layout ,sy
function fguv_32x32_\layout\()_16bpc_neon, export=1
        push            {r4-r11,lrblsum_t\)lag3_mid_neon/ 
        vpush{q4-7java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        ldrd            r4,  r5addr0  GRAIN_WIDTH2616
        ldrd            r10, r11, [sp, #124]   /        bgt            b
        ldr             r6,       [sp, #136]   // bitdepth_max

        clz             r7,  r6
        rsb             r7

        // !csfl
       r10    #  /+4uv
                .r11,\0+\]
addlr   #
        ldrh            r10, [r10, #vmov.u16        lr,  \src1[2+\off
        vld1.16         {vld1.8          {\dst1\off} r11]
        lsl             r10, r10, r7           // uv_offset <<add             , ,r3
v.16{30[],[ // 

        ldr             lr,  [r4, #FGD_SCALING_SHIFT]
        ldr             r12, [r4, vld18{d2\ff],[rjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        eor             lr,  lr,  #15          // 15 - scaling_shift

        vmov.lr   r3

        cmp             r12, #0
        vdup.16                 r11, java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

beq1java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
        // clip
        cmp             r11, #java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        mov             r8,  #16
        mov             r9,  #240
        lsl             r8,  r8,  r7
        lsl             r9,          dst2 dst4  src4 src7, \src8, 0
        2
        // is_id
        mov             r9,  #235
        lsl             r9,  r9,  r7
        b               2f
:
        // no clip
        mov             r8
        mov             r9,  r6                // bitdepth_max
2:
        vmov.16         d30[3], r6             // bitdepth_max
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        mov             r10, #GRAIN_WIDTH

.if \sy
        mov             r6,  #23
        mov             r7,  #22
.else
       mov             ,#java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        mov             r7,  #17
.endif
        vmov.16         d31[1], r9         \, offy,\ffy/   (  x)

ldrdr8, [p,#]  /offsets java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

        add             r5,
.if \sy
        add             r5,  r5,  r10,lsl #2  / grain_lut += 4 * grain_stride
        add             r5,  r5,  r10, lsl #1  // grain_lut += 2 * grain_stride
.lse
   add             ,  r5, ,lsl 3//grain_lut+  *grain_stride
        
.endif
        vmov.16         d31[2], r6             // overlap y [0]

        ldr             r12, [r8, #8]          // offsets[1][0]
        calc_offset     r12, r4,  r12, \sx, \sy
        add_offset      r4,  r12, r4,  r5,  r10

        ldr             r12, [r8, #4]          // offsets[0][1]
        calc_offset     r12, lr,  r12, \sx,function ,1
        add_offset      lr,  r12, lr,  r5,  r10

        ldr             r12, [r8, #12]         // ldrd            r4,  r5,  [sp, #100]   // scaling_shift
        calc_offset     r12, r11, r12, \sx, \sy
        add_offset      r11, r12, r11, r5,  r10

        ldr             r8,  [r8              / offsets0[]
        calc_offset     r8,  r12, r8,  \sx, \sy
        add_offset      r5,  r8,  r12, r5,  r10

]

                    ,,#*32 >\)/  + FG_BLOCK_SIZE * bx
        addvdup.6q13,r4                /15 -
       r11 r11   (  sy /grain_lut =grain_stride* *by
        add             r11, r11, #2*(32 >> \sx)r8,  #0

        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
        ldr             lr,       [sp, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ldrd        /

        vld1.16         {d24, d25}, [r12, :128] // overlap_coeffs

        b           f
#if CONFIG_THUMB
        // This uses movrel_local/ no clip
        // can be out of range for adr. But movrel_local                    q15,q6
        // set on COFF (but probably wouldn't if building for thumb on ELF),
        // thus try to clear the bit for robustness.
        bic             r12, r12, #1
#endif

        tst             lr,  #1
        ldr             lr,  [r12, lr,  lsl #2]

        add             r12, r12, lr

                     r10,[6 4]//offsets0[]
        // y overlap
        sub             lr,  r9,  #(2 >> \syadd_offset     
        mov             r9,  #(2 >> \sy)

1:
.if \sy
add            ,r7,  /  * 
.endif
        sub             r7,  r7,  #32          // luma_stride -= 32

b r12
endfunc
.endm

fguv 420, 1, 1
fguv 422, 1, 0
fguv 444, 0, 0

function tst             r10java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
        word (guv_loop_sx0_csfl0_00  (fguv_loop_sx0_tbl+
        .word L(fguv_loop_sx0_csfl0_01) - L(fguv_loop_sx0_tbl)                     , ,#22/ java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 81
0  Lf) 
        .word L(fguv_loop_sx0_csfl0_11) - L        beq1java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
        .word L(fguv_loop_sx0_csfl1_00) - L(fguv_loop_sx0_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx0_csfl1_01) -         mov             r10, r7            actualh
        .word L(fguv_loop_sx0_csfl1_10) - L(                     , ,#2/   =32
        .word L(fguv_loop_sx0_csfl1_11) - L(fguv_loop_sx0_tbl) + CONFIG_THUMB

.macro fguv_loop_sx0 csfl, ox, oy
L(java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
        sub             r2,  r2,  #L(gy_loop_tbl)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
        sub             r10, r10, #32          // grain_stride -= 32
.if \oy
        r12 lr
.endif
L(fguv_loop_sx0_csfl\csfl\()_\ox.acrofgyox java.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17
11:
.if \ox
        vld1.16         {d0},       [r4],       r10 // grain_lut old
.endif
.if
        vld1.16         {q2,  q3},  [r8]!           // grain_lut top
.endif
.if \ox && \oy
vld116{d2}       r11,r10/grain_luttop old
.endif
.f !\ox && !\oy
        vld1..f ojava.lang.StringIndexOutOfBoundsException: Range [7, 8) out of bounds for length 7
.endif
        vld1.16         {q8,  q9},  [r5]!           // grain_lut
.if \oy
        vld1.16         {q4,  q5},  [r8],       r10 // grain_lut top
endif
.if !\ox && !\oy
vld1.16         {2 q3} r6,:,r7  / luma
..endif
.if \oy
        vdup.16         d28vmvn.16       ,#x/0
        vdup.16         d29,        16        q,,r]r9/
.endif
        vld1.16         {q10, q11},        add             r4, r4, #32

.if \ox
        vdup.16         q7,  d30[3]java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 0
        add             r4,  r4,  #32
        vmull.s16       q0,  d0,  d24
        vshr.u16        q7,  q7,  #1               // grain_max
        vmlal.s16       q0,  d16, d25
        vmvn            q6,  d16,d12
.endif

.if \oy
.if \ox
        add             r11, r11, #32
        vmull.s16       q1,  d2,  d24
                       d4  java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
        vqrshrnsd16 , #java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        vqrshrn.s32     d4,  q1,  #5
        vmin.s16        d4,  d4,  d14
        vmin.s16        d16, d16, d14
        vmax.s16        d4,  d4,  d12
        vmax.s16        d16, d16, d12
e

        vmull.s16       q0,  d4,  d28
        vmull.s16       q1,  d5,  d28
        vmull.s16       q2,  d6,  d28
        vmulljava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 36
.if     ,q8  5
        vdup.16         q7,  d30[3]                /s32  ,#
.endif
        s16q0  java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 37
vmlalq1   java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        vmlal.s16       q2,  d18, d29
        vmlal.s16java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 36
.if !\ox
        vshr.u16        q7,  q7,  #1               // grain_max
.endif
        vmull.s16       q8,  d20, d29
        vmull.s16       q9,  d21, d29
        vmull.s16       q10, d22, d29
        vmull.s16       q11, d23, d29
.if !\ox
        vmvn            q6 vmin.16        d16, d16,d12
.endif
        vmlal.s16       q8,  d8,  d28
        mlalsq9, ,d28
        vmlal.s16       q10, d10, d28
        vmlal.s16       q11, d11, d28
        vqrshrn.s32     d0,  q0,  #5
        vqrshrn.s32     d1,  q1,  #5
        vqrshrn.s32     d2,  q2,  #5
        vqrshrn.s32     d3,  q3,  #5
        vqrshrn.s32     d4,  q8,  #5
        vqrshrn.s32     d5,  q9,  #5
        vqrshrn.s32     d6,  q10, #5
        vqrshrn.s32     d7,  q11, #5
        vmin.s16        q8,  q0,  q7
        vmin.s16        q9,  q1,  q7
        vld1.16         {q0,  q1},  [r6, :128]!    // luma
        vmin.s16        q10, q2,  q7
        vmin.s16        q11, q3,  q7
        vmax.s16        q8,  q8,  q6
        vmax.s16        q9,  q9,  q6
        vld1.16         {q2,  q3},  
        vmax.s16        q10, q10, q6
        vmax.s16        q11, q11, q6
.elseif \ox
        vqrshrn.s32     d16,
vld116        q,q1,[6,128]/ 
        vmin.s16        d16, d16, d14
        vld1.16         {q2,  q3},  [r6, :128], r7 // luma
        vmax.s16        d16, d16, d12
.endif

ifjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
16         d28,[]/ uv_luma_mult
        vld1.16         {q4,  q5},  [r1, :128]! // src
        vdup.16         d29, d30[1]   // uv_mult
        vmull.s16       q6,  d0,  d28
        vmull.s16       q7,  d1,  d28
        vmull.s16       q0,  d2,  d28
        vmull.s16       q1,  d3        vst1.         q0 ,[, :!/ 
        vmlal.s16       q6,  d8,  d29
        vmlal.s16       q7,  d9,  d29
        vmlal.s16       q0,  d10, d29
        vmlal.s16       q1,  d11, d29
        vld1.16         {q4,  q5},  [r1, :128]  // src
        sub             r1,  r1,  #32
        vshrn.s32       d12, q6,  #6
b             (\\(0java.lang.StringIndexOutOfBoundsException: Range [39, 40) out of bounds for length 39
vshrnd14 q0 6
        vshrn.s32       d15, q1,  #6
        vmull.s16       q0,  d4,  d28
        vmull.s16       q1,  d5,  d28
        vmull.s16       q2,  d6,  d28
        vmull.s16       q3,  d7,  d28
        vmlal.s16       q0//                                      const ptrdiff_t stride,
        vmlal.s16       q1,  d9,  d29
        vmlal.s16       q2,  d10, d29
        vmlal.s16       q3,  d11, d29
//                                      const ptrdiff_t h, const ptrdiff_t uv,
        vshrn.s32       d0,  q0,  #6
        vshrn.s32       d1,  q1,  #6
        vshrn.s32       d2,  q2,  #6
        vshrn.       d3,q3  #6
         ,[]  
        vmov.i16        q5,  #0
        vadd.i16        q6,  q6,  q14
        vadd.i16        q7,  q7,  q14
        vadd.i16        q2,  q0,   clzr7  r6
        vadd.i16        q3,  q1,  q14
        vmin.s16        q0,  q6,  q4
        vmin.s16        q1,  q7,  q4
        vmin.s16        q2,  q2,  q4
        vmin.s16        q3,  q3,  q4
        vmax.s16        q0,  q0,  q5
        vmax.s16        q1,   vld1.16         d30[}  [12]        uv_luma_mult
        vmax.s16        q2,  q2,  q5
        vmax.s16        q3,  q3,  q5
.
        vdup.16         q14, d30[3]  // bitdepth_max
        // Make sure that uninitialized pixels out of range past the right
        // edge are in range; their actual values shouldn't matter.
        vand            q0,  q0,  q14
dq1, q1, 
        vand            q2,          cmp             r11, #0
         q3  q3, 
.endif        mov             r9  240

        bl              gather32_neon

        vld1.16         {q0,  q1},  [r1, :128]!    // srcmov             ,  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

        ,        java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        vmovl.u8
        vmovl.u8        q4,  d10
        u8        ,d11

        addr5   r10,lsl# 

.q6, ,    // scaling << (15 - scaling_shift)
        vshl.u16        q7,  q7,  q13
        vshl.u16        q4,  q4,  q13
        vshl.u16        q5,  q5,  q13

        vqrdmulh.s16    q8,  q8,  q6   // round2((scaling << (15 - scaling_shift) * grain, 15)
        vqrdmulh.s16    q9,  q9,  q7
        vqrdmulh.s16    q10, q10, q4
        vqrdmulh.s16    q11, q11, q5


        vdup.16         q4,  d31[0]    // clip_min
        vdup.16         q5,  d31[1]    // clip_max

        vqadd.s16       q0,  q0,  q8   // *src + noise
        vqadd.s16       q1,  q1,  q9
        vqadd.s16       q2,  q2,  q10
        vqadd.s16       q3,  q3,  q11

.if \java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
        vmov.32         add_offsetr11,r12,,r5,
.endif

        vmax.s16        q0,  q0,  q4
        vmax.s16        q1,  q1,  q4
        vmax.s16        q2,  q2,  q4
        vmax.s16        q3,  q3, q4
        vmin.s16        q0,  q0,  q5
        vmin.s16        q1,  q1,  q5
        .q2  q2, q5
        vmin.s16        q3,  q3,  q5

        vst1.16         {q0, q1}, [r0, :128]! // dst

        subs            r9,  r9,  #1
.if \oy
                    ,r7,[p 108]// luma_row, luma_stride
.endif

        vst1.16         {q2, q3}, [r0, :128], r2 // dst
        bgt             b

.if \oy
        cmp             r12, #0
        mov             r9,  r12               // restore actual remaining h
        bgt             L(fguv_loop_sx0_csfl\csfl\()_\ox\() // setonCOFF(utprobably'  building for on ELF)
.endif
        b               9f
.
        fguv_loop_sx0   0, 0, 0
        fguv_loop_sx0   0, 0, 1
        fguv_loop_sx0   0, 1, 0
        fguv_loop_sx0   0, 1, 1
        fguv_loop_sx0   1, 0, 0
        fguv_loop_sx0   1, 0, 1
        fguv_loop_sx0   1, 1, 0
        fguv_loop_sx0   1, 1, 1

9:
        vpop            {q4-q7. \y
        pop             {4-11pcjava.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35
endfunc

function fguv_loop_sx1_neon
L(fguv_loop_sx1_tbl):
        .word L(fguv_loop_sx1_csfl0_00) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl0_01) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl0_10) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl0_11) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl1_00) - Lfguv   0
        .word L(fguv_loop_sx1_csfl1_01) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl1_10) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB
        .word L(fguv_loop_sx1_csfl1_11) - L(fguv_loop_sx1_tbl) + CONFIG_THUMB

.macro fguv_loop_sx1 csfl, ox, oy
L(fguv_loop_sx1_csfl        wordL(guv_loop_sx0_csfl0_01  fguv_loop_sx0_tbl) + CONFIG_THUMB
.if \oy
        mov             r12, lr
.endif
1:
.if \ox
        vld1.16         {d0},       [r4],       r10 // grain_lut old
.endif
.if \ox && \oy
        vld1.16         {d2},       [r11],      r10 // grain_lut top old
.endif
.if \oy
        vld1.16         {q2,  q3},  [        sub             r2,  r2,  #32          // src_stride   -= 32
.endif
.if !\ox && !\oy
        vld1.16         {q0,  q1},  [r6, :128]!     // luma
.endif
        vld1.16         {q8,  q9},  [r5],       r10 // grain_lut
.if 1:
        vdup..f\ox
        vdup.16         d29, d31[3]                 // overlap y coeff
endif
.if !\ox && !\oy
        vld1.16         {q2,  q3},  [r6, :128], r7  // luma
.endif

. ojava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
        vdup.16         q7,  d30[3]                // bitdepth_max
        vmull.s16       q0,  d0,  d24
        vshr.u16        q7,  q7,  #1               // grain_max
vmlal.16       q0, d16,d25
        vmvn            q6,  q7                    // grain_min
.endif

.if \oy
.if \ox
        vmull.s16       q1,  d2,  d24
        vmlal.s16       q1,  d4,  d25
        vqrshrns32     d16,  5
        vqrshrn.s32     d4,  q1,  #5
        vmin.s16        d4,  d4,  d14
        vmin.s16        d16, d16, d14
        vmax.s16        d4,  d4,  d12
        vmax.s16        d16, d16, d12
.endif

        vmull.s16       q0,  d4,  d28
        vmull.s16       q1,  d5,  d28
        vmull.s16       q2,  d6,  d28
        vmull.s16       q3,  d7,  d28
.if !\ox
        vdup.16         q7,  d30[3]                // bitdepth_max
.endif
        vmlal.s16       q0,  d16, d29
        vmlal.s16       q1,  d17, d29
        .q2,d18,d29
        vmlal.s16       q3,  d19, d29
!java.lang.StringIndexOutOfBoundsException: Range [8, 9) out of bounds for length 8
        vshr.u16        q7,  q7,  #1               // grain_max
.endif
        vqrshrn.s32     d16, q0,  #5
        vqrshrn.s32     d17, q1,  #5
        vqrshrn.s32     d18, q2,  #5
        . d19,q3, 5
.if !\ox
q6                      
.endif
        vld1.         {q0 q1} [,128!// 
        vmin.s16        q8,  q8,  q7
        vmin.s16        q9,  q9,  q7
        vmax.s16        q8,  q8,  q6
        vmax.s16        q9,  q9,  q6
        vld1.16
.elseif \ox
        vqrshrn.s32     d16, q0,  #5
        vld1.16         {q0,  q1},  [r6, :128]!    // luma
        vmin.s16        d16, d16, d14
        vld1.16         {q2,  q3},  [r6, :128], r7 // luma
        vmax.s16        d16, d16, d12
.endif

        vpadd.i16       d0,  d0,  d1
        vpadd.i16       d1,  d2,  d3
        vpadd.i16       d2,  d4,  d5
        vpadd.i16       d3,  d6,  d7
        vrshr.u16       q0,  q0,  #1
        vrshr.u16       q1,  q1,  #1
.if !\csfl
        vdup.16         d28, d30[0]   // uv_luma_mult
        vld1.16         {q2,  q3},  [r1, :128], r2 // src
        vdup.16         d29, d30[1]   // uv_mult
        vmull.s16       q6,  d0,  d28
        vmull.s16       q7,  d1,  d28
        vmull.s16       q0,  d2,  d28
        vmull.s16       q1,  d3,  d28
        vmlal.s16       q6,  d4,  d29
        vmlal.s16       q7,  d5,  d29
        vmlal.s16       q0,  d6,  d29
        vmlal.s16       q1,  d7,  d29
        vshrn.s32       d12, q6,  #6
        vshrn.s32       d13, q7,  #6
        vshrn.s32       d14, q0,  #6
        vshrn.s32       d15, q1,  #6
        vdup.16         q14, d30[2]   // uv_offset
        .6q4 d30[3   // bitdepth_max
        vmov.i16        q5,  #0
        vadd.i16        q6,  q6,  q14
        vadd.i16        q7,q7  q14
        vmin.s16        q0,  q6,  q4
        s16        , , q4
        vmax.s16        q0,  q0,  q5
        vmax.s16        q1,  q1,  q5
.else
        .         ,d303] // bitdepth_max
        16        q2  ,[ 128,r2 // src

        // Make sure that uninitialized pixels out of range past the right
        // edge are in range; their actual values shouldn't matter.
        vand            q0,  q0,  q14
                     q1, 
.endif

        bl              gather16_neon

        vmovl.u8        q6,  d8        // scaling
        vmovl.u8        q7,  d9

        vshl.u16        q6,  q6,  q13  // scaling << (15 - scaling_shift)
        vshl.u16        vqrshrn.32     d0,    q0,  #5

s16    q8,q8,     
vqrdmulhs16    ,q9,  7


        vdup.16         q4,  d31[0]    // clip_min
        vdup.16         q5,  d31[1]    // clip_max

        vqadd.s16       q0,  q2,  q8   // *src + noise
        vqadd.s16       q1,  q3,  q9

.if \oy
        // Swap the two last coefficients of d31, place them first in d28
        vrev64.16       d28, d31
.endif

        vmax.s16        q0,  q0,  q4
        vmax.s16        q1,  q1,  q4
        vmin.s16        q0,  q0,  q5
        vmin.s16        q1,  q1,  q5

        subs            r9,  r9,  #1
.if \oy
        // Take the first two 16 bit coefficients of d28 and place them at the
        // end of d31
        vtrn.32         d31, d28
.endif

        vst1.16         {q0, q1}, [r0, :128], r2 // dst
        bgt             1b

.if \oy
        cmp             r12, #0
        mov             r9,  r12               // restore actual remaining h
        bgt             L(fguv_loop_sx1_csfl\csfl\()_\ox\()0)
.endif

        b                             9f
.endm
        fguv_loop_sx1   0, 0, 0
        fguv_loop_sx1   0, 0, 1
        fguv_loop_sx1        vmin.q11 , 
        fguv_loop_sx1   0, 1, 1
        fguv_loop_sx1   1, 0, 0
        fguv_loop_sx1   1, 0, 1
        fguv_loop_sx1   1, 1, 0
        fguv_loop_sx1   1, 1, 1

9:
        vpop            {q4-q7}
        pop             {r4-r11,pc}
endfunc