visus
/
teensy-audio
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
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.
172 Commits
2 Branches
Tree: 8398f637d0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8398f637d0'
${ noResults }
teensy-audio/utility/dspinst.h

158 lines
6.3KB
Raw Blame History 

  1. /* Audio Library for Teensy 3.X

  2.  * Copyright (c) 2014, Paul Stoffregen, paul@pjrc.com

  3.  *

  4.  * Development of this audio library was funded by PJRC.COM, LLC by sales of

  5.  * Teensy and Audio Adaptor boards.  Please support PJRC's efforts to develop

  6.  * open source software by purchasing Teensy or other PJRC products.

  7.  *

  8.  * Permission is hereby granted, free of charge, to any person obtaining a copy

  9.  * of this software and associated documentation files (the "Software"), to deal

  10.  * in the Software without restriction, including without limitation the rights

  11.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

  12.  * copies of the Software, and to permit persons to whom the Software is

  13.  * furnished to do so, subject to the following conditions:

  14.  *

  15.  * The above copyright notice, development funding notice, and this permission

  16.  * notice shall be included in all copies or substantial portions of the Software.

  17.  *

  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  19.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  20.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  21.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  22.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  23.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

  24.  * THE SOFTWARE.

  25.  */

  26. 

  27. #ifndef dspinst_h_

  28. #define dspinst_h_

  29. 

  30. #include <stdint.h>

  31. 

  32. // computes limit((val >> rshift), 2**bits)

  33. static inline int32_t signed_saturate_rshift(int32_t val, int bits, int rshift) __attribute__((always_inline, unused));

  34. static inline int32_t signed_saturate_rshift(int32_t val, int bits, int rshift)

  35. {

  36. 	int32_t out;

  37. 	asm volatile("ssat %0, %1, %2, asr %3" : "=r" (out) : "I" (bits), "r" (val), "I" (rshift));

  38. 	return out;

  39. }

  40. 

  41. // computes ((a[31:0] * b[15:0]) >> 16)

  42. static inline int32_t signed_multiply_32x16b(int32_t a, uint32_t b) __attribute__((always_inline, unused));

  43. static inline int32_t signed_multiply_32x16b(int32_t a, uint32_t b)

  44. {

  45. 	int32_t out;

  46. 	asm volatile("smulwb %0, %1, %2" : "=r" (out) : "r" (a), "r" (b));

  47. 	return out;

  48. }

  49. 

  50. // computes ((a[31:0] * b[31:16]) >> 16)

  51. static inline int32_t signed_multiply_32x16t(int32_t a, uint32_t b) __attribute__((always_inline, unused));

  52. static inline int32_t signed_multiply_32x16t(int32_t a, uint32_t b)

  53. {

  54. 	int32_t out;

  55. 	asm volatile("smulwt %0, %1, %2" : "=r" (out) : "r" (a), "r" (b));

  56. 	return out;

  57. }

  58. 

  59. // computes (((int64_t)a[31:0] * (int64_t)b[31:0]) >> 32)

  60. static inline int32_t multiply_32x32_rshift32(int32_t a, int32_t b) __attribute__((always_inline, unused));

  61. static inline int32_t multiply_32x32_rshift32(int32_t a, int32_t b)

  62. {

  63. 	int32_t out;

  64. 	asm volatile("smmul %0, %1, %2" : "=r" (out) : "r" (a), "r" (b));

  65. 	return out;

  66. }

  67. 

  68. // computes (((int64_t)a[31:0] * (int64_t)b[31:0] + 0x8000000) >> 32)

  69. static inline int32_t multiply_32x32_rshift32_rounded(int32_t a, int32_t b) __attribute__((always_inline, unused));

  70. static inline int32_t multiply_32x32_rshift32_rounded(int32_t a, int32_t b)

  71. {

  72. 	int32_t out;

  73. 	asm volatile("smmulr %0, %1, %2" : "=r" (out) : "r" (a), "r" (b));

  74. 	return out;

  75. }

  76. 

  77. // computes sum + (((int64_t)a[31:0] * (int64_t)b[31:0] + 0x8000000) >> 32)

  78. static inline int32_t multiply_accumulate_32x32_rshift32_rounded(int32_t sum, int32_t a, int32_t b) __attribute__((always_inline, unused));

  79. static inline int32_t multiply_accumulate_32x32_rshift32_rounded(int32_t sum, int32_t a, int32_t b)

  80. {

  81. 	int32_t out;

  82. 	asm volatile("smmlar %0, %2, %3, %1" : "=r" (out) : "r" (sum), "r" (a), "r" (b));

  83. 	return out;

  84. }

  85. 

  86. // computes sum - (((int64_t)a[31:0] * (int64_t)b[31:0] + 0x8000000) >> 32)

  87. static inline int32_t multiply_subtract_32x32_rshift32_rounded(int32_t sum, int32_t a, int32_t b) __attribute__((always_inline, unused));

  88. static inline int32_t multiply_subtract_32x32_rshift32_rounded(int32_t sum, int32_t a, int32_t b)

  89. {

  90. 	int32_t out;

  91. 	asm volatile("smmlsr %0, %2, %3, %1" : "=r" (out) : "r" (sum), "r" (a), "r" (b));

  92. 	return out;

  93. }

  94. 

  95. // computes ((a[15:0] << 16) | b[15:0])

  96. static inline uint32_t pack_16x16(int32_t a, int32_t b) __attribute__((always_inline, unused));

  97. static inline uint32_t pack_16x16(int32_t a, int32_t b)

  98. {

  99. 	int32_t out;

  100. 	asm volatile("pkhbt %0, %1, %2, lsl #16" : "=r" (out) : "r" (b), "r" (a));

  101. 	return out;

  102. }

  103. 

  104. // computes (((a[31:16] + b[31:16]) << 16) | (a[15:0 + b[15:0]))

  105. static inline uint32_t signed_add_16_and_16(uint32_t a, uint32_t b) __attribute__((always_inline, unused));

  106. static inline uint32_t signed_add_16_and_16(uint32_t a, uint32_t b)

  107. {

  108. 	int32_t out;

  109. 	asm volatile("qadd16 %0, %1, %2" : "=r" (out) : "r" (a), "r" (b));

  110. 	return out;

  111. }

  112. 

  113. // computes (sum + ((a[31:0] * b[15:0]) >> 16))

  114. static inline int32_t signed_multiply_accumulate_32x16b(int32_t sum, int32_t a, uint32_t b) __attribute__((always_inline, unused));

  115. static inline int32_t signed_multiply_accumulate_32x16b(int32_t sum, int32_t a, uint32_t b)

  116. {

  117. 	int32_t out;

  118. 	asm volatile("smlawb %0, %2, %3, %1" : "=r" (out) : "r" (sum), "r" (a), "r" (b));

  119. 	return out;

  120. }

  121. 

  122. // computes (sum + ((a[31:0] * b[31:16]) >> 16))

  123. static inline int32_t signed_multiply_accumulate_32x16t(int32_t sum, int32_t a, uint32_t b) __attribute__((always_inline, unused));

  124. static inline int32_t signed_multiply_accumulate_32x16t(int32_t sum, int32_t a, uint32_t b)

  125. {

  126. 	int32_t out;

  127. 	asm volatile("smlawt %0, %2, %3, %1" : "=r" (out) : "r" (sum), "r" (a), "r" (b));

  128. 	return out;

  129. }

  130. 

  131. // computes logical and, forces compiler to allocate register and use single cycle instruction

  132. static inline uint32_t logical_and(uint32_t a, uint32_t b) __attribute__((always_inline, unused));

  133. static inline uint32_t logical_and(uint32_t a, uint32_t b)

  134. {

  135. 	asm volatile("and %0, %1" : "+r" (a) : "r" (b));

  136. 	return a;

  137. }

  138. 

  139. // computes ((a[15:0] * b[15:0]) + (a[31:16] * b[31:16]))

  140. static inline int32_t multiply_16tx16t_add_16bx16b(uint32_t a, uint32_t b) __attribute__((always_inline, unused));

  141. static inline int32_t multiply_16tx16t_add_16bx16b(uint32_t a, uint32_t b)

  142. {

  143. 	int32_t out;

  144. 	asm volatile("smuad %0, %1, %2" : "=r" (out) : "r" (a), "r" (b));

  145. 	return out;

  146. }

  147. 

  148. // computes ((a[15:0] * b[31:16]) + (a[31:16] * b[15:0]))

  149. static inline int32_t multiply_16tx16b_add_16bx16t(uint32_t a, uint32_t b) __attribute__((always_inline, unused));

  150. static inline int32_t multiply_16tx16b_add_16bx16t(uint32_t a, uint32_t b)

  151. {

  152. 	int32_t out;

  153. 	asm volatile("smuadx %0, %1, %2" : "=r" (out) : "r" (a), "r" (b));

  154. 	return out;

  155. }

  156. 

  157. #endif