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.
69 Revīzijas
2 Atzari
Koks: bdc11e316d
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no 'bdc11e316d'
${ noResults }
teensy-audio/utility/dspinst.h

112 rindas
4.2KB
Neapstrādāts Vainot Vēsture 

  1. #include <stdint.h>

  2. 

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

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

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

  6. {

  7. 	int32_t out;

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

  9. 	return out;

  10. }

  11. 

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

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

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

  15. {

  16. 	int32_t out;

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

  18. 	return out;

  19. }

  20. 

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

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

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

  24. {

  25. 	int32_t out;

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

  27. 	return out;

  28. }

  29. 

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

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

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

  33. {

  34. 	int32_t out;

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

  36. 	return out;

  37. }

  38. 

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

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

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

  42. {

  43. 	int32_t out;

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

  45. 	return out;

  46. }

  47. 

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

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

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

  51. {

  52. 	int32_t out;

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

  54. 	return out;

  55. }

  56. 

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

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

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

  60. {

  61. 	int32_t out;

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

  63. 	return out;

  64. }

  65. 

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

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

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

  69. {

  70. 	int32_t out;

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

  72. 	return out;

  73. }

  74. 

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

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

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

  78. {

  79. 	int32_t out;

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

  81. 	return out;

  82. }

  83. 

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

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

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

  87. {

  88. 	int32_t out;

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

  90. 	return out;

  91. }

  92. 

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

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

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

  96. {

  97. 	int32_t out;

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

  99. 	return out;

  100. }

  101. 

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

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

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

  105. {

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

  107. 	return a;

  108. }

  109. 

  110.