1 /* ----------------------------------------------------------------------
2  * Project:      CMSIS DSP Library
3  * Title:        arm_sub_q7.c
4  * Description:  Q7 vector subtraction
5  *
6  * $Date:        23 April 2021
7  * $Revision:    V1.9.0
8  *
9  * Target Processor: Cortex-M and Cortex-A cores
10  * -------------------------------------------------------------------- */
11 /*
12  * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
13  *
14  * SPDX-License-Identifier: Apache-2.0
15  *
16  * Licensed under the Apache License, Version 2.0 (the License); you may
17  * not use this file except in compliance with the License.
18  * You may obtain a copy of the License at
19  *
20  * www.apache.org/licenses/LICENSE-2.0
21  *
22  * Unless required by applicable law or agreed to in writing, software
23  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
24  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
25  * See the License for the specific language governing permissions and
26  * limitations under the License.
27  */
28 
29 #include "dsp/basic_math_functions.h"
30 
31 /**
32   @ingroup groupMath
33  */
34 
35 /**
36   @addtogroup BasicSub
37   @{
38  */
39 
40 /**
41   @brief         Q7 vector subtraction.
42   @param[in]     pSrcA      points to the first input vector
43   @param[in]     pSrcB      points to the second input vector
44   @param[out]    pDst       points to the output vector
45   @param[in]     blockSize  number of samples in each vector
46   @return        none
47 
48   @par           Scaling and Overflow Behavior
49                    The function uses saturating arithmetic.
50                    Results outside of the allowable Q7 range [0x80 0x7F] will be saturated.
51  */
52 #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
53 
54 #include "arm_helium_utils.h"
55 
arm_sub_q7(const q7_t * pSrcA,const q7_t * pSrcB,q7_t * pDst,uint32_t blockSize)56 void arm_sub_q7(
57     const q7_t * pSrcA,
58     const q7_t * pSrcB,
59     q7_t * pDst,
60     uint32_t blockSize)
61 {
62     uint32_t  blkCnt;           /* loop counters */
63     q7x16_t vecA;
64     q7x16_t vecB;
65 
66     /* Compute 16 outputs at a time */
67     blkCnt = blockSize >> 4;
68     while (blkCnt > 0U)
69     {
70         /*
71          * C = A - B
72          * Subtract and then store the results in the destination buffer.
73          */
74         vecA = vld1q(pSrcA);
75         vecB = vld1q(pSrcB);
76         vst1q(pDst, vqsubq(vecA, vecB));
77         /*
78          * Decrement the blockSize loop counter
79          */
80         blkCnt--;
81         /*
82          * advance vector source and destination pointers
83          */
84         pSrcA  += 16;
85         pSrcB  += 16;
86         pDst   += 16;
87     }
88     /*
89      * tail
90      */
91     blkCnt = blockSize & 0xF;
92     if (blkCnt > 0U)
93     {
94         mve_pred16_t p0 = vctp8q(blkCnt);
95         vecA = vld1q(pSrcA);
96         vecB = vld1q(pSrcB);
97         vstrbq_p(pDst, vqsubq(vecA, vecB), p0);
98     }
99 }
100 #else
arm_sub_q7(const q7_t * pSrcA,const q7_t * pSrcB,q7_t * pDst,uint32_t blockSize)101 void arm_sub_q7(
102   const q7_t * pSrcA,
103   const q7_t * pSrcB,
104         q7_t * pDst,
105         uint32_t blockSize)
106 {
107         uint32_t blkCnt;                               /* Loop counter */
108 
109 #if defined (ARM_MATH_LOOPUNROLL)
110 
111   /* Loop unrolling: Compute 4 outputs at a time */
112   blkCnt = blockSize >> 2U;
113 
114   while (blkCnt > 0U)
115   {
116     /* C = A - B */
117 
118 #if defined (ARM_MATH_DSP)
119     /* Subtract and store result in destination buffer (4 samples at a time). */
120     write_q7x4_ia (&pDst, __QSUB8(read_q7x4_ia ((q7_t **) &pSrcA), read_q7x4_ia ((q7_t **) &pSrcB)));
121 #else
122     *pDst++ = (q7_t) __SSAT((q15_t) *pSrcA++ - *pSrcB++, 8);
123     *pDst++ = (q7_t) __SSAT((q15_t) *pSrcA++ - *pSrcB++, 8);
124     *pDst++ = (q7_t) __SSAT((q15_t) *pSrcA++ - *pSrcB++, 8);
125     *pDst++ = (q7_t) __SSAT((q15_t) *pSrcA++ - *pSrcB++, 8);
126 #endif
127 
128     /* Decrement loop counter */
129     blkCnt--;
130   }
131 
132   /* Loop unrolling: Compute remaining outputs */
133   blkCnt = blockSize % 0x4U;
134 
135 #else
136 
137   /* Initialize blkCnt with number of samples */
138   blkCnt = blockSize;
139 
140 #endif /* #if defined (ARM_MATH_LOOPUNROLL) */
141 
142   while (blkCnt > 0U)
143   {
144     /* C = A - B */
145 
146     /* Subtract and store result in destination buffer. */
147     *pDst++ = (q7_t) __SSAT((q15_t) *pSrcA++ - *pSrcB++, 8);
148 
149     /* Decrement loop counter */
150     blkCnt--;
151   }
152 
153 }
154 #endif /* defined(ARM_MATH_MVEI) */
155 
156 /**
157   @} end of BasicSub group
158  */
159