469 lines
15 KiB
C++
469 lines
15 KiB
C++
/*
|
|
Chassis polysynth framework
|
|
|
|
Copyright 2024 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 "chassis.hpp"
|
|
|
|
START_NAMESPACE_DISTRHO
|
|
|
|
Chassis::Chassis() : Plugin(parameterCount, 0, 0), sampleRate(getSampleRate()) { // one parameter, no programs, no states
|
|
}
|
|
|
|
// Initialisation functions
|
|
|
|
void Chassis::initParameter(uint32_t index, Parameter ¶meter) {
|
|
switch (index) {
|
|
case paramLFORate:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "LFO Rate";
|
|
parameter.symbol = "ch_lforate";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 57.0f;
|
|
parameter.midiCC = 3;
|
|
break;
|
|
|
|
case paramLFODelay:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "LFO Delay";
|
|
parameter.symbol = "ch_lfodelay";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 45.0f;
|
|
parameter.midiCC = 9;
|
|
break;
|
|
|
|
case paramVCORange:
|
|
parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
|
|
parameter.name = "Range";
|
|
parameter.symbol = "ch_vcorange";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 4.0f;
|
|
parameter.ranges.def = 2.0f;
|
|
parameter.midiCC = 12;
|
|
break;
|
|
|
|
case paramVCOLFO:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "LFO";
|
|
parameter.symbol = "ch_lfo";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 0.0f;
|
|
parameter.midiCC = 13;
|
|
break;
|
|
|
|
case paramPWMLFO:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "PWM";
|
|
parameter.symbol = "ch_pwm";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 55.0f;
|
|
parameter.midiCC = 14;
|
|
break;
|
|
|
|
case paramPWMMode:
|
|
parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
|
|
parameter.name = "LFO/Manual";
|
|
parameter.symbol = "ch_pwmmode";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 0.0f;
|
|
parameter.midiCC = 15;
|
|
break;
|
|
|
|
case paramSaw:
|
|
parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
|
|
parameter.name = "Saw";
|
|
parameter.symbol = "ch_saw";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 127.0f;
|
|
parameter.midiCC = 17;
|
|
break;
|
|
|
|
case paramSqr:
|
|
parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
|
|
parameter.name = "Square";
|
|
parameter.symbol = "ch_sqr";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 127.0f;
|
|
parameter.midiCC = 16;
|
|
break;
|
|
|
|
case paramSub:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "Sub Osc";
|
|
parameter.symbol = "ch_sub";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 0.0f;
|
|
parameter.midiCC = 18;
|
|
break;
|
|
|
|
case paramNoise:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "Noise";
|
|
parameter.symbol = "ch_noise";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 0.0f;
|
|
parameter.midiCC = 19;
|
|
break;
|
|
|
|
case paramHPF:
|
|
parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
|
|
parameter.name = "HPF";
|
|
parameter.symbol = "ch_hpf";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 4.0f;
|
|
parameter.ranges.def = 0.0f;
|
|
parameter.midiCC = 20;
|
|
break;
|
|
|
|
case paramVCFFreq:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "Freq";
|
|
parameter.symbol = "ch_freq";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 0.0f;
|
|
parameter.midiCC = 74;
|
|
break;
|
|
case paramVCFReso:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "Res";
|
|
parameter.symbol = "ch_reso";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 0.0f;
|
|
parameter.midiCC = 74;
|
|
break;
|
|
case paramVCFMode:
|
|
parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
|
|
parameter.name = "Polarity";
|
|
parameter.symbol = "ch_vcfmode";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 0.0f;
|
|
parameter.midiCC = 21;
|
|
break;
|
|
case paramVCFEnv:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "Env";
|
|
parameter.symbol = "ch_vcfenv";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 0.0f;
|
|
parameter.midiCC = 22;
|
|
break;
|
|
case paramVCFLFO:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "LFO";
|
|
parameter.symbol = "ch_vcflfo";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 0.0f;
|
|
parameter.midiCC = 23;
|
|
break;
|
|
case paramVCFKey:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "Kybd";
|
|
parameter.symbol = "ch_vcfkey";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 0.0f;
|
|
parameter.midiCC = 24;
|
|
break;
|
|
|
|
case paramAttack:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "Attack";
|
|
parameter.symbol = "ch_attack";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 59.0f;
|
|
parameter.midiCC = 73;
|
|
break;
|
|
|
|
case paramDecay:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "Decay";
|
|
parameter.symbol = "ch_decay";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 32.0f;
|
|
parameter.midiCC = 75;
|
|
break;
|
|
|
|
case paramSustain:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "Sustain";
|
|
parameter.symbol = "ch_sustain";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 86.0f;
|
|
parameter.midiCC = 27;
|
|
break;
|
|
|
|
case paramRelease:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "Release";
|
|
parameter.symbol = "ch_release";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 40.0f;
|
|
parameter.midiCC = 72;
|
|
break;
|
|
|
|
case paramEnvGate:
|
|
parameter.hints = kParameterIsAutomatable | kParameterIsBoolean;
|
|
parameter.name = "Env / Gate";
|
|
parameter.symbol = "ch_envgate";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 0.0f;
|
|
parameter.midiCC = 25;
|
|
break;
|
|
|
|
case paramVCALevel:
|
|
parameter.hints = kParameterIsAutomatable;
|
|
parameter.name = "VCA Level";
|
|
parameter.symbol = "ch_vcalevel";
|
|
parameter.ranges.min = 0.0f;
|
|
parameter.ranges.max = 127.0f;
|
|
parameter.ranges.def = 40.0f;
|
|
parameter.midiCC = 26;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Chassis::setParameterValue(uint32_t index, float value) {
|
|
// should be trapped by host, but let's be safe
|
|
if (value < 0.0f) value = 0.0f;
|
|
if (value > 127.0f) value = 127.0f;
|
|
|
|
switch (index) {
|
|
case paramLFORate:
|
|
s.patchRam.lfoRate = value;
|
|
break;
|
|
case paramLFODelay:
|
|
s.patchRam.lfoDelay = value;
|
|
break;
|
|
|
|
case paramVCORange:
|
|
// bits 0-2 of switch 1
|
|
// doesn't look great in Carla because of odd behaviour with small integer knobs
|
|
s.patchRam.switch1 &= 0xf8;
|
|
s.patchRam.switch1 |= (1 << (int)value);
|
|
break;
|
|
|
|
case paramVCOLFO:
|
|
s.patchRam.vcoLfo = value;
|
|
break;
|
|
case paramPWMLFO:
|
|
s.patchRam.pwmLfo = value;
|
|
break;
|
|
|
|
case paramSaw:
|
|
s.patchRam.switch1 &= 0xef;
|
|
s.patchRam.switch1 |= (value > 63) << 4;
|
|
break;
|
|
case paramSqr:
|
|
s.patchRam.switch1 &= 0xf7;
|
|
s.patchRam.switch1 |= (value > 63) << 3;
|
|
break;
|
|
case paramSub:
|
|
s.patchRam.sub = value;
|
|
break;
|
|
case paramAttack:
|
|
s.patchRam.env_a = value;
|
|
break;
|
|
case paramDecay:
|
|
s.patchRam.env_d = value;
|
|
break;
|
|
case paramSustain:
|
|
s.patchRam.env_s = value;
|
|
break;
|
|
case paramRelease:
|
|
s.patchRam.env_r = value;
|
|
break;
|
|
case paramEnvGate:
|
|
s.patchRam.switch2 &= 0xfb;
|
|
s.patchRam.switch2 |= (value > 63) << 2;
|
|
break;
|
|
case paramVCALevel:
|
|
s.patchRam.vca = value;
|
|
break;
|
|
}
|
|
}
|
|
|
|
float Chassis::getParameterValue(uint32_t index) const {
|
|
// printf("getparametervalue %d\n", index);
|
|
|
|
switch (index) {
|
|
case paramSaw:
|
|
return (s.patchRam.switch1 & 0x10) ? 127.0f : 0.0f;
|
|
break;
|
|
case paramSqr:
|
|
return (s.patchRam.switch1 & 0x08) ? 127.0f : 0.0f;
|
|
break;
|
|
case paramAttack:
|
|
return s.patchRam.env_a;
|
|
break;
|
|
case paramDecay:
|
|
return s.patchRam.env_d;
|
|
break;
|
|
case paramSustain:
|
|
return s.patchRam.env_s;
|
|
break;
|
|
case paramRelease:
|
|
return s.patchRam.env_r;
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void Chassis::initAudioPort(bool input, uint32_t index, AudioPort &port) {
|
|
port.groupId = kPortGroupStereo;
|
|
Plugin::initAudioPort(input, index, port);
|
|
|
|
if (!input && index == 0) port.name = "Left Out";
|
|
if (!input && index == 1) port.name = "Right Out";
|
|
}
|
|
|
|
// Processing functions
|
|
|
|
void Chassis::activate() {
|
|
// calculate filter coefficients and stuff
|
|
printf("called activate()\n");
|
|
}
|
|
|
|
void Chassis::deactivate() {
|
|
// zero out the outputs, maybe
|
|
printf("called deactivate()\n");
|
|
// printf("%02x", assign[1]);
|
|
}
|
|
|
|
void Chassis::noteOn(uint8_t note) {
|
|
uint32_t i;
|
|
for (i = 0; i < NUM_VOICES; i++) {
|
|
vPtr++;
|
|
if (vPtr == NUM_VOICES) vPtr = 0;
|
|
if (s.voice[vPtr].isFree()) {
|
|
// printf("voice %d is free, existing note = %d, note = %d\n", vPtr, s.voice[i].note, note);
|
|
// if it's an existing note don't reset
|
|
s.voice[vPtr].on(note, s.voice[i].note != note);
|
|
// printf("note on %d for voice %d\n", note, vPtr);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == NUM_VOICES) { // didn't find a free voice
|
|
vPtr++;
|
|
if (vPtr == NUM_VOICES) vPtr = 0;
|
|
s.voice[vPtr].on(note, true);
|
|
}
|
|
}
|
|
|
|
void Chassis::noteOff(uint8_t note) {
|
|
// printf("noteoff %d\n", note);
|
|
for (uint32_t i = 0; i < NUM_VOICES; i++) {
|
|
if (s.voice[i].note == note && !s.voice[i].isFree()) {
|
|
s.voice[i].off();
|
|
// printf("note off %d for voice %d\n", note, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Chassis::doMidi(const MidiEvent *ev, uint32_t count, uint32_t timeLimit) {
|
|
// printf("doMidi() handling events from %d to %d\n", lastEvent, timeLimit);
|
|
uint32_t i;
|
|
if (count == 0) return;
|
|
for (i = lastEvent; i < count; i++) {
|
|
// printf("doMidi event number %d of %d %02x %02x\n", i, count, ev[i].data[0], ev[i].data[1]);
|
|
if (ev[i].frame > timeLimit) break;
|
|
switch (ev[i].data[0]) {
|
|
case 0x90:
|
|
noteOn(ev[i].data[1]);
|
|
break;
|
|
case 0x80:
|
|
noteOff(ev[i].data[1]);
|
|
break;
|
|
}
|
|
}
|
|
lastEvent = i;
|
|
}
|
|
|
|
void Chassis::run(const float **, float **outputs, uint32_t frames, const MidiEvent *midiEvents, uint32_t midiEventCount) {
|
|
// if (midiEventCount > 0) printf("\n--------------------\n");
|
|
|
|
uint32_t framePos = 0;
|
|
uint32_t sizeThisTime;
|
|
s.framesLeft = frames;
|
|
|
|
// printf("\n------------\ncalled run() for %d frames\n",frames);
|
|
|
|
// flatten the left channel to use as temporary storage, since
|
|
// the synth engine only generates a mono channel
|
|
bzero(outputs[0], sizeof(float) * frames);
|
|
|
|
// get any of the last block's worth of MIDI out of the way
|
|
lastEvent = 0;
|
|
doMidi(midiEvents, midiEventCount, s.blockLeft);
|
|
|
|
while (framePos < frames) {
|
|
if (s.blockLeft == 0) {
|
|
s.blockLeft = sampleRate / 238;
|
|
doMidi(midiEvents, midiEventCount, framePos + s.blockLeft);
|
|
|
|
// printf("compute params and reset block size\n");
|
|
|
|
for (uint32_t i = 0; i < NUM_VOICES; i++) {
|
|
s.voice[i].gate(s);
|
|
}
|
|
}
|
|
|
|
sizeThisTime = (s.framesLeft < s.blockLeft) ? s.framesLeft : s.blockLeft;
|
|
|
|
// printf("sL = %d bL = %d, calculating %d frames at %d\n", s.framesLeft, s.blockLeft, sizeThisTime, framePos);
|
|
|
|
// run each synth voice
|
|
|
|
for (uint8_t i = 0; i < NUM_VOICES; i++) {
|
|
s.voice[i].run(s, outputs[0] + framePos, sizeThisTime);
|
|
}
|
|
|
|
framePos += sizeThisTime;
|
|
s.framesLeft -= sizeThisTime;
|
|
s.blockLeft -= sizeThisTime;
|
|
}
|
|
// printf("and now run the rest of the process for %d frames\n\n", frames);
|
|
|
|
// copy left to right
|
|
memmove(outputs[1], outputs[0], sizeof(float) * frames);
|
|
// outputs[1][1]=1;
|
|
}
|
|
|
|
// create the plugin
|
|
Plugin *createPlugin() { return new Chassis(); }
|
|
|
|
END_NAMESPACE_DISTRHO
|