mystran filter

parameter MIDI value
proper parameter for chorus
2025-12-26 22:08:52 +00:00 · 2025-12-26 00:28:58 +00:00 · 2025-12-25 23:21:12 +00:00 · 2025-12-24 01:46:37 +00:00 · 2025-12-24 00:34:52 +00:00 · 2025-12-23 23:53:41 +00:00
11 changed files with 16192 additions and 15972 deletions
--- a/plugin/DistrhoPluginInfo.h
+++ b/plugin/DistrhoPluginInfo.h
@ -63,7 +63,7 @@
        pSustain,
        pRelease,

-        pChorus,
+        pChorusMode,

        parameterCount
    };
--- a/plugin/artwork.cpp
+++ b/plugin/artwork.cpp
--- a/plugin/assigner.cpp
+++ b/plugin/assigner.cpp
@ -110,6 +110,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 +141,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);
 }
--- a/plugin/assigner.hpp
+++ b/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)
--- a/plugin/chorus.cpp
+++ b/plugin/chorus.cpp
@ -147,6 +147,7 @@ void Chorus::setChorus(uint8_t mode) {
    // switch chorus mode
    switch (mode) {
        case 0x60:
+        case 0x20:
            gain = 0;
            break;
        case 0x40:
--- a/plugin/module.cpp
+++ b/plugin/module.cpp
@ -40,9 +40,29 @@ Module::~Module() {
    delete subBuf;
    delete pwmBuf;
 }
+
+void Module::lfoRampOn() {
+    lfoDelayState = 1;
+    lfoDelayTimer = 0;
+    lfoDelay = 0;
+}
+
 void Module::run(Voice* voices, uint32_t blockSize) {
    // run updates for module board

+    if (lfoDelayState == 1) {
+        lfoDelayTimer += lfoDelayTable[patchRam.lfoDelay >> 4];
+        if (lfoDelayTimer & 0xc000) lfoDelayState = 2;
+    }
+    if ((lfoDelayState == 2)) {
+        lfoDelay += attackTable[patchRam.lfoDelay];
+    }
+
+    if (lfoDelay & 0xc000) {
+        lfoDelayState = 0;
+        lfoDelay = 0x3fff;
+    }
+
    // 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
@ -54,7 +74,7 @@ void Module::run(Voice* voices, uint32_t blockSize) {
    sub = patchRam.sub / 127.0f;
    lfoPhase += lfoRateTable[patchRam.lfoRate];

-    res = patchRam.vcfReso / 127.0 * 5;
+    res = patchRam.vcfReso / 127.0;
    noise = patchRam.noise / 127.0;

    // FIXME the exp in these is expensive, don't call it all the time
@ -70,8 +90,10 @@ void Module::run(Voice* voices, uint32_t blockSize) {
    pw = 0.5 - ((0x2000 + lfo) * patchRam.pwmLfo) / (32768.0f * 128);
    pw = (patchRam.switch2 & 0x01) ? 0.5 - (patchRam.pwmLfo / 256.0f) : pw;

+    lfo = (lfo * lfoDelay) >> 14;
+
    float master = powf(2, (patchRam.vca / 31.75 - 4.0f));
-    float sub = patchRam.sub/ 127.0f;
+    float sub = patchRam.sub / 127.0f;

    for (uint32_t i = 0; i < blockSize; i++) {
        vcaRC = (master - vcaRC) * subTC + vcaRC;
@ -82,14 +104,13 @@ void Module::run(Voice* voices, uint32_t blockSize) {
        pwmBuf[i] = pwmRC;
        subBuf[i] = subRC;

-
        if (bufPtr < bufferSize) bufPtr++;
    }

    int16_t vcf = (patchRam.vcfEnv << 7) * ((patchRam.switch2 & 0x02) ? -1 : 1);

    int16_t pitchBase = 0x1818;
-    pitchBase += (lfo * lfoDepthTable[patchRam.vcoLfo]) >> 9;
+    pitchBase += (lfo * lfoDepthTable[patchRam.vcoLfo]) >> 11;

    for (uint32_t i = 0; i < NUM_VOICES; i++) {
        // maybe move all this into voice.cpp FIXME
@ -121,11 +142,13 @@ void Module::run(Voice* voices, uint32_t blockSize) {

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

-        v->omega = px / (sampleRate * 4.0f);  // fixme use proper scaler
+        v->omega = px / (sampleRate * 8.0f);  // fixme use 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 += (int)(v->note * (patchRam.vcfKey << 1) * 0.375);
+        v->vcfCut += (lfo * patchRam.vcfLfo) >> 9;
+
+        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;
--- a/plugin/module.hpp
+++ b/plugin/module.hpp
@ -33,6 +33,8 @@ class Module {
    Module();
    ~Module();

+    void lfoRampOn();
+
    void run(Voice* voices, uint32_t blockLeft);

    float res = 0;
@ -46,27 +48,50 @@ class Module {

    float saw = 0, square = 0, sub = 0, noise = 0;

-
+#if 0 
    struct {
-        uint8_t lfoRate = 0x18;
+                uint8_t lfoRate = 0x58;
        uint8_t lfoDelay = 0x00;
        uint8_t vcoLfo = 0x00;
-        uint8_t pwmLfo = 0x60;
+        uint8_t pwmLfo = 0x3b;
        uint8_t noise = 0x00;
-        uint8_t vcfFreq = 0x30;  // 1c;  // 0x3f80
-        uint8_t vcfReso = 0x00;
-        uint8_t vcfEnv = 0x40;  // 4e;
-        uint8_t vcfLfo = 0;
-        uint8_t vcfKey = 0x7f;  // 47;
-        uint8_t vca = 0x28;
+        uint8_t vcfFreq = 0x25;  // 1c;  // 0x3f80
+        uint8_t vcfReso = 0x6a;
+        uint8_t vcfEnv = 0x25;  // 4e;
+        uint8_t vcfLfo = 0x00;
+        uint8_t vcfKey = 0x00;  // 47;
+        uint8_t vca = 0x35;
        uint8_t env_a = 0x00;
-        uint8_t env_d = 0x39;
-        uint8_t env_s = 0x30;  // 0x3f80
-        uint8_t env_r = 0x30;
-        uint8_t sub = 0x40;
-        uint8_t switch1 = 0x59;
+        uint8_t env_d = 0x3c;
+        uint8_t env_s = 0x00;  // 0x3f80
+        uint8_t env_r = 0x3c;
+        uint8_t sub = 0x7f;
+        uint8_t switch1 = 0x4a;
        uint8_t switch2 = 0x18;
    } patchRam;
+
+#else
+    struct {
+        uint8_t lfoRate = 0x40;
+        uint8_t lfoDelay = 0x00;
+        uint8_t vcoLfo = 0x00;
+        uint8_t pwmLfo = 0x00;
+        uint8_t noise = 0x01;
+        uint8_t vcfFreq = 0x31;
+        uint8_t vcfReso = 0x7f;
+        uint8_t vcfEnv = 0x00;
+        uint8_t vcfLfo = 0x00;
+        uint8_t vcfKey = 0x7f;
+        uint8_t vca = 0x40;
+        uint8_t env_a = 0x00;
+        uint8_t env_d = 0x00;
+        uint8_t env_s = 0x00;  // 0x3f80
+        uint8_t env_r = 0x00;
+        uint8_t sub = 0x00;
+        uint8_t switch1 = 0x22;
+        uint8_t switch2 = 0x1d;
+    } patchRam;
+#endif
    Chorus* chorus;

    float vcaTC;
@ -75,13 +100,15 @@ class Module {
    float* vcaBuf;
    float* subBuf;
    float* pwmBuf;
-    
+
   private:
    // precalculated coefficients for RC networks
    float pwmTC = 0, subTC = 0, mVcaTC = 0;
    float pwmRC = 0, subRC = 0, vcaRC = 0;

-    // controls
+    uint16_t lfoDelay = 0;
+    uint8_t lfoDelayState = 0;
+    uint16_t lfoDelayTimer = 0;
 };

 class Voice {
@ -108,7 +135,8 @@ class Voice {
    uint8_t note = 0;

    // filter
-    float b1 = 0, b2 = 0, b3 = 0, b4 = 0;
+    float y0 = 0, y1 = 0, y2 = 0, y3 = 0;
+    double s[4] = {0, 0, 0, 0};
 };

 #endif
--- a/plugin/parameters.cpp
+++ b/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;
@ -66,7 +66,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
        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 +76,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 +86,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 +107,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 +117,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 +127,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 +137,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 +147,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 +157,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 +166,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 +175,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 +195,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 +204,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 +213,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 +223,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 +233,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 +243,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 +253,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 +263,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,17 +283,39 @@ 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 pChorusMode:
+            parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
+            parameter.name = "Chorus";
+            parameter.symbol = "pfau_chorus";
+            parameter.ranges.min = 0.0f;
+            parameter.ranges.max = 2.0f;
+            parameter.ranges.def = 0.0f;
+            parameter.midiCC = 93;
+            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;
+            }
+
            /*
                    case pModWheel:
                        parameter.hints = kParameterIsAutomatable | kParameterIsHidden;
                        parameter.name = "Mod wheel";
-                        parameter.symbol = "ch_modwheel";
+                        parameter.symbol = "pfau_modwheel";
                        parameter.ranges.min = 0.0f;
                        parameter.ranges.max = 127.0f;
                        parameter.ranges.def = 0.0f;
@ -379,9 +401,9 @@ 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
@ -506,8 +528,8 @@ 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 +540,6 @@ float Peacock::getParameterValue(uint32_t index) const {
                default:
                    break;
            }
-
-
    }
    return 0;
 }
--- a/plugin/peacock.cpp
+++ b/plugin/peacock.cpp
@ -32,6 +32,7 @@ Peacock::Peacock() : Plugin(parameterCount, 0, 0) {
    m = new Module();
    ic1 = new Assigner;
    ic1->voice = voice;
+    ic1->m = m;
    m->chorus = chorus;
 }

--- a/plugin/ui.cpp
+++ b/plugin/ui.cpp
@ -268,7 +268,7 @@ void DistrhoUIPeacock::parameterChanged(uint32_t index, float value) {
            sw1 |= (value > 0.5) << 4;
            break;

-        case pChorus:
+        case pChorusMode:
            sw1 &= 0x9f;
            // 60, 40, 00
            switch ((int)value) {
@ -325,15 +325,15 @@ 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:
--- a/plugin/voice.cpp
+++ b/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;
-    if (midiNote > 24)
-        note = midiNote - 24;
-    else
-        note = 24;
+    while (midiNote < 24) midiNote += 12;
+    while (midiNote > 108) midiNote -=12;
+    note = midiNote - 24;
    envPhase = 1;
 }

@ -52,16 +50,46 @@ void Voice::off() {
    envPhase = 0;
 }

+
+// tanh(x)/x approximation, flatline at very high inputs
+// so might not be safe for very large feedback gains
+// [limit is 1/15 so very large means ~15 or +23dB]
+
+
+double tanhXdX(double x) {
+
+    return 1-0.1*abs(x);
+    double a = x*x;
+    // IIRC I got this as Pade-approx for tanh(sqrt(x))/sqrt(x) 
+    return ((a + 105)*a + 945) / ((15*a + 420)*a + 945);
+}
+
+
 void Voice::run(Module* m, float* buffer, uint32_t samples) {
    // carry out per-voice calculations for each block of samples
    float out, t, fb;

-    // FIXME incorrect
+double zi;
+
+
    // calculate cutoff frequency
    float cut = 248.0f * (powf(2, (vcfCut - 0x1880) / 1143.0f));
-    cut = 0.25 * 6.2832 * cut / 48000.0f;  // FIXME hardcoded values
+    cut = M_PI * cut / sampleRate;
    cut = cut / (1 + cut);                 // correct tuning warp

+
+   // printf("%f\n", cut);
+
+   //if (cut > 0.5) cut = 0.5;
+
+   // double f = tan(cut);
+   
+
+    //printf("cut = %4f f = %4f\n", cut, f);
+
+    double r = (40.0/9.0) * m->res;
+
+
    float amp = vcaEnv / 4096.0f;

    for (uint32_t i = 0; i < samples; i++) {
@ -100,13 +128,80 @@ void Voice::run(Module* m, float* buffer, uint32_t samples) {
        delay += m->subBuf[i] * subosc ;
        
        out += m->noise * (0.8 - 1.6 * (rand() & 0xffff) / 65536.0);
-        out *= 0.5;
+        out *= 0.01;

        // same time constant for both VCF and VCF RC circuits
        vcfRC = (cut - vcfRC) * m->vcaTC + vcfRC;

+#if 1
+
+//// LICENSE TERMS: Copyright 2012 Teemu Voipio
+// 
+// You can use this however you like for pretty much any purpose,
+// as long as you don't claim you wrote it. There is no warranty.
+//
+// Distribution of substantial portions of this code in source form
+// must include this copyright notice and list of conditions.
+//
+
+// input delay and state for member variables
+
+// cutoff as normalized frequency (eg 0.5 = Nyquist)
+// resonance from 0 to 1, self-oscillates at settings over 0.9
+//void transistorLadder(
+//    double cutoff, double resonance,
+//    double * in, double * out, unsigned nsamples)
+//{
+    // tuning and feedback
+
+    //------------------------------------------------------------------------------ sample loop
+    //for(unsigned n = 0; n < nsamples; ++n)
+    //{
+        // input with half delay, for non-linearities
+        double ih = 0.5 * (out + zi); zi = out;
+
+        //double ih = out;
+
+        // evaluate the non-linear gains
+        double t0 = tanhXdX((ih * (r+1))- r * s[3]);
+       
+        double t1 = tanhXdX(s[0]);
+        double t2 = tanhXdX(s[1]);
+        double t3 = tanhXdX(s[2]);
+        double t4 = tanhXdX(s[3]);
+
+        double f = vcfRC;
+
+        // g# the denominators for solutions of individual stages
+        double g0 = 1 / (1 + f*t1), g1 = 1 / (1 + f*t2);
+        double g2 = 1 / (1 + f*t3), g3 = 1 / (1 + f*t4);
+        
+        // f# are just factored out of the feedback solution
+        double f3 = f*t3*g3, f2 = f*t2*g2*f3, f1 = f*t1*g1*f2, f0 = f*t0*g0*f1;
+
+        // solve feedback 
+        double y3 = (g3*s[3] + f3*g2*s[2] + f2*g1*s[1] + f1*g0*s[0] + f0*out) / (1 + r*f0);
+
+        // then solve the remaining outputs (with the non-linear gains here)
+        double xx = t0*((out * (r+1)) - r*y3);
+        double y0 = t1*g0*(s[0] + f*xx);
+        double y1 = t2*g1*(s[1] + f*y0);
+        double y2 = t3*g2*(s[2] + f*y1);
+
+        // update state
+        s[0] += 2*f * (xx - y0);
+        s[1] += 2*f * (y0 - y1);
+        s[2] += 2*f * (y1 - y2);
+        s[3] += 2*f * (y2 - t4*y3);
+
+        //out[n] = y3;
+   // }
+
+
+#else
+
        for (uint8_t ovs = 0; ovs < 4; ovs++) {
-            fb = b4;
+            fb = y3;
            // hard clip
            fb = ((out * 0.5) - fb) * m->res;
            if (fb > 4) fb = 4;
@ -114,14 +209,14 @@ void Voice::run(Module* m, float* buffer, uint32_t samples) {
            // fb = 1.5 * fb - 0.5 * fb * fb * fb;
            //

-            b1 = ((out + fb - b1) * vcfRC) + b1;
-            b2 = ((b1 - b2) * vcfRC) + b2;
-            b3 = ((b2 - b3) * vcfRC) + b3;
-            b4 = ((b3 - b4) * vcfRC) + b4;
+            y0 = ((out + fb - y0) * vcfRC) + y0;
+            y1 = ((y0 - y1) * vcfRC) + y1;
+            y2 = ((y1 - y2) * vcfRC) + y2;
+            y3 = ((y2 - y3) * vcfRC) + y3;
        }
-
+#endif
        vcaRC = (amp - vcaRC) * m->vcaTC + vcaRC;
-        buffer[i] += 0.09367 * m->vcaBuf[i] * vcaRC * b4;
+        buffer[i] += 1 * m->vcaBuf[i] * vcaRC * y3;
        
        lastpw = m->pwmBuf[i];
    }
Author	SHA1	Message	Date
Gordon JC Pearce	36c27f14d8	mystran filter	2025-12-26 22:08:52 +00:00
Gordon JC Pearce	2d53d3c5da	parameter MIDI value	2025-12-26 00:28:58 +00:00
Gordon JC Pearce	fd392ecf56	proper parameter for chorus	2025-12-25 23:21:12 +00:00
Gordon JC Pearce	13ff93a0a5	LFO delay, basically feature-complete	2025-12-24 01:46:37 +00:00
Gordon JC Pearce	d6e5f21e5b	vcf lfo	2025-12-24 00:34:52 +00:00
Gordon JC Pearce	7a4ebded58	grr, argh, peacock.xcf.final.final.reallythistime.xcf.gz how many times will I cock this up?	2025-12-23 23:53:41 +00:00
Gordon JC Pearce	80c8f409f5	are you kidding, how often will I forget to put the 'off' LEDs back in?	2025-12-23 23:46:10 +00:00
Gordon JC Pearce	cef0957d6e	lfo fix, chorus fix	2025-12-23 23:36:58 +00:00
Gordon JC Pearce	e38cf3da59	fixed some blemishes	2025-12-23 23:11:53 +00:00
Gordon JC Pearce	5c5f8f2229	filter and oscillator tuning	2025-12-23 22:54:08 +00:00
Gordon JC Pearce	8ce34e6b3a	replaced background image with fixed one	2025-12-23 11:09:43 +00:00