Gordonjcp
/
peacock
1
0
Fork 0
Code Issues 6 Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: Gordonjcp:bad4e6b0189099f4ef555f4d63129eabc7f3ce0e
Branches Tags
Gordonjcp:master
Gordonjcp:controllers
Gordonjcp:calibration
Gordonjcp:gui
Gordonjcp:tidyup
Gordonjcp:parameters
Gordonjcp:chorusboard
Gordonjcp:voices
Gordonjcp:modelb
..
compare: Gordonjcp:132b684db729014a21d46b4ac80e8a71e52883b2
Branches Tags
Gordonjcp:controllers
Gordonjcp:master
Gordonjcp:calibration
Gordonjcp:gui
Gordonjcp:tidyup
Gordonjcp:parameters
Gordonjcp:chorusboard
Gordonjcp:voices
Gordonjcp:modelb

No commits in common. "bad4e6b0189099f4ef555f4d63129eabc7f3ce0e" and "132b684db729014a21d46b4ac80e8a71e52883b2" have entirely different histories.
bad4e6b018 ... 132b684db7

12 changed files with 16009 additions and 16298 deletions
Show Stats Expand all files Collapse all files

2
plugin/DistrhoPluginInfo.h
View File

@ -63,7 +63,7 @@
pSustain,
pRelease,
pChorusMode,
pChorus,
parameterCount
};

31855
plugin/artwork.cpp
View File

File diff suppressed because it is too large Load Diff

6
plugin/assigner.cpp
View File

@ -110,10 +110,6 @@ 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];
@ -141,6 +137,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, i);
d_debug("send voice on %3d to voice %d", note, v);
voice[v].on(note);
}

1
plugin/assigner.hpp
View File

@ -27,7 +27,6 @@ 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)

15
plugin/chorus.cpp
View File

@ -21,7 +21,6 @@
#include <math.h>
#include <string.h>
#include <stdio.h>
Chorus::Chorus() {
lpfOut1 = new float[bufferSize];
lpfOut2 = new float[bufferSize];
@ -30,8 +29,6 @@ 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);
// not quite Butterworth but you'd never hear the difference
// these are calculated from the real-world component values
postFilter1l = new SVF(9688, .549);
@ -103,7 +100,6 @@ void Chorus::run(float* input, float** outputs, uint32_t frames) {
delayptr++;
delayptr &= 0x3ff;
}
//printf("dly1 = %f\n", dly1);
postFilter1l->runSVF(lpfOut1, lpfOut1, frames);
postFilter2l->runSVF(lpfOut1, lpfOut1, frames);
@ -112,10 +108,8 @@ 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]);
outputs[0][i] = y + (gain * lpfOut1[i]);
outputs[1][i] = y + (gain * lpfOut2[i]);
}
}
@ -149,16 +143,15 @@ 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.3 / sampleRate;
lfoSpeed = 6.283 * 0.5 / sampleRate;
break;
case 0x00:
gain = 1.2;
lfoSpeed = 6.283 * 0.5 / sampleRate;
lfoSpeed = 6.283 * 0.9 / sampleRate;
break;
}
}

4
plugin/chorus.hpp
View File

@ -40,12 +40,8 @@ class Chorus {
private:
double lfoPhase = 0, lfoSpeed = 0;
uint8_t lfoState=0;
float gain = 1.2;
float gainRC = 0;
float gainTC = 0;
uint16_t delayptr = 0;

72
plugin/module.cpp
View File

@ -18,51 +18,16 @@
#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::lfoRampOn() {
lfoDelayState = 1;
lfoDelayTimer = 0;
lfoDelay = 0;
}
void Module::run(Voice* voices, uint32_t blockSize) {
void Module::run(Voice* voice) {
// 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
@ -74,10 +39,9 @@ void Module::run(Voice* voices, uint32_t blockSize) {
sub = patchRam.sub / 127.0f;
lfoPhase += lfoRateTable[patchRam.lfoRate];
res = patchRam.vcfReso / 127.0;
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);
@ -86,35 +50,17 @@ void Module::run(Voice* voices, uint32_t blockSize) {
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;
lfo = (lfo * lfoDelay) >> 14;
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;
pitchBase += (lfo * lfoDepthTable[patchRam.vcoLfo]) >> 9;
for (uint32_t i = 0; i < NUM_VOICES; i++) {
// maybe move all this into voice.cpp FIXME
Voice* v = &voices[i];
Voice* v = &voice[i];
switch (v->envPhase) {
case 0: // release phase FIXME use an enum I guess
v->env = (v->env * r) >> 16; // "RC" decay to zero
@ -132,7 +78,6 @@ void Module::run(Voice* voices, uint32_t blockSize) {
}
// 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;
@ -142,17 +87,14 @@ void Module::run(Voice* voices, uint32_t blockSize) {
px *= (patchRam.switch1 & 0x07);
v->omega = px / (sampleRate * 8.0f); // fixme use proper scaler
v->omega = px / (sampleRate * 4.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 += (lfo * patchRam.vcfLfo) >> 9;
v->vcfCut += (int)((v->note - 36) * (patchRam.vcfKey << 1) * 0.375);
v->vcfCut = (patchRam.vcfFreq << 7) + ((vcf * v->env) >> 16);
v->vcfCut += (int)(v->note * (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;
}
}

106
plugin/module.hpp
View File

@ -31,11 +31,8 @@ class Voice;
class Module {
public:
Module();
~Module();
void lfoRampOn();
void run(Voice* voices, uint32_t blockLeft);
void run(Voice* voice);
float res = 0;
// precomputed values for all voices
@ -48,91 +45,30 @@ class Module {
float saw = 0, square = 0, sub = 0, noise = 0;
/*
#if 0
struct {
uint8_t lfoRate = 0x58;
uint8_t lfoRate = 0x18;
uint8_t lfoDelay = 0x00;
uint8_t vcoLfo = 0x00;
uint8_t pwmLfo = 0x3b;
uint8_t pwmLfo = 0x60;
uint8_t noise = 0x00;
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 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 env_a = 0x00;
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 env_d = 0x39;
uint8_t env_s = 0x30; // 0x3f80
uint8_t env_r = 0x30;
uint8_t sub = 0x40;
uint8_t switch1 = 0x59;
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
*/
struct {
uint8_t lfoRate = 0x58;
uint8_t lfoDelay = 0x00;
uint8_t vcoLfo = 0x00;
uint8_t pwmLfo = 0x00;
uint8_t noise = 0x00;
uint8_t vcfFreq = 0x00; // 1c; // 0x3f80
uint8_t vcfReso = 0x7f;
uint8_t vcfEnv = 0x7f; // 4e;
uint8_t vcfLfo = 0x00;
uint8_t vcfKey = 0x00; // 47;
uint8_t vca = 0x20;
uint8_t env_a = 0x00;
uint8_t env_d = 0x5c;
uint8_t env_s = 0x00; // 0x3f80
uint8_t env_r = 0x3c;
uint8_t sub = 0x7f;
uint8_t switch1 = 0x3a;
uint8_t switch2 = 0x19;
} patchRam;
Chorus* chorus;
float vcaTC;
uint32_t bufPtr = 0;
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;
uint16_t lfoDelay = 0;
uint8_t lfoDelayState = 0;
uint16_t lfoDelayTimer = 0;
// controls
};
class Voice {
@ -145,6 +81,9 @@ class Voice {
void run(Module* m, float* buffer, uint32_t samples);
private:
// control
float vcaRC = 0, vcfRC = 0;
float omega = 0, theta = 0; // phase increment and angle FIXME better names
float delay = 0, lastpw = 0; // delay slots for antialiasing
uint8_t pulseStage = 1; // pulse wave phase
@ -152,16 +91,13 @@ class Voice {
uint8_t envPhase = 0;
int16_t env = 0; // output amplitude
uint16_t vcfCut;
int16_t vcfCut;
int16_t vcaEnv;
float vcaRC = 0, vcfRC = 0;
float vcaEnvRC = 0;
uint8_t note = 0;
// filter
float y0 = 0, y1 = 0, y2 = 0, y3 = 0;
double s[4] = {0, 0, 0, 0};
float zi = 0;
float b1 = 0, b2 = 0, b3 = 0, b4 = 0;
};
#endif

78
plugin/parameters.cpp
View File

@ -23,7 +23,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pLFORate:
parameter.hints = kParameterIsAutomatable;
parameter.name = "LFO Rate";
parameter.symbol = "pfau_lforate";
parameter.symbol = "ch_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 = "pfau_lfodelay";
parameter.symbol = "ch_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 = "pfau_vcorange";
parameter.symbol = "ch_vcorange";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 2.0f;
parameter.ranges.def = 1.0f;
@ -60,12 +60,13 @@ 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 = "pfau_lfo";
parameter.symbol = "ch_lfo";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 10.0f;
@ -75,7 +76,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pPWMDepth:
parameter.hints = kParameterIsAutomatable;
parameter.name = "PWM";
parameter.symbol = "pfau_pwm";
parameter.symbol = "ch_pwm";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 48.0f;
@ -85,7 +86,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pPWMMode:
parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
parameter.name = "PWM Mode";
parameter.symbol = "pfau_pwmmode";
parameter.symbol = "ch_pwmmode";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 1.0f;
parameter.ranges.def = 1.0f;
@ -106,7 +107,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pSaw:
parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
parameter.name = "Saw";
parameter.symbol = "pfau_saw";
parameter.symbol = "ch_saw";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 1.0f;
parameter.ranges.def = 1.0f;
@ -116,7 +117,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pSqr:
parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
parameter.name = "Square";
parameter.symbol = "pfau_sqr";
parameter.symbol = "ch_sqr";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 1.0f;
parameter.ranges.def = 1.0f;
@ -126,7 +127,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pSubLevel:
parameter.hints = kParameterIsAutomatable;
parameter.name = "Sub Osc";
parameter.symbol = "pfau_sub";
parameter.symbol = "ch_sub";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 0.0f;
@ -136,7 +137,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pNoiseLevel:
parameter.hints = kParameterIsAutomatable;
parameter.name = "Noise";
parameter.symbol = "pfau_noise";
parameter.symbol = "ch_noise";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 0.0f;
@ -146,7 +147,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pHPF:
parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
parameter.name = "HPF";
parameter.symbol = "pfau_hpf";
parameter.symbol = "ch_hpf";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 3.9f;
parameter.ranges.def = 0.0f;
@ -156,7 +157,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pCutoff:
parameter.hints = kParameterIsAutomatable;
parameter.name = "Freq";
parameter.symbol = "pfau_freq";
parameter.symbol = "ch_freq";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 60.0f;
@ -165,7 +166,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pRes:
parameter.hints = kParameterIsAutomatable;
parameter.name = "Res";
parameter.symbol = "pfau_reso";
parameter.symbol = "ch_reso";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 0.0f;
@ -174,7 +175,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pVCFPol:
parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
parameter.name = "Polarity";
parameter.symbol = "pfau_vcfmode";
parameter.symbol = "ch_vcfmode";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 1.0f;
parameter.ranges.def = 0.0f;
@ -194,7 +195,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pEnv:
parameter.hints = kParameterIsAutomatable;
parameter.name = "Env";
parameter.symbol = "pfau_vcfenv";
parameter.symbol = "ch_vcfenv";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 46.0f;
@ -203,7 +204,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pLfo:
parameter.hints = kParameterIsAutomatable;
parameter.name = "LFO";
parameter.symbol = "pfau_vcflfo";
parameter.symbol = "ch_vcflfo";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 0.0f;
@ -212,7 +213,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pKyb:
parameter.hints = kParameterIsAutomatable;
parameter.name = "Kybd";
parameter.symbol = "pfau_vcfkey";
parameter.symbol = "ch_vcfkey";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 71.0f;
@ -222,7 +223,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pAttack:
parameter.hints = kParameterIsAutomatable;
parameter.name = "Attack";
parameter.symbol = "pfau_attack";
parameter.symbol = "ch_attack";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 27.0f;
@ -232,7 +233,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pDecay:
parameter.hints = kParameterIsAutomatable;
parameter.name = "Decay";
parameter.symbol = "pfau_decay";
parameter.symbol = "ch_decay";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 57.0f;
@ -242,7 +243,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pSustain:
parameter.hints = kParameterIsAutomatable;
parameter.name = "Sustain";
parameter.symbol = "pfau_sustain";
parameter.symbol = "ch_sustain";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 57.0f;
@ -252,7 +253,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pRelease:
parameter.hints = kParameterIsAutomatable;
parameter.name = "Release";
parameter.symbol = "pfau_release";
parameter.symbol = "ch_release";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 48.0f;
@ -262,7 +263,7 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pEnvGate:
parameter.hints = kParameterIsAutomatable | kParameterIsInteger; // | kParameterIsBoolean;
parameter.name = "Env-Gate";
parameter.symbol = "pfau_envgate";
parameter.symbol = "ch_envgate";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 1.0f;
parameter.ranges.def = 0.0f;
@ -282,38 +283,17 @@ void Peacock::initParameter(uint32_t index, Parameter& parameter) {
case pVCALevel:
parameter.hints = kParameterIsAutomatable;
parameter.name = "VCA Level";
parameter.symbol = "pfau_vcalevel";
parameter.symbol = "ch_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 = "pfau_modwheel";
parameter.symbol = "ch_modwheel";
parameter.ranges.min = 0.0f;
parameter.ranges.max = 127.0f;
parameter.ranges.def = 0.0f;
@ -399,8 +379,9 @@ void Peacock::setParameterValue(uint32_t index, float value) {
m->patchRam.switch1 |= (value >= 0.5) << 4;
break;
case pChorusMode:
case pChorus:
m->patchRam.switch1 &= 0x9f;
switch ((int)value) {
case 0:
m->patchRam.switch1 |= 0x60; // both off
@ -525,7 +506,8 @@ float Peacock::getParameterValue(uint32_t index) const {
case pVCALevel:
return m->patchRam.vca;
break;
case pChorusMode:
case pChorus:
switch (m->patchRam.switch1 & 0x60) {
case 0x60:
return 0;
@ -536,6 +518,8 @@ float Peacock::getParameterValue(uint32_t index) const {
default:
break;
}
}
return 0;
}

9
plugin/peacock.cpp
View File

@ -32,8 +32,9 @@ Peacock::Peacock() : Plugin(parameterCount, 0, 0) {
m = new Module();
ic1 = new Assigner;
ic1->voice = voice;
ic1->m = m;
m->chorus = chorus;
}
Peacock::~Peacock() {
@ -72,7 +73,6 @@ void Peacock::run(const float**, float** outputs, uint32_t frames, const MidiEve
// if there were any events that happen between now and the end of this block, process them
lastEvent = 0;
m->bufPtr = 0;
runMidi(midiEvents, midiEventCount, blockLeft);
while (framePos < frames) {
@ -81,12 +81,11 @@ void Peacock::run(const float**, float** outputs, uint32_t frames, const MidiEve
blockLeft = sampleRate / 238; // update rate in Hz
runMidi(midiEvents, midiEventCount, framePos + blockLeft);
m->run(voice);
}
// 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++) {
@ -99,8 +98,8 @@ 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);
chorus->run(outputs[0], outputs, frames);
}
Plugin* createPlugin() { return new Peacock(); }

9
plugin/ui.cpp
View File

@ -258,7 +258,6 @@ void DistrhoUIPeacock::parameterChanged(uint32_t index, float value) {
sw1 &= 0xf8; // mask
if (value > 2) value = 2;
sw1 |= (1 << (int)value);
xBtn16ft->repaint(); // will repaint all the panel
break;
case pSqr:
sw1 &= 0xf7;
@ -269,7 +268,7 @@ void DistrhoUIPeacock::parameterChanged(uint32_t index, float value) {
sw1 |= (value > 0.5) << 4;
break;
case pChorusMode:
case pChorus:
sw1 &= 0x9f;
// 60, 40, 00
switch ((int)value) {
@ -326,15 +325,15 @@ void DistrhoUIPeacock::imageButtonClicked(ImageButton* imgBtn, int) {
break;
case btnCh0:
sw1 = (sw1 & 0x9f) | 0x20;
setParameterValue(pChorusMode, 0);
setParameterValue(pChorus, 0);
break;
case btnCh1:
sw1 = (sw1 & 0x9f) | 0x40;
setParameterValue(pChorusMode, 1);
setParameterValue(pChorus, 1);
break;
case btnCh2:
sw1 = (sw1 & 0x9f);
setParameterValue(pChorusMode, 2);
setParameterValue(pChorus, 2);
break;
default:

138
plugin/voice.cpp
View File

@ -40,9 +40,9 @@ Voice::Voice() {
}
void Voice::on(uint8_t midiNote) {
while (midiNote < 24) midiNote += 12;
while (midiNote > 108) midiNote -= 12;
note = midiNote - 24;
//omega = 261.63 * powf(2, (note - 60) / 12.0f) / 48000.0f;
if (midiNote>24) note = midiNote-24;
else note = 24;
envPhase = 1;
}
@ -50,26 +50,16 @@ 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) {
float s = 0.0333, d = 30.0;
return 1.0f - s * (d + 1.0f) * x * x / (d + x * x);
}
void Voice::run(Module* m, float* buffer, uint32_t samples) {
// carry out per-voice calculations for each block of samples
float out, t, fb;
//float cut = 0.00513 + 0.0000075*env;
// calculate cutoff frequency
float cut = 261.0f * (powf(2, (vcfCut - 0x1880) / 1143.0f));
cut = M_PI * cut / sampleRate;
float cut = 248.0f * (powf(2, (vcfCut - 0x1880) / 1143.0f));
cut = 0.25 * 6.2832 * cut / 48000.0f; // FIXME hardcoded values
cut = cut/(1+cut); // correct tuning warp
// if (cut > 0.7) cut = 0.7;
double r = 5 * m->res;
float amp = vcaEnv / 4096.0f;
@ -81,8 +71,8 @@ void Voice::run(Module* m, float* buffer, uint32_t samples) {
while (true) {
if (pulseStage == 0) {
if (theta < m->pwmBuf[i]) break;
t = (theta - m->pwmBuf[i]) / (lastpw - m->pwmBuf[i] + omega);
if (theta < m->pw) break;
t = (theta - m->pw) / (lastpw - m->pw + omega);
out -= poly3blep0(t) * m->square;
delay -= poly3blep1(t) * m->square;
pulseStage = 1;
@ -94,8 +84,8 @@ void Voice::run(Module* m, float* buffer, uint32_t samples) {
out += poly3blep0(t) * (m->saw + m->square);
delay += poly3blep1(t) * (m->saw + m->square);
out -= poly3blep0(t) * (m->subBuf[i] * subosc);
delay -= poly3blep1(t) * (m->subBuf[i] * subosc);
out -= poly3blep0(t) * (m->sub * subosc);
delay -= poly3blep1(t) * (m->sub * subosc);
pulseStage = 0;
subosc = -subosc;
@ -103,109 +93,33 @@ 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->square * (pulseStage ? -1.f : 1.f);
delay += m->sub * subosc;
// delay += (1-(m->noisegen/(float)(1<<30))) * m->noise; FIXME figure out what to do about noise
out += m->noise * (0.8-1.6 *(rand() & 0xffff) / 65536.0);
// out *= 0.1;
// 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)
//{
out *= 0.025;
// 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;
// }
// out *= 0.1;
out = y3;
#else
out *= 0.5;
for (uint8_t ovs = 0; ovs < 2; ovs++) {
fb = y3;
for (uint8_t ovs = 0; ovs < 4; ovs++) {
fb = b4;
// hard clip
fb = ((out * 0.5) - fb) * r;
fb = ((out*0.5) - fb) * m->res;
if (fb > 4) fb = 4;
if (fb < -4) fb = -4;
// fb = 1.5 * fb - 0.5 * fb * fb * fb;
//
y0 = ((out + fb - y0) * vcfRC) + y0;
y1 = ((y0 - y1) * vcfRC) + y1;
y2 = ((y1 - y2) * vcfRC) + y2;
y3 = ((y2 - y3) * vcfRC) + y3;
b1 = ((out + fb - b1) * cut) + b1;
b2 = ((b1 - b2) * cut) + b2;
b3 = ((b2 - b3) * cut) + b3;
b4 = ((b3 - b4) * cut) + b4;
}
#endif
vcaRC = (amp - vcaRC) * m->vcaTC + vcaRC;
buffer[i] += m->vcaBuf[i] * vcaRC * out;
lastpw = m->pwmBuf[i];
vcaEnvRC = (amp - vcaEnvRC) * 0.0203 + vcaEnvRC;
buffer[i] += 0.0367 * vcaEnvRC * b4;
lastpw = m->pw;
}
// buffer[0] += 1;
}