pio
10 months ago
parent
699abca893
commit
8801c8f122
@ -0,0 +1,22 @@ |
||||
#ifndef _BASIC_DSPUTILS_H_ |
||||
#define _BASIC_DSPUTILS_H_ |
||||
|
||||
#include <arm_math.h> |
||||
|
||||
static inline void mix_pwr(float32_t mix, float32_t *wetMix, float32_t *dryMix); |
||||
static inline void mix_pwr(float32_t mix, float32_t *wetMix, float32_t *dryMix) |
||||
{ |
||||
// Calculate mix parameters
|
||||
// A cheap mostly energy constant crossfade from SignalSmith Blog
|
||||
// https://signalsmith-audio.co.uk/writing/2021/cheap-energy-crossfade/
|
||||
float32_t x2 = 1.0f - mix; |
||||
float32_t A = mix*x2; |
||||
float32_t B = A * (1.0f + 1.4186f * A); |
||||
float32_t C = B + mix; |
||||
float32_t D = B + x2; |
||||
|
||||
*wetMix = C * C; |
||||
*dryMix = D * D; |
||||
} |
||||
|
||||
#endif // _BASIC_DSPUTILS_H_
|
||||
@ -0,0 +1,63 @@ |
||||
/*
|
||||
* AudioEffectGain_F32 |
||||
* |
||||
* Created: Chip Audette, November 2016 |
||||
* Purpose; Apply digital gain to the audio data. Assumes floating-point data. |
||||
* |
||||
* This processes a single stream fo audio data (ie, it is mono) |
||||
* |
||||
* MIT License. use at your own risk. |
||||
*/ |
||||
|
||||
#ifndef _AudioEffectGainStereo_F32_h |
||||
#define _AudioEffectGainStereo_F32_h |
||||
|
||||
#include <arm_math.h> //ARM DSP extensions. for speed! |
||||
#include <AudioStream_F32.h> |
||||
|
||||
class AudioEffectGainStereo_F32 : public AudioStream_F32 |
||||
{ |
||||
public: |
||||
// constructor
|
||||
AudioEffectGainStereo_F32(void) : AudioStream_F32(2, inputQueueArray_f32){}; |
||||
AudioEffectGainStereo_F32(const AudioSettings_F32 &settings) : AudioStream_F32(2, inputQueueArray_f32){}; |
||||
|
||||
void update(void) |
||||
{ |
||||
audio_block_f32_t *blockL, *blockR; |
||||
blockL = AudioStream_F32::receiveWritable_f32(0); |
||||
blockR = AudioStream_F32::receiveWritable_f32(1); |
||||
if (!blockL || !blockR) |
||||
{ |
||||
if (blockL) |
||||
AudioStream_F32::release(blockL); |
||||
if (blockR) |
||||
AudioStream_F32::release(blockR); |
||||
return; |
||||
} |
||||
arm_scale_f32(blockL->data, gain, blockL->data, blockL->length); // use ARM DSP for speed!
|
||||
arm_scale_f32(blockR->data, gain, blockR->data, blockR->length); |
||||
AudioStream_F32::transmit(blockL, 0); |
||||
AudioStream_F32::transmit(blockR, 1); |
||||
AudioStream_F32::release(blockL); |
||||
AudioStream_F32::release(blockR); |
||||
} |
||||
|
||||
// methods to set parameters of this module
|
||||
void setGain(float g) { gain = g; } |
||||
void setGain_dB(float gain_dB) |
||||
{ |
||||
float gain = pow(10.0, gain_dB / 20.0); |
||||
setGain(gain); |
||||
} |
||||
|
||||
// methods to return information about this module
|
||||
float getGain(void) { return gain; } |
||||
float getGain_dB(void) { return 20.0 * log10(gain); } |
||||
|
||||
private: |
||||
audio_block_f32_t *inputQueueArray_f32[2]; // memory pointer for the input to this module
|
||||
float gain = 1.0f; // default value
|
||||
}; |
||||
|
||||
#endif |
||||
@ -0,0 +1,174 @@ |
||||
/*
|
||||
* AudioEffectNoiseGate_F32 |
||||
* |
||||
* Created: Max Huster, Feb 2021 |
||||
* Purpose: This module mutes the Audio completly, when it's below a given threshold. |
||||
* |
||||
* This processes a single stream fo audio data (ie, it is mono) |
||||
* |
||||
* MIT License. use at your own risk. |
||||
*/ |
||||
|
||||
#ifndef _AudioEffectNoiseGateStereo_F32_h |
||||
#define _AudioEffectNoiseGateStereo_F32_h |
||||
|
||||
#include <arm_math.h> //ARM DSP extensions. for speed! |
||||
#include <AudioStream_F32.h> |
||||
|
||||
class AudioEffectNoiseGateStereo_F32 : public AudioStream_F32 |
||||
{ |
||||
public: |
||||
// constructor
|
||||
AudioEffectNoiseGateStereo_F32(void) : AudioStream_F32(4, inputQueueArray_f32){}; |
||||
AudioEffectNoiseGateStereo_F32(const AudioSettings_F32 &settings) : AudioStream_F32(4, inputQueueArray_f32){}; |
||||
|
||||
void update(void) |
||||
{ |
||||
audio_block_f32_t *blockL, *blockR, *blockSideChL, *blockSideChR, *blockSideCh, *blockGain; |
||||
blockL = AudioStream_F32::receiveWritable_f32(0); |
||||
blockR = AudioStream_F32::receiveWritable_f32(1); |
||||
blockSideChL = AudioStream_F32::receiveReadOnly_f32(2); // side chain inputL
|
||||
blockSideChR = AudioStream_F32::receiveReadOnly_f32(3); // side chain inputR
|
||||
blockSideCh = AudioStream_F32::allocate_f32(); // allocate new block for summed L+R
|
||||
blockGain = AudioStream_F32::allocate_f32(); // create a new audio block for the gain
|
||||
|
||||
|
||||
if (!blockL || !blockR || !blockSideChL || !blockSideChR || !blockSideCh || !blockGain)
|
||||
{ |
||||
if (blockSideChL) AudioStream_F32::release(blockSideChL); |
||||
if (blockSideChR) AudioStream_F32::release(blockSideChR); |
||||
if (blockSideCh) AudioStream_F32::release(blockSideCh); |
||||
if (blockGain) AudioStream_F32::release(blockGain);
|
||||
if (blockL) AudioStream_F32::release(blockL); |
||||
if (blockR) AudioStream_F32::release(blockR); |
||||
return;
|
||||
}
|
||||
// sum L + R
|
||||
arm_add_f32(blockSideChL->data, blockSideChR->data, blockSideCh->data, blockSideCh->length); |
||||
arm_scale_f32(blockSideCh->data, 0.5f, blockSideCh->data, blockSideCh->length); // divide by 2
|
||||
|
||||
// calculate the desired gain
|
||||
calcGain(blockSideCh, blockGain); |
||||
// smooth the "blocky" gain block
|
||||
calcSmoothedGain(blockGain); |
||||
|
||||
// multiply it to the input singal
|
||||
arm_mult_f32(blockGain->data, blockL->data, blockL->data, blockL->length); |
||||
arm_mult_f32(blockGain->data, blockR->data, blockR->data, blockR->length); |
||||
// release gainBlock
|
||||
AudioStream_F32::release(blockGain); |
||||
AudioStream_F32::release(blockSideCh); |
||||
AudioStream_F32::release(blockSideChL); |
||||
AudioStream_F32::release(blockSideChR); |
||||
|
||||
// transmit the block and be done
|
||||
AudioStream_F32::transmit(blockL, 0); |
||||
AudioStream_F32::transmit(blockR, 1); |
||||
AudioStream_F32::release(blockL); |
||||
AudioStream_F32::release(blockR); |
||||
} |
||||
|
||||
void setThreshold(float dbfs) |
||||
{ |
||||
// convert dbFS to linear value to comapre against later
|
||||
linearThreshold = pow10f(dbfs / 20.0f); |
||||
} |
||||
|
||||
void setOpeningTime(float timeInSeconds) |
||||
{ |
||||
openingTimeConst = expf(-1.0f / (timeInSeconds * AUDIO_SAMPLE_RATE)); |
||||
} |
||||
|
||||
void setClosingTime(float timeInSeconds) |
||||
{ |
||||
closingTimeConst = expf(-1.0f / (timeInSeconds * AUDIO_SAMPLE_RATE)); |
||||
} |
||||
|
||||
void setHoldTime(float timeInSeconds) |
||||
{ |
||||
holdTimeNumSamples = timeInSeconds * AUDIO_SAMPLE_RATE; |
||||
} |
||||
|
||||
bool infoIsOpen() |
||||
{ |
||||
return _isOpenDisplay; |
||||
} |
||||
|
||||
private: |
||||
float32_t linearThreshold; |
||||
float32_t prev_gain_dB = 0; |
||||
float32_t openingTimeConst, closingTimeConst; |
||||
float lastGainBlockValue = 0; |
||||
int32_t counter, holdTimeNumSamples = 0; |
||||
audio_block_f32_t *inputQueueArray_f32[4]; |
||||
bool falling = false; |
||||
|
||||
bool _isOpen = false; |
||||
bool _isOpenDisplay = false; |
||||
bool _extSideChain = true; |
||||
|
||||
void calcGain(audio_block_f32_t *input, audio_block_f32_t *gainBlock) |
||||
{ |
||||
_isOpen = false; |
||||
for (int i = 0; i < input->length; i++) |
||||
{ |
||||
// take absolute value and compare it to the set threshold
|
||||
bool isAboveThres = abs(input->data[i]) > linearThreshold; |
||||
_isOpen |= isAboveThres; |
||||
// if above the threshold set volume to 1 otherwise to 0, we did not account for holdtime
|
||||
gainBlock->data[i] = isAboveThres ? 1 : 0; |
||||
|
||||
// if we are falling and are above the threshold, the level is not falling
|
||||
if (falling & isAboveThres) |
||||
{ |
||||
falling = false; |
||||
} |
||||
// if we have a falling signal
|
||||
if (falling || lastGainBlockValue > gainBlock->data[i]) |
||||
{ |
||||
// check whether the hold time is not reached
|
||||
if (counter < holdTimeNumSamples) |
||||
{ |
||||
// signal is (still) falling
|
||||
falling = true; |
||||
counter++; |
||||
gainBlock->data[i] = 1.0f; |
||||
} |
||||
// otherwise the signal is already muted due to the line: "gainBlock->data[i] = isAboveThres ? 1 : 0;"
|
||||
} |
||||
// note the last gain value, so we can compare it if the signal is falling in the next sample
|
||||
lastGainBlockValue = gainBlock->data[i]; |
||||
} |
||||
// note the display value
|
||||
_isOpenDisplay = _isOpen; |
||||
}; |
||||
|
||||
// this method applies the "opening" and "closing" constants to smooth the
|
||||
// target gain level through time.
|
||||
void calcSmoothedGain(audio_block_f32_t *gain_block) |
||||
{ |
||||
float32_t gain; |
||||
float32_t one_minus_opening_const = 1.0f - openingTimeConst; |
||||
float32_t one_minus_closing_const = 1.0f - closingTimeConst; |
||||
for (int i = 0; i < gain_block->length; i++) |
||||
{ |
||||
gain = gain_block->data[i]; |
||||
|
||||
// smooth the gain using the opening or closing constants
|
||||
if (gain > prev_gain_dB) |
||||
{ // are we in the opening phase?
|
||||
gain_block->data[i] = openingTimeConst * prev_gain_dB + one_minus_opening_const * gain; |
||||
} |
||||
else |
||||
{ // or, we're in the closing phase
|
||||
gain_block->data[i] = closingTimeConst * prev_gain_dB + one_minus_closing_const * gain; |
||||
} |
||||
|
||||
// save value for the next time through this loop
|
||||
prev_gain_dB = gain_block->data[i]; |
||||
} |
||||
return; // the output here is gain_block
|
||||
} |
||||
}; |
||||
|
||||
#endif |
||||
@ -0,0 +1,311 @@ |
||||
#include "effect_reverbsc_F32.h" |
||||
|
||||
|
||||
#define REVERBSC_DLYBUF_SIZE 98936 |
||||
#define DELAYPOS_SHIFT 28 |
||||
#define DELAYPOS_SCALE 0x10000000 |
||||
#define DELAYPOS_MASK 0x0FFFFFFF |
||||
#ifndef M_PI |
||||
#define M_PI 3.14159265358979323846 /* pi */ |
||||
#endif |
||||
|
||||
/* kReverbParams[n][0] = delay time (in seconds) */ |
||||
/* kReverbParams[n][1] = random variation in delay time (in seconds) */ |
||||
/* kReverbParams[n][2] = random variation frequency (in 1/sec) */ |
||||
/* kReverbParams[n][3] = random seed (0 - 32767) */ |
||||
|
||||
static const float32_t kReverbParams[8][4] = |
||||
{ |
||||
{(2473.0f / AUDIO_SAMPLE_RATE_EXACT), 0.0010f, 3.100f, 1966.0f}, |
||||
{(2767.0f / AUDIO_SAMPLE_RATE_EXACT), 0.0011f, 3.500f, 29491.0f}, |
||||
{(3217.0f / AUDIO_SAMPLE_RATE_EXACT), 0.0017f, 1.110f, 22937.0f}, |
||||
{(3557.0f / AUDIO_SAMPLE_RATE_EXACT), 0.0006f, 3.973f, 9830.0f}, |
||||
{(3907.0f / AUDIO_SAMPLE_RATE_EXACT), 0.0010f, 2.341f, 20643.0f}, |
||||
{(4127.0f / AUDIO_SAMPLE_RATE_EXACT), 0.0011f, 1.897f, 22937.0f}, |
||||
{(2143.0f / AUDIO_SAMPLE_RATE_EXACT), 0.0017f, 0.891f, 29491.0f}, |
||||
{(1933.0f / AUDIO_SAMPLE_RATE_EXACT), 0.0006f, 3.221f, 14417.0f} |
||||
}; |
||||
static int DelayLineMaxSamples(float32_t sr, float32_t i_pitch_mod, int n); |
||||
static int DelayLineBytesAlloc(float32_t sr, float32_t i_pitch_mod, int n); |
||||
static const float32_t kOutputGain = 0.35f; |
||||
static const float32_t kJpScale = 0.25f; |
||||
|
||||
AudioEffectReverbSc_F32::AudioEffectReverbSc_F32(bool use_psram) : AudioStream_F32(2, inputQueueArray_f32) |
||||
{ |
||||
sample_rate_ = AUDIO_SAMPLE_RATE_EXACT; |
||||
feedback_ = 0.7f; |
||||
lpfreq_ = 10000; |
||||
i_pitch_mod_ = 1; |
||||
damp_fact_ = 0.195847f; // ~16kHz
|
||||
|
||||
int i, n_bytes = 0; |
||||
n_bytes = 0; |
||||
if (use_psram) aux_ = (float32_t *) extmem_malloc(REVERBSC_DLYBUF_SIZE*sizeof(float32_t)); |
||||
else
|
||||
{ |
||||
aux_ = (float32_t *) malloc(REVERBSC_DLYBUF_SIZE*sizeof(float32_t)); |
||||
flags.memsetup_done = 1;
|
||||
} |
||||
if (!aux_) return; |
||||
|
||||
for (i = 0; i < 8; i++) |
||||
{ |
||||
if (n_bytes > REVERBSC_DLYBUF_SIZE) |
||||
return; |
||||
delay_lines_[i].buf = (aux_) + n_bytes; |
||||
InitDelayLine(&delay_lines_[i], i); |
||||
n_bytes += DelayLineBytesAlloc(AUDIO_SAMPLE_RATE_EXACT, 1, i); |
||||
} |
||||
mix(0.5f); |
||||
flags.bypass = 0; |
||||
flags.freeze = 0; |
||||
initialised = true; |
||||
} |
||||
|
||||
static int DelayLineMaxSamples(float32_t sr, float32_t i_pitch_mod, int n) |
||||
{ |
||||
float32_t max_del; |
||||
|
||||
max_del = kReverbParams[n][0]; |
||||
max_del += (kReverbParams[n][1] * (float32_t)i_pitch_mod * 1.125); |
||||
return (int)(max_del * sr + 16.5); |
||||
} |
||||
|
||||
static int DelayLineBytesAlloc(float32_t sr, float32_t i_pitch_mod, int n) |
||||
{ |
||||
int n_bytes = 0; |
||||
|
||||
n_bytes += (DelayLineMaxSamples(sr, i_pitch_mod, n) * (int)sizeof(float32_t)); |
||||
return n_bytes; |
||||
} |
||||
|
||||
void AudioEffectReverbSc_F32::NextRandomLineseg(ReverbScDl_t *lp, int n) |
||||
{ |
||||
float32_t prv_del, nxt_del, phs_inc_val; |
||||
|
||||
/* update random seed */ |
||||
if (lp->seed_val < 0) |
||||
lp->seed_val += 0x10000; |
||||
lp->seed_val = (lp->seed_val * 15625 + 1) & 0xFFFF; |
||||
if (lp->seed_val >= 0x8000) |
||||
lp->seed_val -= 0x10000; |
||||
/* length of next segment in samples */ |
||||
lp->rand_line_cnt = (int)((sample_rate_ / kReverbParams[n][2]) + 0.5f); |
||||
prv_del = (float32_t)lp->write_pos; |
||||
prv_del -= ((float32_t)lp->read_pos + ((float32_t)lp->read_pos_frac / (float32_t)DELAYPOS_SCALE)); |
||||
while (prv_del < 0.0) |
||||
prv_del += lp->buffer_size; |
||||
prv_del = prv_del / sample_rate_; /* previous delay time in seconds */ |
||||
nxt_del = (float32_t)lp->seed_val * kReverbParams[n][1] / 32768.0f; |
||||
/* next delay time in seconds */ |
||||
nxt_del = kReverbParams[n][0] + (nxt_del * (float32_t)i_pitch_mod_); |
||||
/* calculate phase increment per sample */ |
||||
phs_inc_val = (prv_del - nxt_del) / (float32_t)lp->rand_line_cnt; |
||||
phs_inc_val = phs_inc_val * sample_rate_ + 1.0; |
||||
lp->read_pos_frac_inc = (int)(phs_inc_val * DELAYPOS_SCALE + 0.5f); |
||||
} |
||||
|
||||
void AudioEffectReverbSc_F32::InitDelayLine(ReverbScDl_t *lp, int n) |
||||
{ |
||||
float32_t read_pos; |
||||
|
||||
/* calculate length of delay line */ |
||||
lp->buffer_size = DelayLineMaxSamples(sample_rate_, 1, n); |
||||
lp->dummy = 0; |
||||
lp->write_pos = 0; |
||||
/* set random seed */ |
||||
lp->seed_val = (int)(kReverbParams[n][3] + 0.5f); |
||||
/* set initial delay time */ |
||||
read_pos = (float32_t)lp->seed_val * kReverbParams[n][1] / 32768.0f; |
||||
read_pos = kReverbParams[n][0] + (read_pos * (float32_t)i_pitch_mod_); |
||||
read_pos = (float32_t)lp->buffer_size - (read_pos * sample_rate_); |
||||
lp->read_pos = (int)read_pos; |
||||
read_pos = (read_pos - (float32_t)lp->read_pos) * (float32_t)DELAYPOS_SCALE; |
||||
lp->read_pos_frac = (int)(read_pos + 0.5); |
||||
/* initialise first random line segment */ |
||||
NextRandomLineseg(lp, n); |
||||
/* clear delay line to zero */ |
||||
lp->filter_state = 0.0f; |
||||
for (int i = 0; i < lp->buffer_size; i++) |
||||
{ |
||||
lp->buf[i] = 0; |
||||
} |
||||
} |
||||
|
||||
void AudioEffectReverbSc_F32::update() |
||||
{ |
||||
#if defined(__IMXRT1062__) |
||||
if (!initialised) return; |
||||
if ( !flags.memsetup_done) |
||||
{ |
||||
memset(aux_, 0, REVERBSC_DLYBUF_SIZE*sizeof(float32_t)); |
||||
arm_dcache_flush_delete(aux_, REVERBSC_DLYBUF_SIZE*sizeof(float32_t)); |
||||
flags.memsetup_done = 1; |
||||
return; |
||||
} |
||||
audio_block_f32_t *blockL, *blockR; |
||||
int16_t i; |
||||
float32_t a_in_l, a_in_r, a_out_l, a_out_r, dryL, dryR; |
||||
float32_t vm1, v0, v1, v2, am1, a0, a1, a2, frac; |
||||
ReverbScDl_t *lp; |
||||
int read_pos; |
||||
uint32_t n; |
||||
int buffer_size; /* Local copy */ |
||||
float32_t damp_fact = damp_fact_; |
||||
|
||||
if (flags.bypass) |
||||
{ |
||||
if (dry_gain > 0.0f) // if dry/wet mixer is used
|
||||
{ |
||||
blockL = AudioStream_F32::receiveReadOnly_f32(0); |
||||
blockR = AudioStream_F32::receiveReadOnly_f32(1); |
||||
if (!blockL || !blockR)
|
||||
{ |
||||
if (blockL) AudioStream_F32::release(blockL); |
||||
if (blockR) AudioStream_F32::release(blockR); |
||||
return; |
||||
} |
||||
AudioStream_F32::transmit(blockL, 0);
|
||||
AudioStream_F32::transmit(blockR, 1); |
||||
AudioStream_F32::release(blockL); |
||||
AudioStream_F32::release(blockR); |
||||
} |
||||
blockL = AudioStream_F32::allocate_f32(); |
||||
if (!blockL) return; |
||||
arm_fill_f32(0.0f, blockL->data, blockL->length); |
||||
AudioStream_F32::transmit(blockL, 0);
|
||||
AudioStream_F32::transmit(blockL, 1); |
||||
AudioStream_F32::release(blockL);
|
||||
return; |
||||
} |
||||
blockL = AudioStream_F32::receiveWritable_f32(0); |
||||
blockR = AudioStream_F32::receiveWritable_f32(1); |
||||
if (!blockL || !blockR) |
||||
{ |
||||
if (blockL) |
||||
AudioStream_F32::release(blockL); |
||||
if (blockR) |
||||
AudioStream_F32::release(blockR); |
||||
return; |
||||
} |
||||
for (i = 0; i < blockL->length; i++) |
||||
{ |
||||
/* calculate "resultant junction pressure" and mix to input signals */ |
||||
a_in_l = a_out_l = a_out_r = 0.0f; |
||||
dryL = blockL->data[i] * input_gain; |
||||
dryR = blockR->data[i] * input_gain; |
||||
|
||||
for (n = 0; n < 8; n++) |
||||
{ |
||||
a_in_l += delay_lines_[n].filter_state; |
||||
} |
||||
a_in_l *= kJpScale; |
||||
a_in_r = a_in_l + dryR; |
||||
a_in_l = a_in_l + dryL; |
||||
|
||||
/* loop through all delay lines */ |
||||
for (n = 0; n < 8; n++) |
||||
{ |
||||
lp = &delay_lines_[n]; |
||||
buffer_size = lp->buffer_size; |
||||
|
||||
/* send input signal and feedback to delay line */ |
||||
lp->buf[lp->write_pos] = (float32_t)((n & 1 ? a_in_r : a_in_l) - lp->filter_state); |
||||
if (++lp->write_pos >= buffer_size) lp->write_pos -= buffer_size; |
||||
|
||||
/* read from delay line with cubic interpolation */ |
||||
if (lp->read_pos_frac >= DELAYPOS_SCALE) |
||||
{ |
||||
lp->read_pos += (lp->read_pos_frac >> DELAYPOS_SHIFT); |
||||
lp->read_pos_frac &= DELAYPOS_MASK; |
||||
} |
||||
if (lp->read_pos >= buffer_size) |
||||
lp->read_pos -= buffer_size; |
||||
read_pos = lp->read_pos; |
||||
frac = (float32_t)lp->read_pos_frac * (1.0f / (float32_t)DELAYPOS_SCALE); |
||||
|
||||
/* calculate interpolation coefficients */ |
||||
a2 = frac * frac; |
||||
a2 *= (1.0f / 6.0f); |
||||
a1 = frac; |
||||
a1 += 1.0f; |
||||
a1 *= 0.5f; |
||||
am1 = a1 - 1.0f; |
||||
a0 = 3.0f * a2; |
||||
a1 -= a0; |
||||
am1 -= a2; |
||||
a0 -= frac; |
||||
|
||||
/* read four samples for interpolation */ |
||||
if (read_pos > 0 && read_pos < (buffer_size - 2)) |
||||
{ |
||||
vm1 = (float32_t)(lp->buf[read_pos - 1]); |
||||
v0 = (float32_t)(lp->buf[read_pos]); |
||||
v1 = (float32_t)(lp->buf[read_pos + 1]); |
||||
v2 = (float32_t)(lp->buf[read_pos + 2]); |
||||
} |
||||
else |
||||
{ |
||||
/* at buffer wrap-around, need to check index */ |
||||
if (--read_pos < 0) read_pos += buffer_size; |
||||
vm1 = (float32_t)lp->buf[read_pos]; |
||||
if (++read_pos >= buffer_size) read_pos -= buffer_size; |
||||
v0 = (float32_t)lp->buf[read_pos]; |
||||
if (++read_pos >= buffer_size) read_pos -= buffer_size; |
||||
v1 = (float32_t)lp->buf[read_pos]; |
||||
if (++read_pos >= buffer_size) read_pos -= buffer_size; |
||||
v2 = (float32_t)lp->buf[read_pos]; |
||||
} |
||||
v0 = (am1 * vm1 + a0 * v0 + a1 * v1 + a2 * v2) * frac + v0; |
||||
|
||||
/* update buffer read position */ |
||||
lp->read_pos_frac += lp->read_pos_frac_inc; |
||||
|
||||
// apply filter
|
||||
v0 = (lp->filter_state - v0) * damp_fact + v0; |
||||
|
||||
/* mix to output */ |
||||
if (n & 1) a_out_r += v0; |
||||
else a_out_l += v0; |
||||
|
||||
v0 *= (float32_t)feedback_; // apply feedback
|
||||
lp->filter_state = v0; // save filter - this will make the reverb volume constant
|
||||
|
||||
/* start next random line segment if current one has reached endpoint */ |
||||
if (--(lp->rand_line_cnt) <= 0) |
||||
{ |
||||
NextRandomLineseg(lp, n); |
||||
} |
||||
} |
||||
blockL->data[i] = a_out_l * wet_gain + blockL->data[i] * dry_gain; |
||||
blockR->data[i] = a_out_r * wet_gain + blockR->data[i] * dry_gain; |
||||
} // end block processing
|
||||
AudioStream_F32::transmit(blockL, 0); |
||||
AudioStream_F32::transmit(blockR, 1); |
||||
AudioStream_F32::release(blockL); |
||||
AudioStream_F32::release(blockR);
|
||||
#endif |
||||
} |
||||
|
||||
void AudioEffectReverbSc_F32::freeze(bool state) |
||||
{ |
||||
flags.freeze = state; |
||||
if (state) |
||||
{ |
||||
feedback_tmp = feedback_; // store the settings
|
||||
damp_fact_tmp = damp_fact_; |
||||
input_gain_tmp = input_gain; |
||||
__disable_irq(); |
||||
feedback_ = 1.0f; // infinite reverb
|
||||
input_gain = freeze_ingain; |
||||
__enable_irq(); |
||||
} |
||||
else |
||||
{ |
||||
__disable_irq(); |
||||
feedback_ = feedback_tmp; |
||||
damp_fact_ = damp_fact_tmp; |
||||
input_gain = input_gain_tmp; |
||||
__enable_irq(); |
||||
} |
||||
} |
||||
@ -0,0 +1,149 @@ |
||||
/*
|
||||
* ReverbSC |
||||
* 8 delay line stereo FDN reverb, with feedback matrix based upon physical modeling
|
||||
* scattering junction of 8 lossless waveguides of equal characteristic impedance.
|
||||
* Based on Csound orchestra version by Sean Costello. |
||||
*
|
||||
* Original Author(s): Sean Costello, Istvan Varga |
||||
* Year: 1999, 2005 |
||||
* Ported to soundpipe by: Paul Batchelor |
||||
*
|
||||
* Ported to Teensy4 and OpenAudio_ArduinoLibrary:
|
||||
* 01.2024 Piotr Zapart www.hexefx.com
|
||||
*
|
||||
* Fixes, changes: |
||||
* - In the original code the reverb level is affected by the feedback control, fixed |
||||
* - Optional
|
||||
*
|
||||
*/ |
||||
|
||||
#ifndef _EFFECT_REVERBSC_F32_H_ |
||||
#define _EFFECT_REVERBSC_F32_H_ |
||||
|
||||
#include <Arduino.h> |
||||
#include "Audio.h" |
||||
#include "AudioStream.h" |
||||
#include "AudioStream_F32.h" |
||||
#include "arm_math.h" |
||||
#include "basic_DSPutils.h" |
||||
|
||||
class AudioEffectReverbSc_F32 : public AudioStream_F32 |
||||
{ |
||||
public: |
||||
AudioEffectReverbSc_F32(bool use_psram = false); |
||||
~AudioEffectReverbSc_F32(){}; |
||||
virtual void update(); |
||||
|
||||
typedef struct |
||||
{ |
||||
int write_pos; /**< write position */ |
||||
int buffer_size; /**< buffer size */ |
||||
int read_pos; /**< read position */ |
||||
int read_pos_frac; /**< fractional component of read pos */ |
||||
int read_pos_frac_inc; /**< increment for fractional */ |
||||
int dummy; /**< dummy var */ |
||||
int seed_val; /**< randseed */ |
||||
int rand_line_cnt; /**< number of random lines */ |
||||
float32_t filter_state; /**< state of filter */ |
||||
float32_t *buf; /**< buffer ptr */ |
||||
} ReverbScDl_t; |
||||
|
||||
inline void feedback(const float32_t &fb)
|
||||
{ |
||||
if (flags.freeze) return; |
||||
float32_t inGain; |
||||
float32_t feedb = 2.0f * fb - fb*fb; |
||||
feedb = map(feedb, 0.0f, 1.0f, 0.1f, feedb_max); |
||||
feedback_tmp = feedb; |
||||
inGain = map(feedb, 0.1f, feedb_max, 0.5f, 0.2f); |
||||
__disable_irq(); |
||||
input_gain = inGain; |
||||
feedback_ = feedb; |
||||
__enable_irq(); |
||||
} |
||||
inline void lowpass(float32_t val) |
||||
{ |
||||
if (flags.freeze) return; |
||||
val = constrain(val, 0.0f, 0.96f); |
||||
val = val*val*val; |
||||
if (damp_fact_ != val) |
||||
{ |
||||
damp_fact_tmp = val; |
||||
__disable_irq(); |
||||
damp_fact_ = val; |
||||
__enable_irq();
|
||||
}
|
||||
} |
||||
|
||||
void mix(float32_t mix) |
||||
{ |
||||
mix = constrain(mix, 0.0f, 1.0f); |
||||
float dry, wet; |
||||
mix_pwr(mix, &wet, &dry); |
||||
|
||||
__disable_irq(); |
||||
wet_gain = wet; |
||||
dry_gain = dry; |
||||
__enable_irq(); |
||||
} |
||||
|
||||
void wet_level(float32_t wet) |
||||
{ |
||||
wet_gain = constrain(wet, 0.0f, 1.0f); |
||||
} |
||||
|
||||
void dry_level(float32_t dry) |
||||
{ |
||||
dry_gain = constrain(dry, 0.0f, 1.0f); |
||||
}
|
||||
void freeze(bool state); |
||||
bool freeze_tgl() {flags.freeze ^= 1; freeze(flags.freeze); return flags.freeze;} |
||||
bool freeze_get() {return flags.freeze;} |
||||
|
||||
bool bypass_get(void) {return flags.bypass;} |
||||
void bypass_set(bool state)
|
||||
{ |
||||
flags.bypass = state; |
||||
if (state) freeze(false); // disable freeze in bypass mode
|
||||
} |
||||
bool bypass_tgl(void)
|
||||
{ |
||||
flags.bypass ^= 1;
|
||||
if (flags.bypass) freeze(false); // disable freeze in bypass mode
|
||||
return flags.bypass; |
||||
} |
||||
|
||||
uint32_t getBfAddr() |
||||
{ |
||||
float32_t *addr = aux_; |
||||
return (uint32_t)addr; |
||||
} |
||||
|
||||
private: |
||||
struct flags_t |
||||
{ |
||||
unsigned bypass: 1; |
||||
unsigned freeze: 1; |
||||
unsigned memsetup_done: 1; |
||||
}flags = {0, 0, 0}; |
||||
|
||||
audio_block_f32_t *inputQueueArray_f32[2]; |
||||
void NextRandomLineseg(ReverbScDl_t *lp, int n); |
||||
void InitDelayLine(ReverbScDl_t *lp, int n); |
||||
float32_t feedback_, feedback_tmp; |
||||
float32_t lpfreq_; |
||||
float32_t i_pitch_mod_; |
||||
float32_t sample_rate_; |
||||
float32_t damp_fact_, damp_fact_tmp; |
||||
bool initialised = false; |
||||
ReverbScDl_t delay_lines_[8]; |
||||
float32_t *aux_; // main delay line storage buffer, placed either in RAM2 or PSRAM
|
||||
float32_t dry_gain = 0.5f; |
||||
float32_t wet_gain = 0.5f; |
||||
|
||||
float32_t input_gain = 0.5f; |
||||
float32_t input_gain_tmp = 0.5f; |
||||
float32_t freeze_ingain = 0.05f; |
||||
static constexpr float32_t feedb_max = 0.99f; |
||||
}; |
||||
#endif // _EFFECT_REVERBSC_H_
|
||||
@ -0,0 +1,408 @@ |
||||
/* Stereo spring reverb for Teensy 4
|
||||
* |
||||
* Author: Piotr Zapart |
||||
* www.hexefx.com |
||||
* |
||||
* Copyright (c) 2024 by Piotr Zapart |
||||
* |
||||
* Development of this audio library was funded by PJRC.COM, LLC by sales of |
||||
* Teensy and Audio Adaptor boards. Please support PJRC's efforts to develop |
||||
* open source software by purchasing Teensy or other PJRC products. |
||||
* |
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
* of this software and associated documentation files (the "Software"), to deal |
||||
* in the Software without restriction, including without limitation the rights |
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
* copies of the Software, and to permit persons to whom the Software is |
||||
* furnished to do so, subject to the following conditions: |
||||
* |
||||
* The above copyright notice, development funding notice, and this permission |
||||
* notice shall be included in all copies or substantial portions of the Software. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
* THE SOFTWARE. |
||||
*/ |
||||
|
||||
#include <Arduino.h> |
||||
#include "effect_springreverb_F32.h" |
||||
|
||||
#define INP_ALLP_COEFF (0.6f) |
||||
#define CHIRP_ALLP_COEFF (-0.6f) |
||||
|
||||
#define TREBLE_LOSS_FREQ (0.55f) |
||||
#define BASS_LOSS_FREQ (0.36f) |
||||
|
||||
AudioEffectSpringReverb_F32::AudioEffectSpringReverb_F32() : AudioStream_F32(2, inputQueueArray) |
||||
{ |
||||
input_attn = 0.5f; |
||||
rv_time_k = 0.8f; |
||||
in_allp_k = INP_ALLP_COEFF; |
||||
bool memOK = true; |
||||
if(!sp_lp_allp1a.init(&in_allp_k)) memOK = false; |
||||
if(!sp_lp_allp1b.init(&in_allp_k)) memOK = false; |
||||
if(!sp_lp_allp1c.init(&in_allp_k)) memOK = false; |
||||
if(!sp_lp_allp1d.init(&in_allp_k)) memOK = false; |
||||
|
||||
if(!sp_lp_allp2a.init(&in_allp_k)) memOK = false; |
||||
if(!sp_lp_allp2b.init(&in_allp_k)) memOK = false; |
||||
if(!sp_lp_allp2c.init(&in_allp_k)) memOK = false; |
||||
if(!sp_lp_allp2d.init(&in_allp_k)) memOK = false;
|
||||
if(!lp_dly1.init()) memOK = false; |
||||
if(!lp_dly2.init()) memOK = false; |
||||
// chirp allpass chain
|
||||
sp_chrp_alp1_buf = (float *)malloc(SPRVB_CHIRP_AMNT*SPRVB_CHIRP1_LEN*sizeof(float)); |
||||
sp_chrp_alp2_buf = (float *)malloc(SPRVB_CHIRP_AMNT*SPRVB_CHIRP2_LEN*sizeof(float)); |
||||
sp_chrp_alp3_buf = (float *)malloc(SPRVB_CHIRP_AMNT*SPRVB_CHIRP3_LEN*sizeof(float)); |
||||
sp_chrp_alp4_buf = (float *)malloc(SPRVB_CHIRP_AMNT*SPRVB_CHIRP4_LEN*sizeof(float)); |
||||
if (!sp_chrp_alp1_buf) memOK = false; |
||||
if (!sp_chrp_alp2_buf) memOK = false; |
||||
if (!sp_chrp_alp3_buf) memOK = false; |
||||
if (!sp_chrp_alp4_buf) memOK = false; |
||||
|
||||
memset(sp_chrp_alp1_buf, 0, SPRVB_CHIRP_AMNT*SPRVB_CHIRP1_LEN*sizeof(float)); |
||||
memset(sp_chrp_alp2_buf, 0, SPRVB_CHIRP_AMNT*SPRVB_CHIRP2_LEN*sizeof(float)); |
||||
memset(sp_chrp_alp3_buf, 0, SPRVB_CHIRP_AMNT*SPRVB_CHIRP3_LEN*sizeof(float)); |
||||
memset(sp_chrp_alp4_buf, 0, SPRVB_CHIRP_AMNT*SPRVB_CHIRP4_LEN*sizeof(float)); |
||||
|
||||
in_BassCut_k = 0.0f; |
||||
in_TrebleCut_k = 0.95f; |
||||
lp_BassCut_k = 0.0f; |
||||
lp_TrebleCut_k = 1.0f; |
||||
flt_in.init(BASS_LOSS_FREQ, &in_BassCut_k, TREBLE_LOSS_FREQ, &in_TrebleCut_k); |
||||
flt_lp1.init(BASS_LOSS_FREQ, &lp_BassCut_k, TREBLE_LOSS_FREQ, &lp_TrebleCut_k); |
||||
flt_lp2.init(BASS_LOSS_FREQ, &lp_BassCut_k, TREBLE_LOSS_FREQ, &lp_TrebleCut_k); |
||||
mix(0.5f); |
||||
cleanup_done = true; |
||||
if (memOK) initialized = true; |
||||
} |
||||
|
||||
void AudioEffectSpringReverb_F32::update() |
||||
{
|
||||
#if defined(__IMXRT1062__) |
||||
audio_block_f32_t *blockL, *blockR; |
||||
int i, j; |
||||
float32_t inL, inR, dryL, dryR; |
||||
float32_t acc; |
||||
float32_t lp_out1, lp_out2, mono_in, dry_in; |
||||
float32_t rv_time; |
||||
uint32_t allp_idx; |
||||
uint32_t offset; |
||||
float lfo_fr;
|
||||
if (!initialized) return; |
||||
if (bp) |
||||
{ |
||||
if (!cleanup_done) |
||||
{ |
||||
sp_lp_allp1a.reset(); |
||||
sp_lp_allp1b.reset(); |
||||
sp_lp_allp1c.reset(); |
||||
sp_lp_allp1d.reset(); |
||||
sp_lp_allp2a.reset(); |
||||
sp_lp_allp2b.reset(); |
||||
sp_lp_allp2c.reset(); |
||||
sp_lp_allp2d.reset(); |
||||
lp_dly1.reset(); |
||||
lp_dly2.reset(); |
||||
memset(sp_chrp_alp1_buf, 0, SPRVB_CHIRP_AMNT*SPRVB_CHIRP1_LEN*sizeof(float)); |
||||
memset(sp_chrp_alp2_buf, 0, SPRVB_CHIRP_AMNT*SPRVB_CHIRP2_LEN*sizeof(float)); |
||||
memset(sp_chrp_alp3_buf, 0, SPRVB_CHIRP_AMNT*SPRVB_CHIRP3_LEN*sizeof(float)); |
||||
memset(sp_chrp_alp4_buf, 0, SPRVB_CHIRP_AMNT*SPRVB_CHIRP4_LEN*sizeof(float));
|
||||
cleanup_done = true; |
||||
} |
||||
|
||||
if (dry_gain > 0.0f) // if dry/wet mixer is used
|
||||
{ |
||||
blockL = AudioStream_F32::receiveReadOnly_f32(0); |
||||
blockR = AudioStream_F32::receiveReadOnly_f32(1); |
||||
if (!blockL || !blockR)
|
||||
{ |
||||
if (blockL) AudioStream_F32::release(blockL); |
||||
if (blockR) AudioStream_F32::release(blockR); |
||||
return; |
||||
} |
||||
AudioStream_F32::transmit(blockL, 0);
|
||||
AudioStream_F32::transmit(blockR, 1); |
||||
AudioStream_F32::release(blockL); |
||||
AudioStream_F32::release(blockR); |
||||
} |
||||
blockL = AudioStream_F32::allocate_f32(); |
||||
if (!blockL) return; |
||||
arm_fill_f32(0.0f, blockL->data, blockL->length); |
||||
AudioStream_F32::transmit(blockL, 0);
|
||||
AudioStream_F32::transmit(blockL, 1); |
||||
AudioStream_F32::release(blockL);
|
||||
return; |
||||
} |
||||
cleanup_done = false; |
||||
blockL = AudioStream_F32::receiveWritable_f32(0); |
||||
blockR = AudioStream_F32::receiveWritable_f32(1); |
||||
if (!blockL || !blockR) |
||||
{ |
||||
if (blockL) |
||||
AudioStream_F32::release(blockL); |
||||
if (blockR) |
||||
AudioStream_F32::release(blockR); |
||||
return; |
||||
} |
||||
rv_time = rv_time_k; |
||||
for (i=0; i < blockL->length; i++)
|
||||
{
|
||||
lfo.update(); |
||||
dryL = blockL->data[i]; |
||||
dryR = blockR->data[i]; |
||||
dry_in = (dryL + dryR) * input_attn; |
||||
|
||||
mono_in = flt_in.process(dry_in)* (1.0f + in_BassCut_k*-1.5f); // add highpass gain compaensation?
|
||||
acc = lp_dly1.getTap(0) * rv_time; // get DLY1 output
|
||||
lp_out1 = flt_lp1.process(acc); // filter it
|
||||
|
||||
acc = sp_lp_allp1a.process(lp_out1);
|
||||
acc = sp_lp_allp1b.process(acc); |
||||
acc = sp_lp_allp1c.process(acc); |
||||
acc = sp_lp_allp1d.process(acc); |
||||
acc = lp_dly2.process(acc + mono_in) * rv_time; |
||||
lp_out2 = flt_lp2.process(acc); |
||||
|
||||
acc = sp_lp_allp2a.process(lp_out2);
|
||||
acc = sp_lp_allp2b.process(acc); |
||||
acc = sp_lp_allp2c.process(acc); |
||||
acc = sp_lp_allp2d.process(acc); |
||||
|
||||
lp_dly1.write_toOffset(acc + mono_in, 0); |
||||
lp_dly1.updateIndex(); |
||||
|
||||
inL = inR = (lp_out1 + lp_out2); |
||||
|
||||
j = 0; |
||||
while(j < SPRVB_CHIRP_AMNT) |
||||
{ |
||||
// 1st 4 are left channel
|
||||
allp_idx = j*SPRVB_CHIRP1_LEN + chrp_alp1_idx[j]; |
||||
acc = sp_chrp_alp1_buf[allp_idx] + inL * chrp_allp_k[0]; |
||||
sp_chrp_alp1_buf[allp_idx] = inL - chrp_allp_k[0] * acc; |
||||
inL = acc; |
||||
if (++chrp_alp1_idx[j] >= SPRVB_CHIRP1_LEN) chrp_alp1_idx[j] = 0;
|
||||
|
||||
allp_idx = (j+1)*SPRVB_CHIRP1_LEN + chrp_alp1_idx[j+1]; |
||||
acc = sp_chrp_alp1_buf[allp_idx] + inL * chrp_allp_k[1];
|
||||
sp_chrp_alp1_buf[allp_idx] = inL - chrp_allp_k[1] * acc;
|
||||
inL = acc; |
||||
if (++chrp_alp1_idx[j+1] >= SPRVB_CHIRP1_LEN) chrp_alp1_idx[j+1] = 0;
|
||||
|
||||
allp_idx = (j+2)*SPRVB_CHIRP1_LEN + chrp_alp1_idx[j+2]; |
||||
acc = sp_chrp_alp1_buf[allp_idx] + inL * chrp_allp_k[2];
|
||||
sp_chrp_alp1_buf[allp_idx] = inL - chrp_allp_k[2] * acc; |
||||
inL = acc; |
||||
if (++chrp_alp1_idx[j+2] >= SPRVB_CHIRP1_LEN) chrp_alp1_idx[j+2] = 0;
|
||||
|
||||
allp_idx = (j+3)*SPRVB_CHIRP1_LEN + chrp_alp1_idx[j+3]; |
||||
acc = sp_chrp_alp1_buf[allp_idx] + inL * chrp_allp_k[3];
|
||||
sp_chrp_alp1_buf[allp_idx] = inL - chrp_allp_k[3] * acc; |
||||
inL = acc; |
||||
if (++chrp_alp1_idx[j+3] >= SPRVB_CHIRP1_LEN) chrp_alp1_idx[j+3] = 0;
|
||||
// channel R
|
||||
allp_idx = (j+4)*SPRVB_CHIRP1_LEN + chrp_alp1_idx[j+4]; |
||||
acc = sp_chrp_alp1_buf[allp_idx] + inR * chrp_allp_k[3];
|
||||
sp_chrp_alp1_buf[allp_idx] = inR - chrp_allp_k[3] * acc; |
||||
inR = acc; |
||||
if (++chrp_alp1_idx[j+4] >= SPRVB_CHIRP1_LEN) chrp_alp1_idx[j+4] = 0;
|
||||
|
||||
allp_idx = (j+5)*SPRVB_CHIRP1_LEN + chrp_alp1_idx[j+5]; |
||||
acc = sp_chrp_alp1_buf[allp_idx] + inR * chrp_allp_k[2];
|
||||
sp_chrp_alp1_buf[allp_idx] = inR - chrp_allp_k[2] * acc; |
||||
inR = acc; |
||||
if (++chrp_alp1_idx[j+5] >= SPRVB_CHIRP1_LEN) chrp_alp1_idx[j+5] = 0;
|
||||
|
||||
allp_idx = (j+6)*SPRVB_CHIRP1_LEN + chrp_alp1_idx[j+6]; |
||||
acc = sp_chrp_alp1_buf[allp_idx] + inR * chrp_allp_k[1];
|
||||
sp_chrp_alp1_buf[allp_idx] = inR - chrp_allp_k[1] * acc; |
||||
inR = acc; |
||||
if (++chrp_alp1_idx[j+6] >= SPRVB_CHIRP1_LEN) chrp_alp1_idx[j+6] = 0;
|
||||
|
||||
allp_idx = (j+7)*SPRVB_CHIRP1_LEN + chrp_alp1_idx[j+7]; |
||||
acc = sp_chrp_alp1_buf[allp_idx] + inR * chrp_allp_k[0];
|
||||
sp_chrp_alp1_buf[allp_idx] = inR - chrp_allp_k[0] * acc;
|
||||
inR = acc; |
||||
if (++chrp_alp1_idx[j+7] >= SPRVB_CHIRP1_LEN) chrp_alp1_idx[j+7] = 0;
|
||||
|
||||
j = j + 8; |
||||
} |
||||
j = 0; |
||||
while(j < SPRVB_CHIRP_AMNT) |
||||
{ // channel L
|
||||
allp_idx = j*SPRVB_CHIRP2_LEN + chrp_alp2_idx[j]; |
||||
acc = sp_chrp_alp2_buf[allp_idx] + inL * chrp_allp_k[0];
|
||||
sp_chrp_alp2_buf[allp_idx] = inL - chrp_allp_k[0] * acc; |
||||
inL = acc; |
||||
if (++chrp_alp2_idx[j] >= SPRVB_CHIRP2_LEN) chrp_alp2_idx[j] = 0;
|
||||
|
||||
allp_idx = (j+1)*SPRVB_CHIRP2_LEN + chrp_alp2_idx[j+1]; |
||||
acc = sp_chrp_alp2_buf[allp_idx] + inL * chrp_allp_k[1];
|
||||
sp_chrp_alp2_buf[allp_idx] = inL - chrp_allp_k[1] * acc;
|
||||
inL = acc; |
||||
if (++chrp_alp2_idx[j+1] >= SPRVB_CHIRP2_LEN) chrp_alp2_idx[j+1] = 0;
|
||||
|
||||
allp_idx = (j+2)*SPRVB_CHIRP2_LEN + chrp_alp2_idx[j+2]; |
||||
acc = sp_chrp_alp2_buf[allp_idx] + inL * chrp_allp_k[2];
|
||||
sp_chrp_alp2_buf[allp_idx] = inL - chrp_allp_k[2] * acc;
|
||||
inL = acc; |
||||
if (++chrp_alp2_idx[j+2] >= SPRVB_CHIRP2_LEN) chrp_alp2_idx[j+2] = 0;
|
||||
|
||||
allp_idx = (j+3)*SPRVB_CHIRP2_LEN + chrp_alp2_idx[j+3]; |
||||
acc = sp_chrp_alp2_buf[allp_idx] + inL * chrp_allp_k[3];
|
||||
sp_chrp_alp2_buf[allp_idx] = inL - chrp_allp_k[3] * acc;
|
||||
inL = acc; |
||||
if (++chrp_alp2_idx[j+3] >= SPRVB_CHIRP2_LEN) chrp_alp2_idx[j+3] = 0;
|
||||
// channel R
|
||||
allp_idx = (j+4)*SPRVB_CHIRP2_LEN + chrp_alp2_idx[j+4]; |
||||
acc = sp_chrp_alp2_buf[allp_idx] + inR * chrp_allp_k[3];
|
||||
sp_chrp_alp2_buf[allp_idx] = inR - chrp_allp_k[3] * acc; |
||||
inR = acc; |
||||
if (++chrp_alp2_idx[j+4] >= SPRVB_CHIRP2_LEN) chrp_alp2_idx[j+4] = 0;
|
||||
|
||||
allp_idx = (j+5)*SPRVB_CHIRP2_LEN + chrp_alp2_idx[j+5]; |
||||
acc = sp_chrp_alp2_buf[allp_idx] + inR * chrp_allp_k[2];
|
||||
sp_chrp_alp2_buf[allp_idx] = inR - chrp_allp_k[2] * acc; |
||||
inR = acc; |
||||
if (++chrp_alp2_idx[j+5] >= SPRVB_CHIRP2_LEN) chrp_alp2_idx[j+5] = 0;
|
||||
|
||||
allp_idx = (j+6)*SPRVB_CHIRP2_LEN + chrp_alp2_idx[j+6]; |
||||
acc = sp_chrp_alp2_buf[allp_idx] + inR * chrp_allp_k[1];
|
||||
sp_chrp_alp2_buf[allp_idx] = inR - chrp_allp_k[1] * acc; |
||||
inR = acc; |
||||
if (++chrp_alp2_idx[j+6] >= SPRVB_CHIRP2_LEN) chrp_alp2_idx[j+6] = 0;
|
||||
|
||||
allp_idx = (j+7)*SPRVB_CHIRP2_LEN + chrp_alp2_idx[j+7]; |
||||
acc = sp_chrp_alp2_buf[allp_idx] + inR * chrp_allp_k[0];
|
||||
sp_chrp_alp2_buf[allp_idx] = inR - chrp_allp_k[0] * acc; |
||||
inR = acc; |
||||
if (++chrp_alp2_idx[j+7] >= SPRVB_CHIRP2_LEN) chrp_alp2_idx[j+7] = 0;
|
||||
j = j + 8; |
||||
} |
||||
j = 0; |
||||
while(j < SPRVB_CHIRP_AMNT) |
||||
{ // channel L
|
||||
allp_idx = j*SPRVB_CHIRP3_LEN + chrp_alp3_idx[j]; |
||||
acc = sp_chrp_alp3_buf[allp_idx] + inL * chrp_allp_k[0];
|
||||
sp_chrp_alp3_buf[allp_idx] = inL - chrp_allp_k[0] * acc; |
||||
inL = acc; |
||||
if (++chrp_alp3_idx[j] >= SPRVB_CHIRP3_LEN) chrp_alp3_idx[j] = 0;
|
||||
|
||||
allp_idx = (j+1)*SPRVB_CHIRP3_LEN + chrp_alp3_idx[j+1]; |
||||
acc = sp_chrp_alp3_buf[allp_idx] + inL * chrp_allp_k[1];
|
||||
sp_chrp_alp3_buf[allp_idx] = inL - chrp_allp_k[1] * acc;
|
||||
inL = acc; |
||||
if (++chrp_alp3_idx[j+1] >= SPRVB_CHIRP3_LEN) chrp_alp3_idx[j+1] = 0;
|
||||
|
||||
allp_idx = (j+2)*SPRVB_CHIRP3_LEN + chrp_alp3_idx[j+2]; |
||||
acc = sp_chrp_alp3_buf[allp_idx] + inL * chrp_allp_k[2];
|
||||
sp_chrp_alp3_buf[allp_idx] = inL - chrp_allp_k[2] * acc;
|
||||
inL = acc; |
||||
if (++chrp_alp3_idx[j+2] >= SPRVB_CHIRP3_LEN) chrp_alp3_idx[j+2] = 0;
|
||||
|
||||
allp_idx = (j+3)*SPRVB_CHIRP3_LEN + chrp_alp3_idx[j+3]; |
||||
acc = sp_chrp_alp3_buf[allp_idx] + inL * chrp_allp_k[3];
|
||||
sp_chrp_alp3_buf[allp_idx] = inL - chrp_allp_k[3] * acc;
|
||||
inL = acc; |
||||
if (++chrp_alp3_idx[j+3] >= SPRVB_CHIRP3_LEN) chrp_alp3_idx[j+3] = 0;
|
||||
// channel R
|
||||
allp_idx = (j+4)*SPRVB_CHIRP3_LEN + chrp_alp3_idx[j+4]; |
||||
acc = sp_chrp_alp3_buf[allp_idx] + inR * chrp_allp_k[3];
|
||||
sp_chrp_alp3_buf[allp_idx] = inR - chrp_allp_k[3] * acc;
|
||||
inR = acc; |
||||
if (++chrp_alp3_idx[j+4] >= SPRVB_CHIRP3_LEN) chrp_alp3_idx[j+4] = 0;
|
||||
|
||||
allp_idx = (j+5)*SPRVB_CHIRP3_LEN + chrp_alp3_idx[j+5]; |
||||
acc = sp_chrp_alp3_buf[allp_idx] + inR * chrp_allp_k[2];
|
||||
sp_chrp_alp3_buf[allp_idx] = inR - chrp_allp_k[2] * acc;
|
||||
inR = acc; |
||||
if (++chrp_alp3_idx[j+5] >= SPRVB_CHIRP3_LEN) chrp_alp3_idx[j+5] = 0;
|
||||
|
||||
allp_idx = (j+6)*SPRVB_CHIRP3_LEN + chrp_alp3_idx[j+6]; |
||||
acc = sp_chrp_alp3_buf[allp_idx] + inR * chrp_allp_k[1];
|
||||
sp_chrp_alp3_buf[allp_idx] = inR - chrp_allp_k[1] * acc;
|
||||
inR = acc; |
||||
if (++chrp_alp3_idx[j+6] >= SPRVB_CHIRP3_LEN) chrp_alp3_idx[j+6] = 0;
|
||||
|
||||
allp_idx = (j+7)*SPRVB_CHIRP3_LEN + chrp_alp3_idx[j+7]; |
||||
acc = sp_chrp_alp3_buf[allp_idx] + inR * chrp_allp_k[0];
|
||||
sp_chrp_alp3_buf[allp_idx] = inR - chrp_allp_k[0] * acc;
|
||||
inR = acc; |
||||
if (++chrp_alp3_idx[j+7] >= SPRVB_CHIRP3_LEN) chrp_alp3_idx[j+7] = 0;
|
||||
j = j + 8; |
||||
} |
||||
j = 0; |
||||
while(j < SPRVB_CHIRP_AMNT) |
||||
{ // channel L
|
||||
allp_idx = j*SPRVB_CHIRP4_LEN + chrp_alp4_idx[j]; |
||||
acc = sp_chrp_alp4_buf[allp_idx] + inL * chrp_allp_k[0];
|
||||
sp_chrp_alp4_buf[allp_idx] = inL - chrp_allp_k[0] * acc; |
||||
inL = acc; |
||||
if (++chrp_alp4_idx[j] >= SPRVB_CHIRP4_LEN) chrp_alp4_idx[j] = 0;
|
||||
|
||||
allp_idx = (j+1)*SPRVB_CHIRP4_LEN + chrp_alp4_idx[j+1]; |
||||
acc = sp_chrp_alp4_buf[allp_idx] + inL * chrp_allp_k[1];
|
||||
sp_chrp_alp4_buf[allp_idx] = inL - chrp_allp_k[1] * acc;
|
||||
inL = acc; |
||||
if (++chrp_alp4_idx[j+1] >= SPRVB_CHIRP4_LEN) chrp_alp4_idx[j+1] = 0;
|
||||
|
||||
allp_idx = (j+2)*SPRVB_CHIRP4_LEN + chrp_alp4_idx[j+2]; |
||||
acc = sp_chrp_alp4_buf[allp_idx] + inL * chrp_allp_k[1];
|
||||
sp_chrp_alp4_buf[allp_idx] = inL - chrp_allp_k[1] * acc;
|
||||
inL = acc; |
||||
if (++chrp_alp4_idx[j+2] >= SPRVB_CHIRP4_LEN) chrp_alp4_idx[j+2] = 0;
|
||||
|
||||
allp_idx = (j+3)*SPRVB_CHIRP4_LEN + chrp_alp4_idx[j+3]; |
||||
acc = sp_chrp_alp4_buf[allp_idx] + inL * chrp_allp_k[3];
|
||||
sp_chrp_alp4_buf[allp_idx] = inL - chrp_allp_k[3] * acc;
|
||||
inL = acc; |
||||
if (++chrp_alp4_idx[j+3] >= SPRVB_CHIRP4_LEN) chrp_alp4_idx[j+3] = 0;
|
||||
// channel R
|
||||
allp_idx = (j+4)*SPRVB_CHIRP4_LEN + chrp_alp4_idx[j+4]; |
||||
acc = sp_chrp_alp4_buf[allp_idx] + inR * chrp_allp_k[3];
|
||||
sp_chrp_alp4_buf[allp_idx] = inR - chrp_allp_k[3] * acc;
|
||||
inR = acc; |
||||
if (++chrp_alp4_idx[j+4] >= SPRVB_CHIRP4_LEN) chrp_alp4_idx[j+4] = 0;
|
||||
|
||||
allp_idx = (j+5)*SPRVB_CHIRP4_LEN + chrp_alp4_idx[j+5]; |
||||
acc = sp_chrp_alp4_buf[allp_idx] + inR * chrp_allp_k[2];
|
||||
sp_chrp_alp4_buf[allp_idx] = inR - chrp_allp_k[2] * acc;
|
||||
inR = acc; |
||||
if (++chrp_alp4_idx[j+5] >= SPRVB_CHIRP4_LEN) chrp_alp4_idx[j+5] = 0;
|
||||
|
||||
allp_idx = (j+6)*SPRVB_CHIRP4_LEN + chrp_alp4_idx[j+6]; |
||||
acc = sp_chrp_alp4_buf[allp_idx] + inR * chrp_allp_k[1];
|
||||
sp_chrp_alp4_buf[allp_idx] = inR - chrp_allp_k[1] * acc;
|
||||
inR = acc; |
||||
if (++chrp_alp4_idx[j+6] >= SPRVB_CHIRP4_LEN) chrp_alp4_idx[j+6] = 0;
|
||||
|
||||
allp_idx = (j+7)*SPRVB_CHIRP4_LEN + chrp_alp4_idx[j+7]; |
||||
acc = sp_chrp_alp4_buf[allp_idx] + inR * chrp_allp_k[0];
|
||||
sp_chrp_alp4_buf[allp_idx] = inR - chrp_allp_k[0] * acc;
|
||||
inR = acc; |
||||
if (++chrp_alp4_idx[j+7] >= SPRVB_CHIRP4_LEN) chrp_alp4_idx[j+7] = 0;
|
||||
j = j + 8; |
||||
} |
||||
|
||||
// modulate the allpass filters
|
||||
lfo.get(BASIC_LFO_PHASE_0, &offset, &lfo_fr);
|
||||
acc = sp_lp_allp1d.getTap(offset+1, lfo_fr); |
||||
sp_lp_allp1d.write_toOffset(acc, (lfo_ampl<<1)+1); |
||||
lfo.get(BASIC_LFO_PHASE_90, &offset, &lfo_fr);
|
||||
acc = sp_lp_allp2d.getTap(offset+1, lfo_fr); |
||||
sp_lp_allp2d.write_toOffset(acc, (lfo_ampl<<1)+1); |
||||
|
||||
blockL->data[i] = inL * wet_gain + dryL * dry_gain;
|
||||
blockR->data[i] = inR * wet_gain + dryR * dry_gain; |
||||
} |
||||
AudioStream_F32::transmit(blockL, 0); |
||||
AudioStream_F32::transmit(blockR, 1); |
||||
AudioStream_F32::release(blockL); |
||||
AudioStream_F32::release(blockR); |
||||
#endif |
||||
} |
||||
@ -0,0 +1,181 @@ |
||||
/* Stereo spring reverb for Teensy 4
|
||||
* |
||||
* Author: Piotr Zapart |
||||
* www.hexefx.com |
||||
* |
||||
* Copyright (c) 2024 by Piotr Zapart |
||||
* |
||||
* Development of this audio library was funded by PJRC.COM, LLC by sales of |
||||
* Teensy and Audio Adaptor boards. Please support PJRC's efforts to develop |
||||
* open source software by purchasing Teensy or other PJRC products. |
||||
* |
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
* of this software and associated documentation files (the "Software"), to deal |
||||
* in the Software without restriction, including without limitation the rights |
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
* copies of the Software, and to permit persons to whom the Software is |
||||
* furnished to do so, subject to the following conditions: |
||||
* |
||||
* The above copyright notice, development funding notice, and this permission |
||||
* notice shall be included in all copies or substantial portions of the Software. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
* THE SOFTWARE. |
||||
*/ |
||||
#ifndef _EFFECT_SPRINGREVERB_F32_H |
||||
#define _EFFECT_SPRINGREVERB_F32_H |
||||
|
||||
#include <Arduino.h> |
||||
#include "Audio.h" |
||||
#include "AudioStream.h" |
||||
#include "AudioStream_F32.h" |
||||
#include "arm_math.h" |
||||
#include "basic_components.h" |
||||
|
||||
// Chirp allpass params
|
||||
#define SPRVB_CHIRP_AMNT 16 //must be mult of 8
|
||||
#define SPRVB_CHIRP1_LEN 3 |
||||
#define SPRVB_CHIRP2_LEN 5 |
||||
#define SPRVB_CHIRP3_LEN 6 |
||||
#define SPRVB_CHIRP4_LEN 7 |
||||
|
||||
#define SPRVB_ALLP1A_LEN (224) |
||||
#define SPRVB_ALLP1B_LEN (420) |
||||
#define SPRVB_ALLP1C_LEN (856) |
||||
#define SPRVB_ALLP1D_LEN (1089) |
||||
|
||||
#define SPRVB_ALLP2A_LEN (156) |
||||
#define SPRVB_ALLP2B_LEN (478) |
||||
#define SPRVB_ALLP2C_LEN (956) |
||||
#define SPRVB_ALLP2D_LEN (1289) |
||||
|
||||
#define SPRVB_DLY1_LEN (1945) |
||||
#define SPRVB_DLY2_LEN (1363) |
||||
|
||||
class AudioEffectSpringReverb_F32 : public AudioStream_F32 |
||||
{ |
||||
public: |
||||
AudioEffectSpringReverb_F32(); |
||||
~AudioEffectSpringReverb_F32(){}; |
||||
|
||||
virtual void update(); |
||||
|
||||
void time(float n) |
||||
{ |
||||
n = constrain(n, 0.0f, 1.0f); |
||||
n = map (n, 0.0f, 1.0f, 0.7f, rv_time_k_max); |
||||
float32_t attn = map(n, 0.0f, rv_time_k_max, 0.5f, 0.2f); |
||||
__disable_irq(); |
||||
rv_time_k = n; |
||||
input_attn = attn; |
||||
__enable_irq(); |
||||
} |
||||
|
||||
void treble_cut(float n) |
||||
{ |
||||
n = 1.0f - constrain(n, 0.0f, 1.0f); |
||||
__disable_irq(); |
||||
lp_TrebleCut_k = n; |
||||
__enable_irq(); |
||||
} |
||||
|
||||
void bass_cut(float n) |
||||
{ |
||||
n = constrain(n, 0.0f, 1.0f); |
||||
n = 2.0f * n - (n*n); |
||||
__disable_irq(); |
||||
in_BassCut_k = -n; |
||||
__enable_irq(); |
||||
} |
||||
void mix(float m) |
||||
{ |
||||
float32_t dry, wet; |
||||
m = constrain(m, 0.0f, 1.0f); |
||||
mix_pwr(m, &wet, &dry); |
||||
__disable_irq(); |
||||
wet_gain = wet; |
||||
dry_gain = dry; |
||||
__enable_irq(); |
||||
} |
||||
|
||||
void wet_level(float wet) |
||||
{ |
||||
wet = constrain(wet, 0.0f, 6.0f); |
||||
__disable_irq(); |
||||
wet_gain = wet; |
||||
__enable_irq(); |
||||
} |
||||
|
||||
void dry_level(float dry) |
||||
{ |
||||
dry = constrain(dry, 0.0f, 1.0f); |
||||
__disable_irq(); |
||||
dry_gain = dry; |
||||
__enable_irq(); |
||||
} |
||||
float32_t get_size(void) {return rv_time_k;} |
||||
bool bypass_get(void) {return bp;} |
||||
void bypass_set(bool state) {bp = state;} |
||||
bool bypass_tgl(void)
|
||||
{ |
||||
bp ^= 1;
|
||||
return bp; |
||||
}
|
||||
private: |
||||
audio_block_f32_t *inputQueueArray[2]; |
||||
|
||||
float32_t input_attn;
|
||||
float32_t wet_gain; |
||||
float32_t dry_gain; |
||||
float32_t in_allp_k; // input allpass coeff (default 0.6)
|
||||
float32_t chrp_allp_k[4] = {-0.7f, -0.65f, -0.6f, -0.5f}; |
||||
|
||||
bool bp = false; |
||||
bool cleanup_done = false; |
||||
uint16_t chrp_alp1_idx[SPRVB_CHIRP_AMNT] = {0}; |
||||
uint16_t chrp_alp2_idx[SPRVB_CHIRP_AMNT] = {0}; |
||||
uint16_t chrp_alp3_idx[SPRVB_CHIRP_AMNT] = {0}; |
||||
uint16_t chrp_alp4_idx[SPRVB_CHIRP_AMNT] = {0}; |
||||
|
||||
static constexpr float32_t rv_time_k_max = 0.97f; |
||||
float32_t rv_time_k; |
||||
|
||||
AudioFilterAllpass<SPRVB_ALLP1A_LEN> sp_lp_allp1a; |
||||
AudioFilterAllpass<SPRVB_ALLP1B_LEN> sp_lp_allp1b; |
||||
AudioFilterAllpass<SPRVB_ALLP1C_LEN> sp_lp_allp1c; |
||||
AudioFilterAllpass<SPRVB_ALLP1D_LEN> sp_lp_allp1d; |
||||
|
||||
AudioFilterAllpass<SPRVB_ALLP2A_LEN> sp_lp_allp2a; |
||||
AudioFilterAllpass<SPRVB_ALLP2B_LEN> sp_lp_allp2b;
|
||||
AudioFilterAllpass<SPRVB_ALLP2D_LEN> sp_lp_allp2c; |
||||
AudioFilterAllpass<SPRVB_ALLP2D_LEN> sp_lp_allp2d;
|
||||
|
||||
float32_t *sp_chrp_alp1_buf; |
||||
float32_t *sp_chrp_alp2_buf; |
||||
float32_t *sp_chrp_alp3_buf; |
||||
float32_t *sp_chrp_alp4_buf; |
||||
|
||||
AudioBasicDelay<SPRVB_DLY1_LEN> lp_dly1; |
||||
AudioBasicDelay<SPRVB_DLY2_LEN> lp_dly2; |
||||
|
||||
float32_t in_TrebleCut_k; |
||||
float32_t in_BassCut_k; |
||||
float32_t lp_TrebleCut_k; |
||||
float32_t lp_BassCut_k; |
||||
|
||||
AudioFilterShelvingLPHP flt_in; |
||||
AudioFilterShelvingLPHP flt_lp1; |
||||
AudioFilterShelvingLPHP flt_lp2; |
||||
|
||||
static const uint8_t lfo_ampl = 10; |
||||
AudioBasicLfo lfo = AudioBasicLfo(1.35f, lfo_ampl); |
||||
|
||||
bool initialized = false; |
||||
}; |
||||
|
||||
#endif |
||||
@ -0,0 +1,153 @@ |
||||
//----------------------------------------------------------------------------
|
||||
// 3 Band EQ :)
|
||||
//
|
||||
// EQ.C - Main Source file for 3 band EQ
|
||||
// (c) Neil C / Etanza Systems / 2K6
|
||||
// Shouts / Loves / Moans = etanza at lycos dot co dot uk
|
||||
//
|
||||
// This work is hereby placed in the public domain for all purposes, including
|
||||
// use in commercial applications.
|
||||
// The author assumes NO RESPONSIBILITY for any problems caused by the use of
|
||||
// this software.
|
||||
//----------------------------------------------------------------------------
|
||||
// NOTES :
|
||||
// - Original filter code by Paul Kellet (musicdsp.pdf)
|
||||
// - Uses 4 first order filters in series, should give 24dB per octave
|
||||
// - Now with P4 Denormal fix :)
|
||||
//----------------------------------------------------------------------------
|
||||
|
||||
#ifndef _FILTER_3BANDEQ_H_ |
||||
#define _FILTER_3BANDEQ_H_ |
||||
|
||||
#include "Arduino.h" |
||||
#include "AudioStream_F32.h" |
||||
#include "arm_math.h" |
||||
#include "mathDSP_F32.h" |
||||
#include "basic_components.h" |
||||
|
||||
|
||||
class AudioFilterEqualizer3band_F32 : public AudioStream_F32 |
||||
{ |
||||
public: |
||||
AudioFilterEqualizer3band_F32(void) : AudioStream_F32(1, inputQueueArray) |
||||
{ |
||||
setBands(500.0f, 3000.0f); |
||||
} |
||||
void setBands(float32_t bassF, float32_t trebleF) |
||||
{ |
||||
trebleF = 2.0f * sinf(M_PI * (trebleF / AUDIO_SAMPLE_RATE_EXACT)); |
||||
bassF = 2.0f * sinf(M_PI * (bassF / AUDIO_SAMPLE_RATE_EXACT)); |
||||
|
||||
__disable_irq(); |
||||
lowpass_f = bassF; |
||||
hipass_f = trebleF;
|
||||
__enable_irq(); |
||||
} |
||||
void treble(float32_t t) |
||||
{ |
||||
__disable_irq(); |
||||
treble_g = t; |
||||
__enable_irq(); |
||||
} |
||||
void mid(float32_t m) |
||||
{ |
||||
__disable_irq(); |
||||
mid_g = m; |
||||
__enable_irq(); |
||||
} |
||||
|
||||
void bass(float32_t b) |
||||
{ |
||||
__disable_irq(); |
||||
bass_g = b; |
||||
__enable_irq(); |
||||
} |
||||
void set(float32_t t, float32_t m, float32_t b) |
||||
{ |
||||
__disable_irq(); |
||||
treble_g = t; |
||||
mid_g = m; |
||||
bass_g = b; |
||||
__enable_irq(); |
||||
} |
||||
void update() |
||||
{ |
||||
audio_block_f32_t *block; |
||||
int i; |
||||
block = AudioStream_F32::receiveWritable_f32(); |
||||
if (!block) |
||||
return; |
||||
if (bp) // bypass mode
|
||||
{ |
||||
AudioStream_F32::transmit(block); |
||||
AudioStream_F32::release(block); |
||||
return; |
||||
} |
||||
for (i = 0; i < block->length; i++) |
||||
{ |
||||
float32_t lpOut, midOut, hpOut; // Low / Mid / High - Sample Values
|
||||
float32_t sample = block->data[i]; // give some headroom
|
||||
// Filter #1 (lowpass)
|
||||
f1p0 += (lowpass_f * (sample - f1p0)) + vsa; |
||||
f1p1 += (lowpass_f * (f1p0 - f1p1)); |
||||
f1p2 += (lowpass_f * (f1p1 - f1p2)); |
||||
f1p3 += (lowpass_f * (f1p2 - f1p3)); |
||||
lpOut = f1p3; |
||||
|
||||
// // Filter #2 (highpass)
|
||||
f2p0 += (hipass_f * (sample - f2p0)) + vsa; |
||||
f2p1 += (hipass_f * (f2p0 - f2p1)); |
||||
f2p2 += (hipass_f * (f2p1 - f2p2)); |
||||
f2p3 += (hipass_f * (f2p2 - f2p3)); |
||||
hpOut = sdm3 - f2p3; |
||||
|
||||
midOut = sdm3 - (lpOut + hpOut); |
||||
// // Scale, Combine and store
|
||||
lpOut *= bass_g; |
||||
midOut *= mid_g; |
||||
hpOut *= treble_g; |
||||
|
||||
// // Shuffle history buffer
|
||||
sdm3 = sdm2; |
||||
sdm2 = sdm1; |
||||
sdm1 = sample; |
||||
|
||||
block->data[i] = (lpOut + midOut + hpOut); |
||||
} |
||||
AudioStream_F32::transmit(block); |
||||
AudioStream_F32::release(block); |
||||
} |
||||
void bypass_set(bool s) { bp = s; } |
||||
bool bypass_tgl() |
||||
{ |
||||
bp ^= 1; |
||||
return bp; |
||||
} |
||||
private: |
||||
audio_block_f32_t *inputQueueArray[1]; |
||||
bool bp = false; |
||||
|
||||
float32_t f1p0 = 0.0f; |
||||
float32_t f1p1 = 0.0f; |
||||
float32_t f1p2 = 0.0f; |
||||
float32_t f1p3 = 0.0f; |
||||
float32_t f2p0 = 0.0f; |
||||
float32_t f2p1 = 0.0f; |
||||
float32_t f2p2 = 0.0f; |
||||
float32_t f2p3 = 0.0f; |
||||
|
||||
float32_t sdm1 = 0.0f;
|
||||
float32_t sdm2 = 0.0f; // 2
|
||||
float32_t sdm3 = 0.0f; // 3
|
||||
|
||||
static constexpr float32_t vsa = (1.0 / 4294967295.0); // Very small amount (Denormal Fix)
|
||||
float32_t lpreg; |
||||
float32_t hpreg; |
||||
float32_t lowpass_f; |
||||
float32_t bass_g = 1.0f; |
||||
float32_t hipass_f; |
||||
float32_t treble_g = 1.0f; |
||||
float32_t mid_g = 1.0f; |
||||
|
||||
}; |
||||
#endif |
||||
Loading…
Reference in new issue