The-Homebrew-Cloud/Cemu
2
0
Fork 0
mirror of https://github.com/cemu-project/Cemu.git synced 2024-11-23 01:29:19 +01:00
Code Issues Packages Projects Releases Wiki Activity
bf2208145b
Cemu/dependencies/ih264d/common/armv8/ih264_deblk_chroma_av8.s
Exzap d60742f52b Add all the files
2022-08-22 22:21:23 +02:00

588 lines
22 KiB
ArmAsm
Raw Blame History

//******************************************************************************
//*
//* 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
//*/
///*****************************************************************************/
///* */
///* File Name : ih264_deblk_chroma_av8.s */
///* */
///* Description : Contains function definitions for deblocking luma */
///* edge. Functions are coded in NEON assembly and can */
///* be compiled using ARM RVDS. */
///* */
///* List of Functions : ih264_deblk_chroma_vert_bs4_av8() */
///* ih264_deblk_chroma_vert_bslt4_av8() */
///* ih264_deblk_chroma_horz_bs4_av8() */
///* ih264_deblk_chroma_horz_bslt4_av8() */
///* Issues / Problems : None */
///* */
///* Revision History : */
///* */
///* DD MM YYYY Author(s) Changes (Describe the changes made) */
///* 28 11 2013 Ittiam Draft */
///*****************************************************************************/
.text
.p2align 2
.include "ih264_neon_macros.s"
///**
//*******************************************************************************
//*
//* @brief
//* Performs filtering of a chroma block horizontal edge when the
//* boundary strength is set to 4 in high profile
//*
//* @par Description:
//* This operation is described in Sec. 8.7.2.4 under the title
//* "Filtering process for edges for bS equal to 4" in ITU T Rec H.264.
//*
//* @param[in] x0 - pu1_src
//* Pointer to the src sample q0
//*
//* @param[in] w1 - src_strd
//* Source stride
//*
//* @param[in] w2 - alpha_cb
//* Alpha Value for the boundary in U
//*
//* @param[in] w3 - beta_cb
//* Beta Value for the boundary in U
//*
//* @param[in] w4 - alpha_cr
//* Alpha Value for the boundary in V
//*
//* @param[in] w5 - beta_cr
//* Beta Value for the boundary in V
//*
//* @returns
//* None
//*
//* @remarks
//* None
//*
//*******************************************************************************
//*/
.global ih264_deblk_chroma_horz_bs4_av8
ih264_deblk_chroma_horz_bs4_av8:
// STMFD sp!,{x4-x6,x14} //
push_v_regs
stp x19, x20, [sp, #-16]!
sxtw x1, w1
mov x6, x5
mov x5, x4
sub x0, x0, x1, lsl #1 //x0 = uc_edgePixel pointing to p1 of chroma
ld2 {v6.8b, v7.8b}, [x0], x1 //D6 = p1u , D7 = p1v
mov x4, x0 //Keeping a backup of the pointer p0 of chroma
ld2 {v4.8b, v5.8b}, [x0], x1 //D4 = p0u , D5 = p0v
dup v20.8b, w2 //D20 contains alpha_cb
dup v21.8b, w5 //D21 contains alpha_cr
mov v20.d[1], v21.d[0]
ld2 {v0.8b, v1.8b}, [x0], x1 //D0 = q0u , D1 = q0v
uaddl v8.8h, v6.8b, v0.8b //
uaddl v10.8h, v7.8b, v1.8b //Q4,Q5 = q0 + p1
movi v31.8b, #2 //
ld2 {v2.8b, v3.8b}, [x0] //D2 = q1u , D3 = q1v
mov v0.d[1], v1.d[0]
mov v2.d[1], v3.d[0]
mov v4.d[1], v5.d[0]
mov v6.d[1], v7.d[0]
uabd v26.16b, v6.16b , v4.16b //Q13 = ABS(p1 - p0)
umlal v8.8h, v2.8b, v31.8b //
umlal v10.8h, v3.8b, v31.8b //Q5,Q4 = (X2(q1U) + q0U + p1U)
uabd v22.16b, v4.16b , v0.16b //Q11 = ABS(p0 - q0)
uabd v24.16b, v2.16b , v0.16b //Q12 = ABS(q1 - q0)
uaddl v14.8h, v4.8b, v2.8b //
uaddl v28.8h, v5.8b, v3.8b //Q14,Q7 = P0 + Q1
dup v16.8b, w3 //D16 contains beta_cb
dup v17.8b, w6 //D17 contains beta_cr
mov v16.d[1], v17.d[0]
umlal v14.8h, v6.8b, v31.8b //
umlal v28.8h, v7.8b, v31.8b //Q14,Q7 = (X2(p1U) + p0U + q1U)
cmhs v18.16b, v22.16b, v20.16b
cmhs v24.16b, v24.16b, v16.16b
cmhs v26.16b, v26.16b, v16.16b
rshrn v8.8b, v8.8h, #2 //
rshrn v9.8b, v10.8h, #2 //Q4 = (X2(q1U) + q0U + p1U + 2) >> 2
mov v8.d[1], v9.d[0]
orr v18.16b, v18.16b , v24.16b //Q9 = ( ABS(p0 - q0) >= Alpha ) | ( ABS(q1 - q0) >= Beta )
rshrn v10.8b, v14.8h, #2 //
rshrn v11.8b, v28.8h, #2 //Q5 = (X2(p1U) + p0U + q1U + 2) >> 2
mov v10.d[1], v11.d[0]
orr v18.16b, v18.16b , v26.16b //Q9 = ( ABS(p0 - q0) >= Alpha ) | ( ABS(q1 - q0) >= Beta ) | ( ABS(p1 - p0) >= Beta )
bit v10.16b, v4.16b , v18.16b //
bit v8.16b, v0.16b , v18.16b //
mov v11.d[0], v10.d[1]
mov v9.d[0], v8.d[1]
st2 {v10.8b, v11.8b}, [x4], x1 //
st2 {v8.8b, v9.8b}, [x4] //
// LDMFD sp!,{x4-x6,pc} //
ldp x19, x20, [sp], #16
pop_v_regs
ret
///**
//*******************************************************************************
//*
//* @brief
//* Performs filtering of a chroma block vertical edge when the
//* boundary strength is set to 4 in high profile
//*
//* @par Description:
//* This operation is described in Sec. 8.7.2.4 under the title
//* "Filtering process for edges for bS equal to 4" in ITU T Rec H.264.
//*
//* @param[in] x0 - pu1_src
//* Pointer to the src sample q0
//*
//* @param[in] w1 - src_strd
//* Source stride
//*
//* @param[in] w2 - alpha_cb
//* Alpha Value for the boundary in U
//*
//* @param[in] w3 - beta_cb
//* Beta Value for the boundary in U
//*
//* @param[in] w4 - alpha_cr
//* Alpha Value for the boundary in V
//*
//* @param[in] w5 - beta_cr
//* Beta Value for the boundary in V
//*
//* @returns
//* None
//*
//* @remarks
//* None
//*
//*******************************************************************************
//*/
.global ih264_deblk_chroma_vert_bs4_av8
ih264_deblk_chroma_vert_bs4_av8:
// STMFD sp!,{x4,x5,x12,x14}
push_v_regs
stp x19, x20, [sp, #-16]!
sxtw x1, w1
sub x0, x0, #4 //point x0 to p1u of row0.
mov x12, x0 //keep a back up of x0 for buffer write
add w2, w2, w4, lsl #8 //w2 = (alpha_cr,alpha_cb)
add w3, w3, w5, lsl #8 //w3 = (beta_cr,beta_cb)
ld4 {v0.h, v1.h, v2.h, v3.h}[0], [x0], x1
ld4 {v0.h, v1.h, v2.h, v3.h}[1], [x0], x1
ld4 {v0.h, v1.h, v2.h, v3.h}[2], [x0], x1
ld4 {v0.h, v1.h, v2.h, v3.h}[3], [x0], x1
ld4 {v4.h, v5.h, v6.h, v7.h}[0], [x0], x1
ld4 {v4.h, v5.h, v6.h, v7.h}[1], [x0], x1
ld4 {v4.h, v5.h, v6.h, v7.h}[2], [x0], x1
ld4 {v4.h, v5.h, v6.h, v7.h}[3], [x0], x1
mov v10.16b, v2.16b
mov v2.16b, v1.16b
mov v1.16b, v4.16b
mov v4.16b, v10.16b
mov v10.16b, v6.16b
mov v6.16b, v3.16b
mov v3.16b, v5.16b
mov v5.16b, v10.16b
dup v22.8h, w2 //Q11 = alpha
dup v24.8h, w3 //Q12 = beta
movi v31.8b, #2
mov v0.d[1], v1.d[0]
mov v2.d[1], v3.d[0]
mov v4.d[1], v5.d[0]
mov v6.d[1], v7.d[0]
uabd v8.16b, v2.16b , v4.16b //|p0-q0|
uabd v10.16b, v6.16b , v4.16b //|q1-q0|
uabd v12.16b, v0.16b , v2.16b //|p1-p0|
uaddl v14.8h, v2.8b, v6.8b
uaddl v16.8h, v3.8b, v7.8b //(p0 + q1)
cmhi v8.16b, v22.16b , v8.16b //|p0-q0| < alpha ?
cmhi v10.16b, v24.16b , v10.16b //|q1-q0| < beta ?
cmhi v12.16b, v24.16b , v12.16b //|p1-p0| < beta ?
umlal v14.8h, v0.8b, v31.8b
umlal v16.8h, v1.8b, v31.8b //2*p1 + (p0 + q1)
uaddl v18.8h, v0.8b, v4.8b
uaddl v20.8h, v1.8b, v5.8b //(p1 + q0)
and v8.16b, v8.16b , v10.16b //|p0-q0| < alpha && |q1-q0| < beta
umlal v18.8h, v6.8b, v31.8b
umlal v20.8h, v7.8b, v31.8b //2*q1 + (p1 + q0)
rshrn v14.8b, v14.8h, #2
rshrn v15.8b, v16.8h, #2 //(2*p1 + (p0 + q1) + 2) >> 2
mov v14.d[1], v15.d[0]
and v8.16b, v8.16b , v12.16b //|p0-q0| < alpha && |q1-q0| < beta && |p1-p0| < beta
rshrn v18.8b, v18.8h, #2
rshrn v19.8b, v20.8h, #2 //(2*q1 + (p1 + q0) + 2) >> 2
mov v18.d[1], v19.d[0]
bit v2.16b, v14.16b , v8.16b
bit v4.16b, v18.16b , v8.16b
mov v1.d[0], v0.d[1]
mov v3.d[0], v2.d[1]
mov v5.d[0], v4.d[1]
mov v7.d[0], v6.d[1]
mov v10.16b, v1.16b
mov v1.16b, v2.16b
mov v2.16b, v4.16b
mov v4.16b, v10.16b
mov v10.16b, v3.16b
mov v3.16b, v6.16b
mov v6.16b, v5.16b
mov v5.16b, v10.16b
st4 {v0.h, v1.h, v2.h, v3.h}[0], [x12], x1
st4 {v0.h, v1.h, v2.h, v3.h}[1], [x12], x1
st4 {v0.h, v1.h, v2.h, v3.h}[2], [x12], x1
st4 {v0.h, v1.h, v2.h, v3.h}[3], [x12], x1
st4 {v4.h, v5.h, v6.h, v7.h}[0], [x12], x1
st4 {v4.h, v5.h, v6.h, v7.h}[1], [x12], x1
st4 {v4.h, v5.h, v6.h, v7.h}[2], [x12], x1
st4 {v4.h, v5.h, v6.h, v7.h}[3], [x12], x1
// LDMFD sp!,{x4,x5,x12,pc}
ldp x19, x20, [sp], #16
pop_v_regs
ret
///**
//*******************************************************************************
//*
//* @brief
//* Performs filtering of a chroma block horizontal edge for cases where the
//* boundary strength is less than 4 in high profile
//*
//* @par Description:
//* This operation is described in Sec. 8.7.2.4 under the title
//* "Filtering process for edges for bS equal to 4" in ITU T Rec H.264.
//*
//* @param[in] x0 - pu1_src
//* Pointer to the src sample q0
//*
//* @param[in] w1 - src_strd
//* Source stride
//*
//* @param[in] w2 - alpha_cb
//* Alpha Value for the boundary in U
//*
//* @param[in] w3 - beta_cb
//* Beta Value for the boundary in U
//*
//* @param[in] w4 - alpha_cr
//* Alpha Value for the boundary in V
//*
//* @param[in] w5 - beta_cr
//* Beta Value for the boundary in V
//*
//* @param[in] w6 - u4_bs
//* Packed Boundary strength array
//*
//* @param[in] x7 - pu1_cliptab_cb
//* tc0_table for U
//*
//* @param[in] sp(0) - pu1_cliptab_cr
//* tc0_table for V
//*
//* @returns
//* None
//*
//* @remarks
//* None
//*
//*******************************************************************************
//*/
.global ih264_deblk_chroma_horz_bslt4_av8
ih264_deblk_chroma_horz_bslt4_av8:
// STMFD sp!,{x4-x9,x14} //
push_v_regs
stp x19, x20, [sp, #-16]!
sxtw x1, w1
ldr x8, [sp, #80]
sub x0, x0, x1, lsl #1 //x0 = uc_edgePixelU pointing to p1 of chroma U
rev w6, w6 //
mov v12.s[0], w6 //D12[0] = ui_Bs
ld1 {v16.s}[0], [x7] //D16[0] contains cliptab_cb
ld1 {v17.s}[0], [x8] //D17[0] contains cliptab_cr
ld2 {v6.8b, v7.8b}, [x0], x1 //Q3=p1
tbl v14.8b, {v16.16b}, v12.8b //Retreiving cliptab values for U
tbl v28.8b, {v17.16b}, v12.8b //Retrieving cliptab values for V
uxtl v12.8h, v12.8b //Q6 = uc_Bs in each 16 bit scalar
mov x6, x0 //Keeping a backup of the pointer to chroma U P0
ld2 {v4.8b, v5.8b}, [x0], x1 //Q2=p0
movi v30.8b, #1 //
dup v20.8b, w2 //D20 contains alpha_cb
dup v21.8b, w4 //D21 contains alpha_cr
mov v20.d[1], v21.d[0]
ld2 {v0.8b, v1.8b}, [x0], x1 //Q0=q0
uxtl v14.8h, v14.8b //
uxtl v28.8h, v28.8b //
mov v15.d[0], v28.d[0] //D14 has cliptab values for U, D15 for V
mov v14.d[1], v28.d[0]
ld2 {v2.8b, v3.8b}, [x0] //Q1=q1
usubl v10.8h, v1.8b, v5.8b //
usubl v8.8h, v0.8b, v4.8b //Q5,Q4 = (q0 - p0)
mov v6.d[1], v7.d[0]
mov v4.d[1], v5.d[0]
uabd v26.16b, v6.16b , v4.16b //Q13 = ABS(p1 - p0)
shl v10.8h, v10.8h, #2 //Q5 = (q0 - p0)<<2
mov v0.d[1], v1.d[0]
uabd v22.16b, v4.16b , v0.16b //Q11 = ABS(p0 - q0)
shl v8.8h, v8.8h, #2 //Q4 = (q0 - p0)<<2
mov v14.d[1], v15.d[0]
sli v14.8h, v14.8h, #8
mov v15.d[0], v14.d[1]
mov v2.d[1], v3.d[0]
uabd v24.16b, v2.16b , v0.16b //Q12 = ABS(q1 - q0)
cmhs v18.16b, v22.16b, v20.16b
usubl v20.8h, v6.8b, v2.8b //Q10 = (p1 - q1)L
usubl v6.8h, v7.8b, v3.8b //Q3 = (p1 - q1)H
dup v16.8b, w3 //Q8 contains beta_cb
dup v17.8b, w5 //Q8 contains beta_cr
mov v16.d[1], v17.d[0]
add v8.8h, v8.8h , v20.8h //
add v10.8h, v10.8h , v6.8h //Q5,Q4 = [ (q0 - p0)<<2 ] + (p1 - q1)
cmhs v24.16b, v24.16b, v16.16b
cmgt v12.4h, v12.4h, #0
sqrshrn v8.8b, v8.8h, #3 //
sqrshrn v9.8b, v10.8h, #3 //Q4 = i_macro = (((q0 - p0)<<2) + (p1 - q1) + 4)>>3
mov v8.d[1], v9.d[0]
add v14.8b, v14.8b , v30.8b //D14 = C = C0+1 for U
cmhs v26.16b, v26.16b, v16.16b
orr v18.16b, v18.16b , v24.16b //Q9 = ( ABS(p0 - q0) >= Alpha ) | ( ABS(q1 - q0) >= Beta )
abs v6.16b, v8.16b //Q4 = ABS (i_macro)
add v15.8b, v15.8b , v30.8b //D15 = C = C0+1 for V
mov v14.d[1], v15.d[0]
mov v13.8b, v12.8b
mov v12.d[1], v13.d[0] //
orr v18.16b, v18.16b , v26.16b //Q9 = ( ABS(p0 - q0) >= Alpha ) | ( ABS(q1 - q0) >= Beta ) | ( ABS(p1 - p0) >= Beta )
umin v14.16b, v6.16b , v14.16b //Q7 = delta = (ABS(i_macro) > C) ? C : ABS(i_macro)
bic v12.16b, v12.16b , v18.16b //final condition
cmge v8.16b, v8.16b, #0
and v14.16b, v14.16b , v12.16b //Making delta zero in places where values shouldn be filterd
uqadd v16.16b, v4.16b , v14.16b //Q8 = p0 + delta
uqsub v4.16b, v4.16b , v14.16b //Q2 = p0 - delta
uqadd v18.16b, v0.16b , v14.16b //Q9 = q0 + delta
uqsub v0.16b, v0.16b , v14.16b //Q0 = q0 - delta
bif v16.16b, v4.16b , v8.16b //Q8 = (i_macro >= 0 ) ? (p0+delta) : (p0-delta)
bif v0.16b, v18.16b , v8.16b //Q0 = (i_macro >= 0 ) ? (q0-delta) : (q0+delta)
mov v17.d[0], v16.d[1]
mov v1.d[0], v0.d[1]
st2 {v16.8b, v17.8b}, [x6], x1 //
st2 {v0.8b, v1.8b}, [x6] //
ldp x19, x20, [sp], #16
pop_v_regs
ret
///**
//*******************************************************************************
//*
//* @brief
//* Performs filtering of a chroma block vertical edge for cases where the
//* boundary strength is less than 4 in high profile
//*
//* @par Description:
//* This operation is described in Sec. 8.7.2.4 under the title
//* "Filtering process for edges for bS equal to 4" in ITU T Rec H.264.
//*
//* @param[in] x0 - pu1_src
//* Pointer to the src sample q0
//*
//* @param[in] w1 - src_strd
//* Source stride
//*
//* @param[in] w2 - alpha_cb
//* Alpha Value for the boundary in U
//*
//* @param[in] w3 - beta_cb
//* Beta Value for the boundary in U
//*
//* @param[in] w4 - alpha_cr
//* Alpha Value for the boundary in V
//*
//* @param[in] w5 - beta_cr
//* Beta Value for the boundary in V
//*
//* @param[in] w6 - u4_bs
//* Packed Boundary strength array
//*
//* @param[in] x7 - pu1_cliptab_cb
//* tc0_table for U
//*
//* @param[in] sp(0) - pu1_cliptab_cr
//* tc0_table for V
//*
//* @returns
//* None
//*
//* @remarks
//* None
//*
//*******************************************************************************
//*/
.global ih264_deblk_chroma_vert_bslt4_av8
ih264_deblk_chroma_vert_bslt4_av8:
// STMFD sp!,{x4-x7,x10-x12,x14}
push_v_regs
stp x19, x20, [sp, #-16]!
sxtw x1, w1
mov x10, x7
ldr x11, [sp, #80] //x11 = u4_bs
sub x0, x0, #4 //point x0 to p1u of row0.
add w2, w2, w4, lsl #8
add w3, w3, w5, lsl #8
mov x12, x0 //keep a back up of x0 for buffer write
ld4 {v0.h, v1.h, v2.h, v3.h}[0], [x0], x1
ld4 {v0.h, v1.h, v2.h, v3.h}[1], [x0], x1
ld4 {v0.h, v1.h, v2.h, v3.h}[2], [x0], x1
ld4 {v0.h, v1.h, v2.h, v3.h}[3], [x0], x1
ld4 {v4.h, v5.h, v6.h, v7.h}[0], [x0], x1
ld4 {v4.h, v5.h, v6.h, v7.h}[1], [x0], x1
ld4 {v4.h, v5.h, v6.h, v7.h}[2], [x0], x1
ld4 {v4.h, v5.h, v6.h, v7.h}[3], [x0], x1
mov v10.16b, v2.16b
mov v2.16b, v1.16b
mov v1.16b, v4.16b
mov v4.16b, v10.16b
mov v10.16b, v6.16b
mov v6.16b, v3.16b
mov v3.16b, v5.16b
mov v5.16b, v10.16b
dup v22.8h, w2 //Q11 = alpha
mov v2.d[1], v3.d[0]
mov v4.d[1], v5.d[0]
uabd v8.16b, v2.16b , v4.16b //|p0-q0|
dup v24.8h, w3 //Q12 = beta
mov v25.d[0], v24.d[1]
mov v6.d[1], v7.d[0]
mov v0.d[1], v1.d[0]
uabd v10.16b, v6.16b , v4.16b //|q1-q0|
uabd v12.16b, v0.16b , v2.16b //|p1-p0|
cmhi v8.16b, v22.16b , v8.16b //|p0-q0| < alpha ?
usubl v14.8h, v0.8b, v6.8b
cmhi v10.16b, v24.16b , v10.16b //|q1-q0| < beta ?
usubl v16.8h, v1.8b, v7.8b //(p1 - q1)
cmhi v12.16b, v24.16b , v12.16b //|p1-p0| < beta ?
usubl v18.8h, v4.8b, v2.8b
and v8.16b, v8.16b , v10.16b //|p0-q0| < alpha && |q1-q0| < beta
usubl v20.8h, v5.8b, v3.8b //(q0 - p0)
movi v28.8h, #4
ld1 {v24.s}[0], [x10] //Load ClipTable for U
ld1 {v25.s}[0], [x11] //Load ClipTable for V
rev w6, w6 //Blocking strengths
and v8.16b, v8.16b , v12.16b //|p0-q0| < alpha && |q1-q0| < beta && |p1-p0| < beta
mov v10.s[0], w6
mla v14.8h, v18.8h , v28.8h
mla v16.8h, v20.8h , v28.8h //4*(q0 - p0) + (p1 - q1)
uxtl v10.8h, v10.8b
sli v10.4h, v10.4h, #8
tbl v12.8b, {v24.16b}, v10.8b //tC0 for U
tbl v13.8b, {v25.16b}, v10.8b //tC0 for V
zip1 v31.8b, v12.8b, v13.8b
zip2 v13.8b, v12.8b, v13.8b
mov v12.8b, v31.8b
mov v12.d[1], v13.d[0]
uxtl v10.4s, v10.4h
sli v10.4s, v10.4s, #16
movi v24.16b, #1
add v12.16b, v12.16b , v24.16b //tC0 + 1
cmhs v10.16b, v10.16b , v24.16b
and v8.16b, v8.16b , v10.16b //|p0-q0| < alpha && |q1-q0| < beta && |p1-p0| < beta && u4_bs != 0
// Q0 - Q3(inputs),
// Q4 (|p0-q0| < alpha && |q1-q0| < beta && |p1-p0| < beta && u4_bs != 0),
// Q6 (tC)
srshr v14.8h, v14.8h, #3
srshr v16.8h, v16.8h, #3 //(((q0 - p0) << 2) + (p1 - q1) + 4) >> 3)
cmgt v18.8h, v14.8h , #0
cmgt v20.8h, v16.8h , #0
xtn v18.8b, v18.8h
xtn v19.8b, v20.8h //Q9 = sign(delta)
mov v18.d[1], v19.d[0]
abs v14.8h, v14.8h
abs v16.8h, v16.8h
xtn v14.8b, v14.8h
xtn v15.8b, v16.8h
mov v14.d[1], v15.d[0]
umin v14.16b, v14.16b , v12.16b //Q7 = |delta|
uqadd v20.16b, v2.16b , v14.16b //p0+|delta|
uqadd v22.16b, v4.16b , v14.16b //q0+|delta|
uqsub v24.16b, v2.16b , v14.16b //p0-|delta|
uqsub v26.16b, v4.16b , v14.16b //q0-|delta|
bit v24.16b, v20.16b , v18.16b //p0 + delta
bit v22.16b, v26.16b , v18.16b //q0 - delta
bit v2.16b, v24.16b , v8.16b
bit v4.16b, v22.16b , v8.16b
mov v1.d[0], v0.d[1]
mov v3.d[0], v2.d[1]
mov v5.d[0], v4.d[1]
mov v7.d[0], v6.d[1]
mov v10.16b, v1.16b
mov v1.16b, v2.16b
mov v2.16b, v4.16b
mov v4.16b, v10.16b
mov v10.16b, v3.16b
mov v3.16b, v6.16b
mov v6.16b, v5.16b
mov v5.16b, v10.16b
st4 {v0.h, v1.h, v2.h, v3.h}[0], [x12], x1
st4 {v0.h, v1.h, v2.h, v3.h}[1], [x12], x1
st4 {v0.h, v1.h, v2.h, v3.h}[2], [x12], x1
st4 {v0.h, v1.h, v2.h, v3.h}[3], [x12], x1
st4 {v4.h, v5.h, v6.h, v7.h}[0], [x12], x1
st4 {v4.h, v5.h, v6.h, v7.h}[1], [x12], x1
st4 {v4.h, v5.h, v6.h, v7.h}[2], [x12], x1
st4 {v4.h, v5.h, v6.h, v7.h}[3], [x12], x1
ldp x19, x20, [sp], #16
pop_v_regs
ret
Reference in New Issue View Git Blame Copy Permalink