desc:Attack Eater & Bow Synth (Adaptive Guitar Transient Remover)
//tags: guitar dynamics swell transient synth
//author: Synthesized via Algorithmic Synthesis (C99 -> EEL2)
slider1:65<10,250,1>Attack Swell Time (ms)
slider2:100<0,100,1>Speed Adapt (%)
slider3:100<10,200,1>Eat Depth (%)
slider4:0<-12,12,0.5>Sensitivity / Pickups (dB)
slider5:1015<350,3000,10>Pick Crossover (Hz)
slider6:4.5<1.5,15,0.5>Shred Body Floor (ms)
slider7:100<0,100,1>Attack Eater Mix (%)
slider8:0<0,100,1>Synth Layer Mix (%)
slider9:1<0,2,1{Warm Bow Pad,Analog Poly Brass,Octave Shimmer Organ}>Synth Mode
slider10:55<0,100,1>Synth Tone / VCF (%)
slider11:65<0,100,1>Synth Stereo Chorus (%)
slider12:0<-18,18,0.5>Output Gain (dB)
in_pin:left input
in_pin:right input
out_pin:left output
out_pin:right output
@Init
ext_noinit = 0;
// Non-overlapping memory layout
MEM_BLK_BODY = 0; // [0..3] 4-block sliding max for body env
MEM_DLY_L = 64; // [64..4159] 4096-sample chorus delay L
MEM_DLY_R = 4200; // [4200..8295] 4096-sample chorus delay R
DLY_MASK = 4095;
GFX_LEN = 256;
GFX_IN = 8400; // [8400..8655]
GFX_OUT = 8700; // [8700..8955]
GFX_GB = 9000; // [9000..9255]
GFX_GH = 9300; // [9300..9555]
GFX_D = 9600; // [9600..9855]
memset(0, 0, 10000);
DENORM_FLOOR = pow(10.0, -20.0);
function clamp(v, lo, hi) (
min(max(v, lo), hi);
);
function sanitize(x) (
(x != x || abs(x) > 32.0) ? 0.0 : x;
);
function flush_denorm(v) (
(abs(v) < DENORM_FLOOR) ? 0.0 : v;
);
function ms_to_pole(ms, inv_fs) local(tau_s) (
tau_s = max(ms, 0.02) * 0.001;
exp(-inv_fs / tau_s);
);
function ms_to_pole_fast(ms, inv_fs) local(x) (
x = inv_fs / (max(ms, 0.5) * 0.001);
(x < 0.05) ?
(1.0 - x * (1.0 - x * (0.5 - x * (0.16666667 - 0.04166667 * x)))) :
exp(-x);
);
function asym_onepole(prev, target, a_rise, a_fall) local(a) (
a = (target > prev) ? a_rise : a_fall;
max(a * prev + (1.0 - a) * target, DENORM_FLOOR);
);
function fast_tanh(x) local(xc, x2) (
xc = clamp(x, -3.0, 3.0);
x2 = xc * xc;
xc * (27.0 + x2) / (27.0 + 9.0 * x2);
);
function compute_band_gain(ef, es, eps, d0, k_knee, g_depth, min_g) local(delta, u, phi, g) (
delta = log((ef + eps) / (es + eps));
u = max(0.0, delta - d0);
phi = (u * u) / (u + k_knee + 0.000000000001);
g = exp(-g_depth * phi);
clamp(g, min_g, 1.0);
);
// Cytomic Trapezoidal (TPT) SVF: unconditionally stable under fast envelope modulation
function svf_lp(x, g_svf, k_svf) instance(ic1, ic2) local(a1, a2, a3, v1, v2, v3) (
a1 = 1.0 / (1.0 + g_svf * (g_svf + k_svf));
a2 = g_svf * a1;
a3 = g_svf * a2;
v3 = x - ic2;
v1 = a1 * ic1 + a2 * v3;
v2 = ic2 + a2 * ic1 + a3 * v3;
ic1 = 2.0 * v1 - ic1;
ic2 = 2.0 * v2 - ic2;
v2;
);
function read_delay_lerp(buf_base, w_idx, dly_spl) local(rpos, i0, i1, frac) (
rpos = w_idx - dly_spl;
rpos < 0 ? rpos += 4096;
i0 = floor(rpos) & DLY_MASK;
i1 = (i0 + 1) & DLY_MASK;
frac = rpos - floor(rpos);
buf_base[i0] + frac * (buf_base[i1] - buf_base[i0]);
);
function recalc_params() (
inv_fs = 1.0 / max(srate, 8000.0);
swell_ms = clamp(slider1, 10.0, 250.0);
speed_adapt = clamp(slider2 * 0.01, 0.0, 1.0);
depth_val = 1.08 * clamp(slider3 * 0.01, 0.1, 2.0);
sens_db = clamp(slider4, -12.0, 12.0);
xo_hz = clamp(slider5, 350.0, min(3000.0, 0.4 * srate));
fast_body_ms = clamp(slider6, 1.5, min(15.0, swell_ms));
fast_high_ms = clamp(max(18.5, fast_body_ms + 4.0), fast_body_ms, swell_ms);
ae_mix = clamp(slider7 * 0.01, 0.0, 1.0);
synth_mix = clamp(slider8 * 0.01, 0.0, 1.0);
synth_mode = floor(slider9 + 0.5);
synth_tone = clamp(slider10 * 0.01, 0.0, 1.0);
chorus_amt = clamp(slider11 * 0.01, 0.0, 1.0);
out_gain = exp(slider12 * 0.11512925465);
// Sensitivity shifts deadzone & noise floor smoothly for singles vs hot humbuckers
sens_nepers = sens_db * 0.11512925465;
delta0 = clamp(0.318 - 0.22 * sens_nepers, 0.06, 0.65);
knee = 0.11;
noise_eps = exp((-76.0 - 0.8 * sens_db) * 0.11512925465);
floor_min_g = exp(-48.0 * 0.11512925465);
block_len = max(1, floor(0.003 * srate + 0.5));
a_xo = exp(-2.0 * $pi * xo_hz * inv_fs);
a_body_down = ms_to_pole(4.0, inv_fs);
a_hi_down = ms_to_pole(5.0, inv_fs);
a_fall = ms_to_pole(3.1, inv_fs);
a_spd_fast_hi= ms_to_pole(6.0, inv_fs);
a_spd_ref = ms_to_pole(12.0, inv_fs);
a_d_up = ms_to_pole(31.5, inv_fs);
a_d_dn = ms_to_pole(494.0, inv_fs);
a_r_up = ms_to_pole(4.0, inv_fs);
a_r_dn = ms_to_pole(28.0, inv_fs);
a_g_down = ms_to_pole(0.025, inv_fs);
a_g_up = ms_to_pole(0.50, inv_fs);
d_deadzone = 0.127;
d_scale = 7.0;
log_rat_body = log(fast_body_ms / swell_ms);
log_rat_high = log(fast_high_ms / swell_ms);
// Synth layer constants
a_oct_dc = exp(-2.0 * $pi * 150.0 * inv_fs);
a_syn_dc = exp(-2.0 * $pi * 25.0 * inv_fs);
a_synth_env = ms_to_pole(18.0, inv_fs);
lfo_inc1 = 2.0 * $pi * 0.43 * inv_fs;
lfo_inc2 = 2.0 * $pi * 1.17 * inv_fs;
gfx_step = max(1, floor(srate / 120.0));
);
// State initialization
blk_cur_max = 0.0;
blk_cnt = 0;
ef_body = DENORM_FLOOR;
ef_high = DENORM_FLOOR;
e_spd_ref_tot = DENORM_FLOOR;
e_spd_fast_hi = DENORM_FLOOR;
e_spd_ref_hi = DENORM_FLOOR;
refractory = 0.0;
density = DENORM_FLOOR;
d_eff = 0.0;
lpL = 0.0;
lpR = 0.0;
ref_body_s1 = DENORM_FLOOR;
ref_body_s2 = DENORM_FLOOR;
ref_high_s1 = DENORM_FLOOR;
ref_high_s2 = DENORM_FLOOR;
g_body_smooth = 1.0;
g_high_smooth = 1.0;
// Synth state
oct_dc_L = 0.0;
oct_dc_R = 0.0;
syn_dc_L = 0.0;
syn_dc_R = 0.0;
synth_env_s = DENORM_FLOOR;
vcf_cut_disp = 1000.0;
dly_w = 0;
lfo_ph1 = 0.0;
lfo_ph2 = 0.0;
// GFX telemetry state
gfx_cnt = 0;
gfx_wpos = 0;
gfx_pk_in = 0.0;
gfx_pk_out = 0.0;
tau_body_disp = 65.0;
recalc_params();
@slider
recalc_params();
@Sample
inL = sanitize(spl0);
inR = sanitize(spl1);
// 1. Complementary zero-phase-sum crossover per channel
x_low_L = flush_denorm(a_xo * lpL + (1.0 - a_xo) * inL);
lpL = x_low_L;
x_high_L = inL - x_low_L;
x_low_R = flush_denorm(a_xo * lpR + (1.0 - a_xo) * inR);
lpR = x_low_R;
x_high_R = inR - x_low_R;
// 2. Stereo-linked detection preserves stereo image
abs_lo = max(abs(x_low_L), abs(x_low_R));
abs_hi = max(abs(x_high_L), abs(x_high_R));
// 12ms 4-block sliding peak on body (no 82Hz ripple, 0ms onset lag)
blk_cur_max = max(blk_cur_max, abs_lo);
raw_max = max(blk_cur_max, max(max(MEM_BLK_BODY[0], MEM_BLK_BODY[1]), max(MEM_BLK_BODY[2], MEM_BLK_BODY[3])));
ef_body = max(max(raw_max, a_body_down * ef_body), DENORM_FLOOR);
blk_cnt += 1;
blk_cnt >= block_len ? (
MEM_BLK_BODY[3] = MEM_BLK_BODY[2];
MEM_BLK_BODY[2] = MEM_BLK_BODY[1];
MEM_BLK_BODY[1] = MEM_BLK_BODY[0];
MEM_BLK_BODY[0] = blk_cur_max;
blk_cur_max = 0.0;
blk_cnt = 0;
);
ef_high = max(max(abs_hi, a_hi_down * ef_high), DENORM_FLOOR);
// 3. Refractory playing-speed density reservoir D in [0, 1]
e_spd_fast_hi = max(max(abs_hi, a_spd_fast_hi * e_spd_fast_hi), DENORM_FLOOR);
e_spd_ref_tot = asym_onepole(e_spd_ref_tot, ef_body, a_spd_ref, a_spd_ref);
e_spd_ref_hi = asym_onepole(e_spd_ref_hi, e_spd_fast_hi, a_spd_ref, a_spd_ref);
eps_hi_spd = max(noise_eps, 0.12 * ef_body);
eps_hi_gain = max(noise_eps, 0.04 * ef_body);
d_tot = log((ef_body + noise_eps) / (e_spd_ref_tot + noise_eps));
d_hi = log((e_spd_fast_hi + eps_hi_spd) / (e_spd_ref_hi + eps_hi_spd));
u_spd = max(0.0, max(d_tot, d_hi) - delta0);
raw_onset = clamp(u_spd * 2.85, 0.0, 1.0);
spike = raw_onset * (1.0 - refractory);
refractory = asym_onepole(refractory, raw_onset, a_r_up, a_r_dn);
density = asym_onepole(density, spike, a_d_up, a_d_dn);
d_norm = clamp((density - d_deadzone) * d_scale, 0.0, 1.0);
d_eff = speed_adapt * (d_norm * d_norm * (3.0 - 2.0 * d_norm));
// 4. Speed-adaptive 2-pole asymmetric swell envelopes
tau_body_eff = swell_ms * exp(log_rat_body * d_eff);
tau_high_eff = swell_ms * exp(log_rat_high * d_eff);
tau_body_disp = tau_body_eff;
a_rise_body = ms_to_pole_fast(tau_body_eff * 0.465, inv_fs);
a_rise_high = ms_to_pole_fast(tau_high_eff * 0.465, inv_fs);
ref_body_s1 = asym_onepole(ref_body_s1, ef_body, a_rise_body, a_fall);
ref_body_s2 = asym_onepole(ref_body_s2, ref_body_s1, a_rise_body, a_fall);
ref_high_s1 = asym_onepole(ref_high_s1, ef_high, a_rise_high, a_fall);
ref_high_s2 = asym_onepole(ref_high_s2, ref_high_s1, a_rise_high, a_fall);
depth_body = depth_val * (1.0 - 0.35 * d_eff);
min_gain_body = floor_min_g + (0.28 - floor_min_g) * (d_eff * d_eff);
g_body_raw = compute_band_gain(ef_body, ref_body_s2, noise_eps, delta0, knee, depth_body, min_gain_body);
g_high_raw = compute_band_gain(ef_high, ref_high_s2, eps_hi_gain, delta0, knee, depth_val, floor_min_g);
g_body_smooth = asym_onepole(g_body_smooth, g_body_raw, a_g_up, a_g_down);
g_high_smooth = asym_onepole(g_high_smooth, g_high_raw, a_g_up, a_g_down);
ae_L = g_body_smooth * x_low_L + g_high_smooth * x_high_L;
ae_R = g_body_smooth * x_low_R + g_high_smooth * x_high_R;
clean_L = inL + ae_mix * (ae_L - inL);
clean_R = inR + ae_mix * (ae_R - inR);
// 5. Layer 2: Polyphonic Bow-Synth / Pad Shaper (runs only when Synth Layer Mix > 0)
outL = clean_L;
outR = clean_R;
synth_mix > 0.001 ? (
env_tot = max(ef_body, ef_high);
synth_env_s = a_synth_env * synth_env_s + (1.0 - a_synth_env) * env_tot;
// Envelope-normalized polyphonic waveshaper (keeps harmonic character steady into decay)
norm_s = 1.0 / (synth_env_s + 0.020);
xnL = ae_L * norm_s;
xnR = ae_R * norm_s;
// Gate near noise floor so hum never amplifies during silence
gate_s = synth_env_s / (synth_env_s + noise_eps * 16.0);
amp_s = 0.85 * pow(max(synth_env_s, DENORM_FLOOR), 0.78) * gate_s;
synth_mode == 0 ? (
// Warm Bow Pad: smooth odd/even harmonic warmth
exL = fast_tanh(2.1 * xnL + 0.25 * (xnL * xnL));
exR = fast_tanh(2.1 * xnR + 0.25 * (xnR * xnR));
f_min = 240.0 + 300.0 * synth_tone;
f_max = 1400.0 + 2800.0 * synth_tone;
res_s = 0.22 + 0.25 * synth_tone;
) : synth_mode == 1 ? (
// Analog Poly Brass: asymmetric PWM-style waveshaping + resonant filter sweep
exL = fast_tanh(3.4 * xnL + 0.65 * (xnL * xnL - 0.25));
exR = fast_tanh(3.4 * xnR + 0.65 * (xnR * xnR - 0.25));
f_min = 200.0 + 250.0 * synth_tone;
f_max = 2200.0 + 4600.0 * synth_tone;
res_s = 0.45 + 0.30 * synth_tone;
) : (
// Octave Shimmer Organ: fundamental + DC-blocked frequency doubler (+1 oct)
octL_raw = xnL * xnL;
octR_raw = xnR * xnR;
oct_dc_L = a_oct_dc * oct_dc_L + (1.0 - a_oct_dc) * octL_raw;
oct_dc_R = a_oct_dc * oct_dc_R + (1.0 - a_oct_dc) * octR_raw;
octL = octL_raw - oct_dc_L;
octR = octR_raw - oct_dc_R;
exL = 0.65 * fast_tanh(2.0 * xnL) + (0.65 + 0.55 * synth_tone) * fast_tanh(2.4 * octL);
exR = 0.65 * fast_tanh(2.0 * xnR) + (0.65 + 0.55 * synth_tone) * fast_tanh(2.4 * octR);
f_min = 380.0 + 350.0 * synth_tone;
f_max = 2600.0 + 5200.0 * synth_tone;
res_s = 0.28 + 0.25 * synth_tone;
);
// VCF cutoff tracks the attack-eater S-curve!
vcf_mod = clamp(g_body_smooth * clamp(synth_env_s * 5.0, 0.0, 1.0), 0.0, 1.0);
vcf_hz = min(f_min * exp(log(f_max / f_min) * vcf_mod), 0.42 * srate);
vcf_cut_disp = vcf_hz;
g_svf = tan($pi * vcf_hz * inv_fs);
k_svf = 2.0 - 2.0 * res_s;
synL = svfL.svf_lp(exL * amp_s, g_svf, k_svf);
synR = svfR.svf_lp(exR * amp_s, g_svf, k_svf);
// 25 Hz DC blocker removes asymmetric-shaper offset before downstream amp sims
syn_dc_L = a_syn_dc * syn_dc_L + (1.0 - a_syn_dc) * synL;
syn_dc_R = a_syn_dc * syn_dc_R + (1.0 - a_syn_dc) * synR;
synL -= syn_dc_L;
synR -= syn_dc_R;
// Stereo quadrature ensemble chorus
chorus_amt > 0.001 ? (
lfo_ph1 += lfo_inc1;
lfo_ph1 > 2.0 * $pi ? lfo_ph1 -= 2.0 * $pi;
lfo_ph2 += lfo_inc2;
lfo_ph2 > 2.0 * $pi ? lfo_ph2 -= 2.0 * $pi;
modL = 0.7 * sin(lfo_ph1) + 0.3 * sin(lfo_ph2);
modR = 0.7 * cos(lfo_ph1) - 0.3 * cos(lfo_ph2);
base_dly = 0.011 * srate;
depth_dly = 0.0038 * srate * chorus_amt;
dly_spl_L = clamp(base_dly + depth_dly * modL, 1.0, 4094.0);
dly_spl_R = clamp(base_dly + depth_dly * modR, 1.0, 4094.0);
MEM_DLY_L[dly_w] = synL;
MEM_DLY_R[dly_w] = synR;
chL = read_delay_lerp(MEM_DLY_L, dly_w, dly_spl_L);
chR = read_delay_lerp(MEM_DLY_R, dly_w, dly_spl_R);
dly_w = (dly_w + 1) & DLY_MASK;
synL = synL + chorus_amt * 0.65 * (chR - synL * 0.35);
synR = synR + chorus_amt * 0.65 * (chL - synR * 0.35);
);
outL = clean_L + synth_mix * (synL - clean_L);
outR = clean_R + synth_mix * (synR - clean_R);
);
spl0 = clamp(outL * out_gain, -4.0, 4.0);
spl1 = clamp(outR * out_gain, -4.0, 4.0);
// 6. Downsampled history for
@GFX scope
gfx_pk_in = max(gfx_pk_in, max(abs(inL), abs(inR)));
gfx_pk_out = max(gfx_pk_out, max(abs(spl0), abs(spl1)));
gfx_cnt += 1;
gfx_cnt >= gfx_step ? (
GFX_IN[gfx_wpos] = min(1.0, gfx_pk_in);
GFX_OUT[gfx_wpos] = min(1.0, gfx_pk_out);
GFX_GB[gfx_wpos] = g_body_smooth;
GFX_GH[gfx_wpos] = g_high_smooth;
GFX_D[gfx_wpos] = d_eff;
gfx_wpos = (gfx_wpos + 1) & 255;
gfx_pk_in = 0.0;
gfx_pk_out = 0.0;
gfx_cnt = 0;
);
@GFX 640 300
// Background
gfx_set(0.07, 0.08, 0.11, 1.0);
gfx_rect(0, 0, gfx_w, gfx_h);
pad = 14;
top_h = 66;
scope_x = pad;
scope_y = top_h + 8;
scope_w = gfx_w - 2 * pad;
scope_h = gfx_h - scope_y - 28;
// Header & telemetry bars
gfx_set(0.11, 0.13, 0.18, 1.0);
gfx_rect(pad, 10, gfx_w - 2 * pad, top_h - 10);
// 3-column header meters without overlap
col_w = max(80, (gfx_w - 2 * pad - 44) / 3);
x1 = pad + 10;
x2 = x1 + col_w + 12;
x3 = x2 + col_w + 12;
// Col 1: Density D meter
gfx_set(0.75, 0.80, 0.88, 1.0);
gfx_x = x1; gfx_y = 16;
gfx_drawstr("D: ");
gfx_drawnumber(d_eff * 100.0, 0);
gfx_drawstr("% (");
gfx_drawnumber(tau_body_disp, 1);
gfx_drawstr("ms)");
gfx_set(0.18, 0.21, 0.27, 1.0);
gfx_rect(x1, 34, col_w, 12);
gfx_set(0.15 + 0.82 * d_eff, 0.78 - 0.35 * d_eff, 0.90 - 0.70 * d_eff, 1.0);
gfx_rect(x1, 34, col_w * d_eff, 12);
// Col 2: Body Gain meter
gfx_set(0.95, 0.78, 0.25, 1.0);
gfx_x = x2; gfx_y = 16;
gfx_drawstr("Body (<Cross)");
gfx_set(0.18, 0.21, 0.27, 1.0);
gfx_rect(x2, 34, col_w, 12);
gfx_set(0.95, 0.78, 0.25, 1.0);
gfx_rect(x2, 34, col_w * g_body_smooth, 12);
// Col 3: Pick Gain meter
gfx_set(0.95, 0.38, 0.75, 1.0);
gfx_x = x3; gfx_y = 16;
gfx_drawstr("Pick (>Cross)");
gfx_set(0.18, 0.21, 0.27, 1.0);
gfx_rect(x3, 34, col_w, 12);
gfx_set(0.95, 0.38, 0.75, 1.0);
gfx_rect(x3, 34, col_w * g_high_smooth, 12);
// Scope frame & grid
gfx_set(0.05, 0.06, 0.08, 1.0);
gfx_rect(scope_x, scope_y, scope_w, scope_h);
gfx_set(0.16, 0.19, 0.25, 1.0);
gfx_line(scope_x, scope_y, scope_x + scope_w, scope_y);
gfx_line(scope_x, scope_y + scope_h, scope_x + scope_w, scope_y + scope_h);
gfx_line(scope_x, scope_y, scope_x, scope_y + scope_h);
gfx_line(scope_x + scope_w, scope_y, scope_x + scope_w, scope_y + scope_h);
gfx_line(scope_x, scope_y + scope_h * 0.5, scope_x + scope_w, scope_y + scope_h * 0.5);
// Plot Input (gray fill), Output (cyan), Body Gain (gold), Pick Gain (magenta)
i = 0;
prev_x = scope_x;
prev_gb_y = scope_y + scope_h;
prev_gh_y = scope_y + scope_h;
prev_d_y = scope_y + scope_h;
loop(GFX_LEN,
idx = (gfx_wpos + i) & 255;
xx = scope_x + (i / (GFX_LEN - 1)) * scope_w;
v_in = GFX_IN[idx];
v_out = GFX_OUT[idx];
v_gb = GFX_GB[idx];
v_gh = GFX_GH[idx];
v_d = GFX_D[idx];
// Input envelope bars (subtle gray)
gfx_set(0.32, 0.36, 0.44, 0.55);
bar_h_in = v_in * (scope_h - 8);
gfx_line(xx, scope_y + scope_h - 2, xx, scope_y + scope_h - 2 - bar_h_in);
// Output envelope bars (bright cyan)
gfx_set(0.20, 0.85, 0.92, 0.80);
bar_h_out = v_out * (scope_h - 8);
gfx_line(xx, scope_y + scope_h - 2, xx, scope_y + scope_h - 2 - bar_h_out);
gb_y = scope_y + scope_h - 2 - v_gb * (scope_h - 8);
gh_y = scope_y + scope_h - 2 - v_gh * (scope_h - 8);
d_y = scope_y + scope_h - 2 - v_d * (scope_h - 8);
i > 0 ? (
gfx_set(0.95, 0.78, 0.25, 0.95);
gfx_line(prev_x, prev_gb_y, xx, gb_y);
gfx_set(0.95, 0.38, 0.75, 0.90);
gfx_line(prev_x, prev_gh_y, xx, gh_y);
gfx_set(1.0, 0.50, 0.15, 0.55);
gfx_line(prev_x, prev_d_y, xx, d_y);
);
prev_x = xx;
prev_gb_y = gb_y;
prev_gh_y = gh_y;
prev_d_y = d_y;
i += 1;
);
// Legend footer
gfx_x = scope_x; gfx_y = gfx_h - 20;
gfx_set(0.45, 0.50, 0.58, 1.0); gfx_drawstr("In(Gray) ");
gfx_set(0.20, 0.85, 0.92, 1.0); gfx_drawstr("Out(Cyan) ");
gfx_set(0.95, 0.78, 0.25, 1.0); gfx_drawstr("Body(Gold) ");
gfx_set(0.95, 0.38, 0.75, 1.0); gfx_drawstr("Pick(Pink) ");
gfx_set(1.00, 0.50, 0.15, 1.0); gfx_drawstr("D(Orange)");
synth_mix > 0.001 ? (
gfx_set(0.65, 0.95, 0.55, 1.0);
gfx_drawstr(" VCF:");
gfx_drawnumber(vcf_cut_disp, 0);
gfx_drawstr("Hz");
);