642 lines
21 KiB
C
642 lines
21 KiB
C
/*
|
|
* Brickworks
|
|
*
|
|
* Copyright (C) 2022-2024 Orastron Srl unipersonale
|
|
*
|
|
* Brickworks is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, version 3 of the License.
|
|
*
|
|
* Brickworks is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with Brickworks. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* File author: Stefano D'Angelo
|
|
*/
|
|
|
|
#include "common.h"
|
|
#include <bw_phase_gen.h>
|
|
#include <bw_osc_saw.h>
|
|
#include <bw_osc_pulse.h>
|
|
#include <bw_osc_tri.h>
|
|
#include <bw_osc_sin.h>
|
|
#include <bw_osc_filt.h>
|
|
#include <bw_noise_gen.h>
|
|
#include <bw_pink_filt.h>
|
|
#include <bw_svf.h>
|
|
#include <bw_env_gen.h>
|
|
#include <bw_gain.h>
|
|
#include <bw_ppm.h>
|
|
#include <bw_buf.h>
|
|
|
|
#define BUFFER_SIZE 128
|
|
#define SYNC_RATE 1e-3f // synchronous control rate, seconds
|
|
|
|
typedef struct plugin {
|
|
bw_osc_saw_coeffs vco_saw_coeffs;
|
|
bw_phase_gen_coeffs vco1_phase_gen_coeffs;
|
|
bw_phase_gen_state vco1_phase_gen_state;
|
|
bw_osc_pulse_coeffs vco1_pulse_coeffs;
|
|
bw_osc_tri_coeffs vco1_tri_coeffs;
|
|
bw_gain_coeffs vco1_gain_coeffs;
|
|
bw_phase_gen_coeffs vco2_phase_gen_coeffs;
|
|
bw_phase_gen_state vco2_phase_gen_state;
|
|
bw_osc_pulse_coeffs vco2_pulse_coeffs;
|
|
bw_osc_tri_coeffs vco2_tri_coeffs;
|
|
bw_gain_coeffs vco2_gain_coeffs;
|
|
bw_phase_gen_coeffs vco3_phase_gen_coeffs;
|
|
bw_phase_gen_state vco3_phase_gen_state;
|
|
bw_osc_pulse_coeffs vco3_pulse_coeffs;
|
|
bw_osc_tri_coeffs vco3_tri_coeffs;
|
|
bw_gain_coeffs vco3_gain_coeffs;
|
|
bw_osc_filt_state osc_filt_state;
|
|
bw_noise_gen_coeffs noise_gen_coeffs;
|
|
bw_pink_filt_coeffs pink_filt_coeffs;
|
|
bw_pink_filt_state pink_filt_state;
|
|
bw_gain_coeffs noise_gain_coeffs;
|
|
bw_env_gen_coeffs vcf_env_gen_coeffs;
|
|
bw_env_gen_state vcf_env_gen_state;
|
|
bw_svf_coeffs vcf_coeffs;
|
|
bw_svf_state vcf_state;
|
|
bw_env_gen_coeffs vca_env_gen_coeffs;
|
|
bw_env_gen_state vca_env_gen_state;
|
|
bw_phase_gen_coeffs a440_phase_gen_coeffs;
|
|
bw_phase_gen_state a440_phase_gen_state;
|
|
bw_gain_coeffs gain_coeffs;
|
|
bw_ppm_coeffs ppm_coeffs;
|
|
bw_ppm_state ppm_state;
|
|
|
|
size_t sync_count;
|
|
|
|
uint64_t rand_state;
|
|
float master_tune;
|
|
float modulation_mix;
|
|
float vco1_modulation;
|
|
float vco1_coarse;
|
|
float vco1_fine;
|
|
char vco1_waveform;
|
|
float vco2_modulation;
|
|
float vco2_coarse;
|
|
float vco2_fine;
|
|
char vco2_waveform;
|
|
char vco3_kbd_ctrl;
|
|
float vco3_coarse;
|
|
float vco3_fine;
|
|
char vco3_waveform;
|
|
char noise_color;
|
|
float vcf_modulation;
|
|
char vcf_kbd_ctrl;
|
|
float vcf_cutoff;
|
|
float vcf_contour;
|
|
char a440;
|
|
|
|
int note;
|
|
char gate;
|
|
float pitch_bend;
|
|
float mod_wheel;
|
|
char notes_pressed[128];
|
|
size_t sync_left;
|
|
char vco3_waveform_cur;
|
|
char noise_color_cur;
|
|
float mod_k;
|
|
char vco1_waveform_cur;
|
|
char vco2_waveform_cur;
|
|
float vcf_env_k;
|
|
|
|
float buf[4][BUFFER_SIZE];
|
|
} plugin;
|
|
|
|
static void plugin_init(plugin *instance) {
|
|
bw_osc_saw_init(&instance->vco_saw_coeffs);
|
|
bw_phase_gen_init(&instance->vco1_phase_gen_coeffs);
|
|
bw_osc_pulse_init(&instance->vco1_pulse_coeffs);
|
|
bw_osc_tri_init(&instance->vco1_tri_coeffs);
|
|
bw_gain_init(&instance->vco1_gain_coeffs);
|
|
bw_phase_gen_init(&instance->vco2_phase_gen_coeffs);
|
|
bw_osc_pulse_init(&instance->vco2_pulse_coeffs);
|
|
bw_osc_tri_init(&instance->vco2_tri_coeffs);
|
|
bw_gain_init(&instance->vco2_gain_coeffs);
|
|
bw_phase_gen_init(&instance->vco3_phase_gen_coeffs);
|
|
bw_osc_pulse_init(&instance->vco3_pulse_coeffs);
|
|
bw_osc_tri_init(&instance->vco3_tri_coeffs);
|
|
bw_gain_init(&instance->vco3_gain_coeffs);
|
|
bw_noise_gen_init(&instance->noise_gen_coeffs, &instance->rand_state);
|
|
bw_pink_filt_init(&instance->pink_filt_coeffs);
|
|
bw_gain_init(&instance->noise_gain_coeffs);
|
|
bw_env_gen_init(&instance->vcf_env_gen_coeffs);
|
|
bw_svf_init(&instance->vcf_coeffs);
|
|
bw_env_gen_init(&instance->vca_env_gen_coeffs);
|
|
bw_phase_gen_init(&instance->a440_phase_gen_coeffs);
|
|
bw_gain_init(&instance->gain_coeffs);
|
|
bw_ppm_init(&instance->ppm_coeffs);
|
|
|
|
bw_osc_saw_set_antialiasing(&instance->vco_saw_coeffs, 1);
|
|
bw_osc_pulse_set_antialiasing(&instance->vco1_pulse_coeffs, 1);
|
|
bw_osc_tri_set_antialiasing(&instance->vco1_tri_coeffs, 1);
|
|
bw_osc_pulse_set_antialiasing(&instance->vco2_pulse_coeffs, 1);
|
|
bw_osc_tri_set_antialiasing(&instance->vco2_tri_coeffs, 1);
|
|
bw_osc_pulse_set_antialiasing(&instance->vco3_pulse_coeffs, 1);
|
|
bw_osc_tri_set_antialiasing(&instance->vco3_tri_coeffs, 1);
|
|
bw_phase_gen_set_frequency(&instance->a440_phase_gen_coeffs, 440.f);
|
|
|
|
instance->rand_state = 0xbaddecaf600dfeed;
|
|
}
|
|
|
|
static void plugin_fini(plugin *instance) {
|
|
(void)instance;
|
|
}
|
|
|
|
static void plugin_set_sample_rate(plugin *instance, float sample_rate) {
|
|
bw_osc_saw_set_sample_rate(&instance->vco_saw_coeffs, sample_rate);
|
|
bw_phase_gen_set_sample_rate(&instance->vco1_phase_gen_coeffs, sample_rate);
|
|
bw_osc_pulse_set_sample_rate(&instance->vco1_pulse_coeffs, sample_rate);
|
|
bw_osc_tri_set_sample_rate(&instance->vco1_tri_coeffs, sample_rate);
|
|
bw_gain_set_sample_rate(&instance->vco1_gain_coeffs, sample_rate);
|
|
bw_phase_gen_set_sample_rate(&instance->vco2_phase_gen_coeffs, sample_rate);
|
|
bw_osc_pulse_set_sample_rate(&instance->vco2_pulse_coeffs, sample_rate);
|
|
bw_osc_tri_set_sample_rate(&instance->vco2_tri_coeffs, sample_rate);
|
|
bw_gain_set_sample_rate(&instance->vco2_gain_coeffs, sample_rate);
|
|
bw_phase_gen_set_sample_rate(&instance->vco3_phase_gen_coeffs, sample_rate);
|
|
bw_osc_pulse_set_sample_rate(&instance->vco3_pulse_coeffs, sample_rate);
|
|
bw_osc_tri_set_sample_rate(&instance->vco3_tri_coeffs, sample_rate);
|
|
bw_gain_set_sample_rate(&instance->vco3_gain_coeffs, sample_rate);
|
|
bw_noise_gen_set_sample_rate(&instance->noise_gen_coeffs, sample_rate);
|
|
bw_pink_filt_set_sample_rate(&instance->pink_filt_coeffs, sample_rate);
|
|
bw_gain_set_sample_rate(&instance->noise_gain_coeffs, sample_rate);
|
|
bw_env_gen_set_sample_rate(&instance->vcf_env_gen_coeffs, sample_rate);
|
|
bw_svf_set_sample_rate(&instance->vcf_coeffs, sample_rate);
|
|
bw_env_gen_set_sample_rate(&instance->vca_env_gen_coeffs, sample_rate);
|
|
bw_phase_gen_set_sample_rate(&instance->a440_phase_gen_coeffs, sample_rate);
|
|
bw_gain_set_sample_rate(&instance->gain_coeffs, sample_rate);
|
|
bw_ppm_set_sample_rate(&instance->ppm_coeffs, sample_rate);
|
|
|
|
bw_osc_saw_reset_coeffs(&instance->vco_saw_coeffs);
|
|
bw_noise_gen_reset_coeffs(&instance->noise_gen_coeffs);
|
|
bw_pink_filt_reset_coeffs(&instance->pink_filt_coeffs);
|
|
|
|
instance->sync_count = (size_t)bw_roundf(sample_rate * SYNC_RATE);
|
|
}
|
|
|
|
static size_t plugin_mem_req(plugin *instance) {
|
|
(void)instance;
|
|
return 0;
|
|
}
|
|
|
|
static void plugin_mem_set(plugin *instance, void *mem) {
|
|
(void)instance;
|
|
(void)mem;
|
|
}
|
|
|
|
static void plugin_reset(plugin *instance) {
|
|
bw_svf_set_cutoff(&instance->vcf_coeffs, instance->vcf_cutoff);
|
|
|
|
float p, pi;
|
|
bw_phase_gen_reset_coeffs(&instance->vco1_phase_gen_coeffs);
|
|
bw_phase_gen_reset_state(&instance->vco1_phase_gen_coeffs, &instance->vco1_phase_gen_state, 0.f, &p, &pi);
|
|
bw_osc_pulse_reset_coeffs(&instance->vco1_pulse_coeffs);
|
|
bw_osc_tri_reset_coeffs(&instance->vco1_tri_coeffs);
|
|
bw_gain_reset_coeffs(&instance->vco1_gain_coeffs);
|
|
bw_phase_gen_reset_coeffs(&instance->vco2_phase_gen_coeffs);
|
|
bw_phase_gen_reset_state(&instance->vco2_phase_gen_coeffs, &instance->vco2_phase_gen_state, 0.f, &p, &pi);
|
|
bw_osc_pulse_reset_coeffs(&instance->vco2_pulse_coeffs);
|
|
bw_osc_tri_reset_coeffs(&instance->vco2_tri_coeffs);
|
|
bw_gain_reset_coeffs(&instance->vco2_gain_coeffs);
|
|
bw_phase_gen_reset_coeffs(&instance->vco3_phase_gen_coeffs);
|
|
bw_phase_gen_reset_state(&instance->vco3_phase_gen_coeffs, &instance->vco3_phase_gen_state, 0.f, &p, &pi);
|
|
bw_osc_pulse_reset_coeffs(&instance->vco3_pulse_coeffs);
|
|
bw_osc_tri_reset_coeffs(&instance->vco3_tri_coeffs);
|
|
bw_gain_reset_coeffs(&instance->vco3_gain_coeffs);
|
|
bw_osc_filt_reset_state(&instance->osc_filt_state, 0.f);
|
|
bw_pink_filt_reset_state(&instance->pink_filt_coeffs, &instance->pink_filt_state, 0.f);
|
|
bw_gain_reset_coeffs(&instance->noise_gain_coeffs);
|
|
bw_env_gen_reset_coeffs(&instance->vcf_env_gen_coeffs);
|
|
bw_env_gen_reset_state(&instance->vcf_env_gen_coeffs, &instance->vcf_env_gen_state, 0);
|
|
bw_svf_reset_coeffs(&instance->vcf_coeffs);
|
|
float lp, bp, hp;
|
|
bw_svf_reset_state(&instance->vcf_coeffs, &instance->vcf_state, 0.f, &lp, &bp, &hp);
|
|
bw_env_gen_reset_coeffs(&instance->vca_env_gen_coeffs);
|
|
bw_env_gen_reset_state(&instance->vca_env_gen_coeffs, &instance->vca_env_gen_state, 0);
|
|
bw_phase_gen_reset_coeffs(&instance->a440_phase_gen_coeffs);
|
|
bw_phase_gen_reset_state(&instance->a440_phase_gen_coeffs, &instance->a440_phase_gen_state, 0.f, &p, &pi);
|
|
bw_gain_reset_coeffs(&instance->gain_coeffs);
|
|
bw_ppm_reset_coeffs(&instance->ppm_coeffs);
|
|
bw_ppm_reset_state(&instance->ppm_coeffs, &instance->ppm_state, 0.f);
|
|
instance->note = 60;
|
|
instance->gate = 0;
|
|
instance->pitch_bend = 0.f;
|
|
instance->mod_wheel = 0.f;
|
|
for (int i = 0; i < 128; i++)
|
|
instance->notes_pressed[i] = 0;
|
|
instance->sync_left = instance->sync_count;
|
|
instance->vco3_waveform_cur = instance->vco3_waveform;
|
|
instance->noise_color_cur = instance->noise_color;
|
|
instance->vco1_waveform_cur = instance->vco1_waveform;
|
|
instance->vco2_waveform_cur = instance->vco2_waveform;
|
|
}
|
|
|
|
static void plugin_set_parameter(plugin *instance, size_t index, float value) {
|
|
switch (index) {
|
|
case 0:
|
|
{
|
|
const float v = 0.01f * value;
|
|
bw_gain_set_gain_lin(&instance->gain_coeffs, v * v * v);
|
|
}
|
|
break;
|
|
case 1:
|
|
instance->master_tune = value;
|
|
break;
|
|
case 2:
|
|
{
|
|
// using portamento time 0% -> 90%: tau = portamento time / log(10)
|
|
const float v = (0.001f * 0.4342944819032517f) * value;
|
|
bw_phase_gen_set_portamento_tau(&instance->vco1_phase_gen_coeffs, v);
|
|
bw_phase_gen_set_portamento_tau(&instance->vco2_phase_gen_coeffs, v);
|
|
bw_phase_gen_set_portamento_tau(&instance->vco3_phase_gen_coeffs, v);
|
|
break;
|
|
}
|
|
case 3:
|
|
instance->modulation_mix = 0.01f * value;
|
|
break;
|
|
case 4:
|
|
instance->vco1_modulation = 0.01f * value;
|
|
break;
|
|
case 5:
|
|
instance->vco1_coarse = value;
|
|
break;
|
|
case 6:
|
|
instance->vco1_fine = value;
|
|
break;
|
|
case 7:
|
|
instance->vco1_waveform = value;
|
|
break;
|
|
case 8:
|
|
{
|
|
const float v = 0.01f * value;
|
|
bw_osc_pulse_set_pulse_width(&instance->vco1_pulse_coeffs, v);
|
|
bw_osc_tri_set_slope(&instance->vco1_tri_coeffs, bw_clipf(v, 0.001f, 0.999f));
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
const float v = 0.01f * value;
|
|
bw_gain_set_gain_lin(&instance->vco1_gain_coeffs, v * v * v);
|
|
break;
|
|
}
|
|
case 10:
|
|
instance->vco2_modulation = 0.01f * value;
|
|
break;
|
|
case 11:
|
|
instance->vco2_coarse = value;
|
|
break;
|
|
case 12:
|
|
instance->vco2_fine = value;
|
|
break;
|
|
case 13:
|
|
instance->vco2_waveform = value;
|
|
break;
|
|
case 14:
|
|
{
|
|
const float v = 0.01f * value;
|
|
bw_osc_pulse_set_pulse_width(&instance->vco2_pulse_coeffs, v);
|
|
bw_osc_tri_set_slope(&instance->vco2_tri_coeffs, bw_clipf(v, 0.001f, 0.999f));
|
|
break;
|
|
}
|
|
case 15:
|
|
{
|
|
const float v = 0.01f * value;
|
|
bw_gain_set_gain_lin(&instance->vco2_gain_coeffs, v * v * v);
|
|
break;
|
|
}
|
|
case 16:
|
|
instance->vco3_kbd_ctrl = value >= 0.5f;
|
|
break;
|
|
case 17:
|
|
instance->vco3_coarse = value;
|
|
break;
|
|
case 18:
|
|
instance->vco3_fine = value;
|
|
break;
|
|
case 19:
|
|
instance->vco3_waveform = value;
|
|
break;
|
|
case 20:
|
|
{
|
|
const float v = 0.01f * value;
|
|
bw_osc_pulse_set_pulse_width(&instance->vco3_pulse_coeffs, v);
|
|
bw_osc_tri_set_slope(&instance->vco3_tri_coeffs, bw_clipf(v, 0.001f, 0.999f));
|
|
break;
|
|
}
|
|
case 21:
|
|
{
|
|
const float v = 0.01f * value;
|
|
bw_gain_set_gain_lin(&instance->vco3_gain_coeffs, v * v * v);
|
|
break;
|
|
}
|
|
case 22:
|
|
instance->noise_color = value;
|
|
break;
|
|
case 23:
|
|
{
|
|
const float v = 0.01f * value;
|
|
bw_gain_set_gain_lin(&instance->noise_gain_coeffs, v * v * v);
|
|
break;
|
|
}
|
|
case 24:
|
|
instance->vcf_modulation = 0.01f * value;
|
|
break;
|
|
case 25:
|
|
instance->vcf_kbd_ctrl = value;
|
|
break;
|
|
case 26:
|
|
instance->vcf_cutoff = value;
|
|
break;
|
|
case 27:
|
|
bw_svf_set_Q(&instance->vcf_coeffs, 0.5f + (0.01f * 9.5f) * value);
|
|
break;
|
|
case 28:
|
|
instance->vcf_contour = 0.01f * value;
|
|
break;
|
|
case 29:
|
|
bw_env_gen_set_attack(&instance->vcf_env_gen_coeffs, 0.001f * value);
|
|
break;
|
|
case 30:
|
|
bw_env_gen_set_decay(&instance->vcf_env_gen_coeffs, 0.001f * value);
|
|
break;
|
|
case 31:
|
|
bw_env_gen_set_sustain(&instance->vcf_env_gen_coeffs, 0.01f * value);
|
|
break;
|
|
case 32:
|
|
bw_env_gen_set_release(&instance->vcf_env_gen_coeffs, 0.001f * value);
|
|
break;
|
|
case 33:
|
|
bw_env_gen_set_attack(&instance->vca_env_gen_coeffs, 0.001f * value);
|
|
break;
|
|
case 34:
|
|
bw_env_gen_set_decay(&instance->vca_env_gen_coeffs, 0.001f * value);
|
|
break;
|
|
case 35:
|
|
bw_env_gen_set_sustain(&instance->vca_env_gen_coeffs, 0.01f * value);
|
|
break;
|
|
case 36:
|
|
bw_env_gen_set_release(&instance->vca_env_gen_coeffs, 0.001f * value);
|
|
break;
|
|
case 37:
|
|
instance->a440 = value >= 0.5f;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static float plugin_get_parameter(plugin *instance, size_t index) {
|
|
(void)index;
|
|
return bw_clipf(bw_ppm_get_y_z1(&instance->ppm_state), -60.f, 0.f);
|
|
}
|
|
|
|
static void plugin_process(plugin *instance, const float **inputs, float **outputs, size_t n_samples) {
|
|
(void)inputs;
|
|
|
|
// asynchronous control-rate operations
|
|
|
|
int n = instance->note - 69;
|
|
int n3 = instance->vco3_kbd_ctrl ? instance->note - 69 : -69;
|
|
bw_phase_gen_set_frequency(&instance->vco1_phase_gen_coeffs,
|
|
instance->master_tune
|
|
* bw_pow2f(instance->vco1_coarse + instance->pitch_bend
|
|
+ 8.333333333333333e-2f * (n + 0.01f * instance->vco1_fine)));
|
|
bw_phase_gen_set_frequency(&instance->vco2_phase_gen_coeffs,
|
|
instance->master_tune
|
|
* bw_pow2f(instance->vco2_coarse + instance->pitch_bend
|
|
+ 8.333333333333333e-2f * (n + 0.01f * instance->vco2_fine)));
|
|
bw_phase_gen_set_frequency(&instance->vco3_phase_gen_coeffs,
|
|
instance->master_tune
|
|
* bw_pow2f(instance->vco3_coarse + instance->pitch_bend
|
|
+ 8.333333333333333e-2f * (n3 + 0.01f * instance->vco3_fine)));
|
|
|
|
if (instance->vco3_waveform_cur != instance->vco3_waveform) {
|
|
switch (instance->vco3_waveform) {
|
|
case 2:
|
|
bw_osc_pulse_reset_coeffs(&instance->vco3_pulse_coeffs);
|
|
break;
|
|
case 3:
|
|
bw_osc_tri_reset_coeffs(&instance->vco3_tri_coeffs);
|
|
break;
|
|
}
|
|
instance->vco3_waveform_cur = instance->vco3_waveform;
|
|
}
|
|
|
|
if (instance->noise_color_cur != instance->noise_color) {
|
|
if (instance->noise_color == 2)
|
|
bw_pink_filt_reset_state(&instance->pink_filt_coeffs, &instance->pink_filt_state, 0.f);
|
|
instance->noise_color_cur = instance->noise_color;
|
|
}
|
|
|
|
if (instance->vco1_waveform_cur != instance->vco1_waveform) {
|
|
switch (instance->vco1_waveform) {
|
|
case 2:
|
|
bw_osc_pulse_reset_coeffs(&instance->vco1_pulse_coeffs);
|
|
break;
|
|
case 3:
|
|
bw_osc_tri_reset_coeffs(&instance->vco1_tri_coeffs);
|
|
break;
|
|
}
|
|
instance->vco1_waveform_cur = instance->vco1_waveform;
|
|
}
|
|
|
|
if (instance->vco2_waveform_cur != instance->vco2_waveform) {
|
|
switch (instance->vco2_waveform) {
|
|
case 2:
|
|
bw_osc_pulse_reset_coeffs(&instance->vco2_pulse_coeffs);
|
|
break;
|
|
case 3:
|
|
bw_osc_tri_reset_coeffs(&instance->vco2_tri_coeffs);
|
|
break;
|
|
}
|
|
instance->vco2_waveform_cur = instance->vco2_waveform;
|
|
}
|
|
|
|
// synchronous control-rate and audio-rate operations
|
|
|
|
for (size_t i = 0; i < n_samples; ) {
|
|
float *out = outputs[0] + i;
|
|
int n = bw_minf(bw_minf(n_samples - i, BUFFER_SIZE), instance->sync_left);
|
|
|
|
const char sync = instance->sync_left == instance->sync_count;
|
|
|
|
// osc 3
|
|
|
|
bw_phase_gen_process(&instance->vco3_phase_gen_coeffs, &instance->vco3_phase_gen_state, NULL, out, instance->buf[0], n);
|
|
switch (instance->vco3_waveform_cur) {
|
|
case 1:
|
|
bw_osc_saw_process(&instance->vco_saw_coeffs, out, instance->buf[0], out, n);
|
|
break;
|
|
case 2:
|
|
bw_osc_pulse_process(&instance->vco3_pulse_coeffs, out, instance->buf[0], out, n);
|
|
break;
|
|
default:
|
|
bw_osc_tri_process(&instance->vco3_tri_coeffs, out, instance->buf[0], out, n);
|
|
break;
|
|
}
|
|
|
|
// noise generator
|
|
|
|
bw_noise_gen_process(&instance->noise_gen_coeffs, instance->buf[0], n);
|
|
if (instance->noise_color_cur == 2)
|
|
bw_pink_filt_process(&instance->pink_filt_coeffs, &instance->pink_filt_state, instance->buf[0], instance->buf[0], n);
|
|
bw_buf_scale(instance->buf[0], 5.f, instance->buf[0], n);
|
|
|
|
// modulation signals
|
|
|
|
for (int j = 0; j < n; j++)
|
|
instance->buf[1][j] = instance->mod_wheel * (out[j] + instance->modulation_mix * (instance->buf[0][j] - out[j]));
|
|
if (sync)
|
|
instance->mod_k = instance->buf[1][0];
|
|
|
|
// osc 1
|
|
|
|
bw_buf_scale(instance->buf[1], instance->vco1_modulation, instance->buf[2], n);
|
|
bw_phase_gen_process(&instance->vco1_phase_gen_coeffs, &instance->vco1_phase_gen_state, instance->buf[2], instance->buf[2], instance->buf[3], n);
|
|
switch (instance->vco1_waveform_cur) {
|
|
case 1:
|
|
bw_osc_saw_process(&instance->vco_saw_coeffs, instance->buf[2], instance->buf[3], instance->buf[2], n);
|
|
break;
|
|
case 2:
|
|
bw_osc_pulse_process(&instance->vco1_pulse_coeffs, instance->buf[2], instance->buf[3], instance->buf[2], n);
|
|
break;
|
|
default:
|
|
bw_osc_tri_process(&instance->vco1_tri_coeffs, instance->buf[2], instance->buf[3], instance->buf[2], n);
|
|
break;
|
|
}
|
|
|
|
// osc 2
|
|
|
|
bw_buf_scale(instance->buf[1], instance->vco2_modulation, instance->buf[1], n);
|
|
bw_phase_gen_process(&instance->vco2_phase_gen_coeffs, &instance->vco2_phase_gen_state, instance->buf[1], instance->buf[1], instance->buf[3], n);
|
|
switch (instance->vco2_waveform_cur) {
|
|
case 1:
|
|
bw_osc_saw_process(&instance->vco_saw_coeffs, instance->buf[1], instance->buf[3], instance->buf[1], n);
|
|
break;
|
|
case 2:
|
|
bw_osc_pulse_process(&instance->vco2_pulse_coeffs, instance->buf[1], instance->buf[3], instance->buf[1], n);
|
|
break;
|
|
default:
|
|
bw_osc_tri_process(&instance->vco2_tri_coeffs, instance->buf[1], instance->buf[3], instance->buf[1], n);
|
|
break;
|
|
}
|
|
|
|
// mixer
|
|
|
|
bw_gain_process(&instance->vco1_gain_coeffs, instance->buf[2], instance->buf[2], n);
|
|
bw_gain_process(&instance->vco2_gain_coeffs, instance->buf[1], instance->buf[1], n);
|
|
bw_gain_process(&instance->vco3_gain_coeffs, out, out, n);
|
|
bw_gain_process(&instance->noise_gain_coeffs, instance->buf[0], instance->buf[0], n);
|
|
bw_buf_mix(out, instance->buf[1], out, n);
|
|
bw_buf_mix(out, instance->buf[2], out, n);
|
|
|
|
bw_osc_filt_process(&instance->osc_filt_state, out, out, n);
|
|
|
|
const float k = instance->noise_color_cur == 2
|
|
? 6.f * bw_noise_gen_get_scaling_k(&instance->noise_gen_coeffs) * bw_pink_filt_get_scaling_k(&instance->pink_filt_coeffs)
|
|
: 0.1f * bw_noise_gen_get_scaling_k(&instance->noise_gen_coeffs);
|
|
bw_buf_scale(instance->buf[0], k, instance->buf[0], n);
|
|
bw_buf_mix(out, instance->buf[0], out, n);
|
|
|
|
// vcf
|
|
|
|
bw_env_gen_process(&instance->vcf_env_gen_coeffs, &instance->vcf_env_gen_state, instance->gate, NULL, n);
|
|
if (sync)
|
|
instance->vcf_env_k = bw_env_gen_get_y_z1(&instance->vcf_env_gen_state);
|
|
const float cutoff_unmapped = 0.1447648273010839f * bw_logf(0.05f * instance->vcf_cutoff);
|
|
const float cutoff_vpos = cutoff_unmapped + instance->vcf_contour * instance->vcf_env_k + 0.3f * instance->vcf_modulation * instance->mod_k;
|
|
float cutoff = 20.f * bw_expf(6.907755278982137 * cutoff_vpos);
|
|
switch (instance->vcf_kbd_ctrl) {
|
|
case 2: // 1/3
|
|
cutoff *= bw_pow2f((0.629960524947437f * 8.333333333333333e-2f) * (instance->note - 60));
|
|
break;
|
|
case 3: // 2/3
|
|
cutoff *= bw_pow2f((0.793700525984100f * 8.333333333333333e-2f) * (instance->note - 60));
|
|
break;
|
|
case 4: // full
|
|
cutoff *= bw_pow2f(8.333333333333333e-2f * (instance->note - 60));
|
|
break;
|
|
default: // off, do nothing
|
|
break;
|
|
}
|
|
bw_svf_set_cutoff(&instance->vcf_coeffs, bw_clipf(cutoff, 20.f, 20e3f));
|
|
bw_svf_process(&instance->vcf_coeffs, &instance->vcf_state, out, out, NULL, NULL, n);
|
|
|
|
// vca
|
|
|
|
bw_env_gen_process(&instance->vca_env_gen_coeffs, &instance->vca_env_gen_state, instance->gate, instance->buf[0], n);
|
|
bw_buf_mul(out, instance->buf[0], out, n);
|
|
|
|
// A 440 Hz osc
|
|
|
|
if (instance->a440) { // nobody will notice or care about phase issues here
|
|
bw_phase_gen_process(&instance->a440_phase_gen_coeffs, &instance->a440_phase_gen_state, NULL, instance->buf[0], NULL, n);
|
|
bw_osc_sin_process(instance->buf[0], instance->buf[0], n);
|
|
bw_buf_mix(out, instance->buf[0], out, n);
|
|
}
|
|
|
|
// output
|
|
|
|
bw_gain_process(&instance->gain_coeffs, out, out, n);
|
|
bw_ppm_process(&instance->ppm_coeffs, &instance->ppm_state, out, NULL, n);
|
|
|
|
instance->sync_left -= n;
|
|
if (instance->sync_left == 0)
|
|
instance->sync_left = instance->sync_count;
|
|
|
|
i += n;
|
|
}
|
|
}
|
|
|
|
static void update_note_gate(plugin *instance) {
|
|
for (int i = 0; i < 128; i++)
|
|
if (instance->notes_pressed[i]) {
|
|
instance->note = i;
|
|
instance->gate = 1;
|
|
return;
|
|
}
|
|
instance->gate = 0;
|
|
}
|
|
|
|
static void note_on(plugin *instance, char note) {
|
|
instance->notes_pressed[(int)note] = 1;
|
|
update_note_gate(instance);
|
|
}
|
|
|
|
static void note_off(plugin *instance, char note) {
|
|
if (instance->notes_pressed[(int)note]) {
|
|
instance->notes_pressed[(int)note] = 0;
|
|
update_note_gate(instance);
|
|
}
|
|
}
|
|
|
|
static void plugin_midi_msg_in(plugin *instance, size_t index, const uint8_t * data) {
|
|
(void)index;
|
|
switch (data[0] & 0xf0) {
|
|
case 0x90: // note on
|
|
if (data[2] == 0) // no, note off actually
|
|
note_off(instance, data[1]);
|
|
else
|
|
note_on(instance, data[1]);
|
|
break;
|
|
case 0x80: // note off
|
|
note_off(instance, data[1]);
|
|
break;
|
|
case 0xe0: // pitch bend
|
|
{
|
|
const uint16_t v = (data[2] << 7) | data[1];
|
|
instance->pitch_bend = 2.f * bw_maxf((1.f / 16383.f) * (v - 0x2000), -1.f) - 1.f;
|
|
break;
|
|
}
|
|
case 0xb0: // control change
|
|
if (data[1] == 1) // mod wheel
|
|
instance->mod_wheel = (1.f / 127.f) * data[2];
|
|
break;
|
|
}
|
|
}
|