You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
219 lines
7.0 KiB
219 lines
7.0 KiB
/* Audio Library for Teensy 3.X
|
|
Copyright (c) 2014, Pete (El Supremo)
|
|
Copyright (c) 2019, Holger Wirtz
|
|
|
|
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 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 <Audio.h>
|
|
#include "limits.h"
|
|
#include "effect_modulated_delay.h"
|
|
#include "spline.h"
|
|
#include "config.h"
|
|
|
|
/******************************************************************/
|
|
|
|
// Based on; A u d i o E f f e c t D e l a y
|
|
// Written by Pete (El Supremo) Jan 2014
|
|
// 140529 - change to handle mono stream - change modify() to voices()
|
|
// 140219 - correct storage class (not static)
|
|
// 190527 - added modulation input (by Holger Wirtz)
|
|
|
|
boolean AudioEffectModulatedDelay::begin(short *delayline, int d_length)
|
|
{
|
|
#if 0
|
|
Serial.print(F("AudioEffectModulatedDelay.begin(Chorus delay line length = "));
|
|
Serial.print(d_length);
|
|
Serial.println(F(")"));
|
|
#endif
|
|
|
|
_delayline = NULL;
|
|
_delay_length = 0;
|
|
_circ_idx = 0;
|
|
|
|
if (delayline == NULL) {
|
|
return (false);
|
|
}
|
|
if (d_length < 10) {
|
|
return (false);
|
|
}
|
|
|
|
_delayline = delayline;
|
|
_delay_length = _max_delay_length = d_length;
|
|
|
|
// init filter
|
|
filter.numStages = 1;
|
|
filter.pState = filter_state;
|
|
filter.pCoeffs = filter_coeffs;
|
|
calcModFilterCoeff(5000.0, 0.0, 5.0);
|
|
|
|
return (true);
|
|
}
|
|
|
|
void AudioEffectModulatedDelay::update(void)
|
|
{
|
|
audio_block_t *block;
|
|
audio_block_t *modulation;
|
|
|
|
if (_delayline == NULL)
|
|
return;
|
|
|
|
block = receiveWritable(0);
|
|
modulation = receiveReadOnly(1);
|
|
|
|
if (block && modulation)
|
|
{
|
|
int16_t *bp;
|
|
float *mp;
|
|
float mod_idx;
|
|
float mod_number;
|
|
float mod_fraction;
|
|
|
|
#ifdef INTERPOLATE_MODE
|
|
int8_t j;
|
|
float x[INTERPOLATION_WINDOW_SIZE];
|
|
float y[INTERPOLATION_WINDOW_SIZE];
|
|
Spline s(x, y, INTERPOLATION_WINDOW_SIZE, INTERPOLATE_MODE);
|
|
#endif
|
|
|
|
// (Filter implementation: https://web.fhnw.ch/technik/projekte/eit/Fruehling2016/MuelZum/html/parametric__equalizer__example_8c_source.html)
|
|
arm_q15_to_float(modulation->data, modulation_f32, AUDIO_BLOCK_SAMPLES);
|
|
arm_biquad_cascade_df1_f32(&filter, modulation_f32, modulation_f32, AUDIO_BLOCK_SAMPLES);
|
|
bp = block->data;
|
|
mp = modulation_f32;
|
|
|
|
for (uint16_t i = 0; i < AUDIO_BLOCK_SAMPLES; i++)
|
|
{
|
|
// write data into circular buffer
|
|
if (_circ_idx >= _delay_length)
|
|
_circ_idx = 0;
|
|
_delayline[_circ_idx] = *bp;
|
|
|
|
// Calculate modulation index as a float, for interpolation later.
|
|
// The index is located around the half of the delay length multiplied by the current amount of the modulator
|
|
mod_idx = *mp * float(_delay_length >> 1);
|
|
mod_fraction = modff(mod_idx, &mod_number);
|
|
|
|
#ifdef INTERPOLATE_MODE
|
|
// Generate a an array with the size of INTERPOLATION_WINDOW_SIZE of x/y values around mod_idx for interpolation
|
|
uint8_t c;
|
|
int16_t c_mod_idx = _circ_idx - int(round(mod_idx)); // This is the pointer to the value in the circular buffer at the current modulation index
|
|
for (j = ~(INTERPOLATION_WINDOW_SIZE >> 1) | 0x01, c = 0; j <= INTERPOLATION_WINDOW_SIZE >> 1; j++, c++) // only another way to say: from -INTERPOLATION_WINDOW_SIZE/2 to INTERPOLATION_WINDOW_SIZE/2
|
|
{
|
|
int16_t jc_mod_idx = (c_mod_idx + j) % _delay_length; // The modulation index pointer plus the value of the current window pointer
|
|
if (jc_mod_idx < 0)
|
|
y[c] = float(_delayline[_delay_length + jc_mod_idx]);
|
|
else
|
|
y[c] = float(_delayline[jc_mod_idx]);
|
|
x[c] = float(j);
|
|
}
|
|
*bp = int(round(s.value(mod_fraction)));
|
|
#else
|
|
// Simple interpolation
|
|
int16_t c_mod_idx = (_circ_idx - int(round(mod_idx))) % _delay_length;
|
|
float value1, value2;
|
|
|
|
if (c_mod_idx < 0)
|
|
{
|
|
value1 = _delayline[_delay_length + c_mod_idx - 1];
|
|
value2 = _delayline[_delay_length + c_mod_idx];
|
|
}
|
|
else
|
|
{
|
|
value1 = _delayline[c_mod_idx - 1];
|
|
value2 = _delayline[c_mod_idx];
|
|
}
|
|
*bp = mod_fraction * value1 + (1.0 - mod_fraction) * value2;
|
|
#endif
|
|
|
|
bp++; // next audio data
|
|
mp++; // next modulation data
|
|
_circ_idx++; // next circular buffer index
|
|
}
|
|
}
|
|
|
|
if (modulation)
|
|
release(modulation);
|
|
|
|
if (block)
|
|
{
|
|
transmit(block, 0);
|
|
release(block);
|
|
}
|
|
}
|
|
|
|
void AudioEffectModulatedDelay::setDelay(float milliseconds)
|
|
{
|
|
_delay_length = min(AUDIO_SAMPLE_RATE * milliseconds / 500, _max_delay_length);
|
|
}
|
|
|
|
void AudioEffectModulatedDelay::calcModFilterCoeff(float32_t cFrq, float32_t gain, float32_t width)
|
|
{
|
|
/* Calculate intermediate values */
|
|
// float32_t A = sqrt(pow(10, gain / 20.0f));
|
|
// float32_t w0 = 2.0f * PI * cFrq / ((float32_t)AUDIO_SAMPLE_RATE_EXACT);
|
|
// float32_t cosw0 = cos(w0);
|
|
// float32_t sinw0 = sin(w0);
|
|
// float32_t alpha = sinw0 / (2.0f * width);
|
|
|
|
/* Calculate coefficients */
|
|
// float32_t b0 = 1.0f + alpha * A;
|
|
// float32_t b1 = -2.0f * cosw0;
|
|
// float32_t b2 = 1.0f - alpha * A;
|
|
// float32_t a0 = 1.0f + alpha / A;
|
|
// float32_t a1 = -2.0f * cosw0;
|
|
// float32_t a2 = 1.0f - alpha / A;
|
|
|
|
/* https://stackoverflow.com/questions/20924868/calculate-coefficients-of-2nd-order-butterworth-low-pass-filter/20932062
|
|
ff=cutoff_frq/sample_rate=AUDIO_SAMPLE_RATE_EXACT/1000
|
|
const double ita =1.0/ tan(M_PI*ff);
|
|
const double q=sqrt(2.0);
|
|
b0 = 1.0 / (1.0 + q*ita + ita*ita);
|
|
b1= 2*b0;
|
|
b2= b0;
|
|
a1 = 2.0 * (ita*ita - 1.0) * b0;
|
|
a2 = -(1.0 - q*ita + ita*ita) * b0;
|
|
|
|
ff=1000/44117.64706=0.02266666666
|
|
ita=804.60898525
|
|
q=1.414213
|
|
|
|
*/
|
|
// 1kHz 2nd order Butterworth lowpass filter coefficients
|
|
// calculated with Iowa IIR FIlter Designer 6.5
|
|
float32_t b0 = 0.124589380980617656;
|
|
float32_t b1 = 0.124589380980617656;
|
|
float32_t b2 = 0.0;
|
|
float32_t a0 = 1.000000000000000000;
|
|
float32_t a1 = -0.750821238038764660;
|
|
float32_t a2 = 0.0;
|
|
|
|
/* Normalize so a0 = 1 */
|
|
filter_coeffs[0] = b0 / a0;
|
|
filter_coeffs[1] = b1 / a0;
|
|
filter_coeffs[2] = b2 / a0;
|
|
filter_coeffs[3] = -a1 / a0;
|
|
filter_coeffs[4] = -a2 / a0;
|
|
}
|
|
|
|
void AudioEffectModulatedDelay::setModFilter(float cFrq, float gain, float width)
|
|
{
|
|
calcModFilterCoeff(cFrq, gain, width);
|
|
}
|
|
|