| //****************************************************************************** |
| //* |
| //* 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] x1 - src_strd |
| //* Source stride |
| //* |
| //* @param[in] x2 - alpha_cb |
| //* Alpha Value for the boundary in U |
| //* |
| //* @param[in] x3 - beta_cb |
| //* Beta Value for the boundary in U |
| //* |
| //* @param[in] sp(0) - alpha_cr |
| //* Alpha Value for the boundary in V |
| //* |
| //* @param[in] sp(4) - 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]! |
| 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] x1 - src_strd |
| //* Source stride |
| //* |
| //* @param[in] x2 - alpha_cb |
| //* Alpha Value for the boundary in U |
| //* |
| //* @param[in] x3 - beta_cb |
| //* Beta Value for the boundary in U |
| //* |
| //* @param[in] sp(0) - alpha_cr |
| //* Alpha Value for the boundary in V |
| //* |
| //* @param[in] sp(4) - 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]! |
| |
| sub x0, x0, #4 //point x0 to p1u of row0. |
| mov x12, x0 //keep a back up of x0 for buffer write |
| |
| add x2, x2, x4, lsl #8 //x2 = (alpha_cr,alpha_cb) |
| add x3, x3, x5, lsl #8 //x3 = (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] x1 - src_strd |
| //* Source stride |
| //* |
| //* @param[in] x2 - alpha_cb |
| //* Alpha Value for the boundary in U |
| //* |
| //* @param[in] x3 - beta_cb |
| //* Beta Value for the boundary in U |
| //* |
| //* @param[in] sp(0) - alpha_cr |
| //* Alpha Value for the boundary in V |
| //* |
| //* @param[in] sp(4) - beta_cr |
| //* Beta Value for the boundary in V |
| //* |
| //* @param[in] sp(8) - u4_bs |
| //* Packed Boundary strength array |
| //* |
| //* @param[in] sp(12) - pu1_cliptab_cb |
| //* tc0_table for U |
| //* |
| //* @param[in] sp(16) - 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]! |
| mov x8, x7 |
| mov x7, x6 |
| ldr x9, [sp, #80] |
| sub x0, x0, x1, lsl #1 //x0 = uc_edgePixelU pointing to p1 of chroma U |
| rev w7, w7 // |
| mov v12.s[0], w7 //D12[0] = ui_Bs |
| ld1 {v16.s}[0], [x8] //D16[0] contains cliptab_cb |
| ld1 {v17.s}[0], [x9] //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] x1 - src_strd |
| //* Source stride |
| //* |
| //* @param[in] x2 - alpha_cb |
| //* Alpha Value for the boundary in U |
| //* |
| //* @param[in] x3 - beta_cb |
| //* Beta Value for the boundary in U |
| //* |
| //* @param[in] sp(0) - alpha_cr |
| //* Alpha Value for the boundary in V |
| //* |
| //* @param[in] sp(4) - beta_cr |
| //* Beta Value for the boundary in V |
| //* |
| //* @param[in] sp(8) - u4_bs |
| //* Packed Boundary strength array |
| //* |
| //* @param[in] sp(12) - pu1_cliptab_cb |
| //* tc0_table for U |
| //* |
| //* @param[in] sp(16) - 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]! |
| mov x10, x7 |
| ldr x11, [sp, #80] //x6 = u4_bs |
| sub x0, x0, #4 //point x0 to p1u of row0. |
| add x2, x2, x4, lsl #8 |
| add x3, x3, x5, 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 |
| |
| |
