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

Further development

Browse Source
pull/1/head
Steve Lascos 7 years ago
parent d2a8227f91
commit 03da5145b3
5 changed files with 194 additions and 53 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. 101
      src/AudioEffectAnalogDelay.cpp
  2. 4
      src/AudioEffectAnalogDelay.h
  3. 43
      src/LibBasicFunctions.h
  4. 96
      src/LibMemoryManagement.cpp
  5. 3
      src/LibMemoryManagement.h

101
src/AudioEffectAnalogDelay.cpp
Unescape View File

@ -18,6 +18,15 @@ AudioEffectAnalogDelay::AudioEffectAnalogDelay(INTERNAL_MEMORY, float maxDelay)
} }
} }
AudioEffectAnalogDelay::AudioEffectAnalogDelay(INTERNAL_MEMORY, size_t numSamples)
: AudioStream(1, m_inputQueueArray)
{
m_memory = new MemAudioBlock(numSamples);
for (int i=0; i<MAX_DELAY_CHANNELS; i++) {
m_channelOffsets[i] = 0;
}
}
// requires preallocated memory large enough // requires preallocated memory large enough
AudioEffectAnalogDelay::AudioEffectAnalogDelay(EXTERNAL_MEMORY, MemSlot &slot) AudioEffectAnalogDelay::AudioEffectAnalogDelay(EXTERNAL_MEMORY, MemSlot &slot)
: AudioStream(1, m_inputQueueArray) : AudioStream(1, m_inputQueueArray)
@ -31,7 +40,32 @@ AudioEffectAnalogDelay::AudioEffectAnalogDelay(EXTERNAL_MEMORY, MemSlot &slot)
void AudioEffectAnalogDelay::update(void) void AudioEffectAnalogDelay::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 samplestransmit(inputAudioBlock, 0);
if (!inputAudioBlock) {
return;
}
// else {
// transmit(inputAudioBlock, 0);
// release(inputAudioBlock);
// return;
// }
if (m_callCount < 1024) {
if (inputAudioBlock) {
transmit(inputAudioBlock, 0);
release(inputAudioBlock);
}
m_callCount++; return;
}
// else if (m_callCount > 1400) {
// if (inputAudioBlock) release(inputAudioBlock);
// return;
// }
m_callCount++;
Serial.println(String("AudioEffectAnalgDelay::update: ") + m_callCount);
if (m_externalMemory) { if (m_externalMemory) {
// external mem requires an actual write to memory with the new data block // external mem requires an actual write to memory with the new data block
@ -45,13 +79,30 @@ void AudioEffectAnalogDelay::update(void)
} else { } else {
// internal memory only requires updating the queue of audio block pointers. // internal memory only requires updating the queue of audio block pointers.
MemAudioBlock *memory = reinterpret_cast<MemAudioBlock*>(m_memory); MemAudioBlock *memory = reinterpret_cast<MemAudioBlock*>(m_memory);
memory->push(inputAudioBlock); // MemAudioBlock supports nullptrs, no need to check
// check to see if the queue has reached full size yet // check to see if the queue has reached full size yet
if (memory->getNumQueues() > m_numQueues) { //Serial.println(String("memory queues:") + memory->getNumQueues() + String(" m_numQueues:") + m_numQueues);
if (memory->getNumQueues() >= m_numQueues) {
release(memory->pop()); release(memory->pop());
} }
// now push in the newest audio block
//Serial.println(String("push ") + (uint32_t)inputAudioBlock);
memory->push(inputAudioBlock); // MemAudioBlock supports nullptrs, no need to check
//Serial.println("done memory->push()");
// audio_block_t *output = memory->getQueueBack();
// Serial.println("got the output");
// if (output) {
// transmit(output, 0);
// }
// Serial.println("Done transmit");
} }
// return;
//Serial.print("Active channels: "); Serial.print(m_activeChannels, HEX); Serial.println("");
// For each active channel, output the delayed audio // For each active channel, output the delayed audio
audio_block_t *blockToOutput = nullptr; audio_block_t *blockToOutput = nullptr;
@ -62,10 +113,13 @@ void AudioEffectAnalogDelay::update(void)
// internal memory // internal memory
MemAudioBlock *memory = reinterpret_cast<MemAudioBlock*>(m_memory); MemAudioBlock *memory = reinterpret_cast<MemAudioBlock*>(m_memory);
QueuePosition queuePosition = calcQueuePosition(m_channelOffsets[channel]); QueuePosition queuePosition = calcQueuePosition(m_channelOffsets[channel]);
Serial.println(String("Position info: ") + queuePosition.index + " : " + queuePosition.offset);
if (queuePosition.offset == 0) { if (queuePosition.offset == 0) {
// only one queue needs to be read out // only one queue needs to be read out
blockToOutput= memory->getQueue(queuePosition.index); // could be nullptr! //Serial.println(String("Directly sending queue offset ") + queuePosition.index);
transmit(blockToOutput); blockToOutput= memory->getQueueBack(queuePosition.index); // could be nullptr!
if (blockToOutput) transmit(blockToOutput);
continue;
} else { } else {
blockToOutput = allocate(); // allocate if spanning 2 queues blockToOutput = allocate(); // allocate if spanning 2 queues
} }
@ -91,8 +145,43 @@ bool AudioEffectAnalogDelay::delay(unsigned channel, float milliseconds)
if (!m_externalMemory) { if (!m_externalMemory) {
// Internal memory (AudioStream buffers) // Internal memory (AudioStream buffers)
MemAudioBlock *memory = reinterpret_cast<MemAudioBlock*>(m_memory);
QueuePosition queuePosition = calcQueuePosition(milliseconds); QueuePosition queuePosition = calcQueuePosition(milliseconds);
size_t numQueues = queuePosition.index+1; Serial.println(String("CONFIG(") + memory->getMaxSize() + String("): delay: queue position ") + queuePosition.index + String(":") + queuePosition.offset);
// we have to take the queue position and add 1 to get the number of queues. But we need to add one more since this
// is the start of the audio buffer, and the AUDIO_BLOCK_SAMPLES will then flow into the next one, so add 2 overall.
size_t numQueues = queuePosition.index+2;
if (numQueues > m_numQueues)
m_numQueues = numQueues;
} else {
// External memory
if (delaySamples > m_memory->getSize()) {
// error, the external memory is not large enough
return false;
}
}
m_channelOffsets[channel] = delaySamples;
m_activeChannels |= 1<<channel;
return true;
}
bool AudioEffectAnalogDelay::delay(unsigned channel, size_t delaySamples)
{
if (channel > MAX_DELAY_CHANNELS-1) // channel id too high
return false;
if (!m_externalMemory) {
// Internal memory (AudioStream buffers)
MemAudioBlock *memory = reinterpret_cast<MemAudioBlock*>(m_memory);
//QueuePosition queuePosition = calcQueuePosition(milliseconds);
QueuePosition queuePosition = calcQueuePosition(delaySamples);
Serial.println(String("CONFIG(") + memory->getMaxSize() + String("): delay: queue position ") + queuePosition.index + String(":") + queuePosition.offset);
// we have to take the queue position and add 1 to get the number of queues. But we need to add one more since this
// is the start of the audio buffer, and the AUDIO_BLOCK_SAMPLES will then flow into the next one, so add 2 overall.
size_t numQueues = queuePosition.index+2;
if (numQueues > m_numQueues) if (numQueues > m_numQueues)
m_numQueues = numQueues; m_numQueues = numQueues;
} else { } else {

4
src/AudioEffectAnalogDelay.h
Unescape View File

@ -23,11 +23,13 @@ public:
AudioEffectAnalogDelay() = delete; AudioEffectAnalogDelay() = delete;
AudioEffectAnalogDelay(INTERNAL_MEMORY, float maxDelay); AudioEffectAnalogDelay(INTERNAL_MEMORY, float maxDelay);
AudioEffectAnalogDelay(INTERNAL_MEMORY, size_t numSamples);
AudioEffectAnalogDelay(EXTERNAL_MEMORY, MemSlot &slot); // requires sufficiently sized pre-allocated memory AudioEffectAnalogDelay(EXTERNAL_MEMORY, MemSlot &slot); // requires sufficiently sized pre-allocated memory
virtual ~AudioEffectAnalogDelay() {} virtual ~AudioEffectAnalogDelay() {}
virtual void update(void); virtual void update(void);
bool delay(unsigned channel, float milliseconds); bool delay(unsigned channel, float milliseconds);
bool delay(unsigned channel, size_t delaySamples);
void disable(unsigned channel); void disable(unsigned channel);
private: private:
@ -38,6 +40,8 @@ private:
size_t m_numQueues = 0; size_t m_numQueues = 0;
size_t m_channelOffsets[MAX_DELAY_CHANNELS]; size_t m_channelOffsets[MAX_DELAY_CHANNELS];
size_t m_callCount = 0;
}; };
} }

43
src/LibBasicFunctions.h
Unescape View File

@ -24,6 +24,7 @@ public:
RingBuffer() = delete; RingBuffer() = delete;
RingBuffer(const size_t maxSize) : m_maxSize(maxSize) { RingBuffer(const size_t maxSize) : m_maxSize(maxSize) {
m_buffer = new T[maxSize]; m_buffer = new T[maxSize];
//Serial.println(String("New RingBuffer: max size is ") + m_maxSize);
} }
virtual ~RingBuffer(){ virtual ~RingBuffer(){
if (m_buffer) delete [] m_buffer; if (m_buffer) delete [] m_buffer;
@ -31,23 +32,28 @@ public:
int push_back(T element) { int push_back(T element) {
Serial.println(String("RingBuffer::push_back...") + m_head + String(":") + m_tail + String(":") + m_size);
if ( (m_head == m_tail) && (m_size > 0) ) { if ( (m_head == m_tail) && (m_size > 0) ) {
// overflow // overflow
Serial.println("RingBuffer::push_back: overflow"); Serial.println("RingBuffer::push_back: overflow");
while(1) {} // TODO REMOVE
return -1; return -1;
} }
m_buffer[m_head] = element; m_buffer[m_head] = element;
if (m_head < m_maxSize-1) { if (m_head < (m_maxSize-1) ) {
m_head++; m_head++;
} else { } else {
m_head = 0; m_head = 0;
} }
m_size++; m_size++;
//Serial.println(" ...Done push");
return 0; return 0;
} }
int pop_front() { int pop_front() {
if (m_size == 0) { if (m_size == 0) {
// buffer is empty // buffer is empty
Serial.println("RingBuffer::pop_front: buffer is empty\n"); Serial.println("RingBuffer::pop_front: buffer is empty\n");
@ -59,6 +65,7 @@ public:
m_tail = 0; m_tail = 0;
} }
m_size--; m_size--;
Serial.println(String("RingBuffer::pop_front: ") + m_head + String(":") + m_tail + String(":") + m_size);
return 0; return 0;
} }
@ -66,17 +73,41 @@ public:
return m_buffer[m_tail]; return m_buffer[m_tail];
} }
T back() const {
return m_buffer[m_head-1];
}
size_t getBackIndex(size_t offset = 0) const {
// the target at m_head - 1 - offset or m_maxSize + m_head -1 - offset;
size_t idx = (m_maxSize + m_head -1 - offset);
if ( idx >= m_maxSize) {
idx -= m_maxSize;
}
//Serial.println(String("BackIndex is ") + idx + String(" address: ") + (uint32_t)m_buffer[idx] + String(" data: ") + (uint32_t)m_buffer[idx]->data);
// for (int i=0; i<m_maxSize; i++) {
// Serial.println(i + String(":") + (uint32_t)m_buffer[i]->data);
// }
return idx;
}
size_t size() const { size_t size() const {
size_t size = 0; //Serial.println(String("RingBuffer::size: ") + m_head + String(":") + m_tail + String(":") + m_size);
if (m_head == m_tail) { size = 0; } return m_size;
else if (m_head > m_tail) { size = (m_head - m_tail); }
else { size = (m_tail - m_head + 1); }
return size;
} }
size_t getMaxSize() const { return m_maxSize; }
T& operator[] (size_t index) { T& operator[] (size_t index) {
return m_buffer[index]; return m_buffer[index];
} }
void print() const {
for (int idx=0; idx<m_maxSize; idx++) {
Serial.println(idx + String(" address: ") + (uint32_t)m_buffer[idx] + String(" data: ") + (uint32_t)m_buffer[idx]->data);
}
}
private: private:
size_t m_head=0; size_t m_head=0;
size_t m_tail=0; size_t m_tail=0;

96
src/LibMemoryManagment.cpp → src/LibMemoryManagement.cpp
Unescape View File

@ -6,12 +6,10 @@
namespace BAGuitar { namespace BAGuitar {
bool ExternalSramManager::m_configured = false; bool ExternalSramManager::m_configured = false;
MemConfig ExternalSramManager::m_memConfig[BAGuitar::NUM_MEM_SLOTS]; MemConfig ExternalSramManager::m_memConfig[BAGuitar::NUM_MEM_SLOTS];
inline size_t calcAudioSamples(float milliseconds) size_t calcAudioSamples(float milliseconds)
{ {
return (size_t)((milliseconds*(AUDIO_SAMPLE_RATE_EXACT/1000.0f))+0.5f); return (size_t)((milliseconds*(AUDIO_SAMPLE_RATE_EXACT/1000.0f))+0.5f);
} }
@ -42,7 +40,7 @@ size_t calcOffset(QueuePosition position)
// MEM VIRTUAL // MEM VIRTUAL
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
MemAudioBlock::MemAudioBlock(size_t numSamples) MemAudioBlock::MemAudioBlock(size_t numSamples)
: m_queues((numSamples + AUDIO_BLOCK_SAMPLES - 1)/AUDIO_BLOCK_SAMPLES) : m_queues(((numSamples + AUDIO_BLOCK_SAMPLES - 1)/AUDIO_BLOCK_SAMPLES) +1)
{ {
// // round up to an integer multiple of AUDIO_BLOCK_SAMPLES // // round up to an integer multiple of AUDIO_BLOCK_SAMPLES
// int numQueues = (numSamples + AUDIO_BLOCK_SAMPLES - 1)/AUDIO_BLOCK_SAMPLES; // int numQueues = (numSamples + AUDIO_BLOCK_SAMPLES - 1)/AUDIO_BLOCK_SAMPLES;
@ -63,14 +61,28 @@ MemAudioBlock::~MemAudioBlock()
} }
// the index is referenced from the head
audio_block_t *MemAudioBlock::getQueueBack(size_t offset)
{
// for (int i=0; i<m_queues.getMaxSize(); i++) {
// Serial.println(i + String(":") + (uint32_t)m_queues[i]->data);
// }
// Serial.println(String("Returning ") + (uint32_t)m_queues[m_queues.getBackIndex(offset)]);
return m_queues[m_queues.getBackIndex(offset)];
}
bool MemAudioBlock::push(audio_block_t *block) bool MemAudioBlock::push(audio_block_t *block)
{ {
//Serial.println("MemAudioBlock::push()");
m_queues.push_back(block); m_queues.push_back(block);
//Serial.println("MemAudioBlock::push() done");
return true; return true;
} }
audio_block_t* MemAudioBlock::pop() audio_block_t* MemAudioBlock::pop()
{ {
//Serial.println("MemAudioBlock::pop()");
audio_block_t* block = m_queues.front(); audio_block_t* block = m_queues.front();
m_queues.pop_front(); m_queues.pop_front();
return block; return block;
@ -86,7 +98,7 @@ bool MemAudioBlock::clear()
return true; return true;
} }
bool MemAudioBlock::write16(size_t offset, int16_t *dataPtr, size_t numData) bool MemAudioBlock::write16(size_t offset, int16_t *srcDataPtr, size_t numData)
{ {
// Calculate the queue position // Calculate the queue position
auto position = calcQueuePosition(offset); auto position = calcQueuePosition(offset);
@ -98,33 +110,38 @@ bool MemAudioBlock::write16(size_t offset, int16_t *dataPtr, size_t numData)
// loop over a series of memcpys until all data is transferred. // loop over a series of memcpys until all data is transferred.
size_t samplesRemaining = numData; size_t samplesRemaining = numData;
int16_t *srcStart = srcDataPtr; // this will increment during each loop iteration
while (samplesRemaining > 0) { while (samplesRemaining > 0) {
size_t numSamplesToWrite; size_t numSamplesToWrite;
void *start = static_cast<void*>(m_queues[index]->data + writeOffset); void *destStart = static_cast<void*>(m_queues[index]->data + writeOffset);
// determine if the transfer will complete or will hit the end of a block first // determine if the transfer will complete or will hit the end of a block first
if ( (writeOffset + samplesRemaining) > AUDIO_BLOCK_SAMPLES ) { if ( (writeOffset + samplesRemaining) > AUDIO_BLOCK_SAMPLES ) {
// goes past end of the queue // goes past end of the queue
numSamplesToWrite = (AUDIO_BLOCK_SAMPLES - writeOffset); numSamplesToWrite = (AUDIO_BLOCK_SAMPLES - writeOffset);
writeOffset = 0; //writeOffset = 0;
index++; //index++;
} else { } else {
// transfer ends in this audio block // transfer ends in this audio block
numSamplesToWrite = samplesRemaining; numSamplesToWrite = samplesRemaining;
writeOffset += numSamplesToWrite; //writeOffset += numSamplesToWrite;
} }
// perform the transfer // perform the transfer
if (!m_queues[index]) { if (!m_queues[index]) {
// no allocated audio block, skip the copy // no allocated audio block, skip the copy
} else { } else {
if (dataPtr) { if (srcDataPtr) {
memcpy(start, dataPtr, numSamplesToWrite * sizeof(int16_t)); memcpy(destStart, static_cast<const void*>(srcStart), numSamplesToWrite * sizeof(int16_t));
} else { } else {
memset(start, 0, numSamplesToWrite * sizeof(int16_t)); memset(destStart, 0, numSamplesToWrite * sizeof(int16_t));
} }
} }
writeOffset = 0;
index++;
srcStart += numSamplesToWrite;
samplesRemaining -= numSamplesToWrite; samplesRemaining -= numSamplesToWrite;
} }
m_currentPosition.offset = writeOffset; m_currentPosition.offset = writeOffset;
@ -140,44 +157,43 @@ inline bool MemAudioBlock::zero16(size_t offset, size_t numData)
bool MemAudioBlock::read16(int16_t *dest, size_t destOffset, size_t srcOffset, size_t numSamples) bool MemAudioBlock::read16(int16_t *dest, size_t destOffset, size_t srcOffset, size_t numSamples)
{ {
if (!dest) return false; // destination is not valid if (!dest) return false; // destination is not valid
(void)destOffset; // not supported with audio_block_t;
//Serial.println("*************************************************************************");
//Serial.println(String("read16():") + (uint32_t)dest + String(":") + destOffset + String(":") + srcOffset + String(":") + numSamples);
// Calculate the queue position // Calculate the queue position
auto position = calcQueuePosition(srcOffset); auto position = calcQueuePosition(srcOffset);
int readOffset = position.offset;
size_t index = position.index; size_t index = position.index;
if ( (index+1) > m_queues.size()) return false; // out of range // Break the transfer in two. Note that the audio is stored first sample (in time) last (in memory).
// loop over a series of memcpys until all data is transferred. int16_t *destStart = dest;
size_t samplesRemaining = numSamples; audio_block_t *currentQueue;
int16_t *srcStart;
while (samplesRemaining > 0) { // Break the transfer into two. Note that the audio
size_t numSamplesToRead; //Serial.println("Calling getQueue");
currentQueue = getQueueBack(index+1); // buffer indexes go backwards from the back
//Serial.println(String("Q. Address: ") + (uint32_t)currentQueue + String(" Data: ") + (uint32_t)currentQueue->data);
srcStart = (currentQueue->data + AUDIO_BLOCK_SAMPLES - position.offset);
size_t numData = position.offset;
//Serial.println(String("Source Start1: ") + (uint32_t)currentQueue->data + String(" Dest start1: ") + (uint32_t)dest);
//Serial.println(String("copying to ") + (uint32_t)destStart + String(" from ") + (uint32_t)srcStart + String(" numData= ") + numData);
memcpy(static_cast<void*>(destStart), static_cast<void*>(srcStart), numData * sizeof(int16_t));
void *srcStart = static_cast<void*>(m_queues[index]->data + readOffset);
void *destStart = static_cast<void *>(dest + destOffset);
// determine if the transfer will complete or will hit the end of a block first currentQueue = getQueueBack(index); // buffer indexes go backwards from the back
if ( (readOffset + samplesRemaining) > AUDIO_BLOCK_SAMPLES ) { //Serial.println(String("Q. Address: ") + (uint32_t)currentQueue + String(" Data: ") + (uint32_t)currentQueue->data);
// goes past end of the queue destStart += numData;
numSamplesToRead = (AUDIO_BLOCK_SAMPLES - readOffset); srcStart = (currentQueue->data);
readOffset = 0; numData = AUDIO_BLOCK_SAMPLES - numData;
index++; //Serial.println(String("Source Start2: ") + (uint32_t)currentQueue->data + String(" Dest start2: ") + (uint32_t)dest);
} else { //Serial.println(String("copying to ") + (uint32_t)destStart + String(" from ") + (uint32_t)srcStart + String(" numData= ") + numData);
// transfer ends in this audio block memcpy(static_cast<void*>(destStart), static_cast<void*>(srcStart), numData * sizeof(int16_t));
numSamplesToRead = samplesRemaining;
readOffset += numSamplesToRead; //m_queues.print();
} //Serial.println("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
// perform the transfer
if (!m_queues[index]) {
// no allocated audio block, copy zeros
memset(destStart, 0, numSamplesToRead * sizeof(int16_t));
} else {
memcpy(srcStart, destStart, numSamplesToRead * sizeof(int16_t));
}
samplesRemaining -= numSamplesToRead;
}
return true; return true;
} }

3
src/LibMemoryManagement.h
Unescape View File

@ -62,8 +62,9 @@ public:
bool push(audio_block_t *block); bool push(audio_block_t *block);
audio_block_t *pop(); audio_block_t *pop();
audio_block_t *getQueue(size_t index) { return m_queues[index]; } audio_block_t *getQueueBack(size_t offset=0);
size_t getNumQueues() const { return m_queues.size(); } size_t getNumQueues() const { return m_queues.size(); }
size_t getMaxSize() const { return m_queues.getMaxSize(); }
bool clear() override; bool clear() override;
bool write16(size_t offset, int16_t *dataPtr, size_t numData) override; bool write16(size_t offset, int16_t *dataPtr, size_t numData) override;
bool zero16(size_t offset, size_t numSamples) override; bool zero16(size_t offset, size_t numSamples) override;

Write Preview
Loading…
Cancel
Save