visus
/
teensy-audio
Sledovat 1
Oblíbit 0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
969 Revize
2 Větve
Strom: d37974663b
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „d37974663b“
${ noResults }
teensy-audio/output_i2s_oct.cpp

420 lines
11KB
Surový Blame Historie 

  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. #include <Arduino.h>

  28. #include "output_i2s_oct.h"

  29. #include "output_i2s.h"

  30. #include "memcpy_audio.h"

  31. 

  32. #if defined(__IMXRT1062__)

  33. #include "utility/imxrt_hw.h"

  34. 

  35. audio_block_t * AudioOutputI2SOct::block_ch1_1st = NULL;

  36. audio_block_t * AudioOutputI2SOct::block_ch2_1st = NULL;

  37. audio_block_t * AudioOutputI2SOct::block_ch3_1st = NULL;

  38. audio_block_t * AudioOutputI2SOct::block_ch4_1st = NULL;

  39. audio_block_t * AudioOutputI2SOct::block_ch5_1st = NULL;

  40. audio_block_t * AudioOutputI2SOct::block_ch6_1st = NULL;

  41. audio_block_t * AudioOutputI2SOct::block_ch7_1st = NULL;

  42. audio_block_t * AudioOutputI2SOct::block_ch8_1st = NULL;

  43. audio_block_t * AudioOutputI2SOct::block_ch1_2nd = NULL;

  44. audio_block_t * AudioOutputI2SOct::block_ch2_2nd = NULL;

  45. audio_block_t * AudioOutputI2SOct::block_ch3_2nd = NULL;

  46. audio_block_t * AudioOutputI2SOct::block_ch4_2nd = NULL;

  47. audio_block_t * AudioOutputI2SOct::block_ch5_2nd = NULL;

  48. audio_block_t * AudioOutputI2SOct::block_ch6_2nd = NULL;

  49. audio_block_t * AudioOutputI2SOct::block_ch7_2nd = NULL;

  50. audio_block_t * AudioOutputI2SOct::block_ch8_2nd = NULL;

  51. uint16_t  AudioOutputI2SOct::ch1_offset = 0;

  52. uint16_t  AudioOutputI2SOct::ch2_offset = 0;

  53. uint16_t  AudioOutputI2SOct::ch3_offset = 0;

  54. uint16_t  AudioOutputI2SOct::ch4_offset = 0;

  55. uint16_t  AudioOutputI2SOct::ch5_offset = 0;

  56. uint16_t  AudioOutputI2SOct::ch6_offset = 0;

  57. uint16_t  AudioOutputI2SOct::ch7_offset = 0;

  58. uint16_t  AudioOutputI2SOct::ch8_offset = 0;

  59. bool AudioOutputI2SOct::update_responsibility = false;

  60. DMAMEM __attribute__((aligned(32))) static uint32_t i2s_tx_buffer[AUDIO_BLOCK_SAMPLES*4];

  61. DMAChannel AudioOutputI2SOct::dma(false);

  62. 

  63. static const uint32_t zerodata[AUDIO_BLOCK_SAMPLES/4] = {0};

  64. 

  65. void AudioOutputI2SOct::begin(void)

  66. {

  67. 	dma.begin(true); // Allocate the DMA channel first

  68. 

  69. 	block_ch1_1st = NULL;

  70. 	block_ch2_1st = NULL;

  71. 	block_ch3_1st = NULL;

  72. 	block_ch4_1st = NULL;

  73. 	block_ch5_1st = NULL;

  74. 	block_ch6_1st = NULL;

  75. 

  76. 	memset(i2s_tx_buffer, 0, sizeof(i2s_tx_buffer));

  77. 	AudioOutputI2S::config_i2s();

  78. 	I2S1_TCR3 = I2S_TCR3_TCE_4CH;

  79. 	CORE_PIN7_CONFIG  = 3;

  80. 	CORE_PIN32_CONFIG = 3;

  81. 	CORE_PIN6_CONFIG  = 3;

  82. 	CORE_PIN9_CONFIG  = 3;

  83. 	dma.TCD->SADDR = i2s_tx_buffer;

  84. 	dma.TCD->SOFF = 2;

  85. 	dma.TCD->ATTR = DMA_TCD_ATTR_SSIZE(1) | DMA_TCD_ATTR_DSIZE(1);

  86. 	dma.TCD->NBYTES_MLOFFYES = DMA_TCD_NBYTES_DMLOE |

  87. 		DMA_TCD_NBYTES_MLOFFYES_MLOFF(-16) |

  88. 		DMA_TCD_NBYTES_MLOFFYES_NBYTES(8);

  89. 	dma.TCD->SLAST = -sizeof(i2s_tx_buffer);

  90. 	dma.TCD->DADDR = (void *)((uint32_t)&I2S1_TDR0 + 2);

  91. 	dma.TCD->DOFF = 4;

  92. 	dma.TCD->CITER_ELINKNO = AUDIO_BLOCK_SAMPLES * 2;

  93. 	dma.TCD->DLASTSGA = -16;

  94. 	dma.TCD->BITER_ELINKNO = AUDIO_BLOCK_SAMPLES * 2;

  95. 	dma.TCD->CSR = DMA_TCD_CSR_INTHALF | DMA_TCD_CSR_INTMAJOR;

  96. 	dma.triggerAtHardwareEvent(DMAMUX_SOURCE_SAI1_TX);

  97. 	dma.enable();

  98. 	I2S1_RCSR |= I2S_RCSR_RE | I2S_RCSR_BCE;

  99. 	I2S1_TCSR = I2S_TCSR_TE | I2S_TCSR_BCE | I2S_TCSR_FRDE;

  100. 	//I2S1_TCR3 = I2S_TCR3_TCE_4CH;

  101. 	update_responsibility = update_setup();

  102. 	dma.attachInterrupt(isr);

  103. }

  104. 

  105. void AudioOutputI2SOct::isr(void)

  106. {

  107. 	uint32_t saddr;

  108. 	const int16_t *src1, *src2, *src3, *src4, *src5, *src6, *src7, *src8;

  109. 	const int16_t *zeros = (const int16_t *)zerodata;

  110. 	int16_t *dest;

  111. 

  112. 	saddr = (uint32_t)(dma.TCD->SADDR);

  113. 	dma.clearInterrupt();

  114. 	if (saddr < (uint32_t)i2s_tx_buffer + sizeof(i2s_tx_buffer) / 2) {

  115. 		// DMA is transmitting the first half of the buffer

  116. 		// so we must fill the second half

  117. 		dest = (int16_t *)((uint32_t)i2s_tx_buffer + sizeof(i2s_tx_buffer) / 2);

  118. 		if (update_responsibility) update_all();

  119. 	} else {

  120. 		dest = (int16_t *)i2s_tx_buffer;

  121. 	}

  122. 

  123. 	src1 = (block_ch1_1st) ? block_ch1_1st->data + ch1_offset : zeros;

  124. 	src2 = (block_ch2_1st) ? block_ch2_1st->data + ch2_offset : zeros;

  125. 	src3 = (block_ch3_1st) ? block_ch3_1st->data + ch3_offset : zeros;

  126. 	src4 = (block_ch4_1st) ? block_ch4_1st->data + ch4_offset : zeros;

  127. 	src5 = (block_ch5_1st) ? block_ch5_1st->data + ch5_offset : zeros;

  128. 	src6 = (block_ch6_1st) ? block_ch6_1st->data + ch6_offset : zeros;

  129. 	src7 = (block_ch7_1st) ? block_ch7_1st->data + ch7_offset : zeros;

  130. 	src8 = (block_ch8_1st) ? block_ch8_1st->data + ch8_offset : zeros;

  131. #if 0

  132. 	// TODO: optimized 8 channel copy...

  133. 	memcpy_tointerleaveQuad(dest, src1, src2, src3, src4);

  134. #else

  135. 	int16_t *p=dest;

  136. 	for (int i=0; i < AUDIO_BLOCK_SAMPLES/2; i++) {

  137. 		*p++ = *src1++;

  138. 		*p++ = *src3++;

  139. 		*p++ = *src5++;

  140. 		*p++ = *src7++;

  141. 		*p++ = *src2++;

  142. 		*p++ = *src4++;

  143. 		*p++ = *src6++;

  144. 		*p++ = *src8++;

  145. 	}

  146. #endif

  147. 	arm_dcache_flush_delete(dest, sizeof(i2s_tx_buffer) / 2);

  148. 

  149. 	if (block_ch1_1st) {

  150. 		if (ch1_offset == 0) {

  151. 			ch1_offset = AUDIO_BLOCK_SAMPLES/2;

  152. 		} else {

  153. 			ch1_offset = 0;

  154. 			release(block_ch1_1st);

  155. 			block_ch1_1st = block_ch1_2nd;

  156. 			block_ch1_2nd = NULL;

  157. 		}

  158. 	}

  159. 	if (block_ch2_1st) {

  160. 		if (ch2_offset == 0) {

  161. 			ch2_offset = AUDIO_BLOCK_SAMPLES/2;

  162. 		} else {

  163. 			ch2_offset = 0;

  164. 			release(block_ch2_1st);

  165. 			block_ch2_1st = block_ch2_2nd;

  166. 			block_ch2_2nd = NULL;

  167. 		}

  168. 	}

  169. 	if (block_ch3_1st) {

  170. 		if (ch3_offset == 0) {

  171. 			ch3_offset = AUDIO_BLOCK_SAMPLES/2;

  172. 		} else {

  173. 			ch3_offset = 0;

  174. 			release(block_ch3_1st);

  175. 			block_ch3_1st = block_ch3_2nd;

  176. 			block_ch3_2nd = NULL;

  177. 		}

  178. 	}

  179. 	if (block_ch4_1st) {

  180. 		if (ch4_offset == 0) {

  181. 			ch4_offset = AUDIO_BLOCK_SAMPLES/2;

  182. 		} else {

  183. 			ch4_offset = 0;

  184. 			release(block_ch4_1st);

  185. 			block_ch4_1st = block_ch4_2nd;

  186. 			block_ch4_2nd = NULL;

  187. 		}

  188. 	}

  189. 	if (block_ch5_1st) {

  190. 		if (ch5_offset == 0) {

  191. 			ch5_offset = AUDIO_BLOCK_SAMPLES/2;

  192. 		} else {

  193. 			ch5_offset = 0;

  194. 			release(block_ch5_1st);

  195. 			block_ch5_1st = block_ch5_2nd;

  196. 			block_ch5_2nd = NULL;

  197. 		}

  198. 	}

  199. 	if (block_ch6_1st) {

  200. 		if (ch6_offset == 0) {

  201. 			ch6_offset = AUDIO_BLOCK_SAMPLES/2;

  202. 		} else {

  203. 			ch6_offset = 0;

  204. 			release(block_ch6_1st);

  205. 			block_ch6_1st = block_ch6_2nd;

  206. 			block_ch6_2nd = NULL;

  207. 		}

  208. 	}

  209. 	if (block_ch7_1st) {

  210. 		if (ch7_offset == 0) {

  211. 			ch7_offset = AUDIO_BLOCK_SAMPLES/2;

  212. 		} else {

  213. 			ch7_offset = 0;

  214. 			release(block_ch7_1st);

  215. 			block_ch7_1st = block_ch7_2nd;

  216. 			block_ch7_2nd = NULL;

  217. 		}

  218. 	}

  219. 	if (block_ch8_1st) {

  220. 		if (ch8_offset == 0) {

  221. 			ch8_offset = AUDIO_BLOCK_SAMPLES/2;

  222. 		} else {

  223. 			ch8_offset = 0;

  224. 			release(block_ch8_1st);

  225. 			block_ch8_1st = block_ch8_2nd;

  226. 			block_ch8_2nd = NULL;

  227. 		}

  228. 	}

  229. }

  230. 

  231. 

  232. void AudioOutputI2SOct::update(void)

  233. {

  234. 	audio_block_t *block, *tmp;

  235. 

  236. 	block = receiveReadOnly(0); // channel 1

  237. 	if (block) {

  238. 		__disable_irq();

  239. 		if (block_ch1_1st == NULL) {

  240. 			block_ch1_1st = block;

  241. 			ch1_offset = 0;

  242. 			__enable_irq();

  243. 		} else if (block_ch1_2nd == NULL) {

  244. 			block_ch1_2nd = block;

  245. 			__enable_irq();

  246. 		} else {

  247. 			tmp = block_ch1_1st;

  248. 			block_ch1_1st = block_ch1_2nd;

  249. 			block_ch1_2nd = block;

  250. 			ch1_offset = 0;

  251. 			__enable_irq();

  252. 			release(tmp);

  253. 		}

  254. 	}

  255. 	block = receiveReadOnly(1); // channel 2

  256. 	if (block) {

  257. 		__disable_irq();

  258. 		if (block_ch2_1st == NULL) {

  259. 			block_ch2_1st = block;

  260. 			ch2_offset = 0;

  261. 			__enable_irq();

  262. 		} else if (block_ch2_2nd == NULL) {

  263. 			block_ch2_2nd = block;

  264. 			__enable_irq();

  265. 		} else {

  266. 			tmp = block_ch2_1st;

  267. 			block_ch2_1st = block_ch2_2nd;

  268. 			block_ch2_2nd = block;

  269. 			ch2_offset = 0;

  270. 			__enable_irq();

  271. 			release(tmp);

  272. 		}

  273. 	}

  274. 	block = receiveReadOnly(2); // channel 3

  275. 	if (block) {

  276. 		__disable_irq();

  277. 		if (block_ch3_1st == NULL) {

  278. 			block_ch3_1st = block;

  279. 			ch3_offset = 0;

  280. 			__enable_irq();

  281. 		} else if (block_ch3_2nd == NULL) {

  282. 			block_ch3_2nd = block;

  283. 			__enable_irq();

  284. 		} else {

  285. 			tmp = block_ch3_1st;

  286. 			block_ch3_1st = block_ch3_2nd;

  287. 			block_ch3_2nd = block;

  288. 			ch3_offset = 0;

  289. 			__enable_irq();

  290. 			release(tmp);

  291. 		}

  292. 	}

  293. 	block = receiveReadOnly(3); // channel 4

  294. 	if (block) {

  295. 		__disable_irq();

  296. 		if (block_ch4_1st == NULL) {

  297. 			block_ch4_1st = block;

  298. 			ch4_offset = 0;

  299. 			__enable_irq();

  300. 		} else if (block_ch4_2nd == NULL) {

  301. 			block_ch4_2nd = block;

  302. 			__enable_irq();

  303. 		} else {

  304. 			tmp = block_ch4_1st;

  305. 			block_ch4_1st = block_ch4_2nd;

  306. 			block_ch4_2nd = block;

  307. 			ch4_offset = 0;

  308. 			__enable_irq();

  309. 			release(tmp);

  310. 		}

  311. 	}

  312. 	block = receiveReadOnly(4); // channel 5

  313. 	if (block) {

  314. 		__disable_irq();

  315. 		if (block_ch5_1st == NULL) {

  316. 			block_ch5_1st = block;

  317. 			ch5_offset = 0;

  318. 			__enable_irq();

  319. 		} else if (block_ch5_2nd == NULL) {

  320. 			block_ch5_2nd = block;

  321. 			__enable_irq();

  322. 		} else {

  323. 			tmp = block_ch5_1st;

  324. 			block_ch5_1st = block_ch5_2nd;

  325. 			block_ch5_2nd = block;

  326. 			ch5_offset = 0;

  327. 			__enable_irq();

  328. 			release(tmp);

  329. 		}

  330. 	}

  331. 	block = receiveReadOnly(5); // channel 6

  332. 	if (block) {

  333. 		__disable_irq();

  334. 		if (block_ch6_1st == NULL) {

  335. 			block_ch6_1st = block;

  336. 			ch6_offset = 0;

  337. 			__enable_irq();

  338. 		} else if (block_ch6_2nd == NULL) {

  339. 			block_ch6_2nd = block;

  340. 			__enable_irq();

  341. 		} else {

  342. 			tmp = block_ch6_1st;

  343. 			block_ch6_1st = block_ch6_2nd;

  344. 			block_ch6_2nd = block;

  345. 			ch6_offset = 0;

  346. 			__enable_irq();

  347. 			release(tmp);

  348. 		}

  349. 	}

  350. 	block = receiveReadOnly(6); // channel 7

  351. 	if (block) {

  352. 		__disable_irq();

  353. 		if (block_ch7_1st == NULL) {

  354. 			block_ch7_1st = block;

  355. 			ch7_offset = 0;

  356. 			__enable_irq();

  357. 		} else if (block_ch7_2nd == NULL) {

  358. 			block_ch7_2nd = block;

  359. 			__enable_irq();

  360. 		} else {

  361. 			tmp = block_ch7_1st;

  362. 			block_ch7_1st = block_ch7_2nd;

  363. 			block_ch7_2nd = block;

  364. 			ch7_offset = 0;

  365. 			__enable_irq();

  366. 			release(tmp);

  367. 		}

  368. 	}

  369. 	block = receiveReadOnly(7); // channel 8

  370. 	if (block) {

  371. 		__disable_irq();

  372. 		if (block_ch8_1st == NULL) {

  373. 			block_ch8_1st = block;

  374. 			ch8_offset = 0;

  375. 			__enable_irq();

  376. 		} else if (block_ch8_2nd == NULL) {

  377. 			block_ch8_2nd = block;

  378. 			__enable_irq();

  379. 		} else {

  380. 			tmp = block_ch8_1st;

  381. 			block_ch8_1st = block_ch8_2nd;

  382. 			block_ch8_2nd = block;

  383. 			ch8_offset = 0;

  384. 			__enable_irq();

  385. 			release(tmp);

  386. 		}

  387. 	}

  388. }

  389. 

  390. 

  391. #else // not supported

  392. 

  393. void AudioOutputI2SOct::begin(void)

  394. {

  395. }

  396. 

  397. void AudioOutputI2SOct::update(void)

  398. {

  399. 	audio_block_t *block;

  400. 

  401. 	block = receiveReadOnly(0);

  402. 	if (block) release(block);

  403. 	block = receiveReadOnly(1);

  404. 	if (block) release(block);

  405. 	block = receiveReadOnly(2);

  406. 	if (block) release(block);

  407. 	block = receiveReadOnly(3);

  408. 	if (block) release(block);

  409. 	block = receiveReadOnly(4);

  410. 	if (block) release(block);

  411. 	block = receiveReadOnly(5);

  412. 	if (block) release(block);

  413. 	block = receiveReadOnly(6);

  414. 	if (block) release(block);

  415. 	block = receiveReadOnly(7);

  416. 	if (block) release(block);

  417. }

  418. 

  419. #endif