visus
/
teensy-audio
Suivre 1
Ajouter aux favoris 0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
937 Révisions
2 Branches
Aborescence: 29657227d0
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '29657227d0'
${ noResults }
teensy-audio/output_pt8211_2.cpp

433 lines
14KB
Brut Annotations Historique 

  1. /* Audio Library for Teensy 3.X

  2.  * Copyright (c) 2016, 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. //Adapted to PT8211, Frank Bösing, Ben-Rheinland

  28. 

  29. #if defined(__IMXRT1052__) || defined(__IMXRT1062__)

  30. #include <Arduino.h>

  31. #include "output_pt8211_2.h"

  32. #include "memcpy_audio.h"

  33. #include "utility/imxrt_hw.h"

  34. 

  35. audio_block_t * AudioOutputPT8211_2::block_left_1st = NULL;

  36. audio_block_t * AudioOutputPT8211_2::block_right_1st = NULL;

  37. audio_block_t * AudioOutputPT8211_2::block_left_2nd = NULL;

  38. audio_block_t * AudioOutputPT8211_2::block_right_2nd = NULL;

  39. uint16_t  AudioOutputPT8211_2::block_left_offset = 0;

  40. uint16_t  AudioOutputPT8211_2::block_right_offset = 0;

  41. bool AudioOutputPT8211_2::update_responsibility = false;

  42. #if defined(AUDIO_PT8211_OVERSAMPLING)

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

  44. #else

  45. DMAMEM __attribute__((aligned(32))) static uint32_t i2s_tx_buffer[AUDIO_BLOCK_SAMPLES];

  46. #endif

  47. DMAChannel AudioOutputPT8211_2::dma(false);

  48. 

  49. FLASHMEM

  50. void AudioOutputPT8211_2::begin(void)

  51. {

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

  53. 	arm_dcache_flush_delete(i2s_tx_buffer, sizeof(i2s_tx_buffer));		

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

  55. 

  56. 	block_left_1st = NULL;

  57. 	block_right_1st = NULL;

  58. 

  59. 	// TODO: should we set & clear the I2S_TCSR_SR bit here?

  60. 	config_i2s();

  61. 	CORE_PIN2_CONFIG  = 2;  //2:TX_DATA0

  62. 	

  63. 	dma.TCD->SADDR = i2s_tx_buffer;

  64. 	dma.TCD->SOFF = 2;

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

  66. 	dma.TCD->NBYTES_MLNO = 2;

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

  68. 	dma.TCD->DOFF = 0;

  69. 	dma.TCD->CITER_ELINKNO = sizeof(i2s_tx_buffer) / 2;

  70. 	dma.TCD->DLASTSGA = 0;

  71. 	dma.TCD->BITER_ELINKNO = sizeof(i2s_tx_buffer) / 2;

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

  73. 	dma.TCD->DADDR = (void *)((uint32_t)&I2S2_TDR0);

  74. 	dma.triggerAtHardwareEvent(DMAMUX_SOURCE_SAI2_TX);

  75. 

  76. 	I2S2_TCSR |= I2S_TCSR_TE | I2S_TCSR_BCE | I2S_TCSR_FRDE;

  77. 

  78. 	update_responsibility = update_setup();

  79. 	dma.attachInterrupt(isr);

  80. 	dma.enable();

  81. }

  82. 

  83. void AudioOutputPT8211_2::isr(void)

  84. {

  85. 	int16_t *dest, *dest_copy;

  86. 	audio_block_t *blockL, *blockR;

  87. 	uint32_t saddr, offsetL, offsetR;

  88. 

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

  90. 	dma.clearInterrupt();

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

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

  93. 		// so we must fill the second half

  94. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  95. 			dest = (int16_t *)&i2s_tx_buffer[(AUDIO_BLOCK_SAMPLES/2)*4];

  96. 		#else

  97. 			dest = (int16_t *)&i2s_tx_buffer[AUDIO_BLOCK_SAMPLES/2];

  98. 		#endif

  99. 		if (AudioOutputPT8211_2::update_responsibility) AudioStream::update_all();

  100. 	} else {

  101. 		// DMA is transmitting the second half of the buffer

  102. 		// so we must fill the first half

  103. 		dest = (int16_t *)i2s_tx_buffer;

  104. 	}

  105. 	dest_copy = dest;

  106. 

  107. 	blockL = AudioOutputPT8211_2::block_left_1st;

  108. 	blockR = AudioOutputPT8211_2::block_right_1st;

  109. 	offsetL = AudioOutputPT8211_2::block_left_offset;

  110. 	offsetR = AudioOutputPT8211_2::block_right_offset;

  111. 

  112. 	#if defined(AUDIO_PT8211_OVERSAMPLING)

  113. 		static int32_t oldL = 0;

  114. 		static int32_t oldR = 0;

  115. 	#endif

  116. 	if (blockL && blockR) {

  117. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  118. 			#if defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  119. 				for (int i=0; i< AUDIO_BLOCK_SAMPLES / 2; i++, offsetL++, offsetR++) {

  120. 					int32_t valL = blockL->data[offsetL];

  121. 					int32_t valR = blockR->data[offsetR];

  122. 					int32_t nL = (oldL+valL) >> 1;

  123. 					int32_t nR = (oldR+valR) >> 1;

  124. 					*(dest+0) = (oldL+nL) >> 1;

  125. 					*(dest+1) = (oldR+nR) >> 1;

  126. 					*(dest+2) = nL;

  127. 					*(dest+3) = nR;

  128. 					*(dest+4) = (nL+valL) >> 1;

  129. 					*(dest+5) = (nR+valR) >> 1;

  130. 					*(dest+6) = valL;

  131. 					*(dest+7) = valR;

  132. 					dest+=8;

  133. 					oldL = valL;

  134. 					oldR = valR;

  135. 				}

  136. 			#elif defined(AUDIO_PT8211_INTERPOLATION_CIC)

  137. 				for (int i=0; i< AUDIO_BLOCK_SAMPLES / 2; i++, offsetL++, offsetR++) {

  138. 					int32_t valL = blockL->data[offsetL];

  139. 					int32_t valR = blockR->data[offsetR];

  140. 

  141. 					int32_t combL[3] = {0};

  142. 					static int32_t combLOld[2] = {0};

  143. 					int32_t combR[3] = {0};

  144. 					static int32_t combROld[2] = {0};

  145. 

  146. 					combL[0] = valL - oldL;

  147. 					combR[0] = valR - oldR;

  148. 					combL[1] = combL[0] - combLOld[0];

  149. 					combR[1] = combR[0] - combROld[0];

  150. 					combL[2] = combL[1] - combLOld[1];

  151. 					combR[2] = combR[1] - combROld[1];

  152. 					// combL[2] now holds input val

  153. 					// combR[2] now holds input val

  154. 					oldL = valL;

  155. 					oldR = valR;

  156. 					combLOld[0] = combL[0];

  157. 					combROld[0] = combR[0];

  158. 					combLOld[1] = combL[1];

  159. 					combROld[1] = combR[1];

  160. 					for (int j = 0; j < 4; j++) {

  161. 						int32_t integrateL[3];

  162. 						int32_t integrateR[3];

  163. 						static int32_t integrateLOld[3] = {0};

  164. 						static int32_t integrateROld[3] = {0};

  165. 						integrateL[0] = ( (j==0) ? (combL[2]) : (0) ) + integrateLOld[0];

  166. 						integrateR[0] = ( (j==0) ? (combR[2]) : (0) ) + integrateROld[0];

  167. 						integrateL[1] = integrateL[0] + integrateLOld[1];

  168. 						integrateR[1] = integrateR[0] + integrateROld[1];

  169. 						integrateL[2] = integrateL[1] + integrateLOld[2];

  170. 						integrateR[2] = integrateR[1] + integrateROld[2];

  171. 						// integrateL[2] now holds j'th upsampled value

  172. 						// integrateR[2] now holds j'th upsampled value

  173. 						*(dest+j*2) = integrateL[2] >> 4;

  174. 						*(dest+j*2+1) = integrateR[2] >> 4;

  175. 						integrateLOld[0] = integrateL[0];

  176. 						integrateROld[0] = integrateR[0];

  177. 						integrateLOld[1] = integrateL[1];

  178. 						integrateROld[1] = integrateR[1];

  179. 						integrateLOld[2] = integrateL[2];

  180. 						integrateROld[2] = integrateR[2];

  181. 					}

  182. 					dest+=8;

  183. 				}

  184. 			#else

  185. 				#error no interpolation method defined for oversampling.

  186. 			#endif //defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  187. 		#else

  188. 			memcpy_tointerleaveLR(dest, blockL->data + offsetL, blockR->data + offsetR);

  189. 			offsetL += AUDIO_BLOCK_SAMPLES / 2;

  190. 			offsetR += AUDIO_BLOCK_SAMPLES / 2;

  191. 		#endif //defined(AUDIO_PT8211_OVERSAMPLING)

  192. 

  193. 	} else if (blockL) {

  194. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  195. 			#if defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  196. 				for (int i=0; i< AUDIO_BLOCK_SAMPLES / 2; i++, offsetL++) {

  197. 					int32_t val = blockL->data[offsetL];

  198. 					int32_t n = (oldL+val) >> 1;

  199. 					*(dest+0) = (oldL+n) >> 1;

  200. 					*(dest+1) = 0;

  201. 					*(dest+2) = n;

  202. 					*(dest+3) = 0;

  203. 					*(dest+4) = (n+val) >> 1;

  204. 					*(dest+5) = 0;

  205. 					*(dest+6) = val;

  206. 					*(dest+7) = 0;

  207. 					dest+=8;

  208. 					oldL = val;

  209. 				}

  210. 			#elif defined(AUDIO_PT8211_INTERPOLATION_CIC)

  211. 				for (int i=0; i< AUDIO_BLOCK_SAMPLES / 2; i++, offsetL++) {

  212. 					int32_t valL = blockL->data[offsetL];

  213. 

  214. 					int32_t combL[3] = {0};

  215. 					static int32_t combLOld[2] = {0};

  216. 

  217. 					combL[0] = valL - oldL;

  218. 					combL[1] = combL[0] - combLOld[0];

  219. 					combL[2] = combL[1] - combLOld[1];

  220. 					// combL[2] now holds input val

  221. 					combLOld[0] = combL[0];

  222. 					combLOld[1] = combL[1];

  223. 

  224. 					for (int j = 0; j < 4; j++) {

  225. 						int32_t integrateL[3];

  226. 						static int32_t integrateLOld[3] = {0};

  227. 						integrateL[0] = ( (j==0) ? (combL[2]) : (0) ) + integrateLOld[0];

  228. 						integrateL[1] = integrateL[0] + integrateLOld[1];

  229. 						integrateL[2] = integrateL[1] + integrateLOld[2];

  230. 						// integrateL[2] now holds j'th upsampled value

  231. 						*(dest+j*2) = integrateL[2] >> 4;

  232. 						integrateLOld[0] = integrateL[0];

  233. 						integrateLOld[1] = integrateL[1];

  234. 						integrateLOld[2] = integrateL[2];

  235. 					}

  236. 

  237. 					// fill right channel with zeros:

  238. 					*(dest+1) = 0;

  239. 					*(dest+3) = 0;

  240. 					*(dest+5) = 0;

  241. 					*(dest+7) = 0;

  242. 					dest+=8;

  243. 					oldL = valL;

  244. 				}

  245. 			#else

  246. 				#error no interpolation method defined for oversampling.

  247. 			#endif //defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  248. 		#else

  249. 			memcpy_tointerleaveL(dest, blockL->data + offsetL);

  250. 			offsetL += (AUDIO_BLOCK_SAMPLES / 2);

  251. 		#endif //defined(AUDIO_PT8211_OVERSAMPLING)

  252. 	} else if (blockR) {

  253. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  254. 			#if defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  255. 				for (int i=0; i< AUDIO_BLOCK_SAMPLES / 2; i++, offsetR++) {

  256. 					int32_t val = blockR->data[offsetR];

  257. 					int32_t n = (oldR+val) >> 1;

  258. 					*(dest+0) = 0;

  259. 					*(dest+1) = ((oldR+n) >> 1);

  260. 					*(dest+2) = 0;

  261. 					*(dest+3) = n;

  262. 					*(dest+4) = 0;

  263. 					*(dest+5) = ((n+val) >> 1);

  264. 					*(dest+6) = 0;

  265. 					*(dest+7) = val;

  266. 					dest+=8;

  267. 					oldR = val;

  268. 				}

  269. 			#elif defined(AUDIO_PT8211_INTERPOLATION_CIC)

  270. 				for (int i=0; i< AUDIO_BLOCK_SAMPLES / 2; i++, offsetR++) {

  271. 					int32_t valR = blockR->data[offsetR];

  272. 

  273. 					int32_t combR[3] = {0};

  274. 					static int32_t combROld[2] = {0};

  275. 

  276. 					combR[0] = valR - oldR;

  277. 					combR[1] = combR[0] - combROld[0];

  278. 					combR[2] = combR[1] - combROld[1];

  279. 					// combR[2] now holds input val

  280. 					combROld[0] = combR[0];

  281. 					combROld[1] = combR[1];

  282. 

  283. 					for (int j = 0; j < 4; j++) {

  284. 						int32_t integrateR[3];

  285. 						static int32_t integrateROld[3] = {0};

  286. 						integrateR[0] = ( (j==0) ? (combR[2]) : (0) ) + integrateROld[0];

  287. 						integrateR[1] = integrateR[0] + integrateROld[1];

  288. 						integrateR[2] = integrateR[1] + integrateROld[2];

  289. 						// integrateR[2] now holds j'th upsampled value

  290. 						*(dest+j*2+1) = integrateR[2] >> 4;

  291. 						integrateROld[0] = integrateR[0];

  292. 						integrateROld[1] = integrateR[1];

  293. 						integrateROld[2] = integrateR[2];

  294. 					}

  295. 

  296. 					// fill left channel with zeros:

  297. 					*(dest+0) = 0;

  298. 					*(dest+2) = 0;

  299. 					*(dest+4) = 0;

  300. 					*(dest+6) = 0;

  301. 					dest+=8;

  302. 					oldR = valR;

  303. 				}

  304. 			#else

  305. 				#error no interpolation method defined for oversampling.

  306. 			#endif //defined(AUDIO_PT8211_INTERPOLATION_LINEAR)

  307. 		#else

  308. 			memcpy_tointerleaveR(dest, blockR->data + offsetR);

  309. 			offsetR += AUDIO_BLOCK_SAMPLES / 2;

  310. 		#endif //defined(AUDIO_PT8211_OVERSAMPLING)

  311. 	} else {

  312. 		#if defined(AUDIO_PT8211_OVERSAMPLING)

  313. 			memset(dest,0,AUDIO_BLOCK_SAMPLES*8);

  314. 		#else

  315. 			memset(dest,0,AUDIO_BLOCK_SAMPLES*2);

  316. 		#endif

  317. 		return;

  318. 	}

  319. 

  320. 	arm_dcache_flush_delete(dest_copy, sizeof(i2s_tx_buffer) / 2);

  321. 

  322. 	if (offsetL < AUDIO_BLOCK_SAMPLES) {

  323. 		AudioOutputPT8211_2::block_left_offset = offsetL;

  324. 	} else {

  325. 		AudioOutputPT8211_2::block_left_offset = 0;

  326. 		AudioStream::release(blockL);

  327. 		AudioOutputPT8211_2::block_left_1st = AudioOutputPT8211_2::block_left_2nd;

  328. 		AudioOutputPT8211_2::block_left_2nd = NULL;

  329. 	}

  330. 	if (offsetR < AUDIO_BLOCK_SAMPLES) {

  331. 		AudioOutputPT8211_2::block_right_offset = offsetR;

  332. 	} else {

  333. 		AudioOutputPT8211_2::block_right_offset = 0;

  334. 		AudioStream::release(blockR);

  335. 		AudioOutputPT8211_2::block_right_1st = AudioOutputPT8211_2::block_right_2nd;

  336. 		AudioOutputPT8211_2::block_right_2nd = NULL;

  337. 	}

  338. }

  339. 

  340. 

  341. 

  342. void AudioOutputPT8211_2::update(void)

  343. {

  344. 

  345. 	audio_block_t *block;

  346. 	block = receiveReadOnly(0); // input 0 = left channel

  347. 	if (block) {

  348. 		__disable_irq();

  349. 		if (block_left_1st == NULL) {

  350. 			block_left_1st = block;

  351. 			block_left_offset = 0;

  352. 			__enable_irq();

  353. 		} else if (block_left_2nd == NULL) {

  354. 			block_left_2nd = block;

  355. 			__enable_irq();

  356. 		} else {

  357. 			audio_block_t *tmp = block_left_1st;

  358. 			block_left_1st = block_left_2nd;

  359. 			block_left_2nd = block;

  360. 			block_left_offset = 0;

  361. 			__enable_irq();

  362. 			release(tmp);

  363. 		}

  364. 	}

  365. 	block = receiveReadOnly(1); // input 1 = right channel

  366. 	if (block) {

  367. 		__disable_irq();

  368. 		if (block_right_1st == NULL) {

  369. 			block_right_1st = block;

  370. 			block_right_offset = 0;

  371. 			__enable_irq();

  372. 		} else if (block_right_2nd == NULL) {

  373. 			block_right_2nd = block;

  374. 			__enable_irq();

  375. 		} else {

  376. 			audio_block_t *tmp = block_right_1st;

  377. 			block_right_1st = block_right_2nd;

  378. 			block_right_2nd = block;

  379. 			block_right_offset = 0;

  380. 			__enable_irq();

  381. 			release(tmp);

  382. 		}

  383. 	}

  384. }

  385. 

  386. FLASHMEM

  387. void AudioOutputPT8211_2::config_i2s(void)

  388. {

  389. 

  390. 	CCM_CCGR5 |= CCM_CCGR5_SAI2(CCM_CCGR_ON);

  391. //PLL:

  392. 	int fs = AUDIO_SAMPLE_RATE_EXACT;

  393. 	// PLL between 27*24 = 648MHz und 54*24=1296MHz

  394. 	int n1 = 4; //SAI prescaler 4 => (n1*n2) = multiple of 4

  395. 	int n2 = 1 + (24000000 * 27) / (fs * 256 * n1);

  396. 

  397. 	double C = ((double)fs * 256 * n1 * n2) / 24000000;

  398. 	int c0 = C;

  399. 	int c2 = 10000;

  400. 	int c1 = C * c2 - (c0 * c2);

  401. 	set_audioClock(c0, c1, c2);

  402. 

  403. 	CCM_CSCMR1 = (CCM_CSCMR1 & ~(CCM_CSCMR1_SAI2_CLK_SEL_MASK))

  404. 		   | CCM_CSCMR1_SAI2_CLK_SEL(2); // &0x03 // (0,1,2): PLL3PFD0, PLL5, PLL4,

  405. 	CCM_CS2CDR = (CCM_CS2CDR & ~(CCM_CS2CDR_SAI2_CLK_PRED_MASK | CCM_CS2CDR_SAI2_CLK_PODF_MASK))

  406. 		   | CCM_CS2CDR_SAI2_CLK_PRED(n1-1) 

  407. 		   | CCM_CS2CDR_SAI2_CLK_PODF(n2-1);

  408. 	IOMUXC_GPR_GPR1 = (IOMUXC_GPR_GPR1 & ~(IOMUXC_GPR_GPR1_SAI2_MCLK3_SEL_MASK))

  409. 			| (IOMUXC_GPR_GPR1_SAI2_MCLK_DIR | IOMUXC_GPR_GPR1_SAI2_MCLK3_SEL(0));	//Select MCLK

  410. 

  411. 	if (I2S2_TCSR & I2S_TCSR_TE) return;

  412. 

  413. 	//CORE_PIN5_CONFIG  = 2;  //2:MCLK

  414. 	CORE_PIN4_CONFIG  = 2;  //2:TX_BCLK

  415. 	CORE_PIN3_CONFIG  = 2;  //2:TX_SYNC

  416. 

  417. 	#if defined(AUDIO_PT8211_OVERSAMPLING)

  418. 	int div = 0;

  419. 	#else

  420. 	int div = 3;

  421. 	#endif

  422. 	// configure transmitter

  423. 	I2S2_TMR = 0;

  424. 	I2S2_TCR1 = I2S_TCR1_RFW(0);

  425. 	I2S2_TCR2 = I2S_TCR2_SYNC(0) | I2S_TCR2_BCP | I2S_TCR2_MSEL(1) | I2S_TCR2_BCD | I2S_TCR2_DIV(div);

  426. 	I2S2_TCR3 = I2S_TCR3_TCE;

  427. //	I2S2_TCR4 = I2S_TCR4_FRSZ(1) | I2S_TCR4_SYWD(15) | I2S_TCR4_MF | I2S_TCR4_FSE | I2S_TCR4_FSP | I2S_TCR4_FSD; //TDA1543

  428. 	I2S2_TCR4 = I2S_TCR4_FRSZ(1) | I2S_TCR4_SYWD(15) | I2S_TCR4_MF /*| I2S_TCR4_FSE*/ | I2S_TCR4_FSP | I2S_TCR4_FSD; //PT8211

  429. 	I2S2_TCR5 = I2S_TCR5_WNW(15) | I2S_TCR5_W0W(15) | I2S_TCR5_FBT(15);

  430. 

  431. }

  432. #endif