hoo2
/
STM32F10x_Std_Lib
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
A bundled STM32F10x Std Periph and CMSIS library
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1 Commit
1 Branch
2.1 MiB
 
 
 
 
 
Tree: c21da4388c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c21da4388c'
${ noResults }
STM32F10x_Std_Lib/CMSIS/DSP_Lib/Source/BasicMathFunctions/arm_scale_q31.c

240 lines
6.7 KiB
Raw Blame History 

  1. /* ----------------------------------------------------------------------    

  2. * Copyright (C) 2010-2014 ARM Limited. All rights reserved.    

  3. *    

  4. * $Date:        12. March 2014

  5. * $Revision: 	V1.4.4

  6. *    

  7. * Project: 	    CMSIS DSP Library    

  8. * Title:		arm_scale_q31.c    

  9. *    

  10. * Description:	Multiplies a Q31 vector by a scalar.    

  11. *    

  12. * Target Processor: Cortex-M4/Cortex-M3/Cortex-M0

  13. *  

  14. * Redistribution and use in source and binary forms, with or without 

  15. * modification, are permitted provided that the following conditions

  16. * are met:

  17. *   - Redistributions of source code must retain the above copyright

  18. *     notice, this list of conditions and the following disclaimer.

  19. *   - Redistributions in binary form must reproduce the above copyright

  20. *     notice, this list of conditions and the following disclaimer in

  21. *     the documentation and/or other materials provided with the 

  22. *     distribution.

  23. *   - Neither the name of ARM LIMITED nor the names of its contributors

  24. *     may be used to endorse or promote products derived from this

  25. *     software without specific prior written permission.

  26. *

  27. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

  28. * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

  29. * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

  30. * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 

  31. * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

  32. * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

  33. * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

  34. * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

  35. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

  36. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

  37. * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

  38. * POSSIBILITY OF SUCH DAMAGE.   

  39. * -------------------------------------------------------------------- */

  40. 

  41. #include "arm_math.h"

  42. 

  43. /**       

  44.  * @ingroup groupMath       

  45.  */

  46. 

  47. /**       

  48.  * @addtogroup scale       

  49.  * @{       

  50.  */

  51. 

  52. /**       

  53.  * @brief Multiplies a Q31 vector by a scalar.       

  54.  * @param[in]       *pSrc points to the input vector       

  55.  * @param[in]       scaleFract fractional portion of the scale value       

  56.  * @param[in]       shift number of bits to shift the result by       

  57.  * @param[out]      *pDst points to the output vector       

  58.  * @param[in]       blockSize number of samples in the vector       

  59.  * @return none.       

  60.  *       

  61.  * <b>Scaling and Overflow Behavior:</b>       

  62.  * \par       

  63.  * The input data <code>*pSrc</code> and <code>scaleFract</code> are in 1.31 format.       

  64.  * These are multiplied to yield a 2.62 intermediate result and this is shifted with saturation to 1.31 format.       

  65.  */

  66. 

  67. void arm_scale_q31(

  68.   q31_t * pSrc,

  69.   q31_t scaleFract,

  70.   int8_t shift,

  71.   q31_t * pDst,

  72.   uint32_t blockSize)

  73. {

  74.   int8_t kShift = shift + 1;                     /* Shift to apply after scaling */

  75.   int8_t sign = (kShift & 0x80);

  76.   uint32_t blkCnt;                               /* loop counter */

  77.   q31_t in, out;

  78. 

  79. #ifndef ARM_MATH_CM0_FAMILY

  80. 

  81. /* Run the below code for Cortex-M4 and Cortex-M3 */

  82. 

  83.   q31_t in1, in2, in3, in4;                      /* temporary input variables */

  84.   q31_t out1, out2, out3, out4;                  /* temporary output variabels */

  85. 

  86. 

  87.   /*loop Unrolling */

  88.   blkCnt = blockSize >> 2u;

  89. 

  90.   if(sign == 0u)

  91.   {

  92.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.       

  93.      ** a second loop below computes the remaining 1 to 3 samples. */

  94.     while(blkCnt > 0u)

  95.     {

  96.       /* read four inputs from source */

  97.       in1 = *pSrc;

  98.       in2 = *(pSrc + 1);

  99.       in3 = *(pSrc + 2);

  100.       in4 = *(pSrc + 3);

  101. 

  102.       /* multiply input with scaler value */

  103.       in1 = ((q63_t) in1 * scaleFract) >> 32;

  104.       in2 = ((q63_t) in2 * scaleFract) >> 32;

  105.       in3 = ((q63_t) in3 * scaleFract) >> 32;

  106.       in4 = ((q63_t) in4 * scaleFract) >> 32;

  107. 

  108.       /* apply shifting */

  109.       out1 = in1 << kShift;

  110.       out2 = in2 << kShift;

  111. 

  112.       /* saturate the results. */

  113.       if(in1 != (out1 >> kShift))

  114.         out1 = 0x7FFFFFFF ^ (in1 >> 31);

  115. 

  116.       if(in2 != (out2 >> kShift))

  117.         out2 = 0x7FFFFFFF ^ (in2 >> 31);

  118. 

  119.       out3 = in3 << kShift;

  120.       out4 = in4 << kShift;

  121. 

  122.       *pDst = out1;

  123.       *(pDst + 1) = out2;

  124. 

  125.       if(in3 != (out3 >> kShift))

  126.         out3 = 0x7FFFFFFF ^ (in3 >> 31);

  127. 

  128.       if(in4 != (out4 >> kShift))

  129.         out4 = 0x7FFFFFFF ^ (in4 >> 31);

  130. 

  131.       /* Store result destination */

  132.       *(pDst + 2) = out3;

  133.       *(pDst + 3) = out4;

  134. 

  135.       /* Update pointers to process next sampels */

  136.       pSrc += 4u;

  137.       pDst += 4u;

  138. 

  139.       /* Decrement the loop counter */

  140.       blkCnt--;

  141.     }

  142. 

  143.   }

  144.   else

  145.   {

  146.     /* First part of the processing with loop unrolling.  Compute 4 outputs at a time.       

  147.      ** a second loop below computes the remaining 1 to 3 samples. */

  148.     while(blkCnt > 0u)

  149.     {

  150.       /* read four inputs from source */

  151.       in1 = *pSrc;

  152.       in2 = *(pSrc + 1);

  153.       in3 = *(pSrc + 2);

  154.       in4 = *(pSrc + 3);

  155. 

  156.       /* multiply input with scaler value */

  157.       in1 = ((q63_t) in1 * scaleFract) >> 32;

  158.       in2 = ((q63_t) in2 * scaleFract) >> 32;

  159.       in3 = ((q63_t) in3 * scaleFract) >> 32;

  160.       in4 = ((q63_t) in4 * scaleFract) >> 32;

  161. 

  162.       /* apply shifting */

  163.       out1 = in1 >> -kShift;

  164.       out2 = in2 >> -kShift;

  165. 

  166.       out3 = in3 >> -kShift;

  167.       out4 = in4 >> -kShift;

  168. 

  169.       /* Store result destination */

  170.       *pDst = out1;

  171.       *(pDst + 1) = out2;

  172. 

  173.       *(pDst + 2) = out3;

  174.       *(pDst + 3) = out4;

  175. 

  176.       /* Update pointers to process next sampels */

  177.       pSrc += 4u;

  178.       pDst += 4u;

  179. 

  180.       /* Decrement the loop counter */

  181.       blkCnt--;

  182.     }

  183.   }

  184.   /* If the blockSize is not a multiple of 4, compute any remaining output samples here.       

  185.    ** No loop unrolling is used. */

  186.   blkCnt = blockSize % 0x4u;

  187. 

  188. #else

  189. 

  190.   /* Run the below code for Cortex-M0 */

  191. 

  192.   /* Initialize blkCnt with number of samples */

  193.   blkCnt = blockSize;

  194. 

  195. #endif /* #ifndef ARM_MATH_CM0_FAMILY */

  196. 

  197.   if(sign == 0)

  198.   {

  199. 	  while(blkCnt > 0u)

  200. 	  {

  201. 		/* C = A * scale */

  202. 		/* Scale the input and then store the result in the destination buffer. */

  203. 		in = *pSrc++;

  204. 		in = ((q63_t) in * scaleFract) >> 32;

  205. 

  206. 		out = in << kShift;

  207. 		

  208. 		if(in != (out >> kShift))

  209. 			out = 0x7FFFFFFF ^ (in >> 31);

  210. 

  211. 		*pDst++ = out;

  212. 

  213. 		/* Decrement the loop counter */

  214. 		blkCnt--;

  215. 	  }

  216.   }

  217.   else

  218.   {

  219. 	  while(blkCnt > 0u)

  220. 	  {

  221. 		/* C = A * scale */

  222. 		/* Scale the input and then store the result in the destination buffer. */

  223. 		in = *pSrc++;

  224. 		in = ((q63_t) in * scaleFract) >> 32;

  225. 

  226. 		out = in >> -kShift;

  227. 

  228. 		*pDst++ = out;

  229. 

  230. 		/* Decrement the loop counter */

  231. 		blkCnt--;

  232. 	  }

  233.   

  234.   }

  235. }

  236. 

  237. /**       

  238.  * @} end of scale group       

  239.  */