Feature/interpolating delay (#3)

* Added intepolated delay capability to AudioDelay class

* renamed testing verision of AudioEffectAnalogDelay.cpp

examples/Tests/TGA_PRO_MEM2_EXP/TGA_PRO_MEM2_EXP.ino

@@ -85,6 +85,7 @@ unsigned loopCounter = 0;
 
 void setup() {
   Serial.begin(57600);
+  delay(500);
 
   // Disable the audio codec first
   codec.disable();

src/LibBasicFunctions.h

@@ -168,6 +168,9 @@ public:
     /// @param numSamples default value is AUDIO_BLOCK_SAMPLES, so typically you don't have to specify this parameter.
     /// @returns true on success, false on error.
     bool getSamples(audio_block_t *dest, size_t offsetSamples, size_t numSamples = AUDIO_BLOCK_SAMPLES);
+    bool getSamples(int16_t *dest, size_t offsetSamples, size_t numSamples);
+
+    bool interpolateDelay(int16_t *extendedSourceBuffer, int16_t *destBuffer, float fraction, size_t numSamples = AUDIO_BLOCK_SAMPLES);
 
     /// When using EXTERNAL memory, this function can return a pointer to the underlying ExtMemSlot object associated
     /// with the buffer.
@@ -193,6 +196,7 @@ private:
     RingBuffer<audio_block_t *> *m_ringBuffer = nullptr; ///< When using INTERNAL memory, a RingBuffer will be created.
     ExtMemSlot *m_slot = nullptr;                        ///< When using EXTERNAL memory, an ExtMemSlot must be provided.
     size_t m_maxDelaySamples = 0;                        ///< stores the number of audio samples in the AudioDelay.
+    bool m_getSamples(int16_t *dest, size_t offsetSamples, size_t numSamples); ///< operates directly on int16_y buffers
 };
 
 /**************************************************************************//**

src/common/AudioDelay.cpp

@@ -17,6 +17,7 @@
  *  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 <cmath>
 
 #include "Audio.h"
 #include "LibBasicFunctions.h"
@@ -105,6 +106,16 @@ size_t AudioDelay::getMaxDelaySamples()
 }
 
 bool AudioDelay::getSamples(audio_block_t *dest, size_t offsetSamples, size_t numSamples)
+{
+	return m_getSamples(dest->data, offsetSamples, numSamples);
+}
+
+bool AudioDelay::getSamples(int16_t *dest, size_t offsetSamples, size_t numSamples)
+{
+	return m_getSamples(dest, offsetSamples, numSamples);
+}
+
+bool AudioDelay::m_getSamples(int16_t *dest, size_t offsetSamples, size_t numSamples)
 {
 	if (!dest) {
 		Serial.println("getSamples(): dest is invalid");
@@ -120,53 +131,56 @@ bool AudioDelay::getSamples(audio_block_t *dest, size_t offsetSamples, size_t nu
 		audio_block_t *currentQueue1 = m_ringBuffer->at(m_ringBuffer->get_index_from_back(index+1));
 
 		// check if either queue is invalid, if so just zero the destination buffer
-		if ( (!currentQueue0) || (!currentQueue0) ) {
+		if ( (!currentQueue0) || (!currentQueue1) ) {
 			// a valid entry is not in all queue positions while it is filling, use zeros
-			memset(static_cast<void*>(dest->data), 0, numSamples * sizeof(int16_t));
+			memset(static_cast<void*>(dest), 0, numSamples * sizeof(int16_t));
 			return true;
 		}
 
-		if (position.offset == 0) {
+		if ( (position.offset == 0) && numSamples <= AUDIO_BLOCK_SAMPLES ) {
 			// single transfer
-			memcpy(static_cast<void*>(dest->data), static_cast<void*>(currentQueue0->data), numSamples * sizeof(int16_t));
+			memcpy(static_cast<void*>(dest), static_cast<void*>(currentQueue0->data), numSamples * sizeof(int16_t));
 			return true;
 		}
 
 		// Otherwise we need to break the transfer into two memcpy because it will go across two source queues.
 		// Audio is stored in reverse order. That means the first sample (in time) goes in the last location in the audio block.
-		int16_t *destStart = dest->data;
+		int16_t *destStart = dest;
 		int16_t *srcStart;
 
 		// Break the transfer into two. Copy the 'older' data first then the 'newer' data with respect to current time.
-		//currentQueue = m_ringBuffer->at(m_ringBuffer->get_index_from_back(index+1)); // The latest buffer is at the back. We need index+1 counting from the back.
+		// TODO: should AUDIO_BLOCK_SAMPLES on the next line be numSamples?
 		srcStart  = (currentQueue1->data + AUDIO_BLOCK_SAMPLES - position.offset);
 		size_t numData = position.offset;
 		memcpy(static_cast<void*>(destStart), static_cast<void*>(srcStart), numData * sizeof(int16_t));
 
-		//currentQueue = m_ringBuffer->at(m_ringBuffer->get_index_from_back(index)); // now grab the queue where the 'first' data sample was
 		destStart += numData; // we already wrote numData so advance by this much.
 		srcStart  = (currentQueue0->data);
-		numData = AUDIO_BLOCK_SAMPLES - numData;
+		numData = numSamples - numData;
 		memcpy(static_cast<void*>(destStart), static_cast<void*>(srcStart), numData * sizeof(int16_t));
 
 		return true;
 
 	} else {
 		// EXTERNAL Memory
-		if (numSamples*sizeof(int16_t) <= m_slot->size() ) {
+		if (numSamples*sizeof(int16_t) <= m_slot->size() ) { // check for overflow
-			int currentPositionBytes = (int)m_slot->getWritePosition() - (int)(AUDIO_BLOCK_SAMPLES*sizeof(int16_t));
+			// current position is considered the write position subtracted by the number of samples we're going
+			// to read since this is the smallest delay we can get without reading past the write position into
+			// the "future".
+			int currentPositionBytes = (int)m_slot->getWritePosition() - (int)(numSamples*sizeof(int16_t));
 			size_t offsetBytes = offsetSamples * sizeof(int16_t);
 
 			if ((int)offsetBytes <= currentPositionBytes) {
+				// when we back up to read, we won't wrap over the beginning of the slot
 				m_slot->setReadPosition(currentPositionBytes - offsetBytes);
 			} else {
-				// It's going to wrap around to the end of the slot
+				// It's going to wrap around to the from the beginning to the end of the slot.
 				int readPosition = (int)m_slot->size() + currentPositionBytes - offsetBytes;
 				m_slot->setReadPosition((size_t)readPosition);
 			}
 
-			// This causes pops
+			// Read the number of samples
-			m_slot->readAdvance16(dest->data, AUDIO_BLOCK_SAMPLES);
+			m_slot->readAdvance16(dest, numSamples);
 
 			return true;
 		} else {
@@ -179,5 +193,18 @@ bool AudioDelay::getSamples(audio_block_t *dest, size_t offsetSamples, size_t nu
 
 }
 
+bool AudioDelay::interpolateDelay(int16_t *extendedSourceBuffer, int16_t *destBuffer, float fraction, size_t numSamples)
+{
+	int16_t frac1 = static_cast<int16_t>(32767.0f * fraction);
+	int16_t frac2 = 32767 - frac1;
+
+	// TODO optimize this later
+	for (int i=0; i<numSamples; i++) {
+		destBuffer[i] =  ((frac1*extendedSourceBuffer[i]) >> 16) +  ((frac2*extendedSourceBuffer[i+1]) >> 16);
+	}
+	return true;
+}
+
+
 }
 

src/effects/AudioEffectAnalogDelay.cpp

@@ -154,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;
 }

src/effects/AudioEffectAnalogDelay.cpp.interpolated

@@ -0,0 +1,345 @@
+/*
+ * AudioEffectAnalogDelay.cpp
+ *
+ *  Created on: Jan 7, 2018
+ *      Author: slascos
+ */
+#include <new>
+#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<const int32_t *>(&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<const int32_t *>(&WARM), WARM_COEFF_SHIFT);
+		break;
+	case Filter::DARK :
+		m_iir->changeFilterCoeffs(DARK_NUM_STAGES, reinterpret_cast<const int32_t *>(&DARK), DARK_COEFF_SHIFT);
+		break;
+	case Filter::DM3 :
+	default:
+		m_iir->changeFilterCoeffs(DM3_NUM_STAGES, reinterpret_cast<const int32_t *>(&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<size_t>(static_cast<float>(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;
+}
+
+}
+
+