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  
 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
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 (&pSrcA), read_q7x4_ia (&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   */