//******************************************************************************
//*
//* Copyright (C) 2015 The Android Open Source Project
//*
//* Licensed under the Apache License, Version 2.0 (the "License");
//* you may not use this file except in compliance with the License.
//* You may obtain a copy of the License at:
//*
//* http://www.apache.org/licenses/LICENSE-2.0
//*
//* Unless required by applicable law or agreed to in writing, software
//* distributed under the License is distributed on an "AS IS" BASIS,
//* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//* See the License for the specific language governing permissions and
//* limitations under the License.
//*
//*****************************************************************************
//* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
//*/
//**
///**
//******************************************************************************
//*
//*
//* @brief
//* This file contains definitions of routines that compute distortion
//* between two macro/sub blocks of identical dimensions
//*
//* @author
//* Ittiam
//*
//* @par List of Functions:
//* - ime_compute_sad_16x16()
//* - ime_compute_sad_8x8()
//* - ime_compute_sad_4x4()
//* - ime_compute_sad_16x8()
//* - ime_compute_satqd_16x16_lumainter_av8()
//*
//* @remarks
//* None
//*
//*******************************************************************************
//
///**
//******************************************************************************
//*
//* @brief computes distortion (SAD) between 2 16x16 blocks (fast mode)
//*
//* @par Description
//* This functions computes SAD between 2 16x16 blocks. There is a provision
//* for early exit if the up-to computed SAD exceeds maximum allowed SAD. To
//* compute the distortion of the entire block set u4_max_sad to USHRT_MAX.
//*
//* @param[in] pu1_src
//* UWORD8 pointer to the source
//*
//* @param[out] pu1_dst
//* UWORD8 pointer to the destination
//*
//* @param[in] src_strd
//* integer source stride
//*
//* @param[in] dst_strd
//* integer destination stride
//*
//* @param[in] i4_max_sad
//* integer maximum allowed distortion
//*
//* @param[in] pi4_mb_distortion
//* integer evaluated sad
//*
//* @remarks
//*
//******************************************************************************
//*/
.text
.p2align 2
.macro push_v_regs
stp d8, d9, [sp, #-16]!
stp d10, d11, [sp, #-16]!
stp d12, d13, [sp, #-16]!
stp d14, d15, [sp, #-16]!
.endm
.macro pop_v_regs
ldp d14, d15, [sp], #16
ldp d12, d13, [sp], #16
ldp d10, d11, [sp], #16
ldp d8, d9, [sp], #16
.endm
.global ime_compute_sad_16x16_fast_av8
ime_compute_sad_16x16_fast_av8:
push_v_regs
lsl x2, x2, #1
lsl x3, x3, #1
mov x6, #2
movi v30.8h, #0
core_loop_ime_compute_sad_16x16_fast_av8:
ld1 {v0.16b}, [x0], x2
ld1 {v1.16b}, [x1], x3
ld1 {v2.16b}, [x0], x2
ld1 {v3.16b}, [x1], x3
uabal v30.8h, v0.8b, v1.8b
uabal2 v30.8h, v0.16b, v1.16b
uabal v30.8h, v2.8b, v3.8b
uabal2 v30.8h, v2.16b, v3.16b
ld1 {v4.16b}, [x0], x2
ld1 {v5.16b}, [x1], x3
ld1 {v6.16b}, [x0], x2
ld1 {v7.16b}, [x1], x3
uabal v30.8h, v4.8b, v5.8b
uabal2 v30.8h, v4.16b, v5.16b
uabal v30.8h, v6.8b, v7.8b
uabal2 v30.8h, v6.16b, v7.16b
subs x6, x6, #1
bne core_loop_ime_compute_sad_16x16_fast_av8
addp v30.8h, v30.8h, v30.8h
uaddlp v30.4s, v30.8h
addp v30.2s, v30.2s, v30.2s
shl v30.2s, v30.2s, #1
st1 {v30.s}[0], [x5]
pop_v_regs
ret
///**
//******************************************************************************
//*
//* @brief computes distortion (SAD) between 2 16x8 blocks
//*
//*
//* @par Description
//* This functions computes SAD between 2 16x8 blocks. There is a provision
//* for early exit if the up-to computed SAD exceeds maximum allowed SAD. To
//* compute the distortion of the entire block set u4_max_sad to USHRT_MAX.
//*
//* @param[in] pu1_src
//* UWORD8 pointer to the source
//*
//* @param[out] pu1_dst
//* UWORD8 pointer to the destination
//*
//* @param[in] src_strd
//* integer source stride
//*
//* @param[in] dst_strd
//* integer destination stride
//*
//* @param[in] u4_max_sad
//* integer maximum allowed distortion
//*
//* @param[in] pi4_mb_distortion
//* integer evaluated sad
//*
//* @remarks
//*
//******************************************************************************
//*/
//
.global ime_compute_sad_16x8_av8
ime_compute_sad_16x8_av8:
//chheck what stride incremtn to use
//earlier code did not have this lsl
push_v_regs
mov x6, #2
movi v30.8h, #0
core_loop_ime_compute_sad_16x8_av8:
ld1 {v0.16b}, [x0], x2
ld1 {v1.16b}, [x1], x3
ld1 {v2.16b}, [x0], x2
ld1 {v3.16b}, [x1], x3
uabal v30.8h, v0.8b, v1.8b
uabal2 v30.8h, v0.16b, v1.16b
uabal v30.8h, v2.8b, v3.8b
uabal2 v30.8h, v2.16b, v3.16b
ld1 {v4.16b}, [x0], x2
ld1 {v5.16b}, [x1], x3
ld1 {v6.16b}, [x0], x2
ld1 {v7.16b}, [x1], x3
uabal v30.8h, v4.8b, v5.8b
uabal2 v30.8h, v4.16b, v5.16b
uabal v30.8h, v6.8b, v7.8b
uabal2 v30.8h, v6.16b, v7.16b
subs x6, x6, #1
bne core_loop_ime_compute_sad_16x8_av8
addp v30.8h, v30.8h, v30.8h
uaddlp v30.4s, v30.8h
addp v30.2s, v30.2s, v30.2s
st1 {v30.s}[0], [x5]
pop_v_regs
ret
///**
//******************************************************************************
//*
//* @brief computes distortion (SAD) between 2 16x16 blocks with early exit
//*
//* @par Description
//* This functions computes SAD between 2 16x16 blocks. There is a provision
//* for early exit if the up-to computed SAD exceeds maximum allowed SAD. To
//* compute the distortion of the entire block set u4_max_sad to USHRT_MAX.
//*
//* @param[in] pu1_src
//* UWORD8 pointer to the source
//*
//* @param[out] pu1_dst
//* UWORD8 pointer to the destination
//*
//* @param[in] src_strd
//* integer source stride
//*
//* @param[in] dst_strd
//* integer destination stride
//*
//* @param[in] i4_max_sad
//* integer maximum allowed distortion
//*
//* @param[in] pi4_mb_distortion
//* integer evaluated sad
//*
//* @remarks
//*
//******************************************************************************
//*/
.global ime_compute_sad_16x16_ea8_av8
ime_compute_sad_16x16_ea8_av8:
push_v_regs
movi v30.8h, #0
add x7, x0, x2
add x8, x1, x3
lsl x2, x2, #1
lsl x3, x3, #1
ld1 {v0.16b}, [x0], x2
ld1 {v1.16b}, [x1], x3
ld1 {v2.16b}, [x0], x2
ld1 {v3.16b}, [x1], x3
ld1 {v8.16b}, [x0], x2
ld1 {v9.16b}, [x1], x3
ld1 {v10.16b}, [x0], x2
ld1 {v11.16b}, [x1], x3
ld1 {v12.16b}, [x0], x2
ld1 {v13.16b}, [x1], x3
ld1 {v14.16b}, [x0], x2
ld1 {v15.16b}, [x1], x3
ld1 {v16.16b}, [x0], x2
ld1 {v17.16b}, [x1], x3
ld1 {v18.16b}, [x0], x2
ld1 {v19.16b}, [x1], x3
uabal v30.8h, v0.8b, v1.8b
uabal2 v30.8h, v0.16b, v1.16b
uabal v30.8h, v2.8b, v3.8b
uabal2 v30.8h, v2.16b, v3.16b
uabal v30.8h, v8.8b, v9.8b
uabal2 v30.8h, v8.16b, v9.16b
uabal v30.8h, v10.8b, v11.8b
uabal2 v30.8h, v10.16b, v11.16b
uabal v30.8h, v12.8b, v13.8b
uabal2 v30.8h, v12.16b, v13.16b
uabal v30.8h, v14.8b, v15.8b
uabal2 v30.8h, v14.16b, v15.16b
uabal v30.8h, v16.8b, v17.8b
uabal2 v30.8h, v16.16b, v17.16b
uabal v30.8h, v18.8b, v19.8b
uabal2 v30.8h, v18.16b, v19.16b
addp v31.8h, v30.8h, v30.8h
uaddlp v31.4s, v31.8h
addp v31.2s, v31.2s, v31.2s
mov w6, v31.s[0]
cmp w6, w4
bgt end_func_16x16
//do the stuff again
ld1 {v0.16b}, [x7], x2
ld1 {v1.16b}, [x8], x3
ld1 {v2.16b}, [x7], x2
ld1 {v3.16b}, [x8], x3
ld1 {v8.16b}, [x7], x2
ld1 {v9.16b}, [x8], x3
ld1 {v10.16b}, [x7], x2
ld1 {v11.16b}, [x8], x3
ld1 {v12.16b}, [x7], x2
ld1 {v13.16b}, [x8], x3
ld1 {v14.16b}, [x7], x2
ld1 {v15.16b}, [x8], x3
ld1 {v16.16b}, [x7], x2
ld1 {v17.16b}, [x8], x3
ld1 {v18.16b}, [x7], x2
ld1 {v19.16b}, [x8], x3
uabal v30.8h, v0.8b, v1.8b
uabal2 v30.8h, v0.16b, v1.16b
uabal v30.8h, v2.8b, v3.8b
uabal2 v30.8h, v2.16b, v3.16b
uabal v30.8h, v8.8b, v9.8b
uabal2 v30.8h, v8.16b, v9.16b
uabal v30.8h, v10.8b, v11.8b
uabal2 v30.8h, v10.16b, v11.16b
uabal v30.8h, v12.8b, v13.8b
uabal2 v30.8h, v12.16b, v13.16b
uabal v30.8h, v14.8b, v15.8b
uabal2 v30.8h, v14.16b, v15.16b
uabal v30.8h, v16.8b, v17.8b
uabal2 v30.8h, v16.16b, v17.16b
uabal v30.8h, v18.8b, v19.8b
uabal2 v30.8h, v18.16b, v19.16b
addp v31.8h, v30.8h, v30.8h
uaddlp v31.4s, v31.8h
addp v31.2s, v31.2s, v31.2s
end_func_16x16:
st1 {v31.s}[0], [x5]
pop_v_regs
ret
///*
////---------------------------------------------------------------------------
//// Function Name : ime_calculate_sad2_prog_av8()
////
//// Detail Description : This function find the sad values of 4 Progressive MBs
//// at one shot
////
//// Platform : CortexAv8/NEON .
////
////-----------------------------------------------------------------------------
//*/
.global ime_calculate_sad2_prog_av8
ime_calculate_sad2_prog_av8:
// x0 = ref1 <UWORD8 *>
// x1 = ref2 <UWORD8 *>
// x2 = src <UWORD8 *>
// x3 = RefBufferWidth <UWORD32>
// stack = CurBufferWidth <UWORD32>, psad <UWORD32 *>
push_v_regs
mov x6, #8
movi v30.8h, #0
movi v31.8h, #0
core_loop_ime_calculate_sad2_prog_av8:
ld1 {v0.16b}, [x0], x3
ld1 {v1.16b}, [x1], x3
ld1 {v2.16b}, [x3], x4
ld1 {v3.16b}, [x0], x3
ld1 {v4.16b}, [x1], x3
ld1 {v5.16b}, [x3], x4
uabal v30.8h, v0.8b, v2.8b
uabal2 v30.8h, v0.16b, v2.16b
uabal v31.8h, v1.8b, v2.8b
uabal2 v31.8h, v1.16b, v2.16b
uabal v30.8h, v3.8b, v5.8b
uabal2 v30.8h, v3.16b, v5.16b
uabal v31.8h, v4.8b, v5.8b
uabal2 v31.8h, v4.16b, v5.16b
ld1 {v6.16b}, [x0], x3
ld1 {v7.16b}, [x1], x3
ld1 {v8.16b}, [x3], x4
ld1 {v9.16b}, [x0], x3
ld1 {v10.16b}, [x1], x3
ld1 {v11.16b}, [x3], x4
uabal v30.8h, v6.8b, v8.8b
uabal2 v30.8h, v6.16b, v8.16b
uabal v31.8h, v7.8b, v8.8b
uabal2 v31.8h, v7.16b, v8.16b
uabal v30.8h, v9.8b, v11.8b
uabal2 v30.8h, v9.16b, v11.16b
uabal v31.8h, v10.8b, v11.8b
uabal2 v31.8h, v0.16b, v11.16b
subs x6, x6, #1
bne core_loop_ime_calculate_sad2_prog_av8
addp v30.8h, v30.8h, v31.8h
uaddlp v30.4s, v30.8h
addp v30.2s, v30.2s, v30.2s
shl v30.2s, v30.2s, #1
st1 {v30.2s}, [x5]
pop_v_regs
ret
///*
////---------------------------------------------------------------------------
//// Function Name : Calculate_Mad3_prog()
////
//// Detail Description : This function find the sad values of 4 Progressive MBs
//// at one shot
////
//// Platform : CortexA8/NEON .
////
////-----------------------------------------------------------------------------
//*/
.global ime_calculate_sad3_prog_av8
ime_calculate_sad3_prog_av8:
// x0 = ref1 <UWORD8 *>
// x1 = ref2 <UWORD8 *>
// x2 = ref3 <UWORD8 *>
// x3 = src <UWORD8 *>
// stack = RefBufferWidth <UWORD32>, CurBufferWidth <UWORD32>, psad <UWORD32 *>
// x0 = ref1 <UWORD8 *>
// x1 = ref2 <UWORD8 *>
// x2 = src <UWORD8 *>
// x3 = RefBufferWidth <UWORD32>
// stack = CurBufferWidth <UWORD32>, psad <UWORD32 *>
push_v_regs
mov x6, #16
movi v29.8h, #0
movi v30.8h, #0
movi v31.8h, #0
core_loop_ime_calculate_sad3_prog_av8:
ld1 {v0.16b}, [x0], x4
ld1 {v1.16b}, [x1], x4
ld1 {v2.16b}, [x2], x4
ld1 {v3.16b}, [x3], x5
uabal v29.8h, v0.8b, v3.8b
uabal2 v29.8h, v0.16b, v3.16b
uabal v30.8h, v1.8b, v3.8b
uabal2 v30.8h, v1.16b, v3.16b
uabal v31.8h, v2.8b, v3.8b
uabal2 v31.8h, v2.16b, v3.16b
ld1 {v4.16b}, [x0], x4
ld1 {v5.16b}, [x1], x4
ld1 {v6.16b}, [x2], x4
ld1 {v7.16b}, [x3], x5
uabal v29.8h, v4.8b, v7.8b
uabal2 v29.8h, v4.16b, v7.16b
uabal v30.8h, v5.8b, v7.8b
uabal2 v30.8h, v5.16b, v7.16b
uabal v31.8h, v6.8b, v7.8b
uabal2 v31.8h, v6.16b, v7.16b
subs x6, x6, #1
bne core_loop_ime_calculate_sad2_prog_av8
addp v30.8h, v30.8h, v31.8h
uaddlp v30.4s, v30.8h
addp v30.2s, v30.2s, v30.2s
shl v30.2s, v30.2s, #1
st1 {v30.2s}, [x5]
pop_v_regs
ret
///**
//******************************************************************************
//*
//* @brief computes distortion (SAD) for sub-pel motion estimation
//*
//* @par Description
//* This functions computes SAD for all the 8 half pel points
//*
//* @param[out] pi4_sad
//* integer evaluated sad
//* pi4_sad[0] - half x
//* pi4_sad[1] - half x - 1
//* pi4_sad[2] - half y
//* pi4_sad[3] - half y - 1
//* pi4_sad[4] - half xy
//* pi4_sad[5] - half xy - 1
//* pi4_sad[6] - half xy - strd
//* pi4_sad[7] - half xy - 1 - strd
//*
//* @remarks
//*
//******************************************************************************
//*/
.text
.p2align 2
.global ime_sub_pel_compute_sad_16x16_av8
ime_sub_pel_compute_sad_16x16_av8:
push_v_regs
sub x7, x1, #1 //x left
sub x8, x2, x5 //y top
sub x9, x3, #1 //xy left
sub x10, x3, x5 //xy top
sub x11, x10, #1 //xy top left
movi v24.8h, #0
movi v25.8h, #0
movi v26.8h, #0
movi v27.8h, #0
movi v28.8h, #0
movi v29.8h, #0
movi v30.8h, #0
movi v31.8h, #0
mov x12, #16
core_loop_ime_sub_pel_compute_sad_16x16_av8:
ld1 {v0.16b}, [x0], x4 //src
ld1 {v1.16b}, [x1], x5 //x
ld1 {v2.16b}, [x7], x5 //x left
ld1 {v3.16b}, [x2], x5 //y
ld1 {v9.16b}, [x8], x5 //y top
ld1 {v10.16b}, [x3], x5 //xy
ld1 {v11.16b}, [x9], x5 //xy left
ld1 {v12.16b}, [x10], x5 //xy top
ld1 {v13.16b}, [x11], x5 //xy top left
uabal v24.8h, v0.8b, v1.8b
uabal2 v24.8h, v0.16b, v1.16b
uabal v25.8h, v0.8b, v2.8b
uabal2 v25.8h, v0.16b, v2.16b
uabal v26.8h, v0.8b, v3.8b
uabal2 v26.8h, v0.16b, v3.16b
uabal v27.8h, v0.8b, v9.8b
uabal2 v27.8h, v0.16b, v9.16b
uabal v28.8h, v0.8b, v10.8b
uabal2 v28.8h, v0.16b, v10.16b
uabal v29.8h, v0.8b, v11.8b
uabal2 v29.8h, v0.16b, v11.16b
uabal v30.8h, v0.8b, v12.8b
uabal2 v30.8h, v0.16b, v12.16b
uabal v31.8h, v0.8b, v13.8b
uabal2 v31.8h, v0.16b, v13.16b
subs x12, x12, #1
bne core_loop_ime_sub_pel_compute_sad_16x16_av8
addp v24.8h, v24.8h, v25.8h
addp v26.8h, v26.8h, v27.8h
addp v28.8h, v28.8h, v29.8h
addp v30.8h, v30.8h, v31.8h
uaddlp v24.4s, v24.8h
uaddlp v26.4s, v26.8h
uaddlp v28.4s, v28.8h
uaddlp v30.4s, v30.8h
addp v24.4s, v24.4s, v26.4s
addp v25.4s, v28.4s, v30.4s
st1 {v24.4s-v25.4s}, [x6]
pop_v_regs
ret
///**
//******************************************************************************
//*
//* @brief computes distortion (SAD) between 2 16x16 blocks
//*
//* @par Description
//* This functions computes SAD between 2 16x16 blocks. There is a provision
//* for early exit if the up-to computed SAD exceeds maximum allowed SAD. To
//* compute the distortion of the entire block set u4_max_sad to USHRT_MAX.
//*
//* @param[in] pu1_src
//* UWORD8 pointer to the source
//*
//* @param[out] pu1_dst
//* UWORD8 pointer to the destination
//*
//* @param[in] src_strd
//* integer source stride
//*
//* @param[in] dst_strd
//* integer destination stride
//*
//* @param[in] i4_max_sad
//* integer maximum allowed distortion
//*
//* @param[in] pi4_mb_distortion
//* integer evaluated sad
//*
//* @remarks
//*
//******************************************************************************
//*/
.global ime_compute_sad_16x16_av8
ime_compute_sad_16x16_av8:
push_v_regs
mov x6, #4
movi v30.8h, #0
core_loop_ime_compute_sad_16x16_av8:
ld1 {v0.16b}, [x0], x2
ld1 {v1.16b}, [x1], x3
ld1 {v2.16b}, [x0], x2
ld1 {v3.16b}, [x1], x3
uabal v30.8h, v0.8b, v1.8b
uabal2 v30.8h, v0.16b, v1.16b
uabal v30.8h, v2.8b, v3.8b
uabal2 v30.8h, v2.16b, v3.16b
ld1 {v4.16b}, [x0], x2
ld1 {v5.16b}, [x1], x3
ld1 {v6.16b}, [x0], x2
ld1 {v7.16b}, [x1], x3
uabal v30.8h, v4.8b, v5.8b
uabal2 v30.8h, v4.16b, v5.16b
uabal v30.8h, v6.8b, v7.8b
uabal2 v30.8h, v6.16b, v7.16b
subs x6, x6, #1
bne core_loop_ime_compute_sad_16x16_av8
addp v30.8h, v30.8h, v30.8h
uaddlp v30.4s, v30.8h
addp v30.2s, v30.2s, v30.2s
st1 {v30.s}[0], [x5]
pop_v_regs
ret
///*
////---------------------------------------------------------------------------
//// Function Name : Calculate_Mad4_prog()
////
//// Detail Description : This function find the sad values of 4 Progressive MBs
//// at one shot
////
//// Platform : CortexA8/NEON .
////
////-----------------------------------------------------------------------------
//*/
.global ime_calculate_sad4_prog_av8
ime_calculate_sad4_prog_av8:
push_v_regs
sub x5, x0, #1 //left
add x6, x0, #1 //right
sub x7, x0, x2 //top
add x8, x0, x2 //bottom
movi v28.8h, #0
movi v29.8h, #0
movi v30.8h, #0
movi v31.8h, #0
mov x9, #16
core_loop_ime_calculate_sad4_prog_av8:
ld1 {v0.16b}, [x1], x3
ld1 {v1.16b}, [x5], x2
ld1 {v2.16b}, [x6], x2
ld1 {v3.16b}, [x7], x2
ld1 {v9.16b}, [x8], x2
uabal v28.8h, v0.8b, v1.8b
uabal2 v28.8h, v0.16b, v1.16b
uabal v29.8h, v0.8b, v2.8b
uabal2 v29.8h, v0.16b, v2.16b
uabal v30.8h, v0.8b, v3.8b
uabal2 v30.8h, v0.16b, v3.16b
uabal v31.8h, v0.8b, v9.8b
uabal2 v31.8h, v0.16b, v9.16b
subs x9, x9, #1
bne core_loop_ime_calculate_sad4_prog_av8
addp v28.8h, v28.8h, v29.8h
addp v30.8h, v30.8h, v31.8h
uaddlp v28.4s, v28.8h
uaddlp v30.4s, v30.8h
addp v28.4s, v28.4s, v30.4s
st1 {v28.4s}, [x4]
pop_v_regs
ret
//*****************************************************************************
//*
//* Function Name : ime_compute_satqd_16x16_lumainter_av8
//* Description : This fucntion computes SAD for a 16x16 block.
// : It also computes if any 4x4 block will have a nonzero coefficent after transform and quant
//
// Arguments : x0 :pointer to src buffer
// x1 :pointer to est buffer
// x2 :source stride
// x3 :est stride
// STACk :Threshold,distotion,is_nonzero
//*
//* Values Returned : NONE
//*
//* Register Usage : x0-x11
//* Stack Usage :
//* Cycles : Around
//* Interruptiaility : Interruptable
//*
//* Known Limitations
//* \Assumptions :
//*
//* Revision History :
//* DD MM YYYY Author(s) Changes
//* 14 04 2014 Harinarayanan K K First version
//*
//*****************************************************************************
.global ime_compute_satqd_16x16_lumainter_av8
ime_compute_satqd_16x16_lumainter_av8:
//x0 :pointer to src buffer
//x1 :pointer to est buffer
//x2 :Source stride
//x3 :Pred stride
//x4 :Threshold pointer
//x5 :Distortion,ie SAD
//x6 :is nonzero
//x7 :loop counter
push_v_regs
stp d8, d9, [sp, #-16]!
stp d10, d11, [sp, #-16]!
stp d12, d13, [sp, #-16]!
stp d14, d15, [sp, #-16]!
ld1 {v30.8h}, [x4]
dup v20.4h, v30.h[1] //ls1
dup v24.4h, v30.h[0] //ls2
dup v21.4h, v30.h[5] //ls3
dup v25.4h, v30.h[7] //ls4
dup v22.4h, v30.h[3] //ls5
dup v26.4h, v30.h[4] //ls6
dup v23.4h, v30.h[6] //ls7
dup v27.4h, v30.h[2] //ls8
mov v20.d[1], v24.d[0]
mov v21.d[1], v25.d[0]
mov v22.d[1], v26.d[0]
mov v23.d[1], v27.d[0]
add x4, x4, #16
ld1 {v29.h}[0], [x4]
dup v29.4h, v29.h[0]
movi v31.8h, #0
mov x7, #4
core_loop_satqd_ime_compute_satqd_16x16_lumainter:
ld1 {v0.16b}, [x0], x2
ld1 {v1.16b}, [x1], x3
ld1 {v2.16b}, [x0], x2
ld1 {v3.16b}, [x1], x3
ld1 {v4.16b}, [x0], x2
ld1 {v5.16b}, [x1], x3
ld1 {v6.16b}, [x0], x2
ld1 {v7.16b}, [x1], x3
uabdl v10.8h, v0.8b, v1.8b
uabdl2 v15.8h, v0.16b, v1.16b
uabdl v11.8h, v2.8b, v3.8b
uabdl2 v16.8h, v2.16b, v3.16b
uabdl v12.8h, v4.8b, v5.8b
uabdl2 v17.8h, v4.16b, v5.16b
uabdl v13.8h, v6.8b, v7.8b
uabdl2 v18.8h, v6.16b, v7.16b
add v0.8h, v10.8h, v13.8h
add v1.8h, v11.8h, v12.8h
add v2.8h, v15.8h, v18.8h
add v3.8h, v16.8h, v17.8h
//v0 : S1 S4 S4 S1 A1 A4 A4 A1
//v1 : S2 S3 S3 S2 A2 A3 A3 A2
//v2 : B1 B4 B4 B1 X1 X4 X4 X1
//v3 : B3 B2 B2 B3 X3 X2 X2 X3
trn1 v4.8h, v0.8h, v1.8h
trn2 v5.8h, v0.8h, v1.8h
trn1 v6.8h, v2.8h, v3.8h
trn2 v7.8h, v2.8h, v3.8h
trn1 v0.4s, v4.4s, v6.4s
trn2 v2.4s, v4.4s, v6.4s
trn1 v1.4s, v5.4s, v7.4s
trn2 v3.4s, v5.4s, v7.4s
add v4.8h, v0.8h, v3.8h
add v5.8h, v1.8h, v2.8h
//v4 : S1 S2 B1 B2 A1 A2 X1 X2
//v5 : S4 S3 B4 B3 A4 A3 X4 X3
//compute sad for each 4x4 block
add v6.8h, v4.8h, v5.8h
addp v19.8h, v6.8h, v6.8h
//duplicate the sad into 128 bit so that we can compare using 128bit
add v31.4h, v31.4h, v19.4h
//sad_2 = sad_1<<1;
shl v28.8h, v19.8h, #1
//sad_2 - pu2_thrsh
sub v24.8h, v28.8h, v20.8h
sub v25.8h, v28.8h, v21.8h
sub v26.8h, v28.8h, v22.8h
sub v27.8h, v28.8h, v23.8h
trn1 v0.4s, v4.4s, v5.4s
trn2 v1.4s, v4.4s, v5.4s
//v0 : S1 S2 S4 S3 A1 A2 A4 A3
//v1 : B1 B2 B4 B3 X1 X2 X4 X3
trn1 v4.8h, v0.8h, v1.8h
trn2 v5.8h, v0.8h, v1.8h
//v4 : S1 B1 S4 B4 A1 X1 A4 X4
//v5 : S2 B2 S3 B3 A2 X2 A3 X3
mov v7.s[0], v4.s[1]
mov v7.s[1], v4.s[3]
mov v6.s[0], v5.s[1] // V4 //S1 B1 A1 X1
mov v6.s[1], v5.s[3] // V5 //S2 B2 A2 X2
mov v4.s[1], v4.s[2] // V6 //S3 B3 A3 X3
mov v5.s[1], v5.s[2] // V7 //S4 B4 A4 X4
shl v0.4h, v4.4h, #1 //S1<<1
shl v1.4h, v5.4h, #1 //S2<<1
shl v2.4h, v6.4h, #1 //S3<<1
shl v3.4h, v7.4h, #1 //S4<<1
add v8.4h, v5.4h, v6.4h //(s2[j] + s3[j]))
add v9.4h, v4.4h, v7.4h //(s1[j] + s4[j]))
add v10.4h, v6.4h, v7.4h //(s3[j] + s4[j]))
sub v11.4h, v6.4h, v0.4h //(s3[j] - (s1[j]<<1))
sub v12.4h, v7.4h, v1.4h //(s4[j] - (s2[j]<<1))
add v13.4h, v4.4h, v5.4h //(s1[j] + s2[j]))
sub v14.4h, v5.4h, v3.4h //(s2[j] - (s4[j]<<1)))
sub v15.4h, v4.4h, v2.4h //(s1[j] - (s3[j]<<1)))
mov v8.d[1], v9.d[0]
mov v10.d[1], v11.d[0]
mov v12.d[1], v13.d[0]
mov v14.d[1], v15.d[0]
cmge v0.8h, v24.8h, v8.8h //ls1 ls2
cmge v1.8h, v25.8h, v10.8h //ls3 ls4
cmge v2.8h, v26.8h, v12.8h //ls5 ls6
cmge v3.8h, v27.8h, v14.8h //ls7 ls8
cmge v4.4h, v19.4h, v29.4h //sad
orr v0.16b, v0.16b, v1.16b
orr v2.16b, v2.16b, v3.16b
orr v2.16b, v0.16b, v2.16b
xtn v2.8b, v2.8h
orr v2.8b, v2.8b, v4.8b
//if the comparison is non zero, out
mov x4, v2.d[0]
cmp x4, #0
bne core_loop_compute_sad_pre
subs x7, x7, #1
bne core_loop_satqd_ime_compute_satqd_16x16_lumainter
b satdq_end_func
core_loop_compute_sad:
ld1 {v0.16b}, [x0], x2
ld1 {v1.16b}, [x1], x3
ld1 {v2.16b}, [x0], x2
ld1 {v3.16b}, [x1], x3
uabal v31.8h, v0.8b, v1.8b
uabal2 v31.8h, v0.16b, v1.16b
uabal v31.8h, v2.8b, v3.8b
uabal2 v31.8h, v2.16b, v3.16b
ld1 {v4.16b}, [x0], x2
ld1 {v5.16b}, [x1], x3
ld1 {v6.16b}, [x0], x2
ld1 {v7.16b}, [x1], x3
uabal v31.8h, v4.8b, v5.8b
uabal2 v31.8h, v4.16b, v5.16b
uabal v31.8h, v6.8b, v7.8b
uabal2 v31.8h, v6.16b, v7.16b
core_loop_compute_sad_pre:
subs x7, x7, #1
bne core_loop_compute_sad
satdq_end_func:
mov x7, #1
cmp x4, #0
csel x7, x4, x7, eq
str w7, [x6]
addp v31.8h, v31.8h, v31.8h
uaddlp v31.4s, v31.8h
addp v31.2s, v31.2s, v31.2s
st1 {v31.s}[0], [x5]
ldp d14, d15, [sp], #16
ldp d12, d13, [sp], #16
ldp d10, d11, [sp], #16
ldp d8, d9, [sp], #16
pop_v_regs
ret