virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-28 20:53:54 +02:00
Code Issues Releases Activity
7cf5b83f6f
FFmpeg/libavcodec/aarch64/me_cmp_neon.S
Martin Storsjö 184103b310 aarch64: Consistently use lowercase for vector element specifiers 
Signed-off-by: Martin Storsjö <martin@martin.st>
2023-10-21 23:25:18 +03:00

1562 lines
63 KiB
ArmAsm
Raw Blame History

/*
* Copyright (c) 2022 Jonathan Swinney <jswinney@amazon.com>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libavutil/aarch64/asm.S"
function ff_pix_abs16_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
cmp w4, #4 // if h < 4, jump to completion section
movi v16.8h, #0 // clear result accumulator
movi v17.8h, #0 // clear result accumulator
b.lt 2f
1:
ld1 {v0.16b}, [x1], x3 // load pix1
ld1 {v4.16b}, [x2], x3 // load pix2
ld1 {v1.16b}, [x1], x3 // load pix1
ld1 {v5.16b}, [x2], x3 // load pix2
uabal v16.8h, v0.8b, v4.8b // absolute difference accumulate
uabal2 v17.8h, v0.16b, v4.16b
ld1 {v2.16b}, [x1], x3 // load pix1
ld1 {v6.16b}, [x2], x3 // load pix2
uabal v16.8h, v1.8b, v5.8b // absolute difference accumulate
uabal2 v17.8h, v1.16b, v5.16b
ld1 {v3.16b}, [x1], x3
ld1 {v7.16b}, [x2], x3
uabal v16.8h, v2.8b, v6.8b
uabal2 v17.8h, v2.16b, v6.16b
sub w4, w4, #4 // h -= 4
uabal v16.8h, v3.8b, v7.8b
uabal2 v17.8h, v3.16b, v7.16b
cmp w4, #4 // if h >= 4, loop
b.ge 1b
cbnz w4, 2f // if iterations remain, jump to completion section
add v16.8h, v16.8h, v17.8h
uaddlv s16, v16.8h // add up everything in v16 accumulator
fmov w0, s16 // copy result to general purpose register
ret
2:
ld1 {v0.16b}, [x1], x3 // load pix1
ld1 {v4.16b}, [x2], x3 // load pix2
subs w4, w4, #1 // h -= 1
uabal v16.8h, v0.8b, v4.8b // absolute difference accumulate
uabal2 v17.8h, v0.16b, v4.16b
b.ne 2b
add v16.8h, v16.8h, v17.8h
uaddlv s16, v16.8h // add up everything in v16 accumulator
fmov w0, s16 // copy result to general purpose register
ret
endfunc
function ff_pix_abs8_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
movi v30.8h, #0
cmp w4, #4
b.lt 2f
// make 4 iterations at once
1:
ld1 {v0.8b}, [x1], x3 // Load pix1 for first iteration
ld1 {v1.8b}, [x2], x3 // Load pix2 for first iteration
ld1 {v2.8b}, [x1], x3 // Load pix1 for second iteration
uabal v30.8h, v0.8b, v1.8b // Absolute difference, first iteration
ld1 {v3.8b}, [x2], x3 // Load pix2 for second iteration
ld1 {v4.8b}, [x1], x3 // Load pix1 for third iteration
uabal v30.8h, v2.8b, v3.8b // Absolute difference, second iteration
ld1 {v5.8b}, [x2], x3 // Load pix2 for third iteration
sub w4, w4, #4 // h -= 4
ld1 {v6.8b}, [x1], x3 // Load pix1 for foruth iteration
ld1 {v7.8b}, [x2], x3 // Load pix2 for fourth iteration
uabal v30.8h, v4.8b, v5.8b // Absolute difference, third iteration
cmp w4, #4
uabal v30.8h, v6.8b, v7.8b // Absolute difference, foruth iteration
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v0.8b}, [x1], x3 // Load pix1
ld1 {v1.8b}, [x2], x3 // Load pix2
subs w4, w4, #1
uabal v30.8h, v0.8b, v1.8b
b.ne 2b
3:
uaddlv s20, v30.8h // Add up vector
fmov w0, s20
ret
endfunc
function ff_pix_abs8_x2_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
cmp w4, #4
movi v26.8h, #0
add x5, x2, #1 // pix2 + 1
b.lt 2f
// make 4 iterations at once
1:
ld1 {v1.8b}, [x2], x3
ld1 {v2.8b}, [x5], x3
ld1 {v0.8b}, [x1], x3
ld1 {v4.8b}, [x2], x3
urhadd v30.8b, v1.8b, v2.8b
ld1 {v5.8b}, [x5], x3
uabal v26.8h, v0.8b, v30.8b
ld1 {v6.8b}, [x1], x3
urhadd v29.8b, v4.8b, v5.8b
ld1 {v7.8b}, [x2], x3
ld1 {v20.8b}, [x5], x3
uabal v26.8h, v6.8b, v29.8b
ld1 {v21.8b}, [x1], x3
urhadd v28.8b, v7.8b, v20.8b
ld1 {v22.8b}, [x2], x3
ld1 {v23.8b}, [x5], x3
uabal v26.8h, v21.8b, v28.8b
sub w4, w4, #4
ld1 {v24.8b}, [x1], x3
urhadd v27.8b, v22.8b, v23.8b
cmp w4, #4
uabal v26.8h, v24.8b, v27.8b
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v1.8b}, [x2], x3
ld1 {v2.8b}, [x5], x3
ld1 {v0.8b}, [x1], x3
urhadd v30.8b, v1.8b, v2.8b
subs w4, w4, #1
uabal v26.8h, v0.8b, v30.8b
b.ne 2b
3:
uaddlv s20, v26.8h
fmov w0, s20
ret
endfunc
function ff_pix_abs8_y2_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
cmp w4, #4
movi v26.8h, #0
ld1 {v1.8b}, [x2], x3
b.lt 2f
// make 4 iterations at once
1:
ld1 {v2.8b}, [x2], x3
ld1 {v0.8b}, [x1], x3
urhadd v30.8b, v1.8b, v2.8b
ld1 {v5.8b}, [x2], x3
ld1 {v6.8b}, [x1], x3
uabal v26.8h, v0.8b, v30.8b
urhadd v29.8b, v2.8b, v5.8b
ld1 {v20.8b}, [x2], x3
ld1 {v21.8b}, [x1], x3
uabal v26.8h, v6.8b, v29.8b
urhadd v28.8b, v5.8b, v20.8b
ld1 {v1.8b}, [x2], x3
ld1 {v24.8b}, [x1], x3
urhadd v27.8b, v20.8b, v1.8b
sub w4, w4, #4
uabal v26.8h, v21.8b, v28.8b
cmp w4, #4
uabal v26.8h, v24.8b, v27.8b
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v0.8b}, [x1], x3
ld1 {v2.8b}, [x2], x3
urhadd v30.8b, v1.8b, v2.8b
subs w4, w4, #1
uabal v26.8h, v0.8b, v30.8b
mov v1.8b, v2.8b
b.ne 2b
3:
uaddlv s20, v26.8h
fmov w0, s20
ret
endfunc
function ff_pix_abs8_xy2_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
movi v31.8h, #0
add x0, x2, 1 // pix2 + 1
add x5, x2, x3 // pix2 + stride = pix3
cmp w4, #4
add x6, x5, 1 // pix3 + stride + 1
ld1 {v0.8b}, [x2], x3
ld1 {v1.8b}, [x0], x3
uaddl v2.8h, v0.8b, v1.8b
b.lt 2f
// make 4 iterations at once
1:
ld1 {v4.8b}, [x5], x3
ld1 {v5.8b}, [x6], x3
ld1 {v7.8b}, [x5], x3
uaddl v0.8h, v4.8b, v5.8b
ld1 {v16.8b}, [x6], x3
add v4.8h, v0.8h, v2.8h
ld1 {v5.8b}, [x1], x3
rshrn v4.8b, v4.8h, #2
uaddl v7.8h, v7.8b, v16.8b
uabal v31.8h, v5.8b, v4.8b
add v2.8h, v0.8h, v7.8h
ld1 {v17.8b}, [x1], x3
rshrn v2.8b, v2.8h, #2
ld1 {v20.8b}, [x5], x3
uabal v31.8h, v17.8b, v2.8b
ld1 {v21.8b}, [x6], x3
ld1 {v25.8b}, [x5], x3
uaddl v20.8h, v20.8b, v21.8b
ld1 {v26.8b}, [x6], x3
add v7.8h, v7.8h, v20.8h
uaddl v25.8h, v25.8b, v26.8b
rshrn v7.8b, v7.8h, #2
ld1 {v22.8b}, [x1], x3
mov v2.16b, v25.16b
uabal v31.8h, v22.8b, v7.8b
add v20.8h, v20.8h, v25.8h
ld1 {v27.8b}, [x1], x3
sub w4, w4, #4
rshrn v20.8b, v20.8h, #2
cmp w4, #4
uabal v31.8h, v27.8b, v20.8b
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v0.8b}, [x5], x3
ld1 {v1.8b}, [x6], x3
ld1 {v4.8b}, [x1], x3
uaddl v21.8h, v0.8b, v1.8b
subs w4, w4, #1
add v3.8h, v2.8h, v21.8h
mov v2.16b, v21.16b
rshrn v3.8b, v3.8h, #2
uabal v31.8h, v4.8b, v3.8b
b.ne 2b
3:
uaddlv s18, v31.8h
fmov w0, s18
ret
endfunc
function ff_pix_abs16_xy2_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
add x5, x2, x3 // use x5 to hold uint8_t *pix3
movi v21.8h, #0 // initialize the result register
movi v22.8h, #0 // initialize the result register
// Load initial pix2 values for either the unrolled version or completion version.
ldur q4, [x2, #1] // load pix2+1
ldr q3, [x2] // load pix2
uaddl v2.8h, v4.8b, v3.8b // pix2 + pix2+1 0..7
uaddl2 v3.8h, v4.16b, v3.16b // pix2 + pix2+1 8..15
cmp w4, #4 // if h < 4 jump to the completion version
b.lt 2f
1:
// This is an unrolled implementation. It completes 4 iterations of the C for each branch.
// In each iteration, pix2[i+1] == pix3[i]. This means we need only three loads per iteration,
// plus two at the beginning to start.
ldur q5, [x5, #1] // load pix3+1
ld1 {v4.16b}, [x5], x3 // load pix3
ld1 {v1.16b}, [x1], x3 // load pix1
ldur q7, [x5, #1] // load pix3+1
ld1 {v6.16b}, [x5], x3 // load pix3
ld1 {v16.16b}, [x1], x3 // load pix1
// These blocks compute the average: avg(pix2[n], pix2[n+1], pix3[n], pix3[n+1])
uaddl v30.8h, v4.8b, v5.8b // pix3 + pix3+1 0..7
uaddl2 v31.8h, v4.16b, v5.16b // pix3 + pix3+1 8..15
ldur q19, [x5, #1] // load pix3+1
add v23.8h, v2.8h, v30.8h // add up 0..7, using pix2 + pix2+1 values from previous iteration
add v24.8h, v3.8h, v31.8h // add up 8..15, using pix2 + pix2+1 values from previous iteration
ld1 {v18.16b}, [x5], x3 // load pix3
ld1 {v17.16b}, [x1], x3 // load pix1
rshrn v23.8b, v23.8h, #2 // shift right 2 0..7 (rounding shift right)
rshrn2 v23.16b, v24.8h, #2 // shift right 2 8..15
uaddl v2.8h, v6.8b, v7.8b // pix3 + pix3+1 0..7
uaddl2 v3.8h, v6.16b, v7.16b // pix3 + pix3+1 8..15
ldur q7, [x5, #1] // load pix3+1
add v26.8h, v30.8h, v2.8h // add up 0..7, using pix2 + pix2+1 values from pix3 above
add v27.8h, v31.8h, v3.8h // add up 8..15, using pix2 + pix2+1 values from pix3 above
uabal v21.8h, v1.8b, v23.8b // absolute difference 0..7, i=0
uabal2 v22.8h, v1.16b, v23.16b // absolute difference 8..15, i=0
ld1 {v6.16b}, [x5], x3 // load pix3
ld1 {v20.16b}, [x1], x3 // load pix1
rshrn v26.8b, v26.8h, #2 // shift right 2 0..7 (rounding shift right)
rshrn2 v26.16b, v27.8h, #2 // shift right 2 8..15
uaddl v4.8h, v18.8b, v19.8b // pix3 + pix3+1 0..7
uaddl2 v5.8h, v18.16b, v19.16b // pix3 + pix3+1 8..15
add v28.8h, v2.8h, v4.8h // add up 0..7, using pix2 + pix2+1 values from pix3 above
add v29.8h, v3.8h, v5.8h // add up 8..15, using pix2 + pix2+1 values from pix3 above
rshrn v28.8b, v28.8h, #2 // shift right 2 0..7 (rounding shift right)
rshrn2 v28.16b, v29.8h, #2 // shift right 2 8..15
uabal v21.8h, v16.8b, v26.8b // absolute difference 0..7, i=1
uabal2 v22.8h, v16.16b, v26.16b // absolute difference 8..15, i=1
uaddl v2.8h, v6.8b, v7.8b // pix3 + pix3+1 0..7
uaddl2 v3.8h, v6.16b, v7.16b // pix3 + pix3+1 8..15
add v30.8h, v4.8h, v2.8h // add up 0..7, using pix2 + pix2+1 values from pix3 above
add v31.8h, v5.8h, v3.8h // add up 8..15, using pix2 + pix2+1 values from pix3 above
rshrn v30.8b, v30.8h, #2 // shift right 2 0..7 (rounding shift right)
rshrn2 v30.16b, v31.8h, #2 // shift right 2 8..15
sub w4, w4, #4 // h -= 4
uabal v21.8h, v17.8b, v28.8b // absolute difference 0..7, i=2
uabal2 v22.8h, v17.16b, v28.16b // absolute difference 8..15, i=2
cmp w4, #4 // loop if h >= 4
uabal v21.8h, v20.8b, v30.8b // absolute difference 0..7, i=3
uabal2 v22.8h, v20.16b, v30.16b // absolute difference 8..15, i=3
b.ge 1b
cbnz w4, 2f // if iterations remain jump to completion section
add v4.8h, v21.8h, v22.8h
uaddlv s0, v4.8h // finish adding up accumulated values
fmov w0, s0 // copy result to general purpose register
ret
2:
// v2 and v3 are set either at the end of this loop or at from the unrolled version
// which branches here to complete iterations when h % 4 != 0.
ldur q5, [x5, #1] // load pix3+1
ld1 {v4.16b}, [x5], x3 // load pix3
ld1 {v1.16b}, [x1], x3 // load pix1
subs w4, w4, #1 // decrement h
uaddl v18.8h, v4.8b, v5.8b // pix3 + pix3+1 0..7
uaddl2 v19.8h, v4.16b, v5.16b // pix3 + pix3+1 8..15
add v16.8h, v2.8h, v18.8h // add up 0..7, using pix2 + pix2+1 values from previous iteration
add v17.8h, v3.8h, v19.8h // add up 8..15, using pix2 + pix2+1 values from previous iteration
// divide by 4 to compute the average of values summed above
rshrn v16.8b, v16.8h, #2 // shift right by 2 0..7 (rounding shift right)
rshrn2 v16.16b, v17.8h, #2 // shift right by 2 8..15
uabal v21.8h, v1.8b, v16.8b // absolute difference 0..7
uabal2 v22.8h, v1.16b, v16.16b // absolute difference accumulate 8..15
mov v2.16b, v18.16b // pix3 -> pix2
mov v3.16b, v19.16b // pix3+1 -> pix2+1
b.ne 2b // loop if h > 0
add v4.8h, v21.8h, v22.8h
uaddlv s0, v4.8h // finish adding up accumulated values
fmov w0, s0 // copy result to general purpose register
ret
endfunc
function ff_pix_abs16_x2_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
cmp w4, #4
// initialize buffers
movi v16.8h, #0
movi v17.8h, #0
add x5, x2, #1 // pix2 + 1
b.lt 2f
// make 4 iterations at once
1:
// abs(pix1[0] - avg2(pix2[0], pix2[1]))
// avg2(a,b) = (((a) + (b) + 1) >> 1)
// abs(x) = (x < 0 ? -x : x)
ld1 {v1.16b}, [x2], x3
ld1 {v2.16b}, [x5], x3
urhadd v30.16b, v1.16b, v2.16b
ld1 {v0.16b}, [x1], x3
uabal v16.8h, v0.8b, v30.8b
ld1 {v4.16b}, [x2], x3
uabal2 v17.8h, v0.16b, v30.16b
ld1 {v5.16b}, [x5], x3
urhadd v29.16b, v4.16b, v5.16b
ld1 {v3.16b}, [x1], x3
uabal v16.8h, v3.8b, v29.8b
ld1 {v7.16b}, [x2], x3
uabal2 v17.8h, v3.16b, v29.16b
ld1 {v22.16b}, [x5], x3
urhadd v28.16b, v7.16b, v22.16b
ld1 {v6.16b}, [x1], x3
uabal v16.8h, v6.8b, v28.8b
ld1 {v24.16b}, [x2], x3
sub w4, w4, #4
uabal2 v17.8h, v6.16b, v28.16b
ld1 {v25.16b}, [x5], x3
urhadd v27.16b, v24.16b, v25.16b
ld1 {v23.16b}, [x1], x3
cmp w4, #4
uabal v16.8h, v23.8b, v27.8b
uabal2 v17.8h, v23.16b, v27.16b
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v1.16b}, [x2], x3
ld1 {v2.16b}, [x5], x3
subs w4, w4, #1
urhadd v29.16b, v1.16b, v2.16b
ld1 {v0.16b}, [x1], x3
uabal v16.8h, v0.8b, v29.8b
uabal2 v17.8h, v0.16b, v29.16b
b.ne 2b
3:
add v16.8h, v16.8h, v17.8h
uaddlv s16, v16.8h
fmov w0, s16
ret
endfunc
function ff_pix_abs16_y2_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
// initialize buffers
ld1 {v1.16b}, [x2], x3 // Load pix2
movi v29.8h, #0 // clear the accumulator
movi v28.8h, #0 // clear the accumulator
cmp w4, #4
b.lt 2f
// make 4 iterations at once
1:
// abs(pix1[0], avg2(pix2[0], pix2[0 + stride]))
// avg2(a, b) = (((a) + (b) + 1) >> 1)
// abs(x) = (x < 0 ? (-x) : (x))
ld1 {v2.16b}, [x2], x3 // Load pix3 for first iteration
ld1 {v0.16b}, [x1], x3 // Load pix1 for first iteration
urhadd v30.16b, v1.16b, v2.16b // Rounding halving add, first iteration
ld1 {v5.16b}, [x2], x3 // Load pix3 for second iteartion
uabal v29.8h, v0.8b, v30.8b // Absolute difference of lower half, first iteration
uabal2 v28.8h, v0.16b, v30.16b // Absolute difference of upper half, first iteration
ld1 {v3.16b}, [x1], x3 // Load pix1 for second iteration
urhadd v27.16b, v2.16b, v5.16b // Rounding halving add, second iteration
ld1 {v20.16b}, [x2], x3 // Load pix3 for third iteration
uabal v29.8h, v3.8b, v27.8b // Absolute difference of lower half for second iteration
uabal2 v28.8h, v3.16b, v27.16b // Absolute difference of upper half for second iteration
ld1 {v6.16b}, [x1], x3 // Load pix1 for third iteration
urhadd v26.16b, v5.16b, v20.16b // Rounding halving add, third iteration
ld1 {v1.16b}, [x2], x3 // Load pix3 for fourth iteration
uabal v29.8h, v6.8b, v26.8b // Absolute difference of lower half for third iteration
uabal2 v28.8h, v6.16b, v26.16b // Absolute difference of upper half for third iteration
ld1 {v21.16b}, [x1], x3 // Load pix1 for fourth iteration
sub w4, w4, #4 // h-= 4
urhadd v25.16b, v20.16b, v1.16b // Rounding halving add
cmp w4, #4
uabal v29.8h, v21.8b, v25.8b // Absolute difference of lower half for fourth iteration
uabal2 v28.8h, v21.16b, v25.16b // Absolute difference of upper half for fourth iteration
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v2.16b}, [x2], x3 // Load pix3
subs w4, w4, #1
ld1 {v0.16b}, [x1], x3 // Load pix1
urhadd v30.16b, v1.16b, v2.16b // Rounding halving add
mov v1.16b, v2.16b // Shift pix3->pix2
uabal v29.8h, v30.8b, v0.8b
uabal2 v28.8h, v30.16b, v0.16b
b.ne 2b
3:
add v29.8h, v29.8h, v28.8h // Add vectors together
uaddlv s16, v29.8h // Add up vector values
fmov w0, s16
ret
endfunc
function sse16_neon, export=1
// x0 - unused
// x1 - pix1
// x2 - pix2
// x3 - stride
// w4 - h
cmp w4, #4
movi v17.4s, #0
b.lt 2f
// Make 4 iterations at once
1:
// res = abs(pix1[0] - pix2[0])
// res * res
ld1 {v0.16b}, [x1], x3 // Load pix1 vector for first iteration
ld1 {v1.16b}, [x2], x3 // Load pix2 vector for first iteration
ld1 {v2.16b}, [x1], x3 // Load pix1 vector for second iteration
uabd v30.16b, v0.16b, v1.16b // Absolute difference, first iteration
ld1 {v3.16b}, [x2], x3 // Load pix2 vector for second iteration
umull v29.8h, v30.8b, v30.8b // Multiply lower half of vectors, first iteration
umull2 v28.8h, v30.16b, v30.16b // Multiply upper half of vectors, first iteration
uabd v27.16b, v2.16b, v3.16b // Absolute difference, second iteration
uadalp v17.4s, v29.8h // Pairwise add, first iteration
ld1 {v4.16b}, [x1], x3 // Load pix1 for third iteration
umull v26.8h, v27.8b, v27.8b // Mulitply lower half, second iteration
umull2 v25.8h, v27.16b, v27.16b // Multiply upper half, second iteration
ld1 {v5.16b}, [x2], x3 // Load pix2 for third iteration
uadalp v17.4s, v26.8h // Pairwise add and accumulate, second iteration
uabd v24.16b, v4.16b, v5.16b // Absolute difference, third iteration
ld1 {v6.16b}, [x1], x3 // Load pix1 for fourth iteration
uadalp v17.4s, v25.8h // Pairwise add and accumulate, second iteration
umull v23.8h, v24.8b, v24.8b // Multiply lower half, third iteration
umull2 v22.8h, v24.16b, v24.16b // Multiply upper half, third iteration
uadalp v17.4s, v23.8h // Pairwise add and accumulate, third iteration
ld1 {v7.16b}, [x2], x3 // Load pix2 for fouth iteration
uadalp v17.4s, v22.8h // Pairwise add and accumulate, third iteration
uabd v21.16b, v6.16b, v7.16b // Absolute difference, fourth iteration
uadalp v17.4s, v28.8h // Pairwise add and accumulate, first iteration
umull v20.8h, v21.8b, v21.8b // Multiply lower half, fourth iteration
sub w4, w4, #4 // h -= 4
umull2 v19.8h, v21.16b, v21.16b // Multiply upper half, fourth iteration
uadalp v17.4s, v20.8h // Pairwise add and accumulate, fourth iteration
cmp w4, #4
uadalp v17.4s, v19.8h // Pairwise add and accumulate, fourth iteration
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v0.16b}, [x1], x3 // Load pix1
ld1 {v1.16b}, [x2], x3 // Load pix2
uabd v30.16b, v0.16b, v1.16b
umull v29.8h, v30.8b, v30.8b
umull2 v28.8h, v30.16b, v30.16b
uadalp v17.4s, v29.8h
subs w4, w4, #1
uadalp v17.4s, v28.8h
b.ne 2b
3:
uaddlv d16, v17.4s // add up accumulator vector
fmov w0, s16
ret
endfunc
function sse8_neon, export=1
// x0 - unused
// x1 - pix1
// x2 - pix2
// x3 - stride
// w4 - h
movi v21.4s, #0
movi v20.4s, #0
cmp w4, #4
b.lt 2f
// make 4 iterations at once
1:
// res = abs(pix1[0] - pix2[0])
// res * res
ld1 {v0.8b}, [x1], x3 // Load pix1 for first iteration
ld1 {v1.8b}, [x2], x3 // Load pix2 for second iteration
ld1 {v2.8b}, [x1], x3 // Load pix1 for second iteration
ld1 {v3.8b}, [x2], x3 // Load pix2 for second iteration
uabdl v30.8h, v0.8b, v1.8b // Absolute difference, first iteration
ld1 {v4.8b}, [x1], x3 // Load pix1 for third iteration
ld1 {v5.8b}, [x2], x3 // Load pix2 for third iteration
uabdl v29.8h, v2.8b, v3.8b // Absolute difference, second iteration
umlal v21.4s, v30.4h, v30.4h // Multiply lower half, first iteration
ld1 {v6.8b}, [x1], x3 // Load pix1 for fourth iteration
ld1 {v7.8b}, [x2], x3 // Load pix2 for fourth iteration
uabdl v28.8h, v4.8b, v5.8b // Absolute difference, third iteration
umlal v21.4s, v29.4h, v29.4h // Multiply lower half, second iteration
umlal2 v20.4s, v30.8h, v30.8h // Multiply upper half, first iteration
uabdl v27.8h, v6.8b, v7.8b // Absolute difference, fourth iteration
umlal v21.4s, v28.4h, v28.4h // Multiply lower half, third iteration
umlal2 v20.4s, v29.8h, v29.8h // Multiply upper half, second iteration
sub w4, w4, #4 // h -= 4
umlal2 v20.4s, v28.8h, v28.8h // Multiply upper half, third iteration
umlal v21.4s, v27.4h, v27.4h // Multiply lower half, fourth iteration
cmp w4, #4
umlal2 v20.4s, v27.8h, v27.8h // Multiply upper half, fourth iteration
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v0.8b}, [x1], x3 // Load pix1
ld1 {v1.8b}, [x2], x3 // Load pix2
subs w4, w4, #1
uabdl v30.8h, v0.8b, v1.8b
umlal v21.4s, v30.4h, v30.4h
umlal2 v20.4s, v30.8h, v30.8h
b.ne 2b
3:
add v21.4s, v21.4s, v20.4s // Add accumulator vectors together
uaddlv d17, v21.4s // Add up vector
fmov w0, s17
ret
endfunc
function sse4_neon, export=1
// x0 - unused
// x1 - pix1
// x2 - pix2
// x3 - stride
// w4 - h
movi v16.4s, #0 // clear the result accumulator
cmp w4, #4
b.lt 2f
// make 4 iterations at once
1:
// res = abs(pix1[0] - pix2[0])
// res * res
ld1 {v0.s}[0], [x1], x3 // Load pix1, first iteration
ld1 {v1.s}[0], [x2], x3 // Load pix2, first iteration
ld1 {v2.s}[0], [x1], x3 // Load pix1, second iteration
ld1 {v3.s}[0], [x2], x3 // Load pix2, second iteration
uabdl v30.8h, v0.8b, v1.8b // Absolute difference, first iteration
ld1 {v4.s}[0], [x1], x3 // Load pix1, third iteration
ld1 {v5.s}[0], [x2], x3 // Load pix2, third iteration
uabdl v29.8h, v2.8b, v3.8b // Absolute difference, second iteration
umlal v16.4s, v30.4h, v30.4h // Multiply vectors, first iteration
ld1 {v6.s}[0], [x1], x3 // Load pix1, fourth iteration
ld1 {v7.s}[0], [x2], x3 // Load pix2, fourth iteration
uabdl v28.8h, v4.8b, v5.8b // Absolute difference, third iteration
umlal v16.4s, v29.4h, v29.4h // Multiply and accumulate, second iteration
sub w4, w4, #4
uabdl v27.8h, v6.8b, v7.8b // Absolue difference, fourth iteration
umlal v16.4s, v28.4h, v28.4h // Multiply and accumulate, third iteration
cmp w4, #4
umlal v16.4s, v27.4h, v27.4h // Multiply and accumulate, fourth iteration
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v0.s}[0], [x1], x3 // Load pix1
ld1 {v1.s}[0], [x2], x3 // Load pix2
uabdl v30.8h, v0.8b, v1.8b
subs w4, w4, #1
umlal v16.4s, v30.4h, v30.4h
b.ne 2b
3:
uaddlv d17, v16.4s // Add vector
fmov w0, s17
ret
endfunc
function vsad16_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
ld1 {v0.16b}, [x1], x3 // Load pix1[0], first iteration
ld1 {v1.16b}, [x2], x3 // Load pix2[0], first iteration
sub w4, w4, #1 // we need to make h-1 iterations
movi v16.8h, #0
cmp w4, #3 // check if we can make 3 iterations at once
usubl v31.8h, v0.8b, v1.8b // Signed difference pix1[0] - pix2[0], first iteration
usubl2 v30.8h, v0.16b, v1.16b // Signed difference pix1[0] - pix2[0], first iteration
b.lt 2f
1:
// abs(pix1[0] - pix2[0] - pix1[0 + stride] + pix2[0 + stride])
ld1 {v0.16b}, [x1], x3 // Load pix1[0 + stride], first iteration
ld1 {v1.16b}, [x2], x3 // Load pix2[0 + stride], first iteration
ld1 {v2.16b}, [x1], x3 // Load pix1[0 + stride], second iteration
ld1 {v3.16b}, [x2], x3 // Load pix2[0 + stride], second iteration
usubl v29.8h, v0.8b, v1.8b // Signed difference pix1[0 + stride] - pix2[0 + stride], first iteration
usubl2 v28.8h, v0.16b, v1.16b // Signed difference pix1[0 + stride] - pix2[0 + stride], first iteration
ld1 {v4.16b}, [x1], x3 // Load pix1[0 + stride], third iteration
ld1 {v5.16b}, [x2], x3 // Load pix2[0 + stride], third iteration
usubl v27.8h, v2.8b, v3.8b // Signed difference pix1[0 + stride] - pix2[0 + stride], second iteration
saba v16.8h, v31.8h, v29.8h // Signed absolute difference and accumulate the result. first iteration
usubl2 v26.8h, v2.16b, v3.16b // Signed difference pix1[0 + stride] - pix2[0 + stride], second iteration
saba v16.8h, v30.8h, v28.8h // Signed absolute difference and accumulate the result. first iteration
usubl v25.8h, v4.8b, v5.8b // Signed difference pix1[0 + stride] - pix2[0 + stride], third iteration
usubl2 v24.8h, v4.16b, v5.16b // Signed difference pix1[0 + stride] - pix2[0 + stride], third iteration
saba v16.8h, v29.8h, v27.8h // Signed absolute difference and accumulate the result. second iteration
mov v31.16b, v25.16b
saba v16.8h, v28.8h, v26.8h // Signed absolute difference and accumulate the result. second iteration
sub w4, w4, #3 // h -= 3
mov v30.16b, v24.16b
saba v16.8h, v27.8h, v25.8h // Signed absolute difference and accumulate the result. third iteration
cmp w4, #3
saba v16.8h, v26.8h, v24.8h // Signed absolute difference and accumulate the result. third iteration
b.ge 1b
cbz w4, 3f
2:
ld1 {v0.16b}, [x1], x3
ld1 {v1.16b}, [x2], x3
subs w4, w4, #1
usubl v29.8h, v0.8b, v1.8b
usubl2 v28.8h, v0.16b, v1.16b
saba v16.8h, v31.8h, v29.8h
mov v31.16b, v29.16b
saba v16.8h, v30.8h, v28.8h
mov v30.16b, v28.16b
b.ne 2b
3:
uaddlv s17, v16.8h
fmov w0, s17
ret
endfunc
function vsse8_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
ld1 {v0.8b}, [x1], x3 // Load pix1[0], first iteration
ld1 {v1.8b}, [x2], x3 // Load pix2[0], first iteration
sub w4, w4, #1 // we need to make h-1 iterations
movi v16.4s, #0
movi v17.4s, #0
cmp w4, #3 // check if we can make 3 iterations at once
usubl v31.8h, v0.8b, v1.8b // Signed difference of pix1[0] - pix2[0], first iteration
b.lt 2f
1:
// x = abs(pix1[0] - pix2[0] - pix1[0 + stride] + pix2[0 + stride])
// res = (x) * (x)
ld1 {v0.8b}, [x1], x3 // Load pix1[0 + stride], first iteration
ld1 {v1.8b}, [x2], x3 // Load pix2[0 + stride], first iteration
ld1 {v2.8b}, [x1], x3 // Load pix1[0 + stride], second iteration
ld1 {v3.8b}, [x2], x3 // Load pix2[0 + stride], second iteration
usubl v29.8h, v0.8b, v1.8b
usubl2 v28.8h, v0.16b, v1.16b
ld1 {v4.8b}, [x1], x3 // Load pix1[0 + stride], third iteration
ld1 {v5.8b}, [x2], x3 // Load pix1[0 + stride], third iteration
sabd v31.8h, v31.8h, v29.8h
usubl v27.8h, v2.8b, v3.8b
usubl v25.8h, v4.8b, v5.8b
sabd v29.8h, v29.8h, v27.8h
sabd v27.8h, v27.8h, v25.8h
umlal v16.4s, v31.4h, v31.4h
umlal2 v17.4s, v31.8h, v31.8h
mov v31.16b, v25.16b
umlal v16.4s, v29.4h, v29.4h
umlal2 v17.4s, v29.8h, v29.8h
sub w4, w4, #3
umlal v16.4s, v27.4h, v27.4h
umlal2 v17.4s, v27.8h, v27.8h
cmp w4, #3
b.ge 1b
cbz w4, 3f
// iterate by once
2:
ld1 {v0.8b}, [x1], x3
ld1 {v1.8b}, [x2], x3
subs w4, w4, #1
usubl v29.8h, v0.8b, v1.8b
sabd v31.8h, v31.8h, v29.8h
umlal v16.4s, v31.4h, v31.4h
umlal2 v17.4s, v31.8h, v31.8h
mov v31.16b, v29.16b
b.ne 2b
3:
add v16.4s, v16.4s, v17.4s
uaddlv d17, v16.4s
fmov w0, s17
ret
endfunc
function vsse16_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
ld1 {v0.16b}, [x1], x3 // Load pix1[0], first iteration
ld1 {v1.16b}, [x2], x3 // Load pix2[0], first iteration
sub w4, w4, #1 // we need to make h-1 iterations
movi v16.4s, #0
movi v17.4s, #0
cmp w4, #3 // check if we can make 3 iterations at once
usubl v31.8h, v0.8b, v1.8b // Signed difference of pix1[0] - pix2[0], first iteration
usubl2 v30.8h, v0.16b, v1.16b // Signed difference of pix1[0] - pix2[0], first iteration
b.lt 2f
1:
// x = abs(pix1[0] - pix2[0] - pix1[0 + stride] + pix2[0 + stride])
// res = (x) * (x)
ld1 {v0.16b}, [x1], x3 // Load pix1[0 + stride], first iteration
ld1 {v1.16b}, [x2], x3 // Load pix2[0 + stride], first iteration
ld1 {v2.16b}, [x1], x3 // Load pix1[0 + stride], second iteration
ld1 {v3.16b}, [x2], x3 // Load pix2[0 + stride], second iteration
usubl v29.8h, v0.8b, v1.8b
usubl2 v28.8h, v0.16b, v1.16b
ld1 {v4.16b}, [x1], x3 // Load pix1[0 + stride], third iteration
ld1 {v5.16b}, [x2], x3 // Load pix1[0 + stride], third iteration
sabd v31.8h, v31.8h, v29.8h
sabd v30.8h, v30.8h, v28.8h
usubl v27.8h, v2.8b, v3.8b
usubl2 v26.8h, v2.16b, v3.16b
usubl v25.8h, v4.8b, v5.8b
usubl2 v24.8h, v4.16b, v5.16b
sabd v29.8h, v29.8h, v27.8h
sabd v27.8h, v27.8h, v25.8h
umlal v16.4s, v31.4h, v31.4h
umlal2 v17.4s, v31.8h, v31.8h
sabd v28.8h, v28.8h, v26.8h
sabd v26.8h, v26.8h, v24.8h
umlal v16.4s, v30.4h, v30.4h
umlal2 v17.4s, v30.8h, v30.8h
mov v31.16b, v25.16b
umlal v16.4s, v29.4h, v29.4h
umlal2 v17.4s, v29.8h, v29.8h
mov v30.16b, v24.16b
umlal v16.4s, v28.4h, v28.4h
umlal2 v17.4s, v28.8h, v28.8h
sub w4, w4, #3
umlal v16.4s, v27.4h, v27.4h
umlal2 v17.4s, v27.8h, v27.8h
cmp w4, #3
umlal v16.4s, v26.4h, v26.4h
umlal2 v17.4s, v26.8h, v26.8h
b.ge 1b
cbz w4, 3f
// iterate by once
2:
ld1 {v0.16b}, [x1], x3
ld1 {v1.16b}, [x2], x3
subs w4, w4, #1
usubl v29.8h, v0.8b, v1.8b
usubl2 v28.8h, v0.16b, v1.16b
sabd v31.8h, v31.8h, v29.8h
sabd v30.8h, v30.8h, v28.8h
umlal v16.4s, v31.4h, v31.4h
umlal2 v17.4s, v31.8h, v31.8h
mov v31.16b, v29.16b
umlal v16.4s, v30.4h, v30.4h
umlal2 v17.4s, v30.8h, v30.8h
mov v30.16b, v28.16b
b.ne 2b
3:
add v16.4s, v16.4s, v17.4s
uaddlv d17, v16.4s
fmov w0, s17
ret
endfunc
function vsad_intra16_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *dummy
// x3 ptrdiff_t stride
// w4 int h
ld1 {v0.16b}, [x1], x3
sub w4, w4, #1 // we need to make h-1 iterations
cmp w4, #3
movi v16.8h, #0
b.lt 2f
// make 4 iterations at once
1:
// v = abs( pix1[0] - pix1[0 + stride] )
// score = sum(v)
ld1 {v1.16b}, [x1], x3
ld1 {v2.16b}, [x1], x3
uabal v16.8h, v0.8b, v1.8b
ld1 {v3.16b}, [x1], x3
uabal2 v16.8h, v0.16b, v1.16b
sub w4, w4, #3
uabal v16.8h, v1.8b, v2.8b
cmp w4, #3
uabal2 v16.8h, v1.16b, v2.16b
mov v0.16b, v3.16b
uabal v16.8h, v2.8b, v3.8b
uabal2 v16.8h, v2.16b, v3.16b
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v1.16b}, [x1], x3
subs w4, w4, #1
uabal v16.8h, v0.8b, v1.8b
uabal2 v16.8h, v0.16b, v1.16b
mov v0.16b, v1.16b
cbnz w4, 2b
3:
uaddlv s17, v16.8h
fmov w0, s17
ret
endfunc
function vsse_intra16_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *dummy
// x3 ptrdiff_t stride
// w4 int h
ld1 {v0.16b}, [x1], x3
movi v16.4s, #0
movi v17.4s, #0
sub w4, w4, #1 // we need to make h-1 iterations
cmp w4, #3
b.lt 2f
1:
// v = abs( pix1[0] - pix1[0 + stride] )
// score = sum( v * v )
ld1 {v1.16b}, [x1], x3
ld1 {v2.16b}, [x1], x3
uabd v30.16b, v0.16b, v1.16b
ld1 {v3.16b}, [x1], x3
umull v29.8h, v30.8b, v30.8b
umull2 v28.8h, v30.16b, v30.16b
uabd v27.16b, v1.16b, v2.16b
uadalp v16.4s, v29.8h
umull v26.8h, v27.8b, v27.8b
umull2 v27.8h, v27.16b, v27.16b
uadalp v17.4s, v28.8h
uabd v25.16b, v2.16b, v3.16b
uadalp v16.4s, v26.8h
umull v24.8h, v25.8b, v25.8b
umull2 v25.8h, v25.16b, v25.16b
uadalp v17.4s, v27.8h
sub w4, w4, #3
uadalp v16.4s, v24.8h
cmp w4, #3
uadalp v17.4s, v25.8h
mov v0.16b, v3.16b
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v1.16b}, [x1], x3
subs w4, w4, #1
uabd v30.16b, v0.16b, v1.16b
mov v0.16b, v1.16b
umull v29.8h, v30.8b, v30.8b
umull2 v30.8h, v30.16b, v30.16b
uadalp v16.4s, v29.8h
uadalp v17.4s, v30.8h
cbnz w4, 2b
3:
add v16.4s, v16.4s, v17.4s
uaddlv d17, v16.4s
fmov w0, s17
ret
endfunc
function vsse_intra8_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *dummy
// x3 ptrdiff_t stride
// w4 int h
sub w4, w4, #1 // we need to make h-1 iterations
ld1 {v0.8b}, [x1], x3
cmp w4, #3
movi v16.4s, #0
b.lt 2f
1:
// v = abs( pix1[0] - pix1[0 + stride] )
// score = sum( v * v )
ld1 {v1.8b}, [x1], x3
ld1 {v2.8b}, [x1], x3
uabd v30.8b, v0.8b, v1.8b
ld1 {v3.8b}, [x1], x3
uabd v27.8b, v1.8b, v2.8b
umull v29.8h, v30.8b, v30.8b
uabd v25.8b, v2.8b, v3.8b
umull v26.8h, v27.8b, v27.8b
uadalp v16.4s, v29.8h
umull v24.8h, v25.8b, v25.8b
uadalp v16.4s, v26.8h
sub w4, w4, #3
uadalp v16.4s, v24.8h
cmp w4, #3
mov v0.8b, v3.8b
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v1.8b}, [x1], x3
subs w4, w4, #1
uabd v30.8b, v0.8b, v1.8b
mov v0.8b, v1.8b
umull v29.8h, v30.8b, v30.8b
uadalp v16.4s, v29.8h
cbnz w4, 2b
3:
uaddlv d17, v16.4s
fmov w0, s17
ret
endfunc
function nsse16_neon, export=1
// x0 multiplier
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
str x0, [sp, #-0x40]!
stp x1, x2, [sp, #0x10]
stp x3, x4, [sp, #0x20]
str x30, [sp, #0x30]
bl X(sse16_neon)
ldr x30, [sp, #0x30]
mov w9, w0 // here we store score1
ldp x1, x2, [sp, #0x10]
ldp x3, x4, [sp, #0x20]
ldr x5, [sp], #0x40
movi v16.8h, #0
movi v17.8h, #0
movi v18.8h, #0
movi v19.8h, #0
ld1 {v0.16b}, [x1], x3
subs w4, w4, #1 // we need to make h-1 iterations
ld1 {v2.16b}, [x2], x3
ext v1.16b, v0.16b, v0.16b, #1 // x1 + 1
cmp w4, #2
ext v3.16b, v2.16b, v2.16b, #1 // x2 + 1
b.lt 2f
// make 2 iterations at once
1:
ld1 {v4.16b}, [x1], x3
ld1 {v6.16b}, [x2], x3
ld1 {v20.16b}, [x1], x3
ext v5.16b, v4.16b, v4.16b, #1 // x1 + stride + 1
usubl v31.8h, v0.8b, v4.8b
usubl2 v30.8h, v0.16b, v4.16b
ld1 {v22.16b}, [x2], x3
usubl v29.8h, v1.8b, v5.8b
usubl2 v28.8h, v1.16b, v5.16b
ext v7.16b, v6.16b, v6.16b, #1 // x2 + stride + 1
saba v16.8h, v31.8h, v29.8h
ext v21.16b, v20.16b, v20.16b, #1
saba v17.8h, v30.8h, v28.8h
usubl v27.8h, v2.8b, v6.8b
usubl2 v26.8h, v2.16b, v6.16b
ext v23.16b, v22.16b, v22.16b, #1
usubl v25.8h, v3.8b, v7.8b
usubl2 v24.8h, v3.16b, v7.16b
saba v18.8h, v27.8h, v25.8h
saba v19.8h, v26.8h, v24.8h
usubl v31.8h, v4.8b, v20.8b
usubl2 v30.8h, v4.16b, v20.16b
usubl v29.8h, v5.8b, v21.8b
usubl2 v28.8h, v5.16b, v21.16b
saba v16.8h, v31.8h, v29.8h
saba v17.8h, v30.8h, v28.8h
usubl v27.8h, v6.8b, v22.8b
usubl2 v26.8h, v6.16b, v22.16b
usubl v25.8h, v7.8b, v23.8b
usubl2 v24.8h, v7.16b, v23.16b
saba v18.8h, v27.8h, v25.8h
saba v19.8h, v26.8h, v24.8h
sub w4, w4, #2
mov v0.16b, v20.16b
mov v1.16b, v21.16b
cmp w4, #2
mov v2.16b, v22.16b
mov v3.16b, v23.16b
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v4.16b}, [x1], x3
subs w4, w4, #1
ld1 {v6.16b}, [x2], x3
ext v5.16b, v4.16b, v4.16b, #1 // x1 + stride + 1
usubl v31.8h, v0.8b, v4.8b
ext v7.16b, v6.16b, v6.16b, #1 // x2 + stride + 1
usubl2 v30.8h, v0.16b, v4.16b
usubl v29.8h, v1.8b, v5.8b
usubl2 v28.8h, v1.16b, v5.16b
saba v16.8h, v31.8h, v29.8h
saba v17.8h, v30.8h, v28.8h
usubl v27.8h, v2.8b, v6.8b
usubl2 v26.8h, v2.16b, v6.16b
usubl v25.8h, v3.8b, v7.8b
usubl2 v24.8h, v3.16b, v7.16b
saba v18.8h, v27.8h, v25.8h
saba v19.8h, v26.8h, v24.8h
mov v0.16b, v4.16b
mov v1.16b, v5.16b
mov v2.16b, v6.16b
mov v3.16b, v7.16b
cbnz w4, 2b
3:
sqsub v17.8h, v17.8h, v19.8h
sqsub v16.8h, v16.8h, v18.8h
ins v17.h[7], wzr
sqadd v16.8h, v16.8h, v17.8h
saddlv s16, v16.8h
sqabs s16, s16
fmov w0, s16
mul w0, w0, w5
add w0, w0, w9
ret
endfunc
function nsse8_neon, export=1
// x0 multiplier
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
str x0, [sp, #-0x40]!
stp x1, x2, [sp, #0x10]
stp x3, x4, [sp, #0x20]
str x30, [sp, #0x30]
bl X(sse8_neon)
ldr x30, [sp, #0x30]
mov w9, w0 // here we store score1
ldp x1, x2, [sp, #0x10]
ldp x3, x4, [sp, #0x20]
ldr x5, [sp], #0x40
movi v16.8h, #0
movi v17.8h, #0
movi v18.8h, #0
movi v19.8h, #0
ld1 {v0.8b}, [x1], x3
subs w4, w4, #1 // we need to make h-1 iterations
ext v1.8b, v0.8b, v0.8b, #1 // x1 + 1
ld1 {v2.8b}, [x2], x3
cmp w4, #2
ext v3.8b, v2.8b, v2.8b, #1 // x2 + 1
b.lt 2f
// make 2 iterations at once
1:
ld1 {v4.8b}, [x1], x3
ld1 {v20.8b}, [x1], x3
ld1 {v6.8b}, [x2], x3
ext v5.8b, v4.8b, v4.8b, #1 // x1 + stride + 1
ext v21.8b, v20.8b, v20.8b, #1
ld1 {v22.8b}, [x2], x3
ext v7.8b, v6.8b, v6.8b, #1 // x2 + stride + 1
usubl v31.8h, v0.8b, v4.8b
ext v23.8b, v22.8b, v22.8b, #1
usubl v29.8h, v1.8b, v5.8b
usubl v27.8h, v2.8b, v6.8b
usubl v25.8h, v3.8b, v7.8b
saba v16.8h, v31.8h, v29.8h
usubl v31.8h, v4.8b, v20.8b
saba v18.8h, v27.8h, v25.8h
sub w4, w4, #2
usubl v29.8h, v5.8b, v21.8b
mov v0.16b, v20.16b
mov v1.16b, v21.16b
saba v16.8h, v31.8h, v29.8h
usubl v27.8h, v6.8b, v22.8b
usubl v25.8h, v7.8b, v23.8b
mov v2.16b, v22.16b
mov v3.16b, v23.16b
cmp w4, #2
saba v18.8h, v27.8h, v25.8h
b.ge 1b
cbz w4, 3f
// iterate by one
2:
ld1 {v4.8b}, [x1], x3
subs w4, w4, #1
ext v5.8b, v4.8b, v4.8b, #1 // x1 + stride + 1
ld1 {v6.8b}, [x2], x3
usubl v31.8h, v0.8b, v4.8b
ext v7.8b, v6.8b, v6.8b, #1 // x2 + stride + 1
usubl v29.8h, v1.8b, v5.8b
saba v16.8h, v31.8h, v29.8h
usubl v27.8h, v2.8b, v6.8b
usubl v25.8h, v3.8b, v7.8b
saba v18.8h, v27.8h, v25.8h
mov v0.16b, v4.16b
mov v1.16b, v5.16b
mov v2.16b, v6.16b
mov v3.16b, v7.16b
cbnz w4, 2b
3:
sqsub v16.8h, v16.8h, v18.8h
ins v16.h[7], wzr
saddlv s16, v16.8h
sqabs s16, s16
fmov w0, s16
mul w0, w0, w5
add w0, w0, w9
ret
endfunc
function pix_median_abs16_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
ld1 {v2.16b}, [x1], x3
ld1 {v3.16b}, [x2], x3
movi v31.8h, #0
movi v16.8h, #0
ext v0.16b, v2.16b, v2.16b, #1
ext v1.16b, v3.16b, v3.16b, #1
usubl v28.8h, v2.8b, v3.8b
usubl2 v27.8h, v2.16b, v3.16b
usubl v26.8h, v0.8b, v1.8b
usubl2 v25.8h, v0.16b, v1.16b
sub w4, w4, #1 // we need to make h-1 iterations
saba v31.8h, v26.8h, v28.8h
saba v16.8h, v25.8h, v27.8h
mov h18, v28.h[0]
cmp w4, #1
sqabs h18, h18
movi v0.8h, #0
b.lt 2f
1:
ld1 {v6.16b}, [x1], x3 // pix1 vector for V(j-1)
ld1 {v7.16b}, [x2], x3 // pix2 vector for V(j-1)
subs w4, w4, #1
ext v4.16b, v6.16b, v6.16b, #1 // pix1 vector for V(j)
ext v5.16b, v7.16b, v7.16b, #1 // pix2 vector for V(j)
// protected registers: v30, v29, v28, v27, v26, v25, v24, v23
// scratch registers: v22, v21, v20, v19, v17
// To find median of three values, calculate sum of them
// and subtract max and min value from it.
usubl v30.8h, v6.8b, v7.8b // V(j-1)
usubl2 v29.8h, v6.16b, v7.16b // V(j-1)
usubl v24.8h, v4.8b, v5.8b // V(j)
usubl2 v23.8h, v4.16b, v5.16b // V(j)
saba v0.8h, v30.8h, v28.8h
add v22.8h, v26.8h, v30.8h
smin v20.8h, v26.8h, v30.8h
add v21.8h, v25.8h, v29.8h
smax v19.8h, v26.8h, v30.8h
sub v22.8h, v22.8h, v28.8h
sub v21.8h, v21.8h, v27.8h
smin v17.8h, v19.8h, v22.8h
smin v22.8h, v25.8h, v29.8h
mov v28.16b, v30.16b
smax v20.8h, v20.8h, v17.8h // median values lower half
smax v19.8h, v25.8h, v29.8h
saba v31.8h, v24.8h, v20.8h
mov v27.16b, v29.16b
smin v19.8h, v19.8h, v21.8h
mov v26.16b, v24.16b
smax v17.8h, v22.8h, v19.8h // median values upper half
mov v25.16b, v23.16b
saba v16.8h, v23.8h, v17.8h
b.ne 1b
2:
mov h17, v0.h[0]
ins v16.h[7], wzr
add d18, d18, d17
add v31.8h, v31.8h, v16.8h
uaddlv s17, v31.8h
add d18, d18, d17
fmov w0, s18
ret
endfunc
function vsad_intra8_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *dummy
// x3 ptrdiff_t stride
// w4 int h
ld1 {v0.8b}, [x1], x3
sub w4, w4, #1 // we need to make h-1 iterations
cmp w4, #3
movi v16.8h, #0
b.lt 2f
1:
// v = abs( pix1[0] - pix1[0 + stride] )
// score = sum(v)
ld1 {v1.8b}, [x1], x3
sub w4, w4, #3
ld1 {v2.8b}, [x1], x3
uabal v16.8h, v0.8b, v1.8b
ld1 {v3.8b}, [x1], x3
uabal v16.8h, v1.8b, v2.8b
cmp w4, #3
mov v0.8b, v3.8b
uabal v16.8h, v2.8b, v3.8b
b.ge 1b
cbz w4, 3f
2:
ld1 {v1.8b}, [x1], x3
subs w4, w4, #1
uabal v16.8h, v0.8b, v1.8b
mov v0.8b, v1.8b
cbnz w4, 2b
3:
uaddlv s17, v16.8h
fmov w0, s17
ret
endfunc
function pix_median_abs8_neon, export=1
// x0 unused
// x1 uint8_t *pix1
// x2 uint8_t *pix2
// x3 ptrdiff_t stride
// w4 int h
ld1 {v2.8b}, [x1], x3
ld1 {v3.8b}, [x2], x3
movi v31.8h, #0
ext v0.8b, v2.8b, v2.8b, #1
ext v1.8b, v3.8b, v3.8b, #1
usubl v28.8h, v2.8b, v3.8b
usubl v26.8h, v0.8b, v1.8b
sub w4, w4, #1 // we need to make h-1 iterations
saba v31.8h, v26.8h, v28.8h
mov h18, v28.h[0]
cmp w4, #1
sqabs h18, h18
movi v0.8h, #0
b.lt 2f
1:
ld1 {v6.8b}, [x1], x3 // pix1 vector for V(j-1)
ld1 {v7.8b}, [x2], x3 // pix2 vector for V(j-1)
subs w4, w4, #1
ext v4.8b, v6.8b, v6.8b, #1 // pix1 vector for V(j)
ext v5.8b, v7.8b, v7.8b, #1 // pix2 vector for V(j)
// protected registers: v30, v29, v28, v27, v26, v25, v24, v23
// scratch registers: v22, v21, v20, v19, v17
// To find median of three values, calculate sum of them
// and subtract max and min value from it.
usubl v30.8h, v6.8b, v7.8b // V(j-1)
usubl v24.8h, v4.8b, v5.8b // V(j)
saba v0.8h, v30.8h, v28.8h
add v22.8h, v26.8h, v30.8h
smin v20.8h, v26.8h, v30.8h
smax v19.8h, v26.8h, v30.8h
sub v22.8h, v22.8h, v28.8h
smin v17.8h, v19.8h, v22.8h
mov v28.16b, v30.16b
smax v20.8h, v20.8h, v17.8h // median values lower half
smax v19.8h, v25.8h, v29.8h
saba v31.8h, v24.8h, v20.8h
mov v26.16b, v24.16b
smax v17.8h, v22.8h, v19.8h // median values upper half
b.ne 1b
2:
mov h17, v0.h[0]
ins v31.h[7], wzr
add d18, d18, d17
uaddlv s17, v31.8h
add d18, d18, d17
fmov w0, s18
ret
endfunc
Reference in New Issue View Git Blame Copy Permalink