wirtz
/
BALibrary
mirror of https://github.com/Blackaddr/BALibrary.git
1
0
Fork 1
Code Issues Releases Wiki Activity

Initial chorus development check in

Browse Source
feature/AudioEffectAnalogChorus
Steve Lascos 6 years ago
parent 362d0928d2
commit 9b09021ef0
6 changed files with 617 additions and 129 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 217
      examples/Modulation/AnalogChorusDemoExpansion/AnalogChorusDemoExpansion.ino
  2. 19
      examples/Modulation/AnalogChorusDemoExpansion/name.c
  3. 196
      src/AudioEffectAnalogChorus.h
  4. 1
      src/BAEffects.h
  5. 172
      src/effects/AudioEffectAnalogChorus.cpp
  6. 83
      src/effects/AudioEffectAnalogChorusFilters.h

217
examples/Modulation/AnalogChorusDemoExpansion/AnalogChorusDemoExpansion.ino
Unescape View File

@ -0,0 +1,217 @@
/*************************************************************************
* This demo uses the BALibrary library to provide enhanced control of
* the TGA Pro board.
*
* The latest copy of the BA Guitar library can be obtained from
* https://github.com/Blackaddr/BALibrary
*
* This example demonstrates teh BAAudioEffectsAnalogChorus effect. It can
* be controlled using the Blackaddr Audio "Expansion Control Board".
*
* POT1 (left) controls the modulation rate
* POT2 (right) controls the modulation depth
* POT3 (center) controls the wet/dry mix
* SW1 will enable/bypass the audio effect. LED1 will be on when effect is enabled.
* SW2 will cycle through the 3 pre-programmed analog filters. LED2 will be on when SW2 is pressed.
*
* Using the Serial Montitor, send 'u' and 'd' characters to increase or decrease
* the headphone volume between values of 0 and 9.
*/
#define TGA_PRO_REVB // Set which hardware revision of the TGA Pro we're using
#define TGA_PRO_EXPAND_REV2 // pull in the pin definitions for the Blackaddr Audio Expansion Board.
#include "BALibrary.h"
#include "BAEffects.h"
using namespace BAEffects;
using namespace BALibrary;
AudioInputI2S i2sIn;
AudioOutputI2S i2sOut;
BAAudioControlWM8731 codec;
//#define USE_EXT // uncomment this line to use External MEM0
#ifdef USE_EXT
// If using external SPI memory, we will instantiate a SRAM
// manager and create an external memory slot to use as the memory
// for our audio delay
ExternalSramManager externalSram;
ExtMemSlot delaySlot; // Declare an external memory slot.
// Instantiate the AudioEffectAnalogChorus to use external memory by
/// passing it the delay slot.
AudioEffectAnalogChorus analogChorus(&delaySlot);
#else
AudioEffectAnalogChorus analogChorus; // default chorus delays
#endif
AudioFilterBiquad cabFilter; // We'll want something to cut out the highs and smooth the tone, just like a guitar cab.
// Simply connect the input to the delay, and the output
// to both i2s channels
AudioConnection input(i2sIn,0, analogChorus,0);
AudioConnection chorusOut(analogChorus, 0, cabFilter, 0);
AudioConnection leftOut(cabFilter,0, i2sOut, 0);
AudioConnection rightOut(cabFilter,0, i2sOut, 1);
//////////////////////////////////////////
// SETUP PHYSICAL CONTROLS
// - POT1 (left) will control the rate
// - POT2 (right) will control the depth
// - POT3 (centre) will control the wet/dry mix.
// - SW1 (left) will be used as a bypass control
// - LED1 (left) will be illuminated when the effect is ON (not bypass)
// - SW2 (right) will be used to cycle through the three built in analog filter styles available.
// - LED2 (right) will illuminate when pressing SW2.
//////////////////////////////////////////
// To get the calibration values for your particular board, first run the
// BAExpansionCalibrate.ino example and
constexpr int potCalibMin = 1;
constexpr int potCalibMax = 1018;
constexpr bool potSwapDirection = true;
// Create a control object using the number of switches, pots, encoders and outputs on the
// Blackaddr Audio Expansion Board.
BAPhysicalControls controls(BA_EXPAND_NUM_SW, BA_EXPAND_NUM_POT, BA_EXPAND_NUM_ENC, BA_EXPAND_NUM_LED);
int loopCount = 0;
unsigned filterIndex = 0; // variable for storing which analog filter we're currently using.
constexpr unsigned MAX_HEADPHONE_VOL = 10;
unsigned headphoneVolume = 8; // control headphone volume from 0 to 10.
// BAPhysicalControls returns a handle when you register a new control. We'll uses these handles when working with the controls.
int bypassHandle, filterHandle, rateHandle, depthHandle, mixHandle, led1Handle, led2Handle; // Handles for the various controls
void setup() {
delay(100); // wait a bit for serial to be available
Serial.begin(57600); // Start the serial port
delay(100);
// Setup the controls. The return value is the handle to use when checking for control changes, etc.
// pushbuttons
bypassHandle = controls.addSwitch(BA_EXPAND_SW1_PIN); // will be used for bypass control
filterHandle = controls.addSwitch(BA_EXPAND_SW2_PIN); // will be used for stepping through filters
// pots
rateHandle = controls.addPot(BA_EXPAND_POT1_PIN, potCalibMin, potCalibMax, potSwapDirection); // control the amount of delay
depthHandle = controls.addPot(BA_EXPAND_POT2_PIN, potCalibMin, potCalibMax, potSwapDirection);
mixHandle = controls.addPot(BA_EXPAND_POT3_PIN, potCalibMin, potCalibMax, potSwapDirection);
// leds
led1Handle = controls.addOutput(BA_EXPAND_LED1_PIN);
led2Handle = controls.addOutput(BA_EXPAND_LED2_PIN); // will illuminate when pressing SW2
// Disable the audio codec first
codec.disable();
AudioMemory(128);
// Enable and configure the codec
Serial.println("Enabling codec...\n");
codec.enable();
codec.setHeadphoneVolume(1.0f); // Max headphone volume
// If using external memory request request memory from the manager
// for the slot
#ifdef USE_EXT
Serial.println("Using EXTERNAL memory");
// We have to request memory be allocated to our slot.
externalSram.requestMemory(&delaySlot, 40.0f, MemSelect::MEM0, true); // 40 ms is enough to handle the full range of the chorus delay
#else
Serial.println("Using INTERNAL memory");
#endif
// Besure to enable the delay. When disabled, audio is is completely blocked by the effect
// to minimize resource usage to nearly to nearly zero.
analogChorus.enable();
// Set some default values.
// These can be changed using the controls on the Blackaddr Audio Expansion Board
analogChorus.bypass(false);
analogChorus.rate(0.5f);
analogChorus.mix(0.5f);
analogChorus.depth(1.0f);
//////////////////////////////////
// AnalogChorus filter selection //
// These are commented out, in this example we'll use SW2 to cycle through the different filters
//analogChorus.setFilter(AudioEffectAnalogChorus::Filter::CE2); // The default filter. Naturally bright echo (highs stay, lows fade away)
//analogChorus.setFilter(AudioEffectAnalogChorus::Filter::WARM); // A warm filter with a smooth frequency rolloff above 2Khz
//analogChorus.setFilter(AudioEffectAnalogChorus::Filter::DARK); // A very dark filter, with a sharp rolloff above 1Khz
// Guitar cabinet: Setup 2-stages of LPF, cutoff 4500 Hz, Q-factor 0.7071 (a 'normal' Q-factor)
cabFilter.setLowpass(0, 4500, .7071);
cabFilter.setLowpass(1, 4500, .7071);
}
void loop() {
float potValue;
// Check if SW1 has been toggled (pushed)
if (controls.isSwitchToggled(bypassHandle)) {
bool bypass = analogChorus.isBypass(); // get the current state
bypass = !bypass; // change it
analogChorus.bypass(bypass); // set the new state
controls.setOutput(led1Handle, !bypass); // Set the LED when NOT bypassed
Serial.println(String("BYPASS is ") + bypass);
}
// Use SW2 to cycle through the filters
controls.setOutput(led2Handle, controls.getSwitchValue(led2Handle));
if (controls.isSwitchToggled(filterHandle)) {
filterIndex = (filterIndex + 1) % 3; // update and potentionall roll the counter 0, 1, 2, 0, 1, 2, ...
// cast the index between 0 to 2 to the enum class AudioEffectAnalogChorus::Filter
analogChorus.setFilter(static_cast<AudioEffectAnalogChorus::Filter>(filterIndex)); // will cycle through 0 to 2
Serial.println(String("Filter set to ") + filterIndex);
}
// Use POT1 (left) to control the rate setting
if (controls.checkPotValue(rateHandle, potValue)) {
// Pot has changed
Serial.println(String("New RATE setting: ") + potValue);
analogChorus.rate(potValue);
}
// Use POT2 (right) to control the depth setting
if (controls.checkPotValue(depthHandle, potValue)) {
// Pot has changed
Serial.println(String("New DEPTH setting: ") + potValue);
analogChorus.depth(potValue);
}
// Use POT3 (centre) to control the mix setting
if (controls.checkPotValue(mixHandle, potValue)) {
// Pot has changed
Serial.println(String("New MIX setting: ") + potValue);
analogChorus.mix(potValue);
}
// Use the 'u' and 'd' keys to adjust volume across ten levels.
if (Serial) {
if (Serial.available() > 0) {
while (Serial.available()) {
char key = Serial.read();
if (key == 'u') {
headphoneVolume = (headphoneVolume + 1) % MAX_HEADPHONE_VOL;
Serial.println(String("Increasing HEADPHONE volume to ") + headphoneVolume);
}
else if (key == 'd') {
headphoneVolume = (headphoneVolume - 1) % MAX_HEADPHONE_VOL;
Serial.println(String("Decreasing HEADPHONE volume to ") + headphoneVolume);
}
codec.setHeadphoneVolume(static_cast<float>(headphoneVolume) / static_cast<float>(MAX_HEADPHONE_VOL));
}
}
}
// Use the loopCounter to roughly measure human timescales. Every few seconds, print the CPU usage
// to the serial port. About 500,000 loops!
if (loopCount % 524288 == 0) {
Serial.print("Processor Usage, Total: "); Serial.print(AudioProcessorUsage());
Serial.print("% ");
Serial.print(" AnalogChorus: "); Serial.print(analogChorus.processorUsage());
Serial.println("%");
}
loopCount++;
}

19
examples/Modulation/AnalogChorusDemoExpansion/name.c
Unescape View File

@ -0,0 +1,19 @@
// To give your project a unique name, this code must be
// placed into a .c file (its own tab). It can not be in
// a .cpp file or your main sketch (the .ino file).
#include "usb_names.h"
// Edit these lines to create your own name. The length must
// match the number of characters in your custom name.
#define MIDI_NAME {'B','l','a','c','k','a','d','d','r',' ','A','u','d','i','o',' ','T','G','A',' ','P','r','o'}
#define MIDI_NAME_LEN 23
// Do not change this part. This exact format is required by USB.
struct usb_string_descriptor_struct usb_string_product_name = {
2 + MIDI_NAME_LEN * 2,
3,
MIDI_NAME
};

196
src/AudioEffectAnalogChorus.h
Unescape View File

@ -0,0 +1,196 @@
/**************************************************************************//**
* @file
* @author Steve Lascos
* @company Blackaddr Audio
*
* AudioEffectAnalogChorus is a class for simulating a classic BBD based chorus
* like the Boss CE-2. This class works with either internal RAM, or external
* SPI RAM. The external RAM uses DMA to minimize load on the
* CPU.
*
* @copyright This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.*
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*****************************************************************************/
#ifndef __BAEFFECTS_BAAUDIOEFFECTANALOGCHORUS_H
#define __BAEFFECTS_BAAUDIOEFFECTANALOGCHORUS_H
#include <Audio.h>
#include "LibBasicFunctions.h"
namespace BAEffects {
/**************************************************************************//**
* AudioEffectAnalogChorus models BBD based analog chorus. It provides controls
* for rate, depth, mix and output level. All parameters can be
* controlled by MIDI. The class supports internal memory, or external SPI
* memory by providing an ExtMemSlot. External memory access uses DMA to reduce
* process load.
*****************************************************************************/
class AudioEffectAnalogChorus : public AudioStream {
public:
///< List of AudioEffectAnalogChorus MIDI controllable parameters
enum {
BYPASS = 0, ///< controls effect bypass
RATE, ///< controls the modulate rate of the LFO
DEPTH, ///< controls the depth of modulation of the LFO
MIX, ///< controls the the mix of input and chorus signals
VOLUME, ///< controls the output volume level
NUM_CONTROLS ///< this can be used as an alias for the number of MIDI controls
};
enum class Filter {
CE2 = 0,
WARM,
DARK
};
/// Construct an analog chorus using internal memory. The chorus will have the
/// default average delay.
AudioEffectAnalogChorus();
/// Construct an analog chorus using external SPI via an ExtMemSlot. The chorus will have
/// the default average delay.
/// @param slot A pointer to the ExtMemSlot to use for the delay.
AudioEffectAnalogChorus(BALibrary::ExtMemSlot *slot); // requires sufficiently sized pre-allocated memory
virtual ~AudioEffectAnalogChorus(); ///< Destructor
// *** PARAMETERS ***
/// Set the chorus average delay in milliseconds
/// The value should be between 0.0f and 1.0f
void setDelayConfig(float averageDelayMs, float delayRangeMs);
/// Set the chorus average delay in number of audio samples
/// The value should be between 0.0f and 1.0f
void setDelayConfig(size_t averageDelayNumSamples, size_t delayRangeNumSamples);
/// Bypass the effect.
/// @param byp when true, bypass wil disable the effect, when false, effect is enabled.
/// Note that audio still passes through when bypass is enabled.
void bypass(bool byp) { m_bypass = byp; }
/// Get if the effect is bypassed
/// @returns true if bypassed, false if not bypassed
bool isBypass() { return m_bypass; }
/// Toggle the bypass effect
void toggleBypass() { m_bypass = !m_bypass; }
/// Set the LFO frequency where 0.0f is MIN and 1.0f is MAX
void rate(float rate);
/// Set the depth of LFO modulation.
/// @param lfoDepth must be a float between 0.0f and 1.0f
void depth(float lfoDepth) { m_lfoDepth = lfoDepth; }
/// Set the amount of blending between dry and wet (echo) at the output.
/// @param mix When 0.0, output is 100% dry, when 1.0, output is 100% wet. When
/// 0.5, output is 50% Dry, 50% Wet.
void mix(float mix) { m_mix = mix; }
/// Set the output volume. This affect both the wet and dry signals.
/// @details The default is 1.0.
/// @param vol Sets the output volume between -1.0 and +1.0
void volume(float vol) {m_volume = vol; }
// ** ENABLE / DISABLE **
/// Enables audio processing. Note: when not enabled, CPU load is nearly zero.
void enable() { m_enable = true; }
/// Disables audio process. When disabled, CPU load is nearly zero.
void disable() { m_enable = false; }
// ** MIDI **
/// Sets whether MIDI OMNI channel is processig on or off. When on,
/// all midi channels are used for matching CCs.
/// @param isOmni when true, all channels are processed, when false, channel
/// must match configured value.
void setMidiOmni(bool isOmni) { m_isOmni = isOmni; }
/// Configure an effect parameter to be controlled by a MIDI CC
/// number on a particular channel.
/// @param parameter one of the parameter names in the class enum
/// @param midiCC the CC number from 0 to 127
/// @param midiChannel the effect will only response to the CC on this channel
/// when OMNI mode is off.
void mapMidiControl(int parameter, int midiCC, int midiChannel = 0);
/// process a MIDI Continous-Controller (CC) message
/// @param channel the MIDI channel from 0 to 15)
/// @param midiCC the CC number from 0 to 127
/// @param value the CC value from 0 to 127
void processMidi(int channel, int midiCC, int value);
// ** FILTER COEFFICIENTS **
/// Set the filter coefficients to one of the presets. See AudioEffectAnalogChorus::Filter
/// for options.
/// @details See AudioEffectAnalogChorusFIlters.h for more details.
/// @param filter the preset filter. E.g. AudioEffectAnalogChorus::Filter::WARM
void setFilter(Filter filter);
/// Override the default coefficients with your own. The number of filters stages affects how
/// much CPU is consumed.
/// @details The effect uses the CMSIS-DSP library for biquads which requires coefficents.
/// be in q31 format, which means they are 32-bit signed integers representing -1.0 to slightly
/// less than +1.0. The coeffShift parameter effectively multiplies the coefficients by 2^shift. <br>
/// Example: If you really want +1.5, must instead use +0.75 * 2^1, thus 0.75 in q31 format is
/// (0.75 * 2^31) = 1610612736 and coeffShift = 1.
/// @param numStages the actual number of filter stages you want to use. Must be <= MAX_NUM_FILTER_STAGES.
/// @param coeffs pointer to an integer array of coefficients in q31 format.
/// @param coeffShift Coefficient scaling factor = 2^coeffShift.
void setFilterCoeffs(int numStages, const int32_t *coeffs, int coeffShift);
virtual void update(void); ///< update automatically called by the Teesny Audio Library
private:
static constexpr float m_DEFAULT_DELAY_MS = 20.0f; ///< default average delay of chorus in milliseconds
static constexpr float m_DELAY_RANGE = 15.0f; ///< default range of delay variation in milliseconds
static constexpr float m_LFO_MIN_RATE = 2.0f; ///< slowest possible LFO rate in milliseconds
static constexpr float m_LFO_RANGE = 8.0f; ///< fastest possible LFO rate in milliseconds
audio_block_t *m_inputQueueArray[1];
bool m_isOmni = false;
bool m_bypass = true;
bool m_enable = false;
bool m_externalMemory = false;
BALibrary::AudioDelay *m_memory = nullptr;
BALibrary::LowFrequencyOscillatorVector<float> m_lfo;
size_t m_maxDelaySamples = 0;
audio_block_t *m_previousBlock = nullptr;
audio_block_t *m_blockToRelease = nullptr;
BALibrary::IirBiQuadFilterHQ *m_iir = nullptr;
// Controls
int m_midiConfig[NUM_CONTROLS][2]; // stores the midi parameter mapping
size_t m_delaySamples = 0;
float m_lfoDepth = 0.0f;
float m_mix = 0.0f;
float m_volume = 1.0f;
void m_preProcessing(audio_block_t *out, audio_block_t *dry, audio_block_t *wet);
void m_postProcessing(audio_block_t *out, audio_block_t *dry, audio_block_t *wet);
// Coefficients
void m_constructFilter(void);
};
}
#endif /* __BAEFFECTS_BAAUDIOEFFECTAnalogChorus_H */

1
src/BAEffects.h
Unescape View File

@ -26,5 +26,6 @@
#include "AudioEffectAnalogDelay.h" #include "AudioEffectAnalogDelay.h"
#include "AudioEffectSOS.h" #include "AudioEffectSOS.h"
#include "AudioEffectTremolo.h" #include "AudioEffectTremolo.h"
#include "AudioEffectAnalogChorus.h"
#endif /* __BAEFFECTS_H */ #endif /* __BAEFFECTS_H */

172
src/effects/AudioEffectAnalogDelay.cpp.interpolated → src/effects/AudioEffectAnalogChorus.cpp
Unescape View File

@ -1,40 +1,32 @@
/* /*
* AudioEffectAnalogDelay.cpp * AudioEffectAnalogChorus.cpp
* *
* Created on: Jan 7, 2018 * Created on: Jan 7, 2018
* Author: slascos * Author: slascos
*/ */
#include <new> #include <new>
#include "AudioEffectAnalogDelayFilters.h" #include "AudioEffectAnalogChorusFilters.h"
#include "AudioEffectAnalogDelay.h" #include "AudioEffectAnalogChorus.h"
using namespace BALibrary; using namespace BALibrary;
#define INTERPOLATED_DELAY Uncomment this line to test the inteprolated delay which adds 1/10th of a sample //#define INTERPOLATED_DELAY Uncomment this line to test the inteprolated delay which adds 1/10th of a sample
namespace BAEffects { namespace BAEffects {
constexpr int MIDI_CHANNEL = 0; constexpr int MIDI_CHANNEL = 0;
constexpr int MIDI_CONTROL = 1; constexpr int MIDI_CONTROL = 1;
AudioEffectAnalogDelay::AudioEffectAnalogDelay(float maxDelayMs) AudioEffectAnalogChorus::AudioEffectAnalogChorus()
: AudioStream(1, m_inputQueueArray) : AudioStream(1, m_inputQueueArray)
{ {
m_memory = new AudioDelay(maxDelayMs); m_memory = new AudioDelay(m_DEFAULT_DELAY_MS + m_DELAY_RANGE);
m_maxDelaySamples = calcAudioSamples(maxDelayMs); m_maxDelaySamples = calcAudioSamples(m_DEFAULT_DELAY_MS + m_DELAY_RANGE);
m_constructFilter();
}
AudioEffectAnalogDelay::AudioEffectAnalogDelay(size_t numSamples)
: AudioStream(1, m_inputQueueArray)
{
m_memory = new AudioDelay(numSamples);
m_maxDelaySamples = numSamples;
m_constructFilter(); m_constructFilter();
} }
// requires preallocated memory large enough // requires preallocated memory large enough
AudioEffectAnalogDelay::AudioEffectAnalogDelay(ExtMemSlot *slot) AudioEffectAnalogChorus::AudioEffectAnalogChorus(ExtMemSlot *slot)
: AudioStream(1, m_inputQueueArray) : AudioStream(1, m_inputQueueArray)
{ {
m_memory = new AudioDelay(slot); m_memory = new AudioDelay(slot);
@ -43,25 +35,25 @@ AudioEffectAnalogDelay::AudioEffectAnalogDelay(ExtMemSlot *slot)
m_constructFilter(); m_constructFilter();
} }
AudioEffectAnalogDelay::~AudioEffectAnalogDelay() AudioEffectAnalogChorus::~AudioEffectAnalogChorus()
{ {
if (m_memory) delete m_memory; if (m_memory) delete m_memory;
if (m_iir) delete m_iir; if (m_iir) delete m_iir;
} }
// This function just sets up the default filter and coefficients // This function just sets up the default filter and coefficients
void AudioEffectAnalogDelay::m_constructFilter(void) void AudioEffectAnalogChorus::m_constructFilter(void)
{ {
// Use DM3 coefficients by default // Use CE2 coefficients by default
m_iir = new IirBiQuadFilterHQ(DM3_NUM_STAGES, reinterpret_cast<const int32_t *>(&DM3), DM3_COEFF_SHIFT); m_iir = new IirBiQuadFilterHQ(CE2_NUM_STAGES, reinterpret_cast<const int32_t *>(&CE2), CE2_COEFF_SHIFT);
} }
void AudioEffectAnalogDelay::setFilterCoeffs(int numStages, const int32_t *coeffs, int coeffShift) void AudioEffectAnalogChorus::setFilterCoeffs(int numStages, const int32_t *coeffs, int coeffShift)
{ {
m_iir->changeFilterCoeffs(numStages, coeffs, coeffShift); m_iir->changeFilterCoeffs(numStages, coeffs, coeffShift);
} }
void AudioEffectAnalogDelay::setFilter(Filter filter) void AudioEffectAnalogChorus::setFilter(Filter filter)
{ {
switch(filter) { switch(filter) {
case Filter::WARM : case Filter::WARM :
@ -70,14 +62,14 @@ void AudioEffectAnalogDelay::setFilter(Filter filter)
case Filter::DARK : case Filter::DARK :
m_iir->changeFilterCoeffs(DARK_NUM_STAGES, reinterpret_cast<const int32_t *>(&DARK), DARK_COEFF_SHIFT); m_iir->changeFilterCoeffs(DARK_NUM_STAGES, reinterpret_cast<const int32_t *>(&DARK), DARK_COEFF_SHIFT);
break; break;
case Filter::DM3 : case Filter::CE2 :
default: default:
m_iir->changeFilterCoeffs(DM3_NUM_STAGES, reinterpret_cast<const int32_t *>(&DM3), DM3_COEFF_SHIFT); m_iir->changeFilterCoeffs(CE2_NUM_STAGES, reinterpret_cast<const int32_t *>(&CE2), CE2_COEFF_SHIFT);
break; break;
} }
} }
void AudioEffectAnalogDelay::update(void) void AudioEffectAnalogChorus::update(void)
{ {
audio_block_t *inputAudioBlock = receiveReadOnly(); // get the next block of input samples audio_block_t *inputAudioBlock = receiveReadOnly(); // get the next block of input samples
@ -179,9 +171,36 @@ void AudioEffectAnalogDelay::update(void)
m_blockToRelease = blockToRelease; m_blockToRelease = blockToRelease;
} }
void AudioEffectAnalogDelay::delay(float milliseconds) void AudioEffectAnalogChorus::m_preProcessing(audio_block_t *out, audio_block_t *dry, audio_block_t *wet)
{
memcpy(out->data, dry->data, sizeof(int16_t) * AUDIO_BLOCK_SAMPLES);
// if ( out && dry && wet) {
// alphaBlend(out, dry, wet, m_feedback);
// m_iir->process(out->data, out->data, AUDIO_BLOCK_SAMPLES);
// } else if (dry) {
// memcpy(out->data, dry->data, sizeof(int16_t) * AUDIO_BLOCK_SAMPLES);
// }
}
void AudioEffectAnalogChorus::m_postProcessing(audio_block_t *out, audio_block_t *dry, audio_block_t *wet)
{
if (!out) return; // no valid output buffer
if ( out && dry && wet) {
// Simulate the LPF IIR nature of the analog systems
//m_iir->process(wet->data, wet->data, AUDIO_BLOCK_SAMPLES);
alphaBlend(out, dry, wet, m_mix);
} else if (dry) {
memcpy(out->data, dry->data, sizeof(int16_t) * AUDIO_BLOCK_SAMPLES);
}
// Set the output volume
gainAdjust(out, out, m_volume, 1);
}
void AudioEffectAnalogChorus::setDelayConfig(float averageDelayMs, float delayRangeMs)
{ {
size_t delaySamples = calcAudioSamples(milliseconds); size_t delaySamples = calcAudioSamples(averageDelayMs + delayRangeMs);
if (delaySamples > m_memory->getMaxDelaySamples()) { if (delaySamples > m_memory->getMaxDelaySamples()) {
// this exceeds max delay value, limit it. // this exceeds max delay value, limit it.
@ -192,11 +211,9 @@ void AudioEffectAnalogDelay::delay(float milliseconds)
if (!m_externalMemory) { if (!m_externalMemory) {
// internal memory // internal memory
//QueuePosition queuePosition = calcQueuePosition(milliseconds); // Do nothing
//Serial.println(String("CONFIG: delay:") + delaySamples + String(" queue position ") + queuePosition.index + String(":") + queuePosition.offset);
} else { } else {
// external memory // external memory
//Serial.println(String("CONFIG: delay:") + delaySamples);
ExtMemSlot *slot = m_memory->getSlot(); ExtMemSlot *slot = m_memory->getSlot();
if (!slot) { Serial.println("ERROR: slot ptr is not valid"); } if (!slot) { Serial.println("ERROR: slot ptr is not valid"); }
@ -205,32 +222,11 @@ void AudioEffectAnalogDelay::delay(float milliseconds)
Serial.println("WEIRD: slot was not enabled"); Serial.println("WEIRD: slot was not enabled");
} }
} }
m_delaySamples = delaySamples;
} }
void AudioEffectAnalogDelay::delay(size_t delaySamples) void AudioEffectAnalogChorus::setDelayConfig(size_t averageDelayNumSamples, size_t delayRangeNumSamples)
{ {
if (!m_memory) { Serial.println("delay(): m_memory is not valid"); } size_t delaySamples = averageDelayNumSamples + delayRangeNumSamples;
if (!m_externalMemory) {
// internal memory
//QueuePosition queuePosition = calcQueuePosition(delaySamples);
//Serial.println(String("CONFIG: delay:") + delaySamples + String(" queue position ") + queuePosition.index + String(":") + queuePosition.offset);
} else {
// external memory
//Serial.println(String("CONFIG: delay:") + delaySamples);
ExtMemSlot *slot = m_memory->getSlot();
if (!slot->isEnabled()) {
slot->enable();
}
}
m_delaySamples = delaySamples;
}
void AudioEffectAnalogDelay::delayFractionMax(float delayFraction)
{
size_t delaySamples = static_cast<size_t>(static_cast<float>(m_memory->getMaxDelaySamples()) * delayFraction);
if (delaySamples > m_memory->getMaxDelaySamples()) { if (delaySamples > m_memory->getMaxDelaySamples()) {
// this exceeds max delay value, limit it. // this exceeds max delay value, limit it.
@ -241,82 +237,58 @@ void AudioEffectAnalogDelay::delayFractionMax(float delayFraction)
if (!m_externalMemory) { if (!m_externalMemory) {
// internal memory // internal memory
//QueuePosition queuePosition = calcQueuePosition(delaySamples); // Do nothing
//Serial.println(String("CONFIG: delay:") + delaySamples + String(" queue position ") + queuePosition.index + String(":") + queuePosition.offset);
} else { } else {
// external memory // external memory
//Serial.println(String("CONFIG: delay:") + delaySamples);
ExtMemSlot *slot = m_memory->getSlot(); ExtMemSlot *slot = m_memory->getSlot();
if (!slot) { Serial.println("ERROR: slot ptr is not valid"); }
if (!slot->isEnabled()) { if (!slot->isEnabled()) {
slot->enable(); slot->enable();
Serial.println("WEIRD: slot was not enabled");
} }
} }
m_delaySamples = delaySamples;
} }
void AudioEffectAnalogDelay::m_preProcessing(audio_block_t *out, audio_block_t *dry, audio_block_t *wet) void AudioEffectAnalogChorus::rate(float rate)
{ {
if ( out && dry && wet) { // update the LFO by mapping the rate into the MIN/MAX range, pass to LFO in milliseconds
alphaBlend(out, dry, wet, m_feedback); m_lfo.setRateAudio(m_LFO_MIN_RATE + (rate * m_LFO_RANGE));
m_iir->process(out->data, out->data, AUDIO_BLOCK_SAMPLES);
} else if (dry) {
memcpy(out->data, dry->data, sizeof(int16_t) * AUDIO_BLOCK_SAMPLES);
}
} }
void AudioEffectAnalogDelay::m_postProcessing(audio_block_t *out, audio_block_t *dry, audio_block_t *wet) void AudioEffectAnalogChorus::processMidi(int channel, int control, int value)
{
if (!out) return; // no valid output buffer
if ( out && dry && wet) {
// Simulate the LPF IIR nature of the analog systems
//m_iir->process(wet->data, wet->data, AUDIO_BLOCK_SAMPLES);
alphaBlend(out, dry, wet, m_mix);
} else if (dry) {
memcpy(out->data, dry->data, sizeof(int16_t) * AUDIO_BLOCK_SAMPLES);
}
// Set the output volume
gainAdjust(out, out, m_volume, 1);
}
void AudioEffectAnalogDelay::processMidi(int channel, int control, int value)
{ {
float val = (float)value / 127.0f; float val = (float)value / 127.0f;
if ((m_midiConfig[DELAY][MIDI_CHANNEL] == channel) && if ((m_midiConfig[RATE][MIDI_CHANNEL] == channel) &&
(m_midiConfig[DELAY][MIDI_CONTROL] == control)) { (m_midiConfig[RATE][MIDI_CONTROL] == control)) {
// Delay // Rate
if (m_externalMemory) { m_maxDelaySamples = m_memory->getSlot()->size() / sizeof(int16_t); } Serial.println(String("AudioEffectAnalogChorus::rate: ") + 100*val + String("%"));
size_t delayVal = (size_t)(val * (float)m_maxDelaySamples); rate(val);
delay(delayVal);
Serial.println(String("AudioEffectAnalogDelay::delay (ms): ") + calcAudioTimeMs(delayVal)
+ String(" (samples): ") + delayVal + String(" out of ") + m_maxDelaySamples);
return; return;
} }
if ((m_midiConfig[BYPASS][MIDI_CHANNEL] == channel) && if ((m_midiConfig[BYPASS][MIDI_CHANNEL] == channel) &&
(m_midiConfig[BYPASS][MIDI_CONTROL] == control)) { (m_midiConfig[BYPASS][MIDI_CONTROL] == control)) {
// Bypass // Bypass
if (value >= 65) { bypass(false); Serial.println(String("AudioEffectAnalogDelay::not bypassed -> ON") + value); } if (value >= 65) { bypass(false); Serial.println(String("AudioEffectAnalogChorus::not bypassed -> ON") + value); }
else { bypass(true); Serial.println(String("AudioEffectAnalogDelay::bypassed -> OFF") + value); } else { bypass(true); Serial.println(String("AudioEffectAnalogChorus::bypassed -> OFF") + value); }
return; return;
} }
if ((m_midiConfig[FEEDBACK][MIDI_CHANNEL] == channel) && if ((m_midiConfig[DEPTH][MIDI_CHANNEL] == channel) &&
(m_midiConfig[FEEDBACK][MIDI_CONTROL] == control)) { (m_midiConfig[DEPTH][MIDI_CONTROL] == control)) {
// Feedback // depth
Serial.println(String("AudioEffectAnalogDelay::feedback: ") + 100*val + String("%")); Serial.println(String("AudioEffectAnalogChorus::depth: ") + 100*val + String("%"));
feedback(val); depth(val);
return; return;
} }
if ((m_midiConfig[MIX][MIDI_CHANNEL] == channel) && if ((m_midiConfig[MIX][MIDI_CHANNEL] == channel) &&
(m_midiConfig[MIX][MIDI_CONTROL] == control)) { (m_midiConfig[MIX][MIDI_CONTROL] == control)) {
// Mix // Mix
Serial.println(String("AudioEffectAnalogDelay::mix: Dry: ") + 100*(1-val) + String("% Wet: ") + 100*val ); Serial.println(String("AudioEffectAnalogChorus::mix: Dry: ") + 100*(1-val) + String("% Wet: ") + 100*val );
mix(val); mix(val);
return; return;
} }
@ -324,14 +296,14 @@ void AudioEffectAnalogDelay::processMidi(int channel, int control, int value)
if ((m_midiConfig[VOLUME][MIDI_CHANNEL] == channel) && if ((m_midiConfig[VOLUME][MIDI_CHANNEL] == channel) &&
(m_midiConfig[VOLUME][MIDI_CONTROL] == control)) { (m_midiConfig[VOLUME][MIDI_CONTROL] == control)) {
// Volume // Volume
Serial.println(String("AudioEffectAnalogDelay::volume: ") + 100*val + String("%")); Serial.println(String("AudioEffectAnalogChorus::volume: ") + 100*val + String("%"));
volume(val); volume(val);
return; return;
} }
} }
void AudioEffectAnalogDelay::mapMidiControl(int parameter, int midiCC, int midiChannel) void AudioEffectAnalogChorus::mapMidiControl(int parameter, int midiCC, int midiChannel)
{ {
if (parameter >= NUM_CONTROLS) { if (parameter >= NUM_CONTROLS) {
return ; // Invalid midi parameter return ; // Invalid midi parameter

83
src/effects/AudioEffectAnalogChorusFilters.h
Unescape View File

@ -0,0 +1,83 @@
/**************************************************************************//**
* @file
* @author Steve Lascos
* @company Blackaddr Audio
*
* This file constains precomputed co-efficients for the AudioEffectAnalogChorus
* class.
*
* @copyright This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.*
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*****************************************************************************/
#include <cstdint>
namespace BAEffects {
// The number of stages in the analog-response Biquad filter
constexpr unsigned MAX_NUM_FILTER_STAGES = 4;
constexpr unsigned NUM_COEFFS_PER_STAGE = 5;
// Matlab/Octave can be helpful to design a filter. Once you have the IIR filter (bz,az) coefficients
// in the z-domain, they can be converted to second-order-sections. AudioEffectAnalogChorus is designed
// to accept up to a maximum of an 8th order filter, broken into four, 2nd order stages.
//
// Second order sections can be created with:
// [sos] = tf2sos(bz,az);
// The results coefficents must be converted the Q31 format required by the ARM CMSIS-DSP library. This means
// all coefficients must lie between -1.0 and +0.9999. If your (bz,az) coefficients exceed this, you must divide
// them down by a power of 2. For example, if your largest magnitude coefficient is -3.5, you must divide by
// 2^shift where 4=2^2 and thus shift = 2. You must then mutliply by 2^31 to get a 32-bit signed integer value
// that represents the required Q31 coefficient.
// BOSS DM-3 Filters
// b(z) = 1.0e-03 * (0.0032 0.0257 0.0900 0.1800 0.2250 0.1800 0.0900 0.0257 0.0032)
// a(z) = 1.0000 -5.7677 14.6935 -21.3811 19.1491 -10.5202 3.2584 -0.4244 -0.0067
constexpr unsigned CE2_NUM_STAGES = 4;
constexpr unsigned CE2_COEFF_SHIFT = 2;
constexpr int32_t CE2[5*MAX_NUM_FILTER_STAGES] = {
536870912, 988616936, 455608573, 834606945, -482959709,
536870912, 1031466345, 498793368, 965834205, -467402235,
536870912, 1105821939, 573646688, 928470657, -448083489,
2339, 5093, 2776, 302068995, 4412722
};
// Blackaddr WARM Filter
// Butterworth, 8th order, cutoff = 2000 Hz
// Matlab/Octave command: [bz, az] = butter(8, 2000/44100/2);
// b(z) = 1.0e-05 * (0.0086 0.0689 0.2411 0.4821 0.6027 0.4821 0.2411 0.0689 0.0086_
// a(z) = 1.0000 -6.5399 18.8246 -31.1340 32.3473 -21.6114 9.0643 -2.1815 0.2306
constexpr unsigned WARM_NUM_STAGES = 4;
constexpr unsigned WARM_COEFF_SHIFT = 2;
constexpr int32_t WARM[5*MAX_NUM_FILTER_STAGES] = {
536870912,1060309346,523602393,976869875,-481046241,
536870912,1073413910,536711084,891250612,-391829326,
536870912,1087173998,550475248,835222426,-333446881,
46,92,46,807741349,-304811072
};
// Blackaddr DARK Filter
// Chebychev Type II, 8th order, stopband = 60db, cutoff = 1000 Hz
// Matlab command: [bz, az] = cheby2(8, 60, 1000/44100/2);
// b(z) = 0.0009 -0.0066 0.0219 -0.0423 0.0522 -0.0423 0.0219 -0.0066 0.0009
// a(z) = 1.0000 -7.4618 24.3762 -45.5356 53.1991 -39.8032 18.6245 -4.9829 0.5836
constexpr unsigned DARK_NUM_STAGES = 4;
constexpr unsigned DARK_COEFF_SHIFT = 1;
constexpr int32_t DARK[5*MAX_NUM_FILTER_STAGES] = {
1073741824,-2124867808,1073741824,2107780229,-1043948409,
1073741824,-2116080466,1073741824,2042553796,-979786242,
1073741824,-2077777790,1073741824,1964779896,-904264933,
957356,-1462833,957356,1896884898,-838694612
};
};
Write Preview
Loading…
Cancel
Save