visus
/
teensy-audio
Vērot 1
Pievienot zvaigznīti 0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
331 Revīzija
2 Atzari
Koks: 2ee2eac12d
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '2ee2eac12d'
${ noResults }
teensy-audio/utility/dspinst.h

267 rindas
9.4KB
Neapstrādāts Vainot Vēsture 

  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. #if defined(KINETISK)

  37. 	int32_t out;

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

  39. 	return out;

  40. #elif defined(KINETISL)

  41. 	int32_t out, max;

  42. 	out = val >> rshift;

  43. 	max = 1 << (bits - 1);

  44. 	if (out >= 0) {

  45. 		if (out > max - 1) out = max - 1;

  46. 	} else {

  47. 		if (out < -max) out = -max;

  48. 	}

  49. 	return out;

  50. #endif

  51. }

  52. 

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

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

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

  56. {

  57. #if defined(KINETISK)

  58. 	int32_t out;

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

  60. 	return out;

  61. #elif defined(KINETISL)

  62. 	return ((int64_t)a * (int16_t)(b & 0xFFFF)) >> 16;

  63. #endif

  64. }

  65. 

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

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

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

  69. {

  70. #if defined(KINETISK)

  71. 	int32_t out;

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

  73. 	return out;

  74. #elif defined(KINETISL)

  75. 	return ((int64_t)a * (int16_t)(b >> 16)) >> 16;

  76. #endif

  77. }

  78. 

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

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

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

  82. {

  83. 	int32_t out;

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

  85. 	return out;

  86. }

  87. 

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

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

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

  91. {

  92. 	int32_t out;

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

  94. 	return out;

  95. }

  96. 

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

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

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

  100. {

  101. 	int32_t out;

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

  103. 	return out;

  104. }

  105. 

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

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

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

  109. {

  110. 	int32_t out;

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

  112. 	return out;

  113. }

  114. 

  115. 

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

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

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

  119. {

  120. #if defined(KINETISK)

  121. 	int32_t out;

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

  123. 	return out;

  124. #elif defined(KINETISL)

  125. 	return (a & 0xFFFF0000) | ((uint32_t)b >> 16);

  126. #endif

  127. }

  128. 

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

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

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

  132. {

  133. #if defined(KINETISK)

  134. 	int32_t out;

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

  136. 	return out;

  137. #elif defined(KINETISL)

  138. 	return (a & 0xFFFF0000) | (b & 0x0000FFFF);

  139. #endif

  140. }

  141. 

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

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

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

  145. {

  146. #if defined(KINETISK)

  147. 	int32_t out;

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

  149. 	return out;

  150. #elif defined(KINETISL)

  151. 	return (a << 16) | (b & 0x0000FFFF);

  152. #endif

  153. }

  154. 

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

  156. /*

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

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

  159. {

  160. 	int32_t out;

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

  162. 	return out;

  163. }

  164. */

  165. 

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

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

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

  169. {

  170. 	int32_t out;

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

  172. 	return out;

  173. }

  174. 

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

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

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

  178. {

  179. 	int32_t out;

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

  181. 	return out;

  182. }

  183. 

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

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

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

  187. {

  188. 	int32_t out;

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

  190. 	return out;

  191. }

  192. 

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

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

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

  196. {

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

  198. 	return a;

  199. }

  200. 

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

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

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

  204. {

  205. 	int32_t out;

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

  207. 	return out;

  208. }

  209. 

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

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

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

  213. {

  214. 	int32_t out;

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

  216. 	return out;

  217. }

  218. 

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

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

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

  222. {

  223. 	int32_t out;

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

  225. 	return out;

  226. }

  227. 

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

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

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

  231. {

  232. 	int32_t out;

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

  234. 	return out;

  235. }

  236. 

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

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

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

  240. {

  241. 	int32_t out;

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

  243. 	return out;

  244. }

  245. 

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

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

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

  249. {

  250. 	int32_t out;

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

  252. 	return out;

  253. }

  254. 

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

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

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

  258. {

  259. 	int32_t out;

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

  261. 	return out;

  262. }

  263. 

  264. 

  265. 

  266. #endif