@ -32,88 +32,12 @@
* The F32 conversion is under the MIT License . Use at your own risk .
*/
// Updated OpenAudio F32 with this version from Chip Audette's Tympan Library Jan 2021 RSL
// Removed old commented out code. RSL 30 May 2022
# include "output_i2s_f32.h"
//#include "input_i2s_f32.h"
//include "memcpy_audio.h"
//#include "memcpy_interleave.h"
# include <arm_math.h>
# include <Audio.h> //to get access to Audio/utlity/imxrt_hw.h...do we really need this??? WEA 2020-10-31
/* Comment this out
//taken from Teensy Audio utility/imxrt_hw.h and imxrt_hw.cpp...
# if defined(__IMXRT1062__)
# ifndef imxr_hw_h_
# define imxr_hw_h_
# define IMXRT_CACHE_ENABLED 2 // 0=disabled, 1=WT, 2= WB
# include <Arduino.h>
# include <imxrt.h>
PROGMEM
void set_audioClock_tympan ( int nfact , int32_t nmult , uint32_t ndiv , bool force = false ) // sets PLL4
{
if ( ! force & & ( CCM_ANALOG_PLL_AUDIO & CCM_ANALOG_PLL_AUDIO_ENABLE ) ) return ;
CCM_ANALOG_PLL_AUDIO = CCM_ANALOG_PLL_AUDIO_BYPASS | CCM_ANALOG_PLL_AUDIO_ENABLE
| CCM_ANALOG_PLL_AUDIO_POST_DIV_SELECT ( 2 ) // 2: 1/4; 1: 1/2; 0: 1/1
| CCM_ANALOG_PLL_AUDIO_DIV_SELECT ( nfact ) ;
CCM_ANALOG_PLL_AUDIO_NUM = nmult & CCM_ANALOG_PLL_AUDIO_NUM_MASK ;
CCM_ANALOG_PLL_AUDIO_DENOM = ndiv & CCM_ANALOG_PLL_AUDIO_DENOM_MASK ;
CCM_ANALOG_PLL_AUDIO & = ~ CCM_ANALOG_PLL_AUDIO_POWERDOWN ; //Switch on PLL
while ( ! ( CCM_ANALOG_PLL_AUDIO & CCM_ANALOG_PLL_AUDIO_LOCK ) ) { } ; //Wait for pll-lock
const int div_post_pll = 1 ; // other values: 2,4
CCM_ANALOG_MISC2 & = ~ ( CCM_ANALOG_MISC2_DIV_MSB | CCM_ANALOG_MISC2_DIV_LSB ) ;
if ( div_post_pll > 1 ) CCM_ANALOG_MISC2 | = CCM_ANALOG_MISC2_DIV_LSB ;
if ( div_post_pll > 3 ) CCM_ANALOG_MISC2 | = CCM_ANALOG_MISC2_DIV_MSB ;
CCM_ANALOG_PLL_AUDIO & = ~ CCM_ANALOG_PLL_AUDIO_BYPASS ; //Disable Bypass
}
# endif
# else
//No IMXRT
# define IMXRT_CACHE_ENABLED 0
# endif
*/ //end of commented block
////////////
//
// Changing the sample rate based on changing the I2S bus freuqency (just for Teensy 3.x??)
//
//Here's the function to change the sample rate of the system (via changing the clocking of the I2S bus)
//https://forum.pjrc.com/threads/38753-Discussion-about-a-simple-way-to-change-the-sample-rate?p=121365&viewfull=1#post121365
//
//And, a post on how to compute the frac and div portions? I haven't checked the code presented in this post:
//https://forum.pjrc.com/threads/38753-Discussion-about-a-simple-way-to-change-the-sample-rate?p=188812&viewfull=1#post188812
//
//Finally, here is my own Matlab code for computing the mult and div values...(again, just for Teensy 3.x??)
/*
% choose the sample rates that you are hoping to hit
targ_fs_Hz = [ 2000 , 8000 , 11025 , 16000 , 22050 , 24000 , 32000 , 44100 , floor ( 44117.64706 ) , . . .
48000 , 88200 , floor ( 44117.64706 * 2 ) , ( 37000 / 256 * 662 ) , 96000 , 176400 , floor ( 44117.64706 * 4 ) , 192000 ] ;
F_PLL = 180e6 ; % choose the clock rate used for this calculation
PLL_div = 256 ;
all_n = [ ] ; all_d = [ ] ;
for Itarg = 1 : length ( targ_fs_Hz )
if ( 0 )
[ best_d , best_n ] = rat ( ( F_PLL / PLL_div ) / targ_fs_Hz ( Itarg ) ) ;
else
best_n = 1 ; best_d = 1 ; best_err = 1e10 ;
for n = 1 : 255
d = [ 1 : 4095 ] ;
act_fs_Hz = F_PLL / PLL_div * n . / d ;
[ err , I ] = min ( abs ( act_fs_Hz - targ_fs_Hz ( Itarg ) ) ) ;
if err < best_err
best_n = n ; best_d = d ( I ) ;
best_err = err ;
end
end
end
all_n ( Itarg ) = best_n ;
all_d ( Itarg ) = best_d ;
disp ( [ ' fs = ' num2str ( targ_fs_Hz ( Itarg ) ) ' , n = ' num2str ( best_n ) ' , d = ' num2str ( best_d ) ' , true = ' num2str ( F_PLL / PLL_div * best_n / best_d ) ] )
end
*/
float AudioOutputI2S_F32 : : setI2SFreq_T3 ( const float freq_Hz ) {
# if defined(KINETISK) //for Teensy 3.x only!
int freq = ( int ) ( freq_Hz + 0.5 ) ;
@ -329,288 +253,6 @@ void AudioOutputI2S_F32::isr(void)
# endif
}
/* void AudioOutputI2S_F32::begin(bool transferUsing32bit) {
dma . begin ( true ) ; // Allocate the DMA channel first
block_left_1st = NULL ;
block_right_1st = NULL ;
// TODO: should we set & clear the I2S_TCSR_SR bit here?
config_i2s ( transferUsing32bit ) ;
CORE_PIN22_CONFIG = PORT_PCR_MUX ( 6 ) ; // pin 22, PTC1, I2S0_TXD0
//setup DMA parameters
//if (transferUsing32bit) {
sub_begin_i32 ( ) ;
//} else {
// sub_begin_i16();
//}
dma . triggerAtHardwareEvent ( DMAMUX_SOURCE_I2S0_TX ) ;
update_responsibility = update_setup ( ) ;
dma . enable ( ) ;
I2S0_TCSR = I2S_TCSR_SR ;
I2S0_TCSR = I2S_TCSR_TE | I2S_TCSR_BCE | I2S_TCSR_FRDE ;
dma . attachInterrupt ( isr_32 ) ;
// change the I2S frequencies to make the requested sample rate
setI2SFreq ( AudioOutputI2S_F32 : : sample_rate_Hz ) ;
enabled = 1 ;
//AudioInputI2S_F32::begin_guts();
} */
/* void AudioOutputI2S_F32::sub_begin_i16(void) {
dma . TCD - > SADDR = i2s_tx_buffer ;
dma . TCD - > SOFF = 2 ;
dma . TCD - > ATTR = DMA_TCD_ATTR_SSIZE ( 1 ) | DMA_TCD_ATTR_DSIZE ( 1 ) ;
dma . TCD - > NBYTES_MLNO = 2 ;
//dma.TCD->SLAST = -sizeof(i2s_tx_buffer); //original
dma . TCD - > SLAST = - I2S_BUFFER_TO_USE_BYTES ;
dma . TCD - > DADDR = & I2S0_TDR0 ;
dma . TCD - > DOFF = 0 ;
//dma.TCD->CITER_ELINKNO = sizeof(i2s_tx_buffer) / 2; //original
dma . TCD - > CITER_ELINKNO = I2S_BUFFER_TO_USE_BYTES / 2 ;
dma . TCD - > DLASTSGA = 0 ;
//dma.TCD->BITER_ELINKNO = sizeof(i2s_tx_buffer) / 2; //original
dma . TCD - > BITER_ELINKNO = I2S_BUFFER_TO_USE_BYTES / 2 ;
dma . TCD - > CSR = DMA_TCD_CSR_INTHALF | DMA_TCD_CSR_INTMAJOR ;
}
void AudioOutputI2S_F32 : : sub_begin_i32 ( void ) {
dma . TCD - > SADDR = i2s_tx_buffer ; //here's where to get the data from
//let's assume that we'll transfer each sample (left or right) independently. So 4-byte (32bit) transfers.
dma . TCD - > SOFF = 4 ; //step forward pointer for source data by 4 bytes (ie, 32 bits) after each read
dma . TCD - > ATTR = DMA_TCD_ATTR_SSIZE ( DMA_TCD_ATTR_SIZE_32BIT ) | DMA_TCD_ATTR_DSIZE ( DMA_TCD_ATTR_SIZE_32BIT ) ; //each read is 32 bits
dma . TCD - > NBYTES_MLNO = 4 ; //how many bytes to send per minor loop. Do each sample (left or right) independently. So, 4 bytes? Should be 4 or 8?
//dma.TCD->SLAST = -sizeof(i2s_tx_buffer); //original
dma . TCD - > SLAST = - I2S_BUFFER_TO_USE_BYTES ; //jump back to beginning of source data when hit the end
dma . TCD - > DADDR = & I2S0_TDR0 ; //destination of DMA transfers
dma . TCD - > DOFF = 0 ; //do not increment the destination pointer
//dma.TCD->CITER_ELINKNO = sizeof(i2s_tx_buffer) / 2; //original
dma . TCD - > CITER_ELINKNO = I2S_BUFFER_TO_USE_BYTES / 4 ; //number of minor loops in a major loop. I2S_BUFFER_TO_USE_BYTES/NBYTES_MLNO? Should be 4 or 8?
dma . TCD - > DLASTSGA = 0 ;
//dma.TCD->BITER_ELINKNO = sizeof(i2s_tx_buffer) / 2; //original
dma . TCD - > BITER_ELINKNO = I2S_BUFFER_TO_USE_BYTES / 4 ; //number of minor loops in a major loop. I2S_BUFFER_TO_USE_BYTES/NBYTES_MLNO? should be 4 or 8?
dma . TCD - > CSR = DMA_TCD_CSR_INTHALF | DMA_TCD_CSR_INTMAJOR ;
}
*/
/* void AudioOutputI2S_F32::isr_16(void)
{
# if defined(KINETISK)
int16_t * dest ;
audio_block_t * blockL , * blockR ;
uint32_t saddr , offsetL , offsetR ;
saddr = ( uint32_t ) ( dma . TCD - > SADDR ) ;
dma . clearInterrupt ( ) ;
//if (saddr < (uint32_t)i2s_tx_buffer + sizeof(i2s_tx_buffer) / 2) { //original
if ( saddr < ( uint32_t ) i2s_tx_buffer + I2S_BUFFER_TO_USE_BYTES / 2 ) {
// DMA is transmitting the first half of the buffer
// so we must fill the second half
//dest = (int16_t *)&i2s_tx_buffer[AUDIO_BLOCK_SAMPLES/2]; //original
dest = ( int16_t * ) & i2s_tx_buffer [ audio_block_samples / 2 ] ;
if ( AudioOutputI2S_F32 : : update_responsibility ) AudioStream_F32 : : update_all ( ) ;
} else {
// DMA is transmitting the second half of the buffer
// so we must fill the first half
dest = ( int16_t * ) i2s_tx_buffer ;
}
blockL = AudioOutputI2S_F32 : : block_left_1st ;
blockR = AudioOutputI2S_F32 : : block_right_1st ;
offsetL = AudioOutputI2S_F32 : : block_left_offset ;
offsetR = AudioOutputI2S_F32 : : block_right_offset ;
int16_t * d = dest ;
if ( blockL & & blockR ) {
//memcpy_tointerleaveLR(dest, blockL->data + offsetL, blockR->data + offsetR);
//memcpy_tointerleaveLRwLen(dest, blockL->data + offsetL, blockR->data + offsetR, audio_block_samples/2);
int16_t * pL = blockL - > data + offsetL ;
int16_t * pR = blockR - > data + offsetR ;
for ( int i = 0 ; i < audio_block_samples / 2 ; i + + ) { * d + + = * pL + + ; * d + + = * pR + + ; } //interleave
offsetL + = audio_block_samples / 2 ;
offsetR + = audio_block_samples / 2 ;
} else if ( blockL ) {
//memcpy_tointerleaveLR(dest, blockL->data + offsetL, blockR->data + offsetR);
int16_t * pL = blockL - > data + offsetL ;
for ( int i = 0 ; i < audio_block_samples / 2 * 2 ; i + = 2 ) { * ( d + i ) = * pL + + ; } //interleave
offsetL + = audio_block_samples / 2 ;
} else if ( blockR ) {
int16_t * pR = blockR - > data + offsetR ;
for ( int i = 0 ; i < audio_block_samples / 2 * 2 ; i + = 2 ) { * ( d + i ) = * pR + + ; } //interleave
offsetR + = audio_block_samples / 2 ;
} else {
//memset(dest,0,AUDIO_BLOCK_SAMPLES * 2);
memset ( dest , 0 , audio_block_samples * 2 ) ;
return ;
}
//if (offsetL < AUDIO_BLOCK_SAMPLES) { //original
if ( offsetL < ( uint16_t ) audio_block_samples ) {
AudioOutputI2S_F32 : : block_left_offset = offsetL ;
} else {
AudioOutputI2S_F32 : : block_left_offset = 0 ;
AudioStream : : release ( blockL ) ;
AudioOutputI2S_F32 : : block_left_1st = AudioOutputI2S_F32 : : block_left_2nd ;
AudioOutputI2S_F32 : : block_left_2nd = NULL ;
}
//if (offsetR < AUDIO_BLOCK_SAMPLES) {
if ( offsetR < ( uint16_t ) audio_block_samples ) {
AudioOutputI2S_F32 : : block_right_offset = offsetR ;
} else {
AudioOutputI2S_F32 : : block_right_offset = 0 ;
AudioStream : : release ( blockR ) ;
AudioOutputI2S_F32 : : block_right_1st = AudioOutputI2S_F32 : : block_right_2nd ;
AudioOutputI2S_F32 : : block_right_2nd = NULL ;
}
# else
const int16_t * src , * end ;
int16_t * dest ;
audio_block_t * block ;
uint32_t saddr , offset ;
saddr = ( uint32_t ) ( dma . CFG - > SAR ) ;
dma . clearInterrupt ( ) ;
if ( saddr < ( uint32_t ) i2s_tx_buffer + sizeof ( i2s_tx_buffer ) / 2 ) {
// DMA is transmitting the first half of the buffer
// so we must fill the second half
dest = ( int16_t * ) & i2s_tx_buffer [ AUDIO_BLOCK_SAMPLES / 2 ] ;
end = ( int16_t * ) & i2s_tx_buffer [ AUDIO_BLOCK_SAMPLES ] ;
if ( AudioOutputI2S_F32 : : update_responsibility ) AudioStream_F32 : : update_all ( ) ;
} else {
// DMA is transmitting the second half of the buffer
// so we must fill the first half
dest = ( int16_t * ) i2s_tx_buffer ;
end = ( int16_t * ) & i2s_tx_buffer [ AUDIO_BLOCK_SAMPLES / 2 ] ;
}
block = AudioOutputI2S_F32 : : block_left_1st ;
if ( block ) {
offset = AudioOutputI2S_F32 : : block_left_offset ;
src = & block - > data [ offset ] ;
do {
* dest = * src + + ;
dest + = 2 ;
} while ( dest < end ) ;
offset + = AUDIO_BLOCK_SAMPLES / 2 ;
if ( offset < AUDIO_BLOCK_SAMPLES ) {
AudioOutputI2S_F32 : : block_left_offset = offset ;
} else {
AudioOutputI2S_F32 : : block_left_offset = 0 ;
AudioStream : : release ( block ) ;
AudioOutputI2S_F32 : : block_left_1st = AudioOutputI2S_F32 : : block_left_2nd ;
AudioOutputI2S_F32 : : block_left_2nd = NULL ;
}
} else {
do {
* dest = 0 ;
dest + = 2 ;
} while ( dest < end ) ;
}
dest - = AUDIO_BLOCK_SAMPLES - 1 ;
block = AudioOutputI2S_F32 : : block_right_1st ;
if ( block ) {
offset = AudioOutputI2S_F32 : : block_right_offset ;
src = & block - > data [ offset ] ;
do {
* dest = * src + + ;
dest + = 2 ;
} while ( dest < end ) ;
offset + = AUDIO_BLOCK_SAMPLES / 2 ;
if ( offset < AUDIO_BLOCK_SAMPLES ) {
AudioOutputI2S_F32 : : block_right_offset = offset ;
} else {
AudioOutputI2S_F32 : : block_right_offset = 0 ;
AudioStream : : release ( block ) ;
AudioOutputI2S_F32 : : block_right_1st = AudioOutputI2S_F32 : : block_right_2nd ;
AudioOutputI2S_F32 : : block_right_2nd = NULL ;
}
} else {
do {
* dest = 0 ;
dest + = 2 ;
} while ( dest < end ) ;
}
# endif
} */
/* void AudioOutputI2S_F32::isr_32(void) //should be called every half of an audio block
{
int32_t * dest ; //int32 is the data type being sent to the audio codec
audio_block_f32_t * blockL , * blockR ;
uint32_t saddr ;
uint32_t offsetL , offsetR ;
saddr = ( uint32_t ) ( dma . TCD - > SADDR ) ;
dma . clearInterrupt ( ) ;
//if (saddr < (uint32_t)i2s_tx_buffer + sizeof(i2s_tx_buffer) / 2) { //original 16-bit
if ( saddr < ( uint32_t ) i2s_tx_buffer + I2S_BUFFER_TO_USE_BYTES / 2 ) { //are we transmitting the first half or second half of the buffer?
// DMA is transmitting the first half of the buffer
// so we must fill the second half
//dest = (int16_t *)&i2s_tx_buffer[AUDIO_BLOCK_SAMPLES/2]; //original, half-way through buffer (buffer is 32-bit elements filled with 16-bit stereo samples)
dest = ( int32_t * ) & i2s_tx_buffer [ 2 * ( audio_block_samples / 2 ) ] ; //half-way through the buffer..remember, buffer is 32-bit elements filled with 32-bit stereo samples)
if ( AudioOutputI2S_F32 : : update_responsibility ) AudioStream_F32 : : update_all ( ) ;
} else {
// DMA is transmitting the second half of the buffer so we must fill the first half
dest = ( int32_t * ) i2s_tx_buffer ; //beginning of the buffer
}
blockL = AudioOutputI2S_F32 : : block_left_1st ;
blockR = AudioOutputI2S_F32 : : block_right_1st ;
offsetL = AudioOutputI2S_F32 : : block_left_offset ;
offsetR = AudioOutputI2S_F32 : : block_right_offset ;
int32_t * d = dest ;
if ( blockL & & blockR ) {
//memcpy_tointerleaveLR(dest, blockL->data + offsetL, blockR->data + offsetR);
//memcpy_tointerleaveLRwLen(dest, blockL->data + offsetL, blockR->data + offsetR, audio_block_samples/2);
float32_t * pL = blockL - > data + offsetL ;
float32_t * pR = blockR - > data + offsetR ;
for ( int i = 0 ; i < audio_block_samples / 2 ; i + + ) { //loop over half of the audio block (this routine gets called every half an audio block)
* d + + = ( int32_t ) ( * pL + + ) ;
* d + + = ( int32_t ) ( * pR + + ) ; //cast and interleave
}
offsetL + = ( audio_block_samples / 2 ) ;
offsetR + = ( audio_block_samples / 2 ) ;
} else if ( blockL ) {
//memcpy_tointerleaveLR(dest, blockL->data + offsetL, blockR->data + offsetR);
float32_t * pL = blockL - > data + offsetL ;
for ( int i = 0 ; i < audio_block_samples / 2 ; i + + ) {
* d + + = ( int32_t ) * pL + + ; //cast and interleave
* d + + = 0 ;
}
offsetL + = ( audio_block_samples / 2 ) ;
} else if ( blockR ) {
float32_t * pR = blockR - > data + offsetR ;
for ( int i = 0 ; i < audio_block_samples / 2 ; i + + ) {
* d + + = 0 ;
* d + + = ( int32_t ) * pR + + ; //cast and interleave
}
offsetR + = ( audio_block_samples / 2 ) ;
} else {
//memset(dest,0,AUDIO_BLOCK_SAMPLES * 2); //half buffer (AUDIO_BLOCK_SAMPLES/2), 16-bits per sample (AUDIO_BLOCK_SAMPLES/2*2), stereo (AUDIO_BLOCK_SAMPLES/2*2*2)
//memset(dest,0,audio_block_samples * 2 * 4 / 2);//half buffer (AUDIO_BLOCK_SAMPLES/2), 32-bits per sample (AUDIO_BLOCK_SAMPLES/2*4), stereo (AUDIO_BLOCK_SAMPLES/2*4*2)
for ( int i = 0 ; i < audio_block_samples / 2 ; i + + ) { //loop over half of the audio block (this routine gets called every half an audio block)
* d + + = ( int32_t ) 0 ;
* d + + = ( int32_t ) 0 ;
}
return ;
}
//if (offsetL < AUDIO_BLOCK_SAMPLES) { //original
if ( offsetL < ( uint16_t ) audio_block_samples ) {
AudioOutputI2S_F32 : : block_left_offset = offsetL ;
} else {
AudioOutputI2S_F32 : : block_left_offset = 0 ;
AudioStream_F32 : : release ( blockL ) ;
AudioOutputI2S_F32 : : block_left_1st = AudioOutputI2S_F32 : : block_left_2nd ;
AudioOutputI2S_F32 : : block_left_2nd = NULL ;
}
//if (offsetR < AUDIO_BLOCK_SAMPLES) {
if ( offsetR < ( uint16_t ) audio_block_samples ) {
AudioOutputI2S_F32 : : block_right_offset = offsetR ;
} else {
AudioOutputI2S_F32 : : block_right_offset = 0 ;
AudioStream_F32 : : release ( blockR ) ;
AudioOutputI2S_F32 : : block_right_1st = AudioOutputI2S_F32 : : block_right_2nd ;
AudioOutputI2S_F32 : : block_right_2nd = NULL ;
}
}
*/
# define F32_TO_I16_NORM_FACTOR (32767) //which is 2^15-1
void AudioOutputI2S_F32 : : scale_f32_to_i16 ( float32_t * p_f32 , float32_t * p_i16 , int len ) {
for ( int i = 0 ; i < len ; i + + ) { * p_i16 + + = max ( - F32_TO_I16_NORM_FACTOR , min ( F32_TO_I16_NORM_FACTOR , ( * p_f32 + + ) * F32_TO_I16_NORM_FACTOR ) ) ; }
@ -667,15 +309,6 @@ void AudioOutputI2S_F32::update(void)
scale_f32_to_i32 ( block_f32 - > data , block_f32_scaled - > data , audio_block_samples ) ;
//scale_f32_to_i16(block_f32->data, block_f32_scaled->data, audio_block_samples);
//count++;
//if (count > 100) {
// Serial.print("AudioOutputI2S_F32::update() orig, scaled = ");
// Serial.print(block_f32->data[30]);
// Serial.print(", ");
// Serial.println(block_f32_scaled->data[30]);
// count=0;
//}
//now process the data blocks
__disable_irq ( ) ;
if ( block_left_1st = = NULL ) {
@ -897,11 +530,11 @@ void AudioOutputI2S_F32::config_i2s(bool transferUsing32bit, float fs_Hz)
/******************************************************************/
// From Chip: The I2SSlave functionality has NOT been extended to allow for different block sizes or sample rates (2020-10-31)
// From Chip: The I2SSlave functionality has NOT been extended to
// allow for different block sizes or sample rates (2020-10-31)
void AudioOutputI2Sslave_F32 : : begin ( void )
{
dma . begin ( true ) ; // Allocate the DMA channel first
//pinMode(2, OUTPUT);
boblark
3 years ago