peacock/plugin/module.cpp

/*
   Peacock-8 VA polysynth

   Copyright 2025 Gordon JC Pearce <gordonjcp@gjcp.net>

   Permission to use, copy, modify, and/or distribute this software for any
   purpose with or without fee is hereby granted, provided that the above
   copyright notice and this permission notice appear in all copies.

   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
   SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
   OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
   CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#include "module.hpp"

#include <math.h>
#include <stdio.h>

#include "tables.hpp"

Module::Module() {
    // cutoff frequencies for various RC networks
    vcaTC = 1 - exp(-M_PI * 159 / sampleRate);  // VCA and VCF 10k/0.1u time constant
    subTC = 1 - exp(-M_PI * 15 / sampleRate);   // Main VCA and Sub Level 1k + 10u time constant
    pwmTC = 1 - exp(-M_PI * 40 / sampleRate);   // integrator with 100k/0.047u time constant

    vcaBuf = new float[bufferSize];
    subBuf = new float[bufferSize];
    pwmBuf = new float[bufferSize];
    noiseBuf = new float[bufferSize];
}

Module::~Module() {
    printf("module destructor\n");
    delete vcaBuf;
    delete subBuf;
    delete pwmBuf;
}

void Module::genNoise() {
    for (uint32_t i = 0; i < bufferSize; i++) {
        noiseRNG *= 0x8088405;
        noiseRNG++;
        noiseBuf[i] = 2 - (noiseRNG & 0xffff) / 16384.0f;
    }
}

void Module::lfoRampOn() {
    lfoDelayState = 1;
    lfoDelayTimer = 0;
    lfoDelay = 0;
}

void Module::runLFO() {
    if (lfoDelayState == 1) {
        lfoDelayTimer += attackTable[patchRam.lfoDelay];
        if (lfoDelayTimer > 0x3fff) lfoDelayState = 2;
    }
    if ((lfoDelayState == 2)) {
        lfoDelay += lfoDelayTable[patchRam.lfoDelay >> 4];
    }

    if (lfoDelay > 0xff) {
        lfoDelayState = 0;
        lfoDelay = 0xff;
    }

    lfoRate = lfoRateTable[patchRam.lfoRate];  // FIXME move to parameters

    lfoPhase += (lfoState & 0x01) ? -lfoRate : lfoRate;
    if (lfoPhase > 0x1fff) {
        lfoPhase = 0x1fff;
        lfoState++;
    }
    if (lfoPhase < 0x0000) {
        lfoPhase = 0x0000;
        lfoState++;
    }
    lfo = (lfoState & 0x02) ? -lfoPhase : lfoPhase;

    pw = (lfoState & 0x02) ? lfoPhase + 0x2000 : 0x2000 - lfoPhase;  // PW LFO is unipolar
    pw = (patchRam.switch2 & 0x01) ? 0x3fff : pw;                    // either LFO or "all on"
    pw = 0x3fff - ((pw * patchRam.pwmLfo) >> 7);                     // scaled by PWM pot
}

void Module::run(Voice* voices, uint32_t blockSize) {
    // run updates for module board

    int16_t lfoToVco = 0, lfoToVcf = 0;

    // FIXME break these out to the patch setter
    a = attackTable[patchRam.env_a];  // attack time coeff looked up in table
    d = decayTable[patchRam.env_d];   // decay time coeff looked up in table
    r = decayTable[patchRam.env_r];   // release time coeff looked up in table
    s = patchRam.env_s << 7;          // scale 0x00-0x7f to 0x0000-0x3f80

    master = powf(2, (patchRam.vca / 31.75 - 4.0f)) * 0.1;

    // originally I had 0.28, 0.36, 0.4
    // measurement suggests that saw and square are around 100mV each with sub 160mV

    square = (patchRam.switch1 & 0x08) ? 1 : 0;
    saw = (patchRam.switch1 & 0x10) ? 1 : 0;
    sub = (patchRam.sub / 127.0f) * 1.6;

    res = patchRam.vcfReso / 127.0;
    noise = (patchRam.noise / 127.0);

    // FIXME the exp in these is expensive, don't call it all the time
    chorus->setChorus(patchRam.switch1 & 0x60);
    chorus->setHpf(patchRam.switch2 & 0x18);

    runLFO();

    // calculate "smoothed" parameters
    // these are single outputs with heavy RC smoothing
    for (uint32_t i = 0; i < blockSize; i++) {
        vcaRC = (master - vcaRC) * subTC + vcaRC;
        pwmRC = ((pw / 32768.0f) - pwmRC) * pwmTC + pwmRC;
        subRC = (sub - subRC) * vcaTC + subRC;

        vcaBuf[i] = vcaRC;
        pwmBuf[i] = pwmRC;
        subBuf[i] = subRC;

        if (bufPtr < bufferSize) bufPtr++;
    }

    lfoToVco = (lfoDepthTable[patchRam.vcoLfo] * lfoDelay) >> 8;  // lookup table is 0-255
    lfoToVco += /* lfo from modwheel FIXME */ 0;
    if (lfoToVco > 0xff) lfoToVco = 0xff;
    lfoToVco = (lfo * lfoToVco) >> 11;  // 8 for normalisation plus three additional DSLR EA

    lfoToVcf = (patchRam.vcfLfo * lfoDelay) >> 7;  // value is 0-127
    lfoToVcf = (lfo * lfoToVcf) >> 9;              // 8 for normalisation plus one additional DSLR EA

    int16_t pitchBase = 0x1818, vcfBase = 0;
    pitchBase += lfoToVco;
    pitchBase += /* pitch bend FIXME */ 0;

    // int16_t vcf = (patchRam.vcfEnv << 7) * ((patchRam.switch2 & 0x02) ? -1 : 1);
    vcfBase = (patchRam.vcfFreq << 7) + /* vcf bend FIXME */ 0;
    vcfBase += lfoToVcf;
    if (vcfBase > 0x3fff) vcfBase = 0x3fff;
    if (vcfBase < 0x0000) vcfBase = 0x0000;

    // per-voice calculations
    for (uint32_t i = 0; i < NUM_VOICES; i++) {
        // run one step of the envelope
        Voice* v = &voices[i];
        switch (v->envPhase) {
            case 0:                           // release phase FIXME use an enum I guess
                v->env = (v->env * r) >> 16;  // "RC" decay to zero
                break;
            case 1:           // attack phase
                v->env += a;  // linear attack to 0x3fff
                break;
            case 2:
                v->env = (((v->env - s) * d) >> 16) + s;
                break;
        }
        if (v->env > 0x3fff) {
            v->env = 0x3fff;
            v->envPhase = 2;  // flip to decay
        }

        // pitch
        uint16_t pitch = pitchBase + (v->note << 8);
        uint8_t semi = pitch >> 8;
        float frac = (pitch & 0xff) / 256.0;

        float p1 = pitchTable[semi], p2 = pitchTable[semi + 1];
        int16_t px = ((p2 - p1) * frac + p1);  // interpolated pitch from table

        // octave divider
        px *= (patchRam.switch1 & 0x07);

        v->omega = px / (sampleRate * 8.0f);  // FIXME recalculate table using proper scaler

        // per voice we need to calculate the key follow amount and envelope amount
        v->vcfCut = vcfBase + (((v->env * patchRam.vcfEnv)>>7) * ((patchRam.switch2 & 0x02) ? -1 : 1));

        v->vcfCut += (int)((v->note - 36) * (patchRam.vcfKey << 1) * 0.375);

        if (v->vcfCut > 0x3fff) v->vcfCut = 0x3fff;
        if (v->vcfCut < 0) v->vcfCut = 0;

        v->vcaEnv = (patchRam.switch2 & 0x04) ? (v->envPhase ? 0x3fff : 0) : v->env;
    }
}