bunch of stuff to do with controls

.github/workflows/build.yml

@@ -0,0 +1,43 @@
+name: build
+
+on: [push, pull_request]
+
+jobs:
+  linux:
+    strategy:
+      matrix:
+        target: [linux-arm64, linux-armhf, linux-i686, linux-riscv64, linux-x86_64]
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: distrho/dpf-makefile-action@v1
+        with:
+          target: ${{ matrix.target }}
+
+  macos:
+    strategy:
+      matrix:
+        target: [macos-intel, macos-universal]
+    runs-on: macos-15
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: distrho/dpf-makefile-action@v1
+        with:
+          target: ${{ matrix.target }}
+
+  windows:
+    strategy:
+      matrix:
+        target: [win32, win64]
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - uses: distrho/dpf-makefile-action@v1
+        with:
+          target: ${{ matrix.target }}

plugin/DistrhoPluginInfo.h

@@ -23,6 +23,15 @@
 #define DISTRHO_PLUGIN_NAME "peacock-8"
 #define DISTRHO_PLUGIN_URI "https://gjcp.net/plugins/peacock"
 
+#define DISTRHO_PLUGIN_CLAP_ID "net.gjcp.peacock"
+#define DISTRHO_PLUGIN_CLAP_FEATURES "instrument","synthesizer","stereo"
+
+#define DISTRHO_PLUGIN_BRAND_ID GJCP
+#define DISTRHO_PLUGIN_UNIQUE_ID Pfau
+
+#define DISTRHO_PLUGIN_LV2_CATEGORY "lv2:InstrumentPlugin"
+#define DISTRHO_PLUGIN_VST_CATEGORY "Fx|Instrument"
+
 #define DISTRHO_PLUGIN_NUM_INPUTS 0
 #define DISTRHO_PLUGIN_NUM_OUTPUTS 2
 #define DISTRHO_PLUGIN_IS_SYNTH 1
@@ -63,7 +72,11 @@
         pSustain,
         pRelease,
 
-        pChorus,
+        pChorusMode,
+
+        pVcoBend,
+        pVcfBend,
+        pModDepth,
 
         parameterCount
     };

plugin/Makefile

@@ -34,7 +34,8 @@ include ../dpf/Makefile.plugins.mk
 
 SKIP_NATIVE_AUDIO_FALLBACK = true
 
-TARGETS +=  jack lv2_sep
+# omitting LV2 for the moment until I figure out cross-compiling
+TARGETS += jack vst2 vst3 clap
 
 all: $(TARGETS)
 

plugin/assigner.cpp

@@ -43,7 +43,12 @@ Assigner::Assigner() {
 }
 
 void Assigner::handleMidi(MidiEvent* ev) {
+
     uint8_t status = ev->data[0];
+    
+    //printf("called with event %04x (%02x): %02x %02x %02x\n", ev->frame, ev->size,  ev->data[0], ev->data[1], ev->data[2]);
+    if (ev->size > 3) return; // sysex bug
+    
     switch (status & 0xf0) {
         case 0x80:
             noteOff(ev->data[1]);
@@ -56,9 +61,11 @@ void Assigner::handleMidi(MidiEvent* ev) {
             break;
         case 0xb0:
             switch (ev->data[1]) {
+                case 0x01:  // modwheel
+                    printf("mod wheel %02x\n", ev->data[2]);
+                    m->modWheel = ev->data[2];
                 // handle the following
-                // CC   1 - modwheel
+                // CC  64 - sustain // FIXME sustain not implemented
-                // CC  64 - sustain
                 // possibly JU-06 CC values
                 default:
                     break;
@@ -66,7 +73,8 @@ void Assigner::handleMidi(MidiEvent* ev) {
             break;  // nothing to do here except in special cases where we don't expect the host to pass on controls
         case 0xc0:  // program change
             break;
-        case 0xe0:  // pitch bend;
+        case 0xe0:  // pitch bend 
+            m->bend = ((ev->data[1] + (ev->data[2]<<7))>>5)-0x100;
             break;
         case 0xf0:  // sysex
             break;
@@ -110,6 +118,10 @@ void Assigner::noteOn(uint8_t note) {
         return;
     }
 
+    if ((noteTbl[voiceTbl[0]] & 0x80)) {
+        m->lfoRampOn();
+    }
+
     // loop around the voices
     for (i = NUM_VOICES - 1; i >= 0; i--) {
         v = voiceTbl[i];
@@ -137,6 +149,6 @@ void Assigner::noteOn(uint8_t note) {
     // printf("at end, l=%d e=%d\n", l,e);
     noteTbl[v] = note;
 
-    d_debug("send voice on %3d to voice %d", note, v);
+    d_debug("send voice on %3d to voice %d", note, i);
     voice[v].on(note);
 }

plugin/assigner.hpp

@@ -27,6 +27,7 @@ class Assigner {
     Assigner();
     void handleMidi(MidiEvent* ev);
     Voice* voice;
+    Module *m;
 
    private:
     void noteOn(uint8_t note);     // incoming note on (or off, if velocity = 0)

plugin/chorus.cpp

@@ -19,8 +19,8 @@
 #include "chorus.hpp"
 
 #include <math.h>
+#include <stdio.h>
 #include <string.h>
-
 Chorus::Chorus() {
     lpfOut1 = new float[bufferSize];
     lpfOut2 = new float[bufferSize];
@@ -29,7 +29,8 @@ Chorus::Chorus() {
     lfoPhase = 1;
     lfoSpeed = 6.283 * 10.7 / sampleRate;  // plainly silly value to show if it hasn't been set
 
-    gainTC = 1 - exp(-6.283 * 10 / sampleRate);
+    gainTC = 1 - exp(-M_PI * 10 / sampleRate);  // 1/10th of a second declick
+    bbdTC = 1 - exp(-M_PI * 60 / sampleRate);   // hpf into BBD 
 
     // not quite Butterworth but you'd never hear the difference
     // these are calculated from the real-world component values
@@ -58,7 +59,7 @@ void Chorus::run(float* input, float** outputs, uint32_t frames) {
     // run highpass / bass boost and stereo chorus effect for one full block
 
     float s0 = 0, s1 = 0;
-    float lfoMod, dly1, frac, flt;
+    float dly1, frac, flt;
     uint16_t tap, delay;
 
     for (uint32_t i = 0; i < frames; i++) {
@@ -75,11 +76,14 @@ void Chorus::run(float* input, float** outputs, uint32_t frames) {
         hpDelay = flt;
         input[i] += (flt * hpGain);
 
-        ram[delayptr] = input[i];
+        flt = ((input[i] - bbdRC) * bbdTC) + bbdRC;
+        bbdRC = flt;
+
+        ram[delayptr] = input[i] - flt;
 
 // delays in milliseconds
-#define BASE 0.005
+#define BASE 0.0035
-#define AMT 0.00175
+#define AMT 0.002
 
         dly1 = (BASE + (AMT * lfoPhase)) * sampleRate;
         delay = (int)dly1;
@@ -102,7 +106,6 @@ void Chorus::run(float* input, float** outputs, uint32_t frames) {
         delayptr++;
         delayptr &= 0x3ff;
     }
-
     postFilter1l->runSVF(lpfOut1, lpfOut1, frames);
     postFilter2l->runSVF(lpfOut1, lpfOut1, frames);
     postFilter1r->runSVF(lpfOut2, lpfOut2, frames);
@@ -111,7 +114,6 @@ void Chorus::run(float* input, float** outputs, uint32_t frames) {
     for (uint32_t i = 0; i < frames; i++) {
         float y = input[i];
         gainRC = (gain - gainRC) * gainTC + gainRC;
-
         outputs[0][i] = y + (gainRC * lpfOut1[i]);
         outputs[1][i] = y + (gainRC * lpfOut2[i]);
     }
@@ -125,11 +127,11 @@ void Chorus::setHpf(uint8_t mode) {
     // k = 1-exp(-2pi * Fc * sampleRate)
     switch (mode) {
         case 0x00:
-            hpCut = 1 - exp(-6.283 * 720 / sampleRate);
+            hpCut = 1 - exp(-M_PI * 720 / sampleRate);
             hpGain = -1;
             break;
         case 0x08:
-            hpCut = 1 - exp(-6.283 * 225 / sampleRate);
+            hpCut = 1 - exp(-M_PI * 225 / sampleRate);
             hpGain = -1;
             break;
         case 0x10:
@@ -138,7 +140,7 @@ void Chorus::setHpf(uint8_t mode) {
             break;
         case 0x18:
             hpCut = 1 - exp(-6.283 * 85 / sampleRate);
-            hpGain = 1.707;
+            hpGain = 1.0;
             break;
     }
 }
@@ -147,15 +149,16 @@ void Chorus::setChorus(uint8_t mode) {
     // switch chorus mode
     switch (mode) {
         case 0x60:
+        case 0x20:
             gain = 0;
             break;
         case 0x40:
             gain = 1.2;
-            lfoSpeed = 6.283 * 0.5 / sampleRate;
+            lfoSpeed = M_PI * 0.525 / sampleRate;
             break;
         case 0x00:
             gain = 1.2;
-            lfoSpeed = 6.283 * 0.9 / sampleRate;
+            lfoSpeed = M_PI * 0.85 / sampleRate;
             break;
     }
 }

plugin/chorus.hpp

@@ -46,6 +46,8 @@ class Chorus {
     float gainRC = 0;
     float gainTC = 0;
 
+    float bbdRC=0, bbdTC=0;
+
 
     uint16_t delayptr = 0;
 

plugin/module.cpp

@@ -25,13 +25,14 @@
 
 Module::Module() {
     // cutoff frequencies for various RC networks
-    vcaTC = 1 - exp(-6.283 * 159 / sampleRate);  // VCA and VCF 10k/0.1u time constant
+    vcaTC = 1 - exp(-M_PI * 159 / sampleRate);  // VCA and VCF 10k/0.1u time constant
-    subTC = 1 - exp(-6.283 * 15 / sampleRate);   // Main VCA and Sub Level 1k + 10u time constant
+    subTC = 1 - exp(-M_PI * 15 / sampleRate);   // Main VCA and Sub Level 1k + 10u time constant
-    pwmTC = 1 - exp(-6.283 * 40 / sampleRate);   // integrator with 100k/0.047u 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() {
@@ -40,59 +41,115 @@ Module::~Module() {
     delete subBuf;
     delete pwmBuf;
 }
+
+void Module::genNoise() {
+    for (uint32_t i = 0; i < bufferSize; i++) {
+        noiseRNG *= 0x8088405;
+        noiseRNG++;
+        noiseBuf[i] = 1 - (noiseRNG & 0xffff) / 32768.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 * (int)(patchRam.pwmLfo*0.9125)) >> 7);       // FIXME tidy up this bit
+}
+
 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
 
-    square = (patchRam.switch1 & 0x08) ? 0.63 : 0;
+    master = powf(2, (patchRam.vca / 31.75 - 4.0f)) * 0.1;
-    saw = (patchRam.switch1 & 0x10) ? 0.8 : 0;
-    sub = patchRam.sub / 127.0f;
-    lfoPhase += lfoRateTable[patchRam.lfoRate];
 
-    res = patchRam.vcfReso / 127.0 * 5;
+    square = (patchRam.switch1 & 0x08) ? 1 : 0;
-    noise = patchRam.noise / 127.0;
+    saw = (patchRam.switch1 & 0x10) ? 1 : 0;
+    sub = (patchRam.sub / 127.0f) * 1.4;
+
+    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);
 
-    if (lfoPhase & 0x4000)
+    runLFO();
-        lfo = 0x1fff - (lfoPhase & 0x3fff);
-    else
-        lfo = (lfoPhase & 0x3fff) - 0x1fff;
-
-    // FIXME represent PW as int until we calculate the block?
-    pw = 0.5 - ((0x2000 + lfo) * patchRam.pwmLfo) / (32768.0f * 128);
-    pw = (patchRam.switch2 & 0x01) ? 0.5 - (patchRam.pwmLfo / 256.0f) : pw;
-
-    float master = powf(2, (patchRam.vca / 31.75 - 4.0f));
-    float sub = patchRam.sub/ 127.0f;
 
+    // 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 - pwmRC) * pwmTC + pwmRC;
+        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++;
     }
 
-    int16_t vcf = (patchRam.vcfEnv << 7) * ((patchRam.switch2 & 0x02) ? -1 : 1);
+    lfoToVco = (lfoDepthTable[patchRam.vcoLfo] * lfoDelay) >> 8;  // lookup table is 0-255
+    lfoToVco += ((int)(modWheel * modDepth));
 
-    int16_t pitchBase = 0x1818;
+    if (lfoToVco > 0xff) lfoToVco = 0xff;
-    pitchBase += (lfo * lfoDepthTable[patchRam.vcoLfo]) >> 9;
+    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 += vcoBendDepth * bend;
+
+    vcfBase = (patchRam.vcfFreq << 7);
+    vcfBase += lfoToVcf;
+    vcfBase += vcfBendDepth * bend;
+    if (vcfBase > 0x3fff) vcfBase = 0x3fff;
+    if (vcfBase < 0x0000) vcfBase = 0x0000;
+
+    // per-voice calculations
     for (uint32_t i = 0; i < NUM_VOICES; i++) {
-        // maybe move all this into voice.cpp FIXME
+        // run one step of the envelope
         Voice* v = &voices[i];
         switch (v->envPhase) {
             case 0:                           // release phase FIXME use an enum I guess
@@ -111,21 +168,30 @@ void Module::run(Voice* voices, uint32_t blockSize) {
         }
 
         // pitch
-        // FIXME clean this all up a bit
+        uint16_t pitch = pitchBase + (v->note << 8);
-        int16_t pitch = pitchBase + (v->note << 8);
+        int8_t semi = pitch >> 8;
-        int16_t semi = pitch >> 8;
+        semi -= 36;
         float frac = (pitch & 0xff) / 256.0;
-
+        if (semi < 0) {
+            semi = 0;
+            frac = 0;
+        }
+        if (semi >= 103) {
+            semi = 103;
+            frac = 0;
+        };
         float p1 = pitchTable[semi], p2 = pitchTable[semi + 1];
-        int16_t px = ((p2 - p1) * frac + p1);
+        int16_t px = ((p2 - p1) * frac + p1);  // interpolated pitch from table
 
+        // octave divider
         px *= (patchRam.switch1 & 0x07);
 
-        v->omega = px / (sampleRate * 4.0f);  // fixme use proper scaler
+        v->omega = px / sampleRate;  // FIXME recalculate table using proper scaler
 
         // per voice we need to calculate the key follow amount and envelope amount
-        v->vcfCut = (patchRam.vcfFreq << 7) + ((vcf * v->env) >> 14);
+        v->vcfCut = vcfBase + (((v->env * patchRam.vcfEnv) >> 7) * ((patchRam.switch2 & 0x02) ? -1 : 1));
-        v->vcfCut += (int)(v->note * (patchRam.vcfKey << 1) * 0.375);
+
+        v->vcfCut += (int)((v->note - 60) * (patchRam.vcfKey << 1) * 0.375);
 
         if (v->vcfCut > 0x3fff) v->vcfCut = 0x3fff;
         if (v->vcfCut < 0) v->vcfCut = 0;

plugin/module.hpp

@@ -33,40 +33,39 @@ class Module {
     Module();
     ~Module();
 
+    void genNoise();
+    void lfoRampOn();
     void run(Voice* voices, uint32_t blockLeft);
 
     float res = 0;
-    // precomputed values for all voices
-    float pw;  //, saw, square, sub;
 
     // "internal state" values for patch parameters
     uint16_t a, d, s, r;
-    int16_t lfo;
-    uint32_t lfoPhase;
-
-    float saw = 0, square = 0, sub = 0, noise = 0;
-
 
+    float saw = 0, square = 0, sub = 0, noise = 0, master = 0;
+    int16_t bend = 0, modWheel=0;
+    float vcoBendDepth = 4, vcfBendDepth=1.5, modDepth=.5;
     struct {
-        uint8_t lfoRate = 0x18;
+        uint8_t lfoRate = 0x1f;
         uint8_t lfoDelay = 0x00;
         uint8_t vcoLfo = 0x00;
-        uint8_t pwmLfo = 0x60;
+        uint8_t pwmLfo = 0x3c;
         uint8_t noise = 0x00;
-        uint8_t vcfFreq = 0x30;  // 1c;  // 0x3f80
+        uint8_t vcfFreq = 0x25;  // 1c;  // 0x3f80
-        uint8_t vcfReso = 0x00;
+        uint8_t vcfReso = 0x1d;
-        uint8_t vcfEnv = 0x40;  // 4e;
+        uint8_t vcfEnv = 0x1c;  // 4e;
-        uint8_t vcfLfo = 0;
+        uint8_t vcfLfo = 0x00;
-        uint8_t vcfKey = 0x7f;  // 47;
+        uint8_t vcfKey = 0x2b;  // 47;
-        uint8_t vca = 0x28;
+        uint8_t vca = 0x5c;
         uint8_t env_a = 0x00;
-        uint8_t env_d = 0x39;
+        uint8_t env_d = 0x2a;
-        uint8_t env_s = 0x30;  // 0x3f80
+        uint8_t env_s = 0x23;  // 0x3f80
-        uint8_t env_r = 0x30;
+        uint8_t env_r = 0x00;
         uint8_t sub = 0x40;
-        uint8_t switch1 = 0x59;
+        uint8_t switch1 = 0x19;
         uint8_t switch2 = 0x18;
     } patchRam;
+
     Chorus* chorus;
 
     float vcaTC;
@@ -75,13 +74,25 @@ class Module {
     float* vcaBuf;
     float* subBuf;
     float* pwmBuf;
+    float* noiseBuf;
 
    private:
+    void runLFO();
+
     // precalculated coefficients for RC networks
     float pwmTC = 0, subTC = 0, mVcaTC = 0;
     float pwmRC = 0, subRC = 0, vcaRC = 0;
 
-    // controls
+    int16_t lfo, pw;
+    int16_t lfoPhase;
+    uint8_t lfoState = 0;
+    uint16_t lfoRate;
+
+    uint32_t noiseRNG = 1;
+
+    uint16_t lfoDelay = 0;
+    uint8_t lfoDelayState = 0;
+    uint16_t lfoDelayTimer = 0;
 };
 
 class Voice {
@@ -91,7 +102,7 @@ class Voice {
     Voice();
     void on(uint8_t midiNote);
     void off();
-    void run(Module* m, float* buffer, uint32_t samples);
+    void run(Module* m, float* buffer, uint32_t framePos, uint32_t samples);
 
    private:
     float omega = 0, theta = 0;   // phase increment and angle FIXME better names
@@ -99,16 +110,16 @@ class Voice {
     uint8_t pulseStage = 1;       // pulse wave phase
     float subosc = 1;             // sub oscillator flipflop output
 
-    uint8_t envPhase = 0;
+    uint8_t envPhase = 0;   // current running state of envelope
-    int16_t env = 0;  // output amplitude
+    int16_t env = 0; // calculated envelope amount
-    int16_t vcfCut;
+    int16_t vcfCut; // calculated cutoff to filter
-    int16_t vcaEnv;
+    int16_t vcaEnv; // calculated level to VCA (env/gate)
-    float vcaRC = 0, vcfRC = 0;
+    float vcaRC = 0, vcfRC = 0; // RC circuit state values
 
     uint8_t note = 0;
 
     // filter
-    float b1 = 0, b2 = 0, b3 = 0, b4 = 0;
+    float y0 = 0, y1 = 0, y2 = 0, y3 = 0;
 };
 
 #endif

plugin/parameters.cpp

@@ -23,7 +23,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pLFORate:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "LFO Rate";
-            parameter.symbol = "ch_lforate";
+            parameter.symbol = "pfau_lforate";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 48.0f;
@@ -33,7 +33,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pLFODelay:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "LFO Delay";
-            parameter.symbol = "ch_lfodelay";
+            parameter.symbol = "pfau_lfodelay";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 0.0f;
@@ -43,7 +43,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pVCORange:
             parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
             parameter.name = "Range";
-            parameter.symbol = "ch_vcorange";
+            parameter.symbol = "pfau_vcorange";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 2.0f;
             parameter.ranges.def = 1.0f;
@@ -60,13 +60,12 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
                 enumValues[2].label = "4'";
                 parameter.enumValues.values = enumValues;
             }
-
             break;
 
         case pLFODepth:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "LFO";
-            parameter.symbol = "ch_lfo";
+            parameter.symbol = "pfau_lfo";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 10.0f;
@@ -76,7 +75,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pPWMDepth:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "PWM";
-            parameter.symbol = "ch_pwm";
+            parameter.symbol = "pfau_pwm";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 48.0f;
@@ -86,7 +85,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pPWMMode:
             parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
             parameter.name = "PWM Mode";
-            parameter.symbol = "ch_pwmmode";
+            parameter.symbol = "pfau_pwmmode";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 1.0f;
             parameter.ranges.def = 1.0f;
@@ -107,7 +106,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pSaw:
             parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
             parameter.name = "Saw";
-            parameter.symbol = "ch_saw";
+            parameter.symbol = "pfau_saw";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 1.0f;
             parameter.ranges.def = 1.0f;
@@ -117,7 +116,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pSqr:
             parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
             parameter.name = "Square";
-            parameter.symbol = "ch_sqr";
+            parameter.symbol = "pfau_sqr";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 1.0f;
             parameter.ranges.def = 1.0f;
@@ -127,7 +126,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pSubLevel:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "Sub Osc";
-            parameter.symbol = "ch_sub";
+            parameter.symbol = "pfau_sub";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 0.0f;
@@ -137,7 +136,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pNoiseLevel:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "Noise";
-            parameter.symbol = "ch_noise";
+            parameter.symbol = "pfau_noise";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 0.0f;
@@ -147,7 +146,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pHPF:
             parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
             parameter.name = "HPF";
-            parameter.symbol = "ch_hpf";
+            parameter.symbol = "pfau_hpf";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 3.9f;
             parameter.ranges.def = 0.0f;
@@ -157,7 +156,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pCutoff:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "Freq";
-            parameter.symbol = "ch_freq";
+            parameter.symbol = "pfau_freq";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 60.0f;
@@ -166,7 +165,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pRes:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "Res";
-            parameter.symbol = "ch_reso";
+            parameter.symbol = "pfau_reso";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 0.0f;
@@ -175,7 +174,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pVCFPol:
             parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
             parameter.name = "Polarity";
-            parameter.symbol = "ch_vcfmode";
+            parameter.symbol = "pfau_vcfmode";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 1.0f;
             parameter.ranges.def = 0.0f;
@@ -195,7 +194,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pEnv:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "Env";
-            parameter.symbol = "ch_vcfenv";
+            parameter.symbol = "pfau_vcfenv";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 46.0f;
@@ -204,7 +203,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pLfo:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "LFO";
-            parameter.symbol = "ch_vcflfo";
+            parameter.symbol = "pfau_vcflfo";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 0.0f;
@@ -213,7 +212,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pKyb:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "Kybd";
-            parameter.symbol = "ch_vcfkey";
+            parameter.symbol = "pfau_vcfkey";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 71.0f;
@@ -223,7 +222,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pAttack:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "Attack";
-            parameter.symbol = "ch_attack";
+            parameter.symbol = "pfau_attack";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 27.0f;
@@ -233,7 +232,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pDecay:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "Decay";
-            parameter.symbol = "ch_decay";
+            parameter.symbol = "pfau_decay";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 57.0f;
@@ -243,7 +242,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pSustain:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "Sustain";
-            parameter.symbol = "ch_sustain";
+            parameter.symbol = "pfau_sustain";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 57.0f;
@@ -253,7 +252,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pRelease:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "Release";
-            parameter.symbol = "ch_release";
+            parameter.symbol = "pfau_release";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 48.0f;
@@ -263,7 +262,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pEnvGate:
             parameter.hints = kParameterIsAutomatable | kParameterIsInteger;  // | kParameterIsBoolean;
             parameter.name = "Env-Gate";
-            parameter.symbol = "ch_envgate";
+            parameter.symbol = "pfau_envgate";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 1.0f;
             parameter.ranges.def = 0.0f;
@@ -283,25 +282,62 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
         case pVCALevel:
             parameter.hints = kParameterIsAutomatable;
             parameter.name = "VCA Level";
-            parameter.symbol = "ch_vcalevel";
+            parameter.symbol = "pfau_vcalevel";
             parameter.ranges.min = 0.0f;
             parameter.ranges.max = 127.0f;
             parameter.ranges.def = 40.0f;
             parameter.midiCC = 26;
             break;
-            /*
+
-                    case pModWheel:
+        case pChorusMode:
-                        parameter.hints = kParameterIsAutomatable | kParameterIsHidden;
+            parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
-                        parameter.name = "Mod wheel";
+            parameter.name = "Chorus";
-                        parameter.symbol = "ch_modwheel";
+            parameter.symbol = "pfau_chorus";
             parameter.ranges.min = 0.0f;
-                        parameter.ranges.max = 127.0f;
+            parameter.ranges.max = 2.0f;
             parameter.ranges.def = 0.0f;
-                        parameter.midiCC = 1;
+            parameter.midiCC = 93;
-                        break;
+            parameter.enumValues.count = 3;
-                        */
+            parameter.enumValues.restrictedMode = true;
+            {
+                ParameterEnumerationValue* const enumValues = new ParameterEnumerationValue[3];
+                enumValues[0].value = 0.0f;
+                enumValues[0].label = "Off";
+                enumValues[1].value = 1.0f;
+                enumValues[1].label = "Slow";
+                enumValues[2].value = 2.0f;
+                enumValues[2].label = "Fast";
+                parameter.enumValues.values = enumValues;
+            }
+            break;
+
+        case pVcoBend:
+            parameter.hints = kParameterIsAutomatable;
+            parameter.name = "VCO Bend";
+            parameter.symbol = "pfau_vcobend";
+            parameter.ranges.min = 0.0f;
+            parameter.ranges.max = 12.0f;
+            parameter.ranges.def = 4.0f;
+            break;
+
+        case pVcfBend:
+            parameter.hints = kParameterIsAutomatable;
+            parameter.name = "VCF Bend";
+            parameter.symbol = "pfau_vcfbend";
+            parameter.ranges.min = 0.0f;
+            parameter.ranges.max = 42.0f;
+            parameter.ranges.def = 4.0f;
+            break;
+
+        case pModDepth:
+            parameter.hints = kParameterIsAutomatable;
+            parameter.name = "Mod Depth";
+            parameter.symbol = "pfau_moddepth";
+            parameter.ranges.min = 0.0f;
+            parameter.ranges.max = 4.0f;
+            parameter.ranges.def = 0.5f;
+            break;
     }
-    // chorus, porta, bend range, key mode still to do
 }
 
 void Peacock::setParameterValue(uint32_t index, float value) {
@@ -321,7 +357,7 @@ void Peacock::setParameterValue(uint32_t index, float value) {
             m->patchRam.vcoLfo = value;
             break;
         case pPWMDepth:
-            m->patchRam.pwmLfo = value / 1.27;
+            m->patchRam.pwmLfo = value;
             break;
         case pSubLevel:
             m->patchRam.sub = value;
@@ -379,9 +415,8 @@ void Peacock::setParameterValue(uint32_t index, float value) {
             m->patchRam.switch1 |= (value >= 0.5) << 4;
             break;
 
-        case pChorus:
+        case pChorusMode:
             m->patchRam.switch1 &= 0x9f;
-            
             switch ((int)value) {
                 case 0:
                     m->patchRam.switch1 |= 0x60;  // both off
@@ -415,10 +450,15 @@ void Peacock::setParameterValue(uint32_t index, float value) {
             m->patchRam.switch2 &= 0xe7;
             m->patchRam.switch2 |= (3 - (int)value) << 3;
             break;
-            /*
+        case pVcoBend:
-                    case pModWheel:
+            m->vcoBendDepth = value;
-                        //s.ff64 = (int)value << 1;
+            break;
-                        break;*/
+        case pVcfBend:
+            m->vcfBendDepth = value / 2.66f;
+            break;
+        case pModDepth:
+            m->modDepth = value;
+            break;
     }
 }
 
@@ -447,7 +487,7 @@ float Peacock::getParameterValue(uint32_t index) const {
             return m->patchRam.vcoLfo;
             break;
         case pPWMDepth:
-            return m->patchRam.pwmLfo * 1.27f;
+            return m->patchRam.pwmLfo;
             break;
 
         case pPWMMode:
@@ -506,8 +546,7 @@ float Peacock::getParameterValue(uint32_t index) const {
         case pVCALevel:
             return m->patchRam.vca;
             break;
-        case pChorus:
+        case pChorusMode:
-            
             switch (m->patchRam.switch1 & 0x60) {
                 case 0x60:
                     return 0;
@@ -518,8 +557,16 @@ float Peacock::getParameterValue(uint32_t index) const {
                 default:
                     break;
             }
-
+            break;
-
+        case pVcoBend:
+            return m->vcoBendDepth;
+            break;
+        case pVcfBend:
+            return m->vcfBendDepth * 2.66f;
+            break;
+        case pModDepth:
+            return m->modDepth;
+            break;
     }
     return 0;
 }

plugin/peacock.cpp

@@ -28,10 +28,12 @@ Peacock::Peacock() : Plugin(parameterCount, 0, 0) {
 
     sampleRate = getSampleRate();
     bufferSize = getBufferSize();
+    
     chorus = new Chorus();
     m = new Module();
     ic1 = new Assigner;
     ic1->voice = voice;
+    ic1->m = m;
     m->chorus = chorus;
 }
 
@@ -69,27 +71,27 @@ void Peacock::run(const float**, float** outputs, uint32_t frames, const MidiEve
     memset(outputs[0], 0, frames * sizeof(float));
     memset(outputs[1], 0, frames * sizeof(float));
 
+    m->genNoise();
+
     // if there were any events that happen between now and the end of this block, process them
     lastEvent = 0;
-    m->bufPtr = 0;
+    m->bufPtr = 0;  // reset the output buffer pointer
     runMidi(midiEvents, midiEventCount, blockLeft);
 
     while (framePos < frames) {
         if (blockLeft == 0) {
             // no more samples to calculate in this update period
-            blockLeft = sampleRate / 238;  // update rate in Hz
+            blockLeft = sampleRate / 233.5;  // update rate in Hz, measured
             runMidi(midiEvents, midiEventCount, framePos + blockLeft);
-
+            m->run(voice, blockLeft);
         }
 
         // how many frames to do? Are we about to run off an update block
         sizeThisTime = (framesLeft < blockLeft) ? framesLeft : blockLeft;
-        m->run(voice, sizeThisTime);
-
 
         // now run all the voices for this chunk of samples
         for (uint32_t i = 0; i < NUM_VOICES; i++) {
-            voice[i].run(m, outputs[0] + framePos, sizeThisTime);
+            voice[i].run(m, outputs[0], framePos, sizeThisTime);
         }
 
         framePos += sizeThisTime;
@@ -98,7 +100,7 @@ void Peacock::run(const float**, float** outputs, uint32_t frames, const MidiEve
     }
 
     // now we've assembled a full chunk of audio
-    //memcpy(outputs[0], m->vcaBuf, sizeof(float)* frames);
+    // memcpy(outputs[0], m->vcaBuf, sizeof(float)* frames);
     chorus->run(outputs[0], outputs, frames);
 }
 

plugin/tables.cpp

@@ -89,19 +89,19 @@ uint16_t lfoDelayTable[8] = {
     0xffff, 0x0419, 0x020c, 0x015e, 0x0100, 0x0100, 0x0100, 0x0100};
 
 float pitchTable[104] = {
-32.494, 34.430, 36.486, 38.658, 40.962, 43.399, 45.990, 48.731, 
+8.123, 8.607, 9.122, 9.664, 10.240, 10.850, 11.497, 12.183, 
-51.633, 54.711, 57.969, 61.419, 65.072, 68.944, 73.059, 77.405, 
+12.908, 13.678, 14.492, 15.355, 16.268, 17.236, 18.265, 19.351,
-82.014, 86.892, 92.077, 97.556, 103.365, 109.529, 116.043, 122.933,
+20.504, 21.723, 23.019, 24.389, 25.841, 27.382, 29.011, 30.733,
-130.242, 137.988, 146.220, 154.919, 164.136, 173.898, 184.264, 195.217,
+32.561, 34.497, 36.555, 38.730, 41.034, 43.474, 46.066, 48.804,
-206.847, 219.178, 232.207, 245.972, 260.586, 276.091, 292.569, 309.981,
+51.712, 54.795, 58.052, 61.493, 65.147, 69.023, 73.142, 77.495,
-328.407, 347.947, 368.664, 390.549, 413.822, 438.500, 464.576, 492.005,
+82.102, 86.987, 92.166, 97.637, 103.455, 109.625, 116.144, 123.001,
-521.241, 552.334, 585.309, 620.155, 657.030, 696.136, 737.463, 781.250,
+130.310, 138.083, 146.327, 155.039, 164.258, 174.034, 184.366, 195.312,
-827.815, 877.193, 929.368, 984.252, 1042.753, 1104.972, 1170.960, 1240.695,
+206.954, 219.298, 232.342, 246.063, 260.688, 276.243, 292.740, 310.174,
-1314.060, 1392.758, 1474.926, 1562.500, 1655.629, 1754.386, 1858.736, 1968.504,
+328.515, 348.189, 368.732, 390.625, 413.907, 438.596, 464.684, 492.126,
-2085.506, 2209.945, 2341.920, 2481.390, 2628.121, 2785.515, 2949.853, 3125.000,
+521.376, 552.486, 585.480, 620.347, 657.030, 696.379, 737.463, 781.250,
-3311.258, 3508.772, 3717.472, 3937.008, 4175.365, 4424.779, 4683.841, 4962.779,
+827.815, 877.193, 929.368, 984.252, 1043.841, 1106.195, 1170.960, 1240.695,
-5263.158, 5571.031, 5899.705, 6250.000, 6622.517, 7017.544, 7434.944, 7874.016,
+1315.789, 1392.758, 1474.926, 1562.500, 1655.629, 1754.386, 1858.736, 1968.504,
-8333.333, 8849.558, 9389.671, 9950.249, 10526.316, 11173.184, 11834.320, 12500.000
+2083.333, 2212.389, 2347.418, 2487.562, 2631.579, 2793.296, 2958.580, 3125.000,
 };
 
 #endif

plugin/ui.cpp

@@ -258,17 +258,20 @@ void DistrhoUIPeacock::parameterChanged(uint32_t index, float value) {
             sw1 &= 0xf8;  // mask
             if (value > 2) value = 2;
             sw1 |= (1 << (int)value);
+            repaint();
             break;
         case pSqr:
             sw1 &= 0xf7;
             sw1 |= ((value >= 0.5)) << 3;
+            repaint();
             break;
         case pSaw:
             sw1 &= 0xef;
             sw1 |= (value > 0.5) << 4;
+            repaint();
             break;
 
-        case pChorus:
+        case pChorusMode:
             sw1 &= 0x9f;
             // 60, 40, 00
             switch ((int)value) {
@@ -282,6 +285,8 @@ void DistrhoUIPeacock::parameterChanged(uint32_t index, float value) {
                     sw1 |= 0x00;
                     break;
             }
+            repaint();
+            break;
     }
 }
 
@@ -325,20 +330,21 @@ void DistrhoUIPeacock::imageButtonClicked(ImageButton* imgBtn, int) {
             break;
         case btnCh0:
             sw1 = (sw1 & 0x9f) | 0x20;
-            setParameterValue(pChorus, 0);
+            setParameterValue(pChorusMode, 0);
             break;
         case btnCh1:
             sw1 = (sw1 & 0x9f) | 0x40;
-            setParameterValue(pChorus, 1);
+            setParameterValue(pChorusMode, 1);
             break;
         case btnCh2:
             sw1 = (sw1 & 0x9f);
-            setParameterValue(pChorus, 2);
+            setParameterValue(pChorusMode, 2);
             break;
 
         default:
             break;
     }
+    repaint();
 }
 
 void DistrhoUIPeacock::onDisplay() {

plugin/voice.cpp

@@ -40,11 +40,9 @@ Voice::Voice() {
 }
 
 void Voice::on(uint8_t midiNote) {
-    // omega = 261.63 * powf(2, (note - 60) / 12.0f) / 48000.0f;
+    while (midiNote < 24) midiNote += 12;   // limit lowest note to C1
-    if (midiNote > 24)
+    while (midiNote > 108) midiNote -= 12;  // limit highest note to C8
-        note = midiNote - 24;
+    note = midiNote;
-    else
-        note = 24;
     envPhase = 1;
 }
 
@@ -52,17 +50,19 @@ void Voice::off() {
     envPhase = 0;
 }
 
-void Voice::run(Module* m, float* buffer, uint32_t samples) {
+void Voice::run(Module* m, float* buffer, uint32_t framePos, uint32_t samples) {
     // carry out per-voice calculations for each block of samples
     float out, t, fb;
 
-    // FIXME incorrect
     // calculate cutoff frequency
-    float cut = 248.0f * (powf(2, (vcfCut - 0x1880) / 1143.0f));
+    float cut = 261.0f * (powf(2, (vcfCut - 0x1880) / 1143.0f));    // FIXME explain magic numbers
-    cut = 0.25 * 6.2832 * cut / 48000.0f;  // FIXME hardcoded values
+    cut = M_PI * cut / sampleRate;
     cut = cut / (1 + cut);  // correct tuning warp
+    if (cut > 0.7) cut = 0.7;
 
-    float amp = vcaEnv / 4096.0f;
+    float r = 6 * m->res;
+
+    float amp = vcaEnv / 32768.0f;
 
     for (uint32_t i = 0; i < samples; i++) {
         out = delay;
@@ -94,36 +94,31 @@ void Voice::run(Module* m, float* buffer, uint32_t samples) {
             }
         }
 
-        // FIXME DC offset removal
         delay += m->saw * (1 - (2 * theta));
         delay += m->square * ((pulseStage ? -1.f : 1.f) - m->pwmBuf[i] + 0.5);
-        delay += m->subBuf[i] * subosc ;
+        delay += m->subBuf[i] * subosc;
 
-        out += m->noise * (0.8 - 1.6 * (rand() & 0xffff) / 65536.0);
+        out += m->noise * m->noiseBuf[i + framePos];
-        out *= 0.5;
 
         // same time constant for both VCF and VCF RC circuits
         vcfRC = (cut - vcfRC) * m->vcaTC + vcfRC;
 
-        for (uint8_t ovs = 0; ovs < 4; ovs++) {
+        for (uint8_t ovs = 0; ovs < 2; ovs++) {
-            fb = b4;
+            fb = y3;
             // hard clip
-            fb = ((out * 0.5) - fb) * m->res;
+            fb = ((out * 0.5) - fb) * r;
-            if (fb > 4) fb = 4;
+            if (fb > 6) fb = 6;
-            if (fb < -4) fb = -4;
+            if (fb < -6) fb = -6;
-            // fb = 1.5 * fb - 0.5 * fb * fb * fb;
-            //
 
-            b1 = ((out + fb - b1) * vcfRC) + b1;
+            y0 = ((out + fb - y0) * vcfRC) + y0;
-            b2 = ((b1 - b2) * vcfRC) + b2;
+            y1 = ((y0 - y1) * vcfRC) + y1;
-            b3 = ((b2 - b3) * vcfRC) + b3;
+            y2 = ((y1 - y2) * vcfRC) + y2;
-            b4 = ((b3 - b4) * vcfRC) + b4;
+            y3 = ((y2 - y3) * vcfRC) + y3;
         }
-
         vcaRC = (amp - vcaRC) * m->vcaTC + vcaRC;
-        buffer[i] += 0.09367 * m->vcaBuf[i] * vcaRC * b4;
+        buffer[framePos + i] += m->vcaBuf[i] * vcaRC * y3;
 
         lastpw = m->pwmBuf[i];
     }
-    // buffer[0] += 1;
+    // buffer[0] += 1; // buzzing noise to test
 }