visus
/
teensy-audio
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
229 Commits
2 Branches
Tree: 66bb0f0c81
teensy-audio/utility/dspinst.h

233 lines
8.7KB
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. 

  96. // computes (a[31:16] | (b[31:16] >> 16))

  97. static inline uint32_t pack_16t_16t(int32_t a, int32_t b) __attribute__((always_inline, unused));

  98. static inline uint32_t pack_16t_16t(int32_t a, int32_t b)

  99. {

  100. 	int32_t out;

  101. 	asm volatile("pkhtb %0, %1, %2, asr #16" : "=r" (out) : "r" (a), "r" (b));

  102. 	return out;

  103. }

  104. 

  105. // computes (a[31:16] | b[15:0])

  106. static inline uint32_t pack_16t_16b(int32_t a, int32_t b) __attribute__((always_inline, unused));

  107. static inline uint32_t pack_16t_16b(int32_t a, int32_t b)

  108. {

  109. 	int32_t out;

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

  111. 	return out;

  112. }

  113. 

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

  115. static inline uint32_t pack_16b_16b(int32_t a, int32_t b) __attribute__((always_inline, unused));

  116. static inline uint32_t pack_16b_16b(int32_t a, int32_t b)

  117. {

  118. 	int32_t out;

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

  120. 	return out;

  121. }

  122. 

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

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

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

  126. {

  127. 	int32_t out;

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

  129. 	return out;

  130. }

  131. 

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

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

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

  135. {

  136. 	int32_t out;

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

  138. 	return out;

  139. }

  140. 

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

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

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

  144. {

  145. 	int32_t out;

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

  147. 	return out;

  148. }

  149. 

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

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

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

  153. {

  154. 	int32_t out;

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

  156. 	return out;

  157. }

  158. 

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

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

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

  162. {

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

  164. 	return a;

  165. }

  166. 

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

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

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

  170. {

  171. 	int32_t out;

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

  173. 	return out;

  174. }

  175. 

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

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

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

  179. {

  180. 	int32_t out;

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

  182. 	return out;

  183. }

  184. 

  185. // computes ((a[15:0] * b[15:0])

  186. static inline int32_t multiply_16bx16b(uint32_t a, uint32_t b) __attribute__((always_inline, unused));

  187. static inline int32_t multiply_16bx16b(uint32_t a, uint32_t b)

  188. {

  189. 	int32_t out;

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

  191. 	return out;

  192. }

  193. 

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

  195. static inline int32_t multiply_16bx16t(uint32_t a, uint32_t b) __attribute__((always_inline, unused));

  196. static inline int32_t multiply_16bx16t(uint32_t a, uint32_t b)

  197. {

  198. 	int32_t out;

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

  200. 	return out;

  201. }

  202. 

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

  204. static inline int32_t multiply_16tx16b(uint32_t a, uint32_t b) __attribute__((always_inline, unused));

  205. static inline int32_t multiply_16tx16b(uint32_t a, uint32_t b)

  206. {

  207. 	int32_t out;

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

  209. 	return out;

  210. }

  211. 

  212. // computes ((a[31:16] * b[31:16])

  213. static inline int32_t multiply_16tx16t(uint32_t a, uint32_t b) __attribute__((always_inline, unused));

  214. static inline int32_t multiply_16tx16t(uint32_t a, uint32_t b)

  215. {

  216. 	int32_t out;

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

  218. 	return out;

  219. }

  220. 

  221. // computes (a - b), result saturated to 32 bit integer range

  222. static inline int32_t substract_32_saturate(uint32_t a, uint32_t b) __attribute__((always_inline, unused));

  223. static inline int32_t substract_32_saturate(uint32_t a, uint32_t b)

  224. {

  225. 	int32_t out;

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

  227. 	return out;

  228. }

  229. 

  230. 

  231. 

  232. #endif