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.
693 Revīzijas
2 Atzari
Koks: e2db4871c6
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no 'e2db4871c6'
${ noResults }
teensy-audio/synth_waveform.cpp

389 rindas
10KB
Neapstrādāts Vainot Vēsture 

  1. /* Audio Library for Teensy 3.X

  2.  * Copyright (c) 2018, 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. #include <Arduino.h>

  28. #include "synth_waveform.h"

  29. #include "arm_math.h"

  30. #include "utility/dspinst.h"

  31. 

  32. 

  33. void AudioSynthWaveform::update(void)

  34. {

  35. 	audio_block_t *block;

  36. 	int16_t *bp, *end;

  37. 	int32_t val1, val2;

  38. 	int16_t magnitude15;

  39. 	uint32_t i, ph, index, index2, scale;

  40. 	const uint32_t inc = phase_increment;

  41. 

  42. 	ph = phase_accumulator + phase_offset;

  43. 	if (magnitude == 0) {

  44. 		phase_accumulator += inc * AUDIO_BLOCK_SAMPLES;

  45. 		return;

  46. 	}

  47. 	block = allocate();

  48. 	if (!block) {

  49. 		phase_accumulator += inc * AUDIO_BLOCK_SAMPLES;

  50. 		return;

  51. 	}

  52. 	bp = block->data;

  53. 

  54. 	switch(tone_type) {

  55. 	case WAVEFORM_SINE:

  56. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  57. 			index = ph >> 24;

  58. 			val1 = AudioWaveformSine[index];

  59. 			val2 = AudioWaveformSine[index+1];

  60. 			scale = (ph >> 8) & 0xFFFF;

  61. 			val2 *= scale;

  62. 			val1 *= 0x10000 - scale;

  63. 			*bp++ = multiply_32x32_rshift32(val1 + val2, magnitude);

  64. 			ph += inc;

  65. 		}

  66. 		break;

  67. 

  68. 	case WAVEFORM_ARBITRARY:

  69. 		if (!arbdata) {

  70. 			release(block);

  71. 			phase_accumulator += inc * AUDIO_BLOCK_SAMPLES;

  72. 			return;

  73. 		}

  74. 		// len = 256

  75. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  76. 			index = ph >> 24;

  77. 			index2 = index + 1;

  78. 			if (index2 >= 256) index2 = 0;

  79. 			val1 = *(arbdata + index);

  80. 			val2 = *(arbdata + index2);

  81. 			scale = (ph >> 8) & 0xFFFF;

  82. 			val2 *= scale;

  83. 			val1 *= 0x10000 - scale;

  84. 			*bp++ = multiply_32x32_rshift32(val1 + val2, magnitude);

  85. 			ph += inc;

  86. 		}

  87. 		break;

  88. 

  89. 	case WAVEFORM_SQUARE:

  90. 		magnitude15 = signed_saturate_rshift(magnitude, 16, 1);

  91. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  92. 			if (ph & 0x80000000) {

  93. 				*bp++ = -magnitude15;

  94. 			} else {

  95. 				*bp++ = magnitude15;

  96. 			}

  97. 			ph += inc;

  98. 		}

  99. 		break;

  100. 

  101. 	case WAVEFORM_SAWTOOTH:

  102. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  103. 			*bp++ = signed_multiply_32x16t(magnitude, ph);

  104. 			ph += inc;

  105. 		}

  106. 		break;

  107. 

  108. 	case WAVEFORM_SAWTOOTH_REVERSE:

  109. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  110. 			*bp++ = signed_multiply_32x16t(0xFFFFFFFFu - magnitude, ph);

  111. 			ph += inc;

  112. 		}

  113. 		break;

  114. 

  115. 	case WAVEFORM_TRIANGLE:

  116. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  117. 			uint32_t phtop = ph >> 30;

  118. 			if (phtop == 1 || phtop == 2) {

  119. 				*bp++ = ((0xFFFF - (ph >> 15)) * magnitude) >> 16;

  120. 			} else {

  121. 				*bp++ = ((ph >> 15) * magnitude) >> 16;

  122. 			}

  123. 			ph += inc;

  124. 		}

  125. 		break;

  126. 

  127. 	case WAVEFORM_TRIANGLE_VARIABLE:

  128. 		do {

  129. 		uint32_t rise = 0xFFFFFFFF / (pulse_width >> 16);

  130. 		uint32_t fall = 0xFFFFFFFF / (0xFFFF - (pulse_width >> 16));

  131. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  132. 			if (ph < pulse_width/2) {

  133. 				uint32_t n = (ph >> 16) * rise;

  134. 				*bp++ = ((n >> 16) * magnitude) >> 16;

  135. 			} else if (ph < 0xFFFFFFFF - pulse_width/2) {

  136. 				uint32_t n = 0x7FFFFFFF - (((ph - pulse_width/2) >> 16) * fall);

  137. 				*bp++ = ((n >> 16) * magnitude) >> 16;

  138. 			} else {

  139. 				uint32_t n = ((ph + pulse_width/2) >> 16) * rise + 0x80000000;

  140. 				*bp++ = ((n >> 16) * magnitude) >> 16;

  141. 			}

  142. 			ph += inc;

  143. 		}

  144. 		} while (0);

  145. 		break;

  146. 

  147. 	case WAVEFORM_PULSE:

  148. 		magnitude15 = signed_saturate_rshift(magnitude, 16, 1);

  149. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  150. 			if (ph < pulse_width) {

  151. 				*bp++ = magnitude15;

  152. 			} else {

  153. 				*bp++ = -magnitude15;

  154. 			}

  155. 			ph += inc;

  156. 		}

  157. 		break;

  158. 

  159. 	case WAVEFORM_SAMPLE_HOLD:

  160. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  161. 			*bp++ = sample;

  162. 			uint32_t newph = ph + inc;

  163. 			if (newph < ph) {

  164. 				sample = random(magnitude) - (magnitude >> 1);

  165. 			}

  166. 			ph = newph;

  167. 		}

  168. 		break;

  169. 	}

  170. 	phase_accumulator = ph - phase_offset;

  171. 

  172. 	if (tone_offset) {

  173. 		bp = block->data;

  174. 		end = bp + AUDIO_BLOCK_SAMPLES;

  175. 		do {

  176. 			val1 = *bp;

  177. 			*bp++ = signed_saturate_rshift(val1 + tone_offset, 16, 0);

  178. 		} while (bp < end);

  179. 	}

  180. 	transmit(block, 0);

  181. 	release(block);

  182. }

  183. 

  184. //--------------------------------------------------------------------------------

  185. 

  186. void AudioSynthWaveformModulated::update(void)

  187. {

  188. 	audio_block_t *block, *moddata, *shapedata;

  189. 	int16_t *bp, *end;

  190. 	int32_t val1, val2;

  191. 	int16_t magnitude15;

  192. 	uint32_t i, ph, index, index2, scale, priorphase;

  193. 	const uint32_t inc = phase_increment;

  194. 

  195. 	moddata = receiveReadOnly(0);

  196. 	shapedata = receiveReadOnly(1);

  197. 

  198. 	ph = phase_accumulator;

  199. 	priorphase = phasedata[AUDIO_BLOCK_SAMPLES-1];

  200. 	if (moddata && modulation_type == 0) {

  201. 		// Frequency Modulation

  202. 		bp = moddata->data;

  203. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  204. 			int32_t n = (*bp++) * modulation_factor; // n is # of octaves to mod

  205. 			int32_t ipart = n >> 27; // 4 integer bits

  206. 			n &= 0x7FFFFFF;          // 27 fractional bits

  207. 			#ifdef IMPROVE_EXPONENTIAL_ACCURACY

  208. 			// exp2 polynomial suggested by Stefan Stenzel on "music-dsp"

  209. 			// mail list, Wed, 3 Sep 2014 10:08:55 +0200

  210. 			int32_t x = n << 3;

  211. 			n = multiply_accumulate_32x32_rshift32_rounded(536870912, x, 1494202713);

  212. 			int32_t sq = multiply_32x32_rshift32_rounded(x, x);

  213. 			n = multiply_accumulate_32x32_rshift32_rounded(n, sq, 1934101615);

  214. 			n = n + (multiply_32x32_rshift32_rounded(sq,

  215. 				multiply_32x32_rshift32_rounded(x, 1358044250)) << 1);

  216. 			#else

  217. 			// exp2 algorithm by Laurent de Soras

  218. 			// http://www.musicdsp.org/showone.php?id=106

  219. 			n = (n + 134217728) << 3;

  220. 			n = multiply_32x32_rshift32_rounded(n, n);

  221. 			n = multiply_32x32_rshift32_rounded(n, 715827883) << 3;

  222. 			n = n + 715827882;

  223. 			#endif

  224. 			uint32_t scale = n >> (14 - ipart);

  225. 			uint32_t phinc = ((uint64_t)inc * scale) >> 16; // TODO: saturate 31 bits??

  226. 			ph += phinc;

  227. 			phasedata[i] = ph;

  228. 		}

  229. 		release(moddata);

  230. 	} else if (moddata) {

  231. 		// Phase Modulation

  232. 

  233. 		// TODO.....

  234. 

  235. 		release(moddata);

  236. 	} else {

  237. 		// No Modulation Input

  238. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  239. 			phasedata[i] = ph;

  240. 			ph += inc;

  241. 		}

  242. 	}

  243. 	phase_accumulator = ph;

  244. 

  245. 	if (magnitude == 0) {

  246. 		if (shapedata) release(shapedata);

  247. 		return;

  248. 	}

  249. 	block = allocate();

  250. 	if (!block) {

  251. 		if (shapedata) release(shapedata);

  252. 		return;

  253. 	}

  254. 	bp = block->data;

  255. 

  256. 	switch(tone_type) {

  257. 	case WAVEFORM_SINE:

  258. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  259. 			ph = phasedata[i];

  260. 			index = ph >> 24;

  261. 			val1 = AudioWaveformSine[index];

  262. 			val2 = AudioWaveformSine[index+1];

  263. 			scale = (ph >> 8) & 0xFFFF;

  264. 			val2 *= scale;

  265. 			val1 *= 0x10000 - scale;

  266. 			*bp++ = multiply_32x32_rshift32(val1 + val2, magnitude);

  267. 		}

  268. 		break;

  269. 

  270. 	case WAVEFORM_ARBITRARY:

  271. 		if (!arbdata) {

  272. 			release(block);

  273. 			if (shapedata) release(shapedata);

  274. 			return;

  275. 		}

  276. 		// len = 256

  277. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  278. 			ph = phasedata[i];

  279. 			index = ph >> 24;

  280. 			index2 = index + 1;

  281. 			if (index2 >= 256) index2 = 0;

  282. 			val1 = *(arbdata + index);

  283. 			val2 = *(arbdata + index2);

  284. 			scale = (ph >> 8) & 0xFFFF;

  285. 			val2 *= scale;

  286. 			val1 *= 0x10000 - scale;

  287. 			*bp++ = multiply_32x32_rshift32(val1 + val2, magnitude);

  288. 		}

  289. 		break;

  290. 

  291. 	case WAVEFORM_PULSE:

  292. 		if (shapedata) {

  293. 			magnitude15 = signed_saturate_rshift(magnitude, 16, 1);

  294. 			for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  295. 				uint32_t width = ((shapedata->data[i] + 0x8000) & 0xFFFF) << 16;

  296. 				if (phasedata[i] < width) {

  297. 					*bp++ = magnitude15;

  298. 				} else {

  299. 					*bp++ = -magnitude15;

  300. 				}

  301. 			}

  302. 			break;

  303. 		} // else fall through to orginary square without shape modulation

  304. 

  305. 	case WAVEFORM_SQUARE:

  306. 		magnitude15 = signed_saturate_rshift(magnitude, 16, 1);

  307. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  308. 			if (phasedata[i] & 0x80000000) {

  309. 				*bp++ = -magnitude15;

  310. 			} else {

  311. 				*bp++ = magnitude15;

  312. 			}

  313. 		}

  314. 		break;

  315. 

  316. 	case WAVEFORM_SAWTOOTH:

  317. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  318. 			*bp++ = signed_multiply_32x16t(magnitude, phasedata[i]);

  319. 		}

  320. 		break;

  321. 

  322. 	case WAVEFORM_SAWTOOTH_REVERSE:

  323. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  324. 			*bp++ = signed_multiply_32x16t(0xFFFFFFFFu - magnitude, phasedata[i]);

  325. 		}

  326. 		break;

  327. 

  328. 	case WAVEFORM_TRIANGLE_VARIABLE:

  329. 		if (shapedata) {

  330. 			for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  331. 				uint32_t width = (shapedata->data[i] + 0x8000) & 0xFFFF;

  332. 				uint32_t rise = 0xFFFFFFFF / width;

  333. 				uint32_t fall = 0xFFFFFFFF / (0xFFFF - width);

  334. 				width = width << 15;

  335. 				uint32_t n;

  336. 				ph = phasedata[i];

  337. 				if (ph < width) {

  338. 					n = (ph >> 16) * rise;

  339. 					*bp++ = ((n >> 16) * magnitude) >> 16;

  340. 				} else if (ph < 0xFFFFFFFF - width) {

  341. 					n = 0x7FFFFFFF - (((ph - width) >> 16) * fall);

  342. 					*bp++ = ((n >> 16) * magnitude) >> 16;

  343. 				} else {

  344. 					n = ((ph + width) >> 16) * rise + 0x80000000;

  345. 					*bp++ = ((n >> 16) * magnitude) >> 16;

  346. 				}

  347. 				ph += inc;

  348. 			}

  349. 			break;

  350. 		} // else fall through to orginary triangle without shape modulation

  351. 

  352. 	case WAVEFORM_TRIANGLE:

  353. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  354. 			ph = phasedata[i];

  355. 			uint32_t phtop = ph >> 30;

  356. 			if (phtop == 1 || phtop == 2) {

  357. 				*bp++ = ((0xFFFF - (ph >> 15)) * magnitude) >> 16;

  358. 			} else {

  359. 				*bp++ = ((ph >> 15) * magnitude) >> 16;

  360. 			}

  361. 		}

  362. 		break;

  363. 	case WAVEFORM_SAMPLE_HOLD:

  364. 		for (i=0; i < AUDIO_BLOCK_SAMPLES; i++) {

  365. 			ph = phasedata[i];

  366. 			if (ph < priorphase) {

  367. 				sample = random(magnitude) - (magnitude >> 1);

  368. 			}

  369. 			priorphase = ph;

  370. 			*bp++ = sample;

  371. 		}

  372. 		break;

  373. 	}

  374. 

  375. 	if (tone_offset) {

  376. 		bp = block->data;

  377. 		end = bp + AUDIO_BLOCK_SAMPLES;

  378. 		do {

  379. 			val1 = *bp;

  380. 			*bp++ = signed_saturate_rshift(val1 + tone_offset, 16, 0);

  381. 		} while (bp < end);

  382. 	}

  383. 	if (shapedata) release(shapedata);

  384. 	transmit(block, 0);

  385. 	release(block);

  386. }

  387.