From a9b0c03569a534a0745536452eea017c71f0e7b7 Mon Sep 17 00:00:00 2001 From: Steve Lascos Date: Sat, 19 Jan 2019 08:19:50 -0500 Subject: [PATCH] renamed testing verision of AudioEffectAnalogDelay.cpp --- src/effects/AudioEffectAnalogDelay.cpp | 21 -- .../AudioEffectAnalogDelay.cpp.interpolated | 345 ++++++++++++++++++ 2 files changed, 345 insertions(+), 21 deletions(-) create mode 100644 src/effects/AudioEffectAnalogDelay.cpp.interpolated diff --git a/src/effects/AudioEffectAnalogDelay.cpp b/src/effects/AudioEffectAnalogDelay.cpp index e51120c..f64f172 100644 --- a/src/effects/AudioEffectAnalogDelay.cpp +++ b/src/effects/AudioEffectAnalogDelay.cpp @@ -10,8 +10,6 @@ using namespace BALibrary; -#define INTERPOLATED_DELAY - namespace BAEffects { constexpr int MIDI_CHANNEL = 0; @@ -126,13 +124,7 @@ void AudioEffectAnalogDelay::update(void) // get the data. If using external memory with DMA, this won't be filled until // later. -#ifdef INTERPOLATED_DELAY - int16_t extendedBuffer[AUDIO_BLOCK_SAMPLES+1]; // need one more sample for intepolating between 128th and 129th (last sample) - m_memory->getSamples(extendedBuffer, m_delaySamples, AUDIO_BLOCK_SAMPLES+1); -#else m_memory->getSamples(blockToOutput, m_delaySamples); -#endif - // If using DMA, we need something else to do while that read executes, so // move on to input preprocessing @@ -154,13 +146,6 @@ void AudioEffectAnalogDelay::update(void) while (m_memory->getSlot()->isReadBusy()) {} } -#ifdef INTERPOLATED_DELAY - // TODO: partial delay testing - // extendedBuffer is oversized - //memcpy(blockToOutput->data, &extendedBuffer[1], sizeof(int16_t)*AUDIO_BLOCK_SAMPLES); - m_memory->interpolateDelay(extendedBuffer, blockToOutput->data, 0.1f, AUDIO_BLOCK_SAMPLES); -#endif - // perform the wet/dry mix mix m_postProcessing(blockToOutput, inputAudioBlock, blockToOutput); transmit(blockToOutput); @@ -169,12 +154,6 @@ void AudioEffectAnalogDelay::update(void) release(m_previousBlock); m_previousBlock = blockToOutput; -// if (m_externalMemory && m_memory->getSlot()->isUseDma()) { -// // Using DMA -// if (m_blockToRelease) release(m_blockToRelease); -// m_blockToRelease = blockToRelease; -// } - if (m_blockToRelease) release(m_blockToRelease); m_blockToRelease = blockToRelease; } diff --git a/src/effects/AudioEffectAnalogDelay.cpp.interpolated b/src/effects/AudioEffectAnalogDelay.cpp.interpolated new file mode 100644 index 0000000..b5d41cb --- /dev/null +++ b/src/effects/AudioEffectAnalogDelay.cpp.interpolated @@ -0,0 +1,345 @@ +/* + * AudioEffectAnalogDelay.cpp + * + * Created on: Jan 7, 2018 + * Author: slascos + */ +#include +#include "AudioEffectAnalogDelayFilters.h" +#include "AudioEffectAnalogDelay.h" + +using namespace BALibrary; + +#define INTERPOLATED_DELAY Uncomment this line to test the inteprolated delay which adds 1/10th of a sample + +namespace BAEffects { + +constexpr int MIDI_CHANNEL = 0; +constexpr int MIDI_CONTROL = 1; + +AudioEffectAnalogDelay::AudioEffectAnalogDelay(float maxDelayMs) +: AudioStream(1, m_inputQueueArray) +{ + m_memory = new AudioDelay(maxDelayMs); + m_maxDelaySamples = calcAudioSamples(maxDelayMs); + m_constructFilter(); +} + +AudioEffectAnalogDelay::AudioEffectAnalogDelay(size_t numSamples) +: AudioStream(1, m_inputQueueArray) +{ + m_memory = new AudioDelay(numSamples); + m_maxDelaySamples = numSamples; + m_constructFilter(); +} + +// requires preallocated memory large enough +AudioEffectAnalogDelay::AudioEffectAnalogDelay(ExtMemSlot *slot) +: AudioStream(1, m_inputQueueArray) +{ + m_memory = new AudioDelay(slot); + m_maxDelaySamples = (slot->size() / sizeof(int16_t)); + m_externalMemory = true; + m_constructFilter(); +} + +AudioEffectAnalogDelay::~AudioEffectAnalogDelay() +{ + if (m_memory) delete m_memory; + if (m_iir) delete m_iir; +} + +// This function just sets up the default filter and coefficients +void AudioEffectAnalogDelay::m_constructFilter(void) +{ + // Use DM3 coefficients by default + m_iir = new IirBiQuadFilterHQ(DM3_NUM_STAGES, reinterpret_cast(&DM3), DM3_COEFF_SHIFT); +} + +void AudioEffectAnalogDelay::setFilterCoeffs(int numStages, const int32_t *coeffs, int coeffShift) +{ + m_iir->changeFilterCoeffs(numStages, coeffs, coeffShift); +} + +void AudioEffectAnalogDelay::setFilter(Filter filter) +{ + switch(filter) { + case Filter::WARM : + m_iir->changeFilterCoeffs(WARM_NUM_STAGES, reinterpret_cast(&WARM), WARM_COEFF_SHIFT); + break; + case Filter::DARK : + m_iir->changeFilterCoeffs(DARK_NUM_STAGES, reinterpret_cast(&DARK), DARK_COEFF_SHIFT); + break; + case Filter::DM3 : + default: + m_iir->changeFilterCoeffs(DM3_NUM_STAGES, reinterpret_cast(&DM3), DM3_COEFF_SHIFT); + break; + } +} + +void AudioEffectAnalogDelay::update(void) +{ + audio_block_t *inputAudioBlock = receiveReadOnly(); // get the next block of input samples + + // Check is block is disabled + if (m_enable == false) { + // do not transmit or process any audio, return as quickly as possible. + if (inputAudioBlock) release(inputAudioBlock); + + // release all held memory resources + if (m_previousBlock) { + release(m_previousBlock); m_previousBlock = nullptr; + } + if (!m_externalMemory) { + // when using internal memory we have to release all references in the ring buffer + while (m_memory->getRingBuffer()->size() > 0) { + audio_block_t *releaseBlock = m_memory->getRingBuffer()->front(); + m_memory->getRingBuffer()->pop_front(); + if (releaseBlock) release(releaseBlock); + } + } + return; + } + + // Check is block is bypassed, if so either transmit input directly or create silence + if (m_bypass == true) { + // transmit the input directly + if (!inputAudioBlock) { + // create silence + inputAudioBlock = allocate(); + if (!inputAudioBlock) { return; } // failed to allocate + else { + clearAudioBlock(inputAudioBlock); + } + } + transmit(inputAudioBlock, 0); + release(inputAudioBlock); + return; + } + + // Otherwise perform normal processing + // In order to make use of the SPI DMA, we need to request the read from memory first, + // then do other processing while it fills in the back. + audio_block_t *blockToOutput = nullptr; // this will hold the output audio + blockToOutput = allocate(); + if (!blockToOutput) return; // skip this update cycle due to failure + + // get the data. If using external memory with DMA, this won't be filled until + // later. +#ifdef INTERPOLATED_DELAY + int16_t extendedBuffer[AUDIO_BLOCK_SAMPLES+1]; // need one more sample for intepolating between 128th and 129th (last sample) + m_memory->getSamples(extendedBuffer, m_delaySamples, AUDIO_BLOCK_SAMPLES+1); +#else + m_memory->getSamples(blockToOutput, m_delaySamples); +#endif + + + // If using DMA, we need something else to do while that read executes, so + // move on to input preprocessing + + // Preprocessing + audio_block_t *preProcessed = allocate(); + // mix the input with the feedback path in the pre-processing stage + m_preProcessing(preProcessed, inputAudioBlock, m_previousBlock); + + // consider doing the BBD post processing here to use up more time while waiting + // for the read data to come back + audio_block_t *blockToRelease = m_memory->addBlock(preProcessed); + + + // BACK TO OUTPUT PROCESSING + // Check if external DMA, if so, we need to be sure the read is completed + if (m_externalMemory && m_memory->getSlot()->isUseDma()) { + // Using DMA + while (m_memory->getSlot()->isReadBusy()) {} + } + +#ifdef INTERPOLATED_DELAY + // TODO: partial delay testing + // extendedBuffer is oversized + //memcpy(blockToOutput->data, &extendedBuffer[1], sizeof(int16_t)*AUDIO_BLOCK_SAMPLES); + m_memory->interpolateDelay(extendedBuffer, blockToOutput->data, 0.1f, AUDIO_BLOCK_SAMPLES); +#endif + + // perform the wet/dry mix mix + m_postProcessing(blockToOutput, inputAudioBlock, blockToOutput); + transmit(blockToOutput); + + release(inputAudioBlock); + release(m_previousBlock); + m_previousBlock = blockToOutput; + +// if (m_externalMemory && m_memory->getSlot()->isUseDma()) { +// // Using DMA +// if (m_blockToRelease) release(m_blockToRelease); +// m_blockToRelease = blockToRelease; +// } + + if (m_blockToRelease) release(m_blockToRelease); + m_blockToRelease = blockToRelease; +} + +void AudioEffectAnalogDelay::delay(float milliseconds) +{ + size_t delaySamples = calcAudioSamples(milliseconds); + + if (delaySamples > m_memory->getMaxDelaySamples()) { + // this exceeds max delay value, limit it. + delaySamples = m_memory->getMaxDelaySamples(); + } + + if (!m_memory) { Serial.println("delay(): m_memory is not valid"); } + + if (!m_externalMemory) { + // internal memory + //QueuePosition queuePosition = calcQueuePosition(milliseconds); + //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) { Serial.println("ERROR: slot ptr is not valid"); } + if (!slot->isEnabled()) { + slot->enable(); + Serial.println("WEIRD: slot was not enabled"); + } + } + + m_delaySamples = delaySamples; +} + +void AudioEffectAnalogDelay::delay(size_t delaySamples) +{ + if (!m_memory) { Serial.println("delay(): m_memory is not valid"); } + + 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(static_cast(m_memory->getMaxDelaySamples()) * delayFraction); + + if (delaySamples > m_memory->getMaxDelaySamples()) { + // this exceeds max delay value, limit it. + delaySamples = m_memory->getMaxDelaySamples(); + } + + if (!m_memory) { Serial.println("delay(): m_memory is not valid"); } + + 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::m_preProcessing(audio_block_t *out, audio_block_t *dry, audio_block_t *wet) +{ + 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 AudioEffectAnalogDelay::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 AudioEffectAnalogDelay::processMidi(int channel, int control, int value) +{ + + float val = (float)value / 127.0f; + + if ((m_midiConfig[DELAY][MIDI_CHANNEL] == channel) && + (m_midiConfig[DELAY][MIDI_CONTROL] == control)) { + // Delay + if (m_externalMemory) { m_maxDelaySamples = m_memory->getSlot()->size() / sizeof(int16_t); } + size_t delayVal = (size_t)(val * (float)m_maxDelaySamples); + delay(delayVal); + Serial.println(String("AudioEffectAnalogDelay::delay (ms): ") + calcAudioTimeMs(delayVal) + + String(" (samples): ") + delayVal + String(" out of ") + m_maxDelaySamples); + return; + } + + if ((m_midiConfig[BYPASS][MIDI_CHANNEL] == channel) && + (m_midiConfig[BYPASS][MIDI_CONTROL] == control)) { + // Bypass + if (value >= 65) { bypass(false); Serial.println(String("AudioEffectAnalogDelay::not bypassed -> ON") + value); } + else { bypass(true); Serial.println(String("AudioEffectAnalogDelay::bypassed -> OFF") + value); } + return; + } + + if ((m_midiConfig[FEEDBACK][MIDI_CHANNEL] == channel) && + (m_midiConfig[FEEDBACK][MIDI_CONTROL] == control)) { + // Feedback + Serial.println(String("AudioEffectAnalogDelay::feedback: ") + 100*val + String("%")); + feedback(val); + return; + } + + if ((m_midiConfig[MIX][MIDI_CHANNEL] == channel) && + (m_midiConfig[MIX][MIDI_CONTROL] == control)) { + // Mix + Serial.println(String("AudioEffectAnalogDelay::mix: Dry: ") + 100*(1-val) + String("% Wet: ") + 100*val ); + mix(val); + return; + } + + if ((m_midiConfig[VOLUME][MIDI_CHANNEL] == channel) && + (m_midiConfig[VOLUME][MIDI_CONTROL] == control)) { + // Volume + Serial.println(String("AudioEffectAnalogDelay::volume: ") + 100*val + String("%")); + volume(val); + return; + } + +} + +void AudioEffectAnalogDelay::mapMidiControl(int parameter, int midiCC, int midiChannel) +{ + if (parameter >= NUM_CONTROLS) { + return ; // Invalid midi parameter + } + m_midiConfig[parameter][MIDI_CHANNEL] = midiChannel; + m_midiConfig[parameter][MIDI_CONTROL] = midiCC; +} + +} + +