OscillatorBank.h

#pragma once
#include <string.h>
#include <stdio.h>
 
extern "C" {
        // Function prototype for ARM assembly implementation of oscillator bank
        void oscillator_bank_neon(int numAudioFrames, float *audioOut,
                                                          int activePartialNum, int lookupTableSize,
                                                          float *phases, float *frequencies, float *amplitudes,
                                                          float *freqDerivatives, float *ampDerivatives,
                                                          float *lookupTable);
}

class OscillatorBank{
public:
        OscillatorBank():
        sampleRate(1),
        wavetable(NULL),
        phases(NULL),
        frequencies(NULL),
        amplitudes(NULL),
        dFrequencies(NULL),
        dAmplitudes(NULL)
        {}
 
        ~OscillatorBank(){
                free(wavetable);
                free(phases);
                free(frequencies);
                free(amplitudes);
                free(dFrequencies);
                free(dAmplitudes);
        }

        int setup(float newSampleRate, unsigned int newWavetableLength, unsigned int newNumOscillators){
                wavetableLength = newWavetableLength;
                numOscillators = newNumOscillators;
                sampleRate = newSampleRate;
                // Initialise the sine wavetable
                if(posix_memalign((void **)&wavetable, 16, (wavetableLength + 1) * sizeof(float))) {
                        fprintf(stderr, "Error allocating wavetable\n");
                        return -1;
                }
 
                // Allocate the other buffers
                if(posix_memalign((void **)&phases, 16, numOscillators * sizeof(float))) {
                        fprintf(stderr, "Error allocating phase buffer\n");
                        return -1;
                }
                if(posix_memalign((void **)&frequencies, 16, numOscillators * sizeof(float))) {
                        fprintf(stderr, "Error allocating frequency buffer\n");
                        return -1;
                }
                if(posix_memalign((void **)&amplitudes, 16, numOscillators * sizeof(float))) {
                        fprintf(stderr, "Error allocating amplitude buffer\n");
                        return -1;
                }
                if(posix_memalign((void **)&dFrequencies, 16, numOscillators * sizeof(float))) {
                        fprintf(stderr, "Error allocating frequency derivative buffer\n");
                        return -1;
                }
                if(posix_memalign((void **)&dAmplitudes, 16, numOscillators * sizeof(float))) {
                        fprintf(stderr, "Error allocating amplitude derivative buffer\n");
                        return -1;
                }
                clearArrays();
                        return 0;
        }

        float* getWavetable(){
                return wavetable;
        }

        int getWavetableLength(){
                return wavetableLength;
        }

        int getNumOscillators(){
                return numOscillators;
        }

        float* getAmplitudes(){
                return amplitudes;
        }

        float* getPhases(){
                return phases;
        }

        void setAmplitude(int n, float amplitude){
                amplitudes[n] = amplitude;
        }

        void setFrequency(int n, float frequency){
        // For efficiency, frequency is internally stored in change in wavetable position per sample, not Hz or radians
                frequencies[n] = frequency * (float)wavetableLength / sampleRate;
        }

        void clearArrays(){
                memset(phases, 0, sizeof(float)*numOscillators);
                memset(dFrequencies, 0, sizeof(float)*numOscillators);
                memset(dAmplitudes, 0, sizeof(float)*numOscillators);
        }

        void process(unsigned int frames, float* output){
                // Initialise buffer to 0
                memset(output, 0, frames * sizeof(float));
                oscillator_bank_neon(frames, output,
                                numOscillators, wavetableLength,
                                phases, frequencies, amplitudes,
                                dFrequencies, dAmplitudes,
                                wavetable);
        }
 
private:
        float sampleRate;
        int numOscillators;
        int wavetableLength;
        float *wavetable;               // Buffer holding the precalculated sine lookup table
        float *phases;                  // Buffer holding the phase of each oscillator
        float *frequencies;     // Buffer holding the frequencies of each oscillator
        float *amplitudes;              // Buffer holding the amplitudes of each oscillator
        float *dFrequencies;    // Buffer holding the derivatives of frequency
        float *dAmplitudes;     // Buffer holding the derivatives of amplitude
};