wirtz
/
MicroDexed
mirror of https://codeberg.org/dcoredump/MicroDexed.git
1
1
Fork 0
Code Issues Releases Wiki Activity

Testet delay on external RAM - and it works now!

Browse Source
dev
Holger Wirtz 2 years ago
parent bdac6d9e01
commit 62f3b0a525
5 changed files with 597 additions and 9 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. 2
      MicroDexed.ino
  2. 4
      third-party/effect_delay_ext8/src/effect_delay_ext8.cpp
  3. 12
      third-party/effect_delay_ext8/src/effect_delay_ext8.h
  4. 495
      third-party/effect_delay_ext8/src/extmem8.cpp
  5. 93
      third-party/effect_delay_ext8/src/extmem8.h

2
MicroDexed.ino
Unescape View File

@ -242,7 +242,7 @@ FLASHMEM void create_audio_dexed_chain(uint8_t instance_id) {
chorus_mixer[instance_id] = new AudioMixer<2>();
delay_fb_mixer[instance_id] = new AudioMixer<2>();
#if defined(USE_DELAY_8M)
delay_fx[instance_id] = new AudioEffectDelayExternal8(AUDIO_MEMORY_PSRAM64, DELAY_MAX_TIME);
delay_fx[instance_id] = new AudioEffectDelayExternal8(AUDIO_MEMORY8_EXTMEM, DELAY_MAX_TIME);
#else
delay_fx[instance_id] = new AudioEffectDelay();
#endif

4
third-party/effect_delay_ext8/src/effect_delay_ext8.cpp vendored
Unescape View File

@ -25,7 +25,7 @@
*/
#include <Arduino.h>
#include "extmem.h"
#include "extmem8.h"
#include "effect_delay_ext8.h"
@ -36,7 +36,7 @@ void AudioEffectDelayExternal8::update(void)
// grab incoming data and put it into the memory
block = receiveReadOnly();
if (memory_type >= AUDIO_MEMORY_UNDEFINED) {
if (memory_type >= AUDIO_MEMORY8_UNDEFINED) {
// ignore input and do nothing if undefined memory type
release(block);
return;

12
third-party/effect_delay_ext8/src/effect_delay_ext8.h vendored
Unescape View File

@ -29,22 +29,22 @@
#include "Arduino.h"
#include "AudioStream.h"
#include "spi_interrupt.h"
#include "extmem.h"
#include "extmem8.h"
class AudioEffectDelayExternal8 : public AudioStream, public AudioExtMem
class AudioEffectDelayExternal8 : public AudioStream, public AudioExtMem8
{
public:
AudioEffectDelayExternal8(AudioEffectDelayMemoryType_t type, float milliseconds=1e6)
AudioEffectDelayExternal8(AudioEffectDelayMemoryType8_t type, float milliseconds=1e6)
: AudioStream(1, inputQueueArray),
AudioExtMem(type, (milliseconds*(AUDIO_SAMPLE_RATE_EXACT/1000.0f))+0.5f),
AudioExtMem8(type, (milliseconds*(AUDIO_SAMPLE_RATE_EXACT/1000.0f))+0.5f),
activemask(0)
{}
AudioEffectDelayExternal8() : AudioEffectDelayExternal8(AUDIO_MEMORY_23LC1024) {}
AudioEffectDelayExternal8() : AudioEffectDelayExternal8(AUDIO_MEMORY8_23LC1024) {}
~AudioEffectDelayExternal8() {}
void delay(uint8_t channel, float milliseconds) {
if (channel >= 8 || memory_type >= AUDIO_MEMORY_UNDEFINED) return;
if (channel >= 8 || memory_type >= AUDIO_MEMORY8_UNDEFINED) return;
if (milliseconds < 0.0f) milliseconds = 0.0f;
uint32_t n = (milliseconds*(AUDIO_SAMPLE_RATE_EXACT/1000.0f))+0.5f;
n += AUDIO_BLOCK_SAMPLES;

495
third-party/effect_delay_ext8/src/extmem8.cpp vendored
Unescape View File

@ -0,0 +1,495 @@
/* Audio Library for Teensy 3.X
* Copyright (c) 2014, Paul Stoffregen, paul@pjrc.com
*
* Development of this audio library was funded by PJRC.COM, LLC by sales of
* Teensy and Audio Adaptor boards. Please support PJRC's efforts to develop
* open source software by purchasing Teensy or other PJRC products.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice, development funding notice, and this permission
* notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <Arduino.h>
#include "extmem8.h"
//#define INTERNAL_TEST
// While 20 MHz (Teensy actually uses 16 MHz in most cases) and even 24 MHz
// have worked well in testing at room temperature with 3.3V power, to fully
// meet all the worst case timing specs, the SPI clock low time would need
// to be 40ns (12.5 MHz clock) for the single chip case and 51ns (9.8 MHz
// clock) for the 6-chip memoryboard with 74LCX126 buffers.
//
// Timing analysis and info is here:
// https://forum.pjrc.com/threads/29276-Limits-of-delay-effect-in-audio-library?p=97506&viewfull=1#post97506
#define SPISETTING SPISettings(20'000'000, MSBFIRST, SPI_MODE0)
// Use these with the audio adaptor board (should be adjustable by the user...)
#define SPIRAM_MOSI_PIN 7
#define SPIRAM_MISO_PIN 12
#define SPIRAM_SCK_PIN 14
#define SPIRAM_CS_PIN 6
#define MEMBOARD_CS0_PIN 2
#define MEMBOARD_CS1_PIN 3
#define MEMBOARD_CS2_PIN 4
#define SIZEOF_SAMPLE (sizeof(((audio_block_t*) 0)->data[0]))
static const uint32_t NOT_ENOUGH_MEMORY = 0xFFFFFFFF;
// This memory size array needs to match the sizes of
// the entries in AudioEffectDelayMemoryType8_t
const uint32_t AudioExtMem8::memSizeSamples[AUDIO_MEMORY8_UNDEFINED] = {65536,393216,262144,4194304,8000};
AudioExtMem8* AudioExtMem8::first[AUDIO_MEMORY8_UNDEFINED] = {nullptr};
AudioExtMem8::~AudioExtMem8()
{
switch (memory_type)
{
case AUDIO_MEMORY8_HEAP:
free((void*) memory_begin);
break;
#if defined(ARDUINO_TEENSY41)
case AUDIO_MEMORY8_EXTMEM:
extmem_free((void*) memory_begin);
break;
#endif // defined(ARDUINO_TEENSY41)
// audio SPI memory is tracked by AudioExtMem8
// objects thenselves - no need to free
default:
break;
}
linkOut();
}
void AudioExtMem8::linkIn(void)
{
if (memory_type < AUDIO_MEMORY8_UNDEFINED)
{
AudioExtMem8** ppEM = &first[memory_type];
while (nullptr != *ppEM)
{
if (memory_begin > (*ppEM)->memory_begin)
ppEM = &((*ppEM)->next);
else
break;
}
next = *ppEM;
*ppEM = this;
}
}
void AudioExtMem8::linkOut(void)
{
if (memory_type < AUDIO_MEMORY8_UNDEFINED) // This Never Happens...
{
AudioExtMem8** ppEM = &first[memory_type];
while (nullptr != *ppEM)
{
if (this != *ppEM)
ppEM = &((*ppEM)->next);
else
{
*ppEM = next;
break;
}
}
next = nullptr; // not really necessary, but...
}
}
/**
* Find space for given number of samples. This MUST be called before the
* newly-created AudioExtMem8 object is linked into the allocation list.
*/
uint32_t AudioExtMem8::findSpace(AudioEffectDelayMemoryType8_t memory_type, uint32_t samples)
{
uint32_t result = 0;
bool gotOne = false;
if (memory_type < AUDIO_MEMORY8_UNDEFINED) // This Never Happens...
{
AudioExtMem8** ppEM = &first[memory_type];
do
{
uint32_t next_start;
if (nullptr == *ppEM) // end of list, or first memory allocation
next_start = memSizeSamples[memory_type];
else // we've found an object using memory
{
AudioExtMem8* nextObj = (*ppEM)->next;
result = (*ppEM)->memory_begin + (*ppEM)->memory_length; // end of object's allocation
if (nullptr != nextObj)
next_start = nextObj->memory_begin;
else
next_start = memSizeSamples[memory_type];
ppEM = &((*ppEM)->next);
}
// simple-minded allocation: first found fit
if (samples <= (next_start - result))
gotOne = true;
} while (!gotOne && nullptr != *ppEM);
}
if (!gotOne)
result = NOT_ENOUGH_MEMORY;
return result;
}
/**
* Find maximum contiguous space in a memory.
*/
uint32_t AudioExtMem8::findMaxSpace(AudioEffectDelayMemoryType8_t memory_type)
{
uint32_t result = 0;
uint32_t samples = 0;
if (memory_type < AUDIO_MEMORY8_UNDEFINED) // This Never Happens...
{
AudioExtMem8** ppEM = &first[memory_type];
do
{
uint32_t next_start;
if (nullptr == *ppEM) // end of list, or first memory allocation
next_start = memSizeSamples[memory_type];
else // we've found an object using memory
{
AudioExtMem8* nextObj = (*ppEM)->next;
result = (*ppEM)->memory_begin + (*ppEM)->memory_length; // end of object's allocation
if (nullptr != nextObj)
next_start = nextObj->memory_begin;
else
next_start = memSizeSamples[memory_type];
ppEM = &((*ppEM)->next);
}
// if space is bigger, bump the answer
if (samples <= (next_start - result))
samples = (next_start - result);
} while (nullptr != *ppEM);
}
return samples;
}
void AudioExtMem8::initialize(AudioEffectDelayMemoryType8_t type, uint32_t samples)
{
//uint32_t memsize, avail;
uint32_t avail;
void* mem;
#if defined(INTERNAL_TEST)
type = AUDIO_MEMORY8_INTERNAL;
#endif // defined(INTERNAL_TEST)
head_offset = 0;
memory_type = type;
SPI.setMOSI(SPIRAM_MOSI_PIN);
SPI.setMISO(SPIRAM_MISO_PIN);
SPI.setSCK(SPIRAM_SCK_PIN);
SPI.begin();
//memsize = memSizeSamples[type];
//Serial.printf("Requested %d samples\n",samples);
switch (type)
{
case AUDIO_MEMORY8_PSRAM64:
case AUDIO_MEMORY8_23LC1024:
case AUDIO_MEMORY8_CY15B104:
pinMode(SPIRAM_CS_PIN, OUTPUT);
digitalWriteFast(SPIRAM_CS_PIN, HIGH);
break;
case AUDIO_MEMORY8_MEMORYBOARD:
pinMode(MEMBOARD_CS0_PIN, OUTPUT);
pinMode(MEMBOARD_CS1_PIN, OUTPUT);
pinMode(MEMBOARD_CS2_PIN, OUTPUT);
digitalWriteFast(MEMBOARD_CS0_PIN, LOW);
digitalWriteFast(MEMBOARD_CS1_PIN, LOW);
digitalWriteFast(MEMBOARD_CS2_PIN, LOW);
pinMode(SPIRAM_CS_PIN, OUTPUT);
digitalWriteFast(SPIRAM_CS_PIN, HIGH);
break;
case AUDIO_MEMORY8_INTERNAL:
case AUDIO_MEMORY8_HEAP:
case AUDIO_MEMORY8_EXTMEM:
break;
default:
samples = 0;
break;
}
#define noOLD_ALLOCATE
#if defined(OLD_ALLOCATE)
avail = memsize - allocated[type];
if (avail < AUDIO_BLOCK_SAMPLES*2+1) {
memory_type = AUDIO_MEMORY8_UNDEFINED;
//return;
}
if (samples > avail) samples = avail;
memory_begin = allocated[type];
allocated[type] += samples;
#else
switch (type)
{
// SPI memory
// Emulate old behaviour: allocate biggest possible chunk
// of delay memory if asked for more than is available.
// Slightly different in dynamic system because of fragmentation,
// but should be the same if used with legacy static design.
case AUDIO_MEMORY8_PSRAM64:
case AUDIO_MEMORY8_23LC1024:
case AUDIO_MEMORY8_CY15B104:
case AUDIO_MEMORY8_MEMORYBOARD:
avail = findMaxSpace(type);
if (samples > avail)
samples = avail;
//Serial.printf("findSpace says we could use %08lX\n",findSpace(type,samples));
memory_begin = findSpace(type,samples);
break;
// processor heap: could be useful on Teensy 4.x etc.
// In this case don't fill heap if asked for too much
case AUDIO_MEMORY8_HEAP:
mem = malloc(samples * SIZEOF_SAMPLE);
if (nullptr != mem)
memory_begin = (uint32_t) mem;
else
memory_begin = NOT_ENOUGH_MEMORY;
break;
#if defined(ARDUINO_TEENSY41)
// PSRAM external memory
case AUDIO_MEMORY8_EXTMEM:
mem = extmem_malloc(samples * SIZEOF_SAMPLE);
if (nullptr != mem)
memory_begin = (uint32_t) mem;
else
memory_begin = NOT_ENOUGH_MEMORY;
break;
#endif // defined(ARDUINO_TEENSY41)
default: // invalid memory type
memory_begin = NOT_ENOUGH_MEMORY;
break;
}
if (NOT_ENOUGH_MEMORY == memory_begin)
memory_type = AUDIO_MEMORY8_UNDEFINED;
#endif // defined(OLD_ALLOCATE)
if (AUDIO_MEMORY8_UNDEFINED != memory_type)
{
memory_length = samples;
zero(0, memory_length);
linkIn();
}
else
memory_length = 0;
}
#ifdef INTERNAL_TEST
static int16_t testmem[8000]; // testing only
#endif
void AudioExtMem8::SPIreadMany(int16_t* data, uint32_t samples)
{
if (nullptr != data)
{
while (samples--)
*data++ = (int16_t)(SPI.transfer16(0));
}
else
{
while (samples--)
(int16_t)(SPI.transfer16(0));
}
}
void AudioExtMem8::SPIwriteMany(const int16_t* data, uint32_t samples)
{
if (nullptr != data)
{
while (samples--)
SPI.transfer16(*data++);
}
else
{
while (samples--)
SPI.transfer16(0);
}
}
void AudioExtMem8::read(uint32_t offset, uint32_t count, int16_t *data)
{
uint32_t addr = memory_begin + offset;
#ifdef INTERNAL_TEST
if (nullptr != data) while (count) { *data++ = testmem[addr++]; count--; } // testing only
#else
switch (memory_type)
{
case AUDIO_MEMORY8_23LC1024:
case AUDIO_MEMORY8_PSRAM64:
case AUDIO_MEMORY8_CY15B104:
addr *= SIZEOF_SAMPLE;
SPI.beginTransaction(SPISETTING);
digitalWriteFast(SPIRAM_CS_PIN, LOW);
SPI.transfer16((0x03 << 8) | (addr >> 16));
SPI.transfer16(addr & 0xFFFF);
SPIreadMany(data,count);
digitalWriteFast(SPIRAM_CS_PIN, HIGH);
SPI.endTransaction();
break;
case AUDIO_MEMORY8_MEMORYBOARD:
SPI.beginTransaction(SPISETTING);
while (count) {
uint32_t chip = (addr >> 16) + 1;
digitalWriteFast(MEMBOARD_CS0_PIN, chip & 1);
digitalWriteFast(MEMBOARD_CS1_PIN, chip & 2);
digitalWriteFast(MEMBOARD_CS2_PIN, chip & 4);
uint32_t chipaddr = (addr & 0xFFFF) * SIZEOF_SAMPLE;
SPI.transfer16((0x03 << 8) | (chipaddr >> 16));
SPI.transfer16(chipaddr & 0xFFFF);
uint32_t num = 0x10000 - (addr & 0xFFFF);
if (num > count) num = count;
count -= num;
addr += num;
SPIreadMany(data,num);
}
digitalWriteFast(MEMBOARD_CS0_PIN, LOW);
digitalWriteFast(MEMBOARD_CS1_PIN, LOW);
digitalWriteFast(MEMBOARD_CS2_PIN, LOW);
SPI.endTransaction();
break;
case AUDIO_MEMORY8_HEAP:
#if defined(ARDUINO_TEENSY41)
case AUDIO_MEMORY8_EXTMEM:
#endif // defined(ARDUINO_TEENSY41)
addr = memory_begin + offset*SIZEOF_SAMPLE;
if (nullptr != data)
memcpy(data,(void*) addr,count*SIZEOF_SAMPLE);
break;
default:
break;
}
#endif
}
void AudioExtMem8::write(uint32_t offset, uint32_t count, const int16_t *data)
{
uint32_t addr = memory_begin + offset;
#ifdef INTERNAL_TEST
while (count) { testmem[addr++] = *data++; count--; } // testing only
#else
switch (memory_type)
{
case AUDIO_MEMORY8_23LC1024:
case AUDIO_MEMORY8_PSRAM64:
addr *= SIZEOF_SAMPLE;
SPI.beginTransaction(SPISETTING);
digitalWriteFast(SPIRAM_CS_PIN, LOW);
SPI.transfer16((0x02 << 8) | (addr >> 16));
SPI.transfer16(addr & 0xFFFF);
SPIwriteMany(data,count);
digitalWriteFast(SPIRAM_CS_PIN, HIGH);
SPI.endTransaction();
break;
case AUDIO_MEMORY8_CY15B104:
addr *= SIZEOF_SAMPLE;
SPI.beginTransaction(SPISETTING);
digitalWriteFast(SPIRAM_CS_PIN, LOW);
SPI.transfer(0x06); //write-enable before every write
digitalWriteFast(SPIRAM_CS_PIN, HIGH);
asm volatile ("NOP\n NOP\n NOP\n NOP\n NOP\n NOP\n");
digitalWriteFast(SPIRAM_CS_PIN, LOW);
SPI.transfer16((0x02 << 8) | (addr >> 16));
SPI.transfer16(addr & 0xFFFF);
SPIwriteMany(data,count);
digitalWriteFast(SPIRAM_CS_PIN, HIGH);
SPI.endTransaction();
break;
case AUDIO_MEMORY8_MEMORYBOARD:
SPI.beginTransaction(SPISETTING);
while (count) {
uint32_t chip = (addr >> 16) + 1;
digitalWriteFast(MEMBOARD_CS0_PIN, chip & 1);
digitalWriteFast(MEMBOARD_CS1_PIN, chip & 2);
digitalWriteFast(MEMBOARD_CS2_PIN, chip & 4);
uint32_t chipaddr = (addr & 0xFFFF) * SIZEOF_SAMPLE;
SPI.transfer16((0x02 << 8) | (chipaddr >> 16));
SPI.transfer16(chipaddr & 0xFFFF);
uint32_t num = 0x10000 - (addr & 0xFFFF);
if (num > count) num = count;
count -= num;
addr += num;
SPIwriteMany(data,num);
}
digitalWriteFast(MEMBOARD_CS0_PIN, LOW);
digitalWriteFast(MEMBOARD_CS1_PIN, LOW);
digitalWriteFast(MEMBOARD_CS2_PIN, LOW);
SPI.endTransaction();
break;
case AUDIO_MEMORY8_HEAP:
#if defined(ARDUINO_TEENSY41)
case AUDIO_MEMORY8_EXTMEM:
#endif // defined(ARDUINO_TEENSY41)
addr = memory_begin + offset*SIZEOF_SAMPLE;
if (nullptr != data)
memcpy((void*) addr,data,count*SIZEOF_SAMPLE);
else
memset((void*) addr,0,count*SIZEOF_SAMPLE);
break;
default:
break;
}
#endif
}

93
third-party/effect_delay_ext8/src/extmem8.h vendored
Unescape View File

@ -0,0 +1,93 @@
/* Audio Library for Teensy 3.X
* Copyright (c) 2014, Paul Stoffregen, paul@pjrc.com
*
* Development of this audio library was funded by PJRC.COM, LLC by sales of
* Teensy and Audio Adaptor boards. Please support PJRC's efforts to develop
* open source software by purchasing Teensy or other PJRC products.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice, development funding notice, and this permission
* notice shall be included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef _extmem8_h_
#define _extmem8_h_
#include "Arduino.h"
#include "spi_interrupt.h"
// A quick experiment with a Teensy 4.1
// suggests a 1-input 3-tap delay line uses:
// mem type CPU%
// Heap <tiny%>
// EXTMEM 1.3%
// SPI PSRAM 12% (40MHz SPI clock)
// SPI PSRAM 19% (20MHz SPI clock)
enum AudioEffectDelayMemoryType8_t {
AUDIO_MEMORY8_23LC1024 = 0, // 128k x 8 S-RAM (1.48s @ 44kHz / 16 bit)
AUDIO_MEMORY8_MEMORYBOARD = 1, // 6x 128k x 8 (8.9s @ 44kHz / 16 bit)
AUDIO_MEMORY8_CY15B104 = 2, // 512k x 8 F-RAM (5.9s @ 44kHz / 16 bit)
AUDIO_MEMORY8_PSRAM64 = 3, // 64Mb / 8MB PSRAM (95s @ 44kHz / 16 bit)
AUDIO_MEMORY8_INTERNAL = 4, // 8000 samples (181ms), for test only!
AUDIO_MEMORY8_HEAP = 5,
AUDIO_MEMORY8_EXTMEM = 6,
AUDIO_MEMORY8_UNDEFINED
};
#define IS_SPI_TYPE (AUDIO_MEMORY8_23LC1024 == memory_type || \
AUDIO_MEMORY8_MEMORYBOARD == memory_type || \
AUDIO_MEMORY8_CY15B104 == memory_type || \
AUDIO_MEMORY8_PSRAM64 == memory_type)
class AudioExtMem8
{
public:
AudioExtMem8(AudioEffectDelayMemoryType8_t type, uint32_t samples = AUDIO_SAMPLE_RATE_EXACT)
: memory_begin(0)
{
initialize(type, samples);
}
AudioExtMem8() : AudioExtMem8(AUDIO_MEMORY8_23LC1024, 65536) {}
~AudioExtMem8();
float getMaxDelay(void) {return (float) memory_length * 1000.0f / AUDIO_SAMPLE_RATE_EXACT;}
private:
void initialize(AudioEffectDelayMemoryType8_t type, uint32_t samples);
inline static void SPIreadMany(int16_t* data, uint32_t samples);
inline static void SPIwriteMany(const int16_t* data, uint32_t samples);
//static uint32_t allocated[AUDIO_MEMORY8_UNDEFINED];
const static uint32_t memSizeSamples[AUDIO_MEMORY8_UNDEFINED];
static AudioExtMem8* first[AUDIO_MEMORY8_UNDEFINED]; // linked lists of all SPI memory types
AudioExtMem8* next; // next allocation after this one
void linkIn(void); // link new AudioExtMem8 object into allocation chain
void linkOut(void); // unlink this AudioExtMem8 object from allocation chain
static uint32_t findSpace(AudioEffectDelayMemoryType8_t memory_type, uint32_t samples); // find a space for a delay buffer
static uint32_t findMaxSpace(AudioEffectDelayMemoryType8_t memory_type); // find max available space for a delay buffer
uint32_t memory_begin; // the first address in the memory we're using
protected:
void read(uint32_t address, uint32_t count, int16_t *data);
void write(uint32_t address, uint32_t count, const int16_t *data);
void zero(uint32_t address, uint32_t count) {
write(address, count, NULL);
}
uint32_t memory_length; // the amount of memory we're using
uint32_t head_offset; // head index (incoming) data into external memory
AudioEffectDelayMemoryType8_t memory_type; // 0=23LC1024, 1=Frank's Memoryboard, etc.
};
#endif // _extmem8.h_
Write Preview
Loading…
Cancel
Save