diff --git a/examples/Tests/TGA_PRO_MEM2_EXP/TGA_PRO_MEM2_EXP.ino b/examples/Tests/TGA_PRO_MEM2_EXP/TGA_PRO_MEM2_EXP.ino index 7eed6a0..aacb327 100644 --- a/examples/Tests/TGA_PRO_MEM2_EXP/TGA_PRO_MEM2_EXP.ino +++ b/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(); diff --git a/src/LibBasicFunctions.h b/src/LibBasicFunctions.h index 5022038..0d8eb0c 100644 --- a/src/LibBasicFunctions.h +++ b/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. @@ -192,7 +195,8 @@ private: MemType m_type; ///< when 0, INTERNAL memory, when 1, external MEMORY. RingBuffer *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. + 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 }; /**************************************************************************//** diff --git a/src/common/AudioDelay.cpp b/src/common/AudioDelay.cpp index 9fec4ea..84f4a24 100644 --- a/src/common/AudioDelay.cpp +++ b/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 . */ +#include #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(dest->data), 0, numSamples * sizeof(int16_t)); + memset(static_cast(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(dest->data), static_cast(currentQueue0->data), numSamples * sizeof(int16_t)); + memcpy(static_cast(dest), static_cast(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(destStart), static_cast(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(destStart), static_cast(srcStart), numData * sizeof(int16_t)); return true; } else { // EXTERNAL Memory - if (numSamples*sizeof(int16_t) <= m_slot->size() ) { - int currentPositionBytes = (int)m_slot->getWritePosition() - (int)(AUDIO_BLOCK_SAMPLES*sizeof(int16_t)); + if (numSamples*sizeof(int16_t) <= m_slot->size() ) { // check for overflow + // 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 - m_slot->readAdvance16(dest->data, AUDIO_BLOCK_SAMPLES); + // Read the number of 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(32767.0f * fraction); + int16_t frac2 = 32767 - frac1; + + // TODO optimize this later + for (int i=0; i> 16) + ((frac2*extendedSourceBuffer[i+1]) >> 16); + } + return true; +} + + } diff --git a/src/effects/AudioEffectAnalogDelay.cpp b/src/effects/AudioEffectAnalogDelay.cpp index fa12c15..e51120c 100644 --- a/src/effects/AudioEffectAnalogDelay.cpp +++ b/src/effects/AudioEffectAnalogDelay.cpp @@ -10,6 +10,8 @@ using namespace BALibrary; +#define INTERPOLATED_DELAY + namespace BAEffects { constexpr int MIDI_CHANNEL = 0; @@ -124,7 +126,13 @@ 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 @@ -146,6 +154,13 @@ 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);