synthlabwtsource.h

#ifndef _SynthLabWTSource_h
#define _SynthLabWTSource_h

#include "synthfunctions.h"

// -----------------------------
//  --- SynthLab SDK File --- // 
//  ----------------------------
// -----------------------------------------------------------------------------
namespace SynthLab
{
    class StaticTableSource : public IWavetableSource
    {
    public:
        StaticTableSource() { }
        ~StaticTableSource() { }

        virtual const char* getWaveformName() override
        {
            return selectedTable.waveformName;
        }

        inline virtual void selectTable(uint32_t midiNoteNumber) override
        {
            selectedTable = wavetableSet[midiNoteNumber];
        }

        inline virtual double readWaveTable(double normalizedPhaseInc) override
        {
            // --- two samples from table
            double wtData[2] = { 0.0, 0.0 };

            // --- location = N(fo/fs)
            double wtReadLocation = selectedTable.tableLength * normalizedPhaseInc;

            // --- split the fractional index into int.frac parts
            //double dIntPart = 0.0;
            //double fracPart = modf(wtReadLocation, &dIntPart);
            uint32_t readIndex = (uint32_t)wtReadLocation;
            uint32_t nextReadIndex = (readIndex + 1) & selectedTable.wrapMask;

            // --- two table reads
            uint64_t u0 = selectedTable.uTable[readIndex];
            uint64_t u1 = selectedTable.uTable[nextReadIndex];
            wtData[0] = *(reinterpret_cast<double*>(&u0));
            wtData[1] = *(reinterpret_cast<double*>(&u1));

            // --- interp
            double fracPart = wtReadLocation - readIndex;
            double output = doLinearInterpolation(wtData[0], wtData[1], fracPart);

            // --- scale as needed
            return selectedTable.outputComp * output;
        }

        virtual uint32_t getWaveTableLength() override { return selectedTable.tableLength; }

        inline void addSynthLabTableSet(SynthLabTableSet* synthLabTableSet)
        {
            for (uint32_t i = 0; i < NUM_MIDI_NOTES; i++)
            {
                StaticWavetable wt(synthLabTableSet->ppHexTableSet[i],
                                     synthLabTableSet->tableLengths[i],
                                     synthLabTableSet->waveformName,
                                     synthLabTableSet->outputComp, 
                                     synthLabTableSet->tableFs);

                wavetableSet[i] = wt;
            }
            // --- set a default table
            selectedTable = wavetableSet[MIDI_NOTE_A4]; 
        }

    protected:
        // --- 128 wavetables
        StaticWavetable wavetableSet[NUM_MIDI_NOTES];
        StaticWavetable selectedTable;
    };

    class DrumWTSource : public IWavetableSource
    {
    public:
        DrumWTSource() { }
        ~DrumWTSource() { }

        virtual const char* getWaveformName() override
        {
            return drumTable.waveformName;
        }

        inline virtual void selectTable(uint32_t midiNoteNumber)  override { }
    
        inline virtual double readWaveTable(double normalizedPhaseInc) override
        {
            // --- core must calculate correct oscClocking (its easy)
            double wtReadLocation = drumTable.tableLength * normalizedPhaseInc;
            double output = 0.0;

            if (drumTable.dTable)
                output = drumTable.dTable[(uint32_t)wtReadLocation];
            else
            {
                // --- two table reads
                uint64_t u0 = drumTable.uTable[(uint32_t)wtReadLocation];
                output = *(reinterpret_cast<double*>(&u0));
            }

            // --- scale as needed
            return drumTable.outputComp * output;
        }

        virtual uint32_t getWaveTableLength() override { return drumTable.tableLength; }

        inline void addWavetable(const double* _table, uint32_t length, const char* name, double outputComp = 1.0)
        {
            // --- create the static table
            StaticWavetable wt(_table, length, name, outputComp);
            drumTable = wt;
        }

        inline void addWavetable(const uint64_t* _table, uint32_t length, const char* name, double outputComp = 1.0)
        {
            // --- create the static table
            StaticWavetable wt(_table, length, name, outputComp);
            drumTable = wt;
        }

    protected:
        // --- one table per source
        StaticWavetable drumTable; 
    };


    struct MorphBankData
    {
        std::string bankName = empty_string.c_str();    
        uint32_t numTables = 1;                         
        std::string tableNames[MODULE_STRINGS];         
        int32_t tableIndexes[MODULE_STRINGS] = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 };         
        StaticTableSource staticSources[MODULE_STRINGS];
    };
}
#endif // definer