mystran filter

plugin/module.cpp

@@ -74,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

plugin/module.hpp

@@ -48,6 +48,7 @@ class Module {
 
     float saw = 0, square = 0, sub = 0, noise = 0;
 
+#if 0 
     struct {
                 uint8_t lfoRate = 0x58;
         uint8_t lfoDelay = 0x00;
@@ -68,6 +69,29 @@ class Module {
         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;
@@ -111,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

plugin/voice.cpp

@@ -50,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++) {
@@ -98,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;
@@ -112,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;
+            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;
         }
-
+#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];
     }