diff --git a/plugin/module.cpp b/plugin/module.cpp index 99b5d51..aff551c 100644 --- a/plugin/module.cpp +++ b/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 diff --git a/plugin/module.hpp b/plugin/module.hpp index a28902f..0b451e6 100644 --- a/plugin/module.hpp +++ b/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 diff --git a/plugin/voice.cpp b/plugin/voice.cpp index ec81b15..1b4d1ac 100644 --- a/plugin/voice.cpp +++ b/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; - 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]; }