137 lines
4.7 KiB
C++
137 lines
4.7 KiB
C++
/*
|
|
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(-6.283 * 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
|
|
pwmTC = 1 - exp(-6.283 * 40 / sampleRate); // integrator with 100k/0.047u time constant
|
|
|
|
vcaBuf = new float[bufferSize];
|
|
subBuf = new float[bufferSize];
|
|
pwmBuf = new float[bufferSize];
|
|
}
|
|
|
|
Module::~Module() {
|
|
printf("module destructor\n");
|
|
delete vcaBuf;
|
|
delete subBuf;
|
|
delete pwmBuf;
|
|
}
|
|
void Module::run(Voice* voices, uint32_t blockSize) {
|
|
// run updates for module board
|
|
|
|
// 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;
|
|
saw = (patchRam.switch1 & 0x10) ? 0.8 : 0;
|
|
sub = patchRam.sub / 127.0f;
|
|
lfoPhase += lfoRateTable[patchRam.lfoRate];
|
|
|
|
res = patchRam.vcfReso / 127.0 * 5;
|
|
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)
|
|
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;
|
|
|
|
for (uint32_t i = 0; i < blockSize; i++) {
|
|
vcaRC = (master - vcaRC) * subTC + vcaRC;
|
|
pwmRC = (pw - 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);
|
|
|
|
int16_t pitchBase = 0x1818;
|
|
pitchBase += (lfo * lfoDepthTable[patchRam.vcoLfo]) >> 11;
|
|
|
|
for (uint32_t i = 0; i < NUM_VOICES; i++) {
|
|
// maybe move all this into voice.cpp FIXME
|
|
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
|
|
// FIXME clean this all up a bit
|
|
int16_t pitch = pitchBase + (v->note << 8);
|
|
int16_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);
|
|
|
|
px *= (patchRam.switch1 & 0x07);
|
|
|
|
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-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;
|
|
}
|
|
}
|